Automatic date update in version.in
[external/binutils.git] / bfd / elfxx-x86.c
1 /* x86 specific support for ELF
2    Copyright (C) 2017-2019 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 #include "elfxx-x86.h"
22 #include "elf-vxworks.h"
23 #include "objalloc.h"
24 #include "elf/i386.h"
25 #include "elf/x86-64.h"
26
27 /* The name of the dynamic interpreter.  This is put in the .interp
28    section.  */
29
30 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
31 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
32 #define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
33
34 bfd_boolean
35 _bfd_x86_elf_mkobject (bfd *abfd)
36 {
37   return bfd_elf_allocate_object (abfd,
38                                   sizeof (struct elf_x86_obj_tdata),
39                                   get_elf_backend_data (abfd)->target_id);
40 }
41
42 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
43    executables.  Rather than setting it to the beginning of the TLS
44    section, we have to set it to the end.    This function may be called
45    multiple times, it is idempotent.  */
46
47 void
48 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
49 {
50   struct elf_x86_link_hash_table *htab;
51   struct bfd_link_hash_entry *base;
52   const struct elf_backend_data *bed;
53
54   if (!bfd_link_executable (info))
55     return;
56
57   bed = get_elf_backend_data (info->output_bfd);
58   htab = elf_x86_hash_table (info, bed->target_id);
59   if (htab == NULL)
60     return;
61
62   base = htab->tls_module_base;
63   if (base == NULL)
64     return;
65
66   base->u.def.value = htab->elf.tls_size;
67 }
68
69 /* Return the base VMA address which should be subtracted from real addresses
70    when resolving @dtpoff relocation.
71    This is PT_TLS segment p_vaddr.  */
72
73 bfd_vma
74 _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info)
75 {
76   /* If tls_sec is NULL, we should have signalled an error already.  */
77   if (elf_hash_table (info)->tls_sec == NULL)
78     return 0;
79   return elf_hash_table (info)->tls_sec->vma;
80 }
81
82 /* Allocate space in .plt, .got and associated reloc sections for
83    dynamic relocs.  */
84
85 static bfd_boolean
86 elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
87 {
88   struct bfd_link_info *info;
89   struct elf_x86_link_hash_table *htab;
90   struct elf_x86_link_hash_entry *eh;
91   struct elf_dyn_relocs *p;
92   unsigned int plt_entry_size;
93   bfd_boolean resolved_to_zero;
94   const struct elf_backend_data *bed;
95
96   if (h->root.type == bfd_link_hash_indirect)
97     return TRUE;
98
99   eh = (struct elf_x86_link_hash_entry *) h;
100
101   info = (struct bfd_link_info *) inf;
102   bed = get_elf_backend_data (info->output_bfd);
103   htab = elf_x86_hash_table (info, bed->target_id);
104   if (htab == NULL)
105     return FALSE;
106
107   plt_entry_size = htab->plt.plt_entry_size;
108
109   resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
110
111   /* We can't use the GOT PLT if pointer equality is needed since
112      finish_dynamic_symbol won't clear symbol value and the dynamic
113      linker won't update the GOT slot.  We will get into an infinite
114      loop at run-time.  */
115   if (htab->plt_got != NULL
116       && h->type != STT_GNU_IFUNC
117       && !h->pointer_equality_needed
118       && h->plt.refcount > 0
119       && h->got.refcount > 0)
120     {
121       /* Don't use the regular PLT if there are both GOT and GOTPLT
122          reloctions.  */
123       h->plt.offset = (bfd_vma) -1;
124
125       /* Use the GOT PLT.  */
126       eh->plt_got.refcount = 1;
127     }
128
129   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
130      here if it is defined and referenced in a non-shared object.  */
131   if (h->type == STT_GNU_IFUNC
132       && h->def_regular)
133     {
134       if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
135                                               &htab->readonly_dynrelocs_against_ifunc,
136                                               plt_entry_size,
137                                               (htab->plt.has_plt0
138                                                * plt_entry_size),
139                                                htab->got_entry_size,
140                                                TRUE))
141         {
142           asection *s = htab->plt_second;
143           if (h->plt.offset != (bfd_vma) -1 && s != NULL)
144             {
145               /* Use the second PLT section if it is created.  */
146               eh->plt_second.offset = s->size;
147
148               /* Make room for this entry in the second PLT section.  */
149               s->size += htab->non_lazy_plt->plt_entry_size;
150             }
151
152           return TRUE;
153         }
154       else
155         return FALSE;
156     }
157   /* Don't create the PLT entry if there are only function pointer
158      relocations which can be resolved at run-time.  */
159   else if (htab->elf.dynamic_sections_created
160            && (h->plt.refcount > 0
161                || eh->plt_got.refcount > 0))
162     {
163       bfd_boolean use_plt_got = eh->plt_got.refcount > 0;
164
165       /* Make sure this symbol is output as a dynamic symbol.
166          Undefined weak syms won't yet be marked as dynamic.  */
167       if (h->dynindx == -1
168           && !h->forced_local
169           && !resolved_to_zero
170           && h->root.type == bfd_link_hash_undefweak)
171         {
172           if (! bfd_elf_link_record_dynamic_symbol (info, h))
173             return FALSE;
174         }
175
176       if (bfd_link_pic (info)
177           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
178         {
179           asection *s = htab->elf.splt;
180           asection *second_s = htab->plt_second;
181           asection *got_s = htab->plt_got;
182           bfd_boolean use_plt;
183
184           /* If this is the first .plt entry, make room for the special
185              first entry.  The .plt section is used by prelink to undo
186              prelinking for dynamic relocations.  */
187           if (s->size == 0)
188             s->size = htab->plt.has_plt0 * plt_entry_size;
189
190           if (use_plt_got)
191             eh->plt_got.offset = got_s->size;
192           else
193             {
194               h->plt.offset = s->size;
195               if (second_s)
196                 eh->plt_second.offset = second_s->size;
197             }
198
199           /* If this symbol is not defined in a regular file, and we are
200              generating PDE, then set the symbol to this location in the
201              .plt.  This is required to make function pointers compare
202              as equal between PDE and the shared library.
203
204              NB: If PLT is PC-relative, we can use the .plt in PIE for
205              function address. */
206           if (h->def_regular)
207             use_plt = FALSE;
208           else if (htab->pcrel_plt)
209             use_plt = ! bfd_link_dll (info);
210           else
211             use_plt = bfd_link_pde (info);
212           if (use_plt)
213             {
214               if (use_plt_got)
215                 {
216                   /* We need to make a call to the entry of the GOT PLT
217                      instead of regular PLT entry.  */
218                   h->root.u.def.section = got_s;
219                   h->root.u.def.value = eh->plt_got.offset;
220                 }
221               else
222                 {
223                   if (second_s)
224                     {
225                       /* We need to make a call to the entry of the
226                          second PLT instead of regular PLT entry.  */
227                       h->root.u.def.section = second_s;
228                       h->root.u.def.value = eh->plt_second.offset;
229                     }
230                   else
231                     {
232                       h->root.u.def.section = s;
233                       h->root.u.def.value = h->plt.offset;
234                     }
235                 }
236             }
237
238           /* Make room for this entry.  */
239           if (use_plt_got)
240             got_s->size += htab->non_lazy_plt->plt_entry_size;
241           else
242             {
243               s->size += plt_entry_size;
244               if (second_s)
245                 second_s->size += htab->non_lazy_plt->plt_entry_size;
246
247               /* We also need to make an entry in the .got.plt section,
248                  which will be placed in the .got section by the linker
249                  script.  */
250               htab->elf.sgotplt->size += htab->got_entry_size;
251
252               /* There should be no PLT relocation against resolved
253                  undefined weak symbol in executable.  */
254               if (!resolved_to_zero)
255                 {
256                   /* We also need to make an entry in the .rel.plt
257                      section.  */
258                   htab->elf.srelplt->size += htab->sizeof_reloc;
259                   htab->elf.srelplt->reloc_count++;
260                 }
261             }
262
263           if (htab->target_os == is_vxworks && !bfd_link_pic (info))
264             {
265               /* VxWorks has a second set of relocations for each PLT entry
266                  in executables.  They go in a separate relocation section,
267                  which is processed by the kernel loader.  */
268
269               /* There are two relocations for the initial PLT entry: an
270                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
271                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
272
273               asection *srelplt2 = htab->srelplt2;
274               if (h->plt.offset == plt_entry_size)
275                 srelplt2->size += (htab->sizeof_reloc * 2);
276
277               /* There are two extra relocations for each subsequent PLT entry:
278                  an R_386_32 relocation for the GOT entry, and an R_386_32
279                  relocation for the PLT entry.  */
280
281               srelplt2->size += (htab->sizeof_reloc * 2);
282             }
283         }
284       else
285         {
286           eh->plt_got.offset = (bfd_vma) -1;
287           h->plt.offset = (bfd_vma) -1;
288           h->needs_plt = 0;
289         }
290     }
291   else
292     {
293       eh->plt_got.offset = (bfd_vma) -1;
294       h->plt.offset = (bfd_vma) -1;
295       h->needs_plt = 0;
296     }
297
298   eh->tlsdesc_got = (bfd_vma) -1;
299
300   /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
301      binary, make it a R_386_TLS_LE_32 requiring no TLS entry.  For
302      x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
303      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
304   if (h->got.refcount > 0
305       && bfd_link_executable (info)
306       && h->dynindx == -1
307       && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
308     h->got.offset = (bfd_vma) -1;
309   else if (h->got.refcount > 0)
310     {
311       asection *s;
312       bfd_boolean dyn;
313       int tls_type = elf_x86_hash_entry (h)->tls_type;
314
315       /* Make sure this symbol is output as a dynamic symbol.
316          Undefined weak syms won't yet be marked as dynamic.  */
317       if (h->dynindx == -1
318           && !h->forced_local
319           && !resolved_to_zero
320           && h->root.type == bfd_link_hash_undefweak)
321         {
322           if (! bfd_elf_link_record_dynamic_symbol (info, h))
323             return FALSE;
324         }
325
326       s = htab->elf.sgot;
327       if (GOT_TLS_GDESC_P (tls_type))
328         {
329           eh->tlsdesc_got = htab->elf.sgotplt->size
330             - elf_x86_compute_jump_table_size (htab);
331           htab->elf.sgotplt->size += 2 * htab->got_entry_size;
332           h->got.offset = (bfd_vma) -2;
333         }
334       if (! GOT_TLS_GDESC_P (tls_type)
335           || GOT_TLS_GD_P (tls_type))
336         {
337           h->got.offset = s->size;
338           s->size += htab->got_entry_size;
339           /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
340              slots.  */
341           if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
342             s->size += htab->got_entry_size;
343         }
344       dyn = htab->elf.dynamic_sections_created;
345       /* R_386_TLS_IE_32 needs one dynamic relocation,
346          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
347          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
348          need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
349          symbol and two if global.  No dynamic relocation against
350          resolved undefined weak symbol in executable.  */
351       if (tls_type == GOT_TLS_IE_BOTH)
352         htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
353       else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
354                || (tls_type & GOT_TLS_IE))
355         htab->elf.srelgot->size += htab->sizeof_reloc;
356       else if (GOT_TLS_GD_P (tls_type))
357         htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
358       else if (! GOT_TLS_GDESC_P (tls_type)
359                && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
360                     && !resolved_to_zero)
361                    || h->root.type != bfd_link_hash_undefweak)
362                && (bfd_link_pic (info)
363                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
364         htab->elf.srelgot->size += htab->sizeof_reloc;
365       if (GOT_TLS_GDESC_P (tls_type))
366         {
367           htab->elf.srelplt->size += htab->sizeof_reloc;
368           if (bed->target_id == X86_64_ELF_DATA)
369             htab->tlsdesc_plt = (bfd_vma) -1;
370         }
371     }
372   else
373     h->got.offset = (bfd_vma) -1;
374
375   if (eh->dyn_relocs == NULL)
376     return TRUE;
377
378   /* In the shared -Bsymbolic case, discard space allocated for
379      dynamic pc-relative relocs against symbols which turn out to be
380      defined in regular objects.  For the normal shared case, discard
381      space for pc-relative relocs that have become local due to symbol
382      visibility changes.  */
383
384   if (bfd_link_pic (info))
385     {
386       /* Relocs that use pc_count are those that appear on a call
387          insn, or certain REL relocs that can generated via assembly.
388          We want calls to protected symbols to resolve directly to the
389          function rather than going via the plt.  If people want
390          function pointer comparisons to work as expected then they
391          should avoid writing weird assembly.  */
392       if (SYMBOL_CALLS_LOCAL (info, h))
393         {
394           struct elf_dyn_relocs **pp;
395
396           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
397             {
398               p->count -= p->pc_count;
399               p->pc_count = 0;
400               if (p->count == 0)
401                 *pp = p->next;
402               else
403                 pp = &p->next;
404             }
405         }
406
407       if (htab->target_os == is_vxworks)
408         {
409           struct elf_dyn_relocs **pp;
410           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
411             {
412               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
413                 *pp = p->next;
414               else
415                 pp = &p->next;
416             }
417         }
418
419       /* Also discard relocs on undefined weak syms with non-default
420          visibility or in PIE.  */
421       if (eh->dyn_relocs != NULL)
422         {
423           if (h->root.type == bfd_link_hash_undefweak)
424             {
425               /* Undefined weak symbol is never bound locally in shared
426                  library.  */
427               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
428                   || resolved_to_zero)
429                 {
430                   if (bed->target_id == I386_ELF_DATA
431                       && h->non_got_ref)
432                     {
433                       /* Keep dynamic non-GOT/non-PLT relocation so
434                          that we can branch to 0 without PLT.  */
435                       struct elf_dyn_relocs **pp;
436
437                       for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
438                         if (p->pc_count == 0)
439                           *pp = p->next;
440                         else
441                           {
442                             /* Remove non-R_386_PC32 relocation.  */
443                             p->count = p->pc_count;
444                             pp = &p->next;
445                           }
446
447                       /* Make sure undefined weak symbols are output
448                          as dynamic symbols in PIEs for dynamic non-GOT
449                          non-PLT reloations.  */
450                       if (eh->dyn_relocs != NULL
451                           && !bfd_elf_link_record_dynamic_symbol (info, h))
452                         return FALSE;
453                     }
454                   else
455                     eh->dyn_relocs = NULL;
456                 }
457               else if (h->dynindx == -1
458                        && !h->forced_local
459                        && !bfd_elf_link_record_dynamic_symbol (info, h))
460                 return FALSE;
461             }
462           else if (bfd_link_executable (info)
463                    && (h->needs_copy || eh->needs_copy)
464                    && h->def_dynamic
465                    && !h->def_regular)
466             {
467               /* NB: needs_copy is set only for x86-64.  For PIE,
468                  discard space for pc-relative relocs against symbols
469                  which turn out to need copy relocs.  */
470               struct elf_dyn_relocs **pp;
471
472               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
473                 {
474                   if (p->pc_count != 0)
475                     *pp = p->next;
476                   else
477                     pp = &p->next;
478                 }
479             }
480         }
481     }
482   else if (ELIMINATE_COPY_RELOCS)
483     {
484       /* For the non-shared case, discard space for relocs against
485          symbols which turn out to need copy relocs or are not
486          dynamic.  Keep dynamic relocations for run-time function
487          pointer initialization.  */
488
489       if ((!h->non_got_ref
490            || (h->root.type == bfd_link_hash_undefweak
491                && !resolved_to_zero))
492           && ((h->def_dynamic
493                && !h->def_regular)
494               || (htab->elf.dynamic_sections_created
495                   && (h->root.type == bfd_link_hash_undefweak
496                       || h->root.type == bfd_link_hash_undefined))))
497         {
498           /* Make sure this symbol is output as a dynamic symbol.
499              Undefined weak syms won't yet be marked as dynamic.  */
500           if (h->dynindx == -1
501               && !h->forced_local
502               && !resolved_to_zero
503               && h->root.type == bfd_link_hash_undefweak
504               && ! bfd_elf_link_record_dynamic_symbol (info, h))
505             return FALSE;
506
507           /* If that succeeded, we know we'll be keeping all the
508              relocs.  */
509           if (h->dynindx != -1)
510             goto keep;
511         }
512
513       eh->dyn_relocs = NULL;
514
515     keep: ;
516     }
517
518   /* Finally, allocate space.  */
519   for (p = eh->dyn_relocs; p != NULL; p = p->next)
520     {
521       asection *sreloc;
522
523       sreloc = elf_section_data (p->sec)->sreloc;
524
525       BFD_ASSERT (sreloc != NULL);
526       sreloc->size += p->count * htab->sizeof_reloc;
527     }
528
529   return TRUE;
530 }
531
532 /* Find dynamic relocs for H that apply to read-only sections.  */
533
534 static asection *
535 readonly_dynrelocs (struct elf_link_hash_entry *h)
536 {
537   struct elf_dyn_relocs *p;
538
539   for (p = elf_x86_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
540     {
541       asection *s = p->sec->output_section;
542
543       if (s != NULL && (s->flags & SEC_READONLY) != 0)
544         return p->sec;
545     }
546   return NULL;
547 }
548
549 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
550    read-only sections.  */
551
552 static bfd_boolean
553 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
554 {
555   asection *sec;
556
557   if (h->root.type == bfd_link_hash_indirect)
558     return TRUE;
559
560   /* Skip local IFUNC symbols. */
561   if (h->forced_local && h->type == STT_GNU_IFUNC)
562     return TRUE;
563
564   sec = readonly_dynrelocs (h);
565   if (sec != NULL)
566     {
567       struct bfd_link_info *info = (struct bfd_link_info *) inf;
568
569       info->flags |= DF_TEXTREL;
570       /* xgettext:c-format */
571       info->callbacks->minfo (_("%pB: dynamic relocation against `%pT' "
572                                 "in read-only section `%pA'\n"),
573                               sec->owner, h->root.root.string, sec);
574
575       if ((info->warn_shared_textrel && bfd_link_pic (info))
576           || info->error_textrel)
577         /* xgettext:c-format */
578         info->callbacks->einfo (_("%P: %pB: warning: relocation against `%s' "
579                                   "in read-only section `%pA'\n"),
580                                 sec->owner, h->root.root.string, sec);
581
582       /* Not an error, just cut short the traversal.  */
583       return FALSE;
584     }
585   return TRUE;
586 }
587
588 /* Allocate space in .plt, .got and associated reloc sections for
589    local dynamic relocs.  */
590
591 static bfd_boolean
592 elf_x86_allocate_local_dynreloc (void **slot, void *inf)
593 {
594   struct elf_link_hash_entry *h
595     = (struct elf_link_hash_entry *) *slot;
596
597   if (h->type != STT_GNU_IFUNC
598       || !h->def_regular
599       || !h->ref_regular
600       || !h->forced_local
601       || h->root.type != bfd_link_hash_defined)
602     abort ();
603
604   return elf_x86_allocate_dynrelocs (h, inf);
605 }
606
607 /* Find and/or create a hash entry for local symbol.  */
608
609 struct elf_link_hash_entry *
610 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
611                                  bfd *abfd, const Elf_Internal_Rela *rel,
612                                  bfd_boolean create)
613 {
614   struct elf_x86_link_hash_entry e, *ret;
615   asection *sec = abfd->sections;
616   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
617                                        htab->r_sym (rel->r_info));
618   void **slot;
619
620   e.elf.indx = sec->id;
621   e.elf.dynstr_index = htab->r_sym (rel->r_info);
622   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
623                                    create ? INSERT : NO_INSERT);
624
625   if (!slot)
626     return NULL;
627
628   if (*slot)
629     {
630       ret = (struct elf_x86_link_hash_entry *) *slot;
631       return &ret->elf;
632     }
633
634   ret = (struct elf_x86_link_hash_entry *)
635         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
636                         sizeof (struct elf_x86_link_hash_entry));
637   if (ret)
638     {
639       memset (ret, 0, sizeof (*ret));
640       ret->elf.indx = sec->id;
641       ret->elf.dynstr_index = htab->r_sym (rel->r_info);
642       ret->elf.dynindx = -1;
643       ret->plt_got.offset = (bfd_vma) -1;
644       *slot = ret;
645     }
646   return &ret->elf;
647 }
648
649 /* Create an entry in a x86 ELF linker hash table.  NB: THIS MUST BE IN
650    SYNC WITH _bfd_elf_link_hash_newfunc.  */
651
652 struct bfd_hash_entry *
653 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
654                                 struct bfd_hash_table *table,
655                                 const char *string)
656 {
657   /* Allocate the structure if it has not already been allocated by a
658      subclass.  */
659   if (entry == NULL)
660     {
661       entry = (struct bfd_hash_entry *)
662         bfd_hash_allocate (table,
663                            sizeof (struct elf_x86_link_hash_entry));
664       if (entry == NULL)
665         return entry;
666     }
667
668   /* Call the allocation method of the superclass.  */
669   entry = _bfd_link_hash_newfunc (entry, table, string);
670   if (entry != NULL)
671     {
672       struct elf_x86_link_hash_entry *eh
673        = (struct elf_x86_link_hash_entry *) entry;
674       struct elf_link_hash_table *htab
675         = (struct elf_link_hash_table *) table;
676
677       memset (&eh->elf.size, 0,
678               (sizeof (struct elf_x86_link_hash_entry)
679                - offsetof (struct elf_link_hash_entry, size)));
680       /* Set local fields.  */
681       eh->elf.indx = -1;
682       eh->elf.dynindx = -1;
683       eh->elf.got = htab->init_got_refcount;
684       eh->elf.plt = htab->init_plt_refcount;
685       /* Assume that we have been called by a non-ELF symbol reader.
686          This flag is then reset by the code which reads an ELF input
687          file.  This ensures that a symbol created by a non-ELF symbol
688          reader will have the flag set correctly.  */
689       eh->elf.non_elf = 1;
690       eh->plt_second.offset = (bfd_vma) -1;
691       eh->plt_got.offset = (bfd_vma) -1;
692       eh->tlsdesc_got = (bfd_vma) -1;
693       eh->zero_undefweak = 1;
694     }
695
696   return entry;
697 }
698
699 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
700   for local symbol so that we can handle local STT_GNU_IFUNC symbols
701   as global symbol.  We reuse indx and dynstr_index for local symbol
702   hash since they aren't used by global symbols in this backend.  */
703
704 hashval_t
705 _bfd_x86_elf_local_htab_hash (const void *ptr)
706 {
707   struct elf_link_hash_entry *h
708     = (struct elf_link_hash_entry *) ptr;
709   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
710 }
711
712 /* Compare local hash entries.  */
713
714 int
715 _bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
716 {
717   struct elf_link_hash_entry *h1
718      = (struct elf_link_hash_entry *) ptr1;
719   struct elf_link_hash_entry *h2
720     = (struct elf_link_hash_entry *) ptr2;
721
722   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
723 }
724
725 /* Destroy an x86 ELF linker hash table.  */
726
727 static void
728 elf_x86_link_hash_table_free (bfd *obfd)
729 {
730   struct elf_x86_link_hash_table *htab
731     = (struct elf_x86_link_hash_table *) obfd->link.hash;
732
733   if (htab->loc_hash_table)
734     htab_delete (htab->loc_hash_table);
735   if (htab->loc_hash_memory)
736     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
737   _bfd_elf_link_hash_table_free (obfd);
738 }
739
740 static bfd_boolean
741 elf_i386_is_reloc_section (const char *secname)
742 {
743   return CONST_STRNEQ (secname, ".rel");
744 }
745
746 static bfd_boolean
747 elf_x86_64_is_reloc_section (const char *secname)
748 {
749   return CONST_STRNEQ (secname, ".rela");
750 }
751
752 /* Create an x86 ELF linker hash table.  */
753
754 struct bfd_link_hash_table *
755 _bfd_x86_elf_link_hash_table_create (bfd *abfd)
756 {
757   struct elf_x86_link_hash_table *ret;
758   const struct elf_backend_data *bed;
759   bfd_size_type amt = sizeof (struct elf_x86_link_hash_table);
760
761   ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
762   if (ret == NULL)
763     return NULL;
764
765   bed = get_elf_backend_data (abfd);
766   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
767                                       _bfd_x86_elf_link_hash_newfunc,
768                                       sizeof (struct elf_x86_link_hash_entry),
769                                       bed->target_id))
770     {
771       free (ret);
772       return NULL;
773     }
774
775   if (bed->target_id == X86_64_ELF_DATA)
776     {
777       ret->is_reloc_section = elf_x86_64_is_reloc_section;
778       ret->dt_reloc = DT_RELA;
779       ret->dt_reloc_sz = DT_RELASZ;
780       ret->dt_reloc_ent = DT_RELAENT;
781       ret->got_entry_size = 8;
782       ret->pcrel_plt = TRUE;
783       ret->tls_get_addr = "__tls_get_addr";
784     }
785   if (ABI_64_P (abfd))
786     {
787       ret->sizeof_reloc = sizeof (Elf64_External_Rela);
788       ret->pointer_r_type = R_X86_64_64;
789       ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
790       ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
791     }
792   else
793     {
794       if (bed->target_id == X86_64_ELF_DATA)
795         {
796           ret->sizeof_reloc = sizeof (Elf32_External_Rela);
797           ret->pointer_r_type = R_X86_64_32;
798           ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
799           ret->dynamic_interpreter_size
800             = sizeof ELFX32_DYNAMIC_INTERPRETER;
801         }
802       else
803         {
804           ret->is_reloc_section = elf_i386_is_reloc_section;
805           ret->dt_reloc = DT_REL;
806           ret->dt_reloc_sz = DT_RELSZ;
807           ret->dt_reloc_ent = DT_RELENT;
808           ret->sizeof_reloc = sizeof (Elf32_External_Rel);
809           ret->got_entry_size = 4;
810           ret->pcrel_plt = FALSE;
811           ret->pointer_r_type = R_386_32;
812           ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
813           ret->dynamic_interpreter_size
814             = sizeof ELF32_DYNAMIC_INTERPRETER;
815           ret->tls_get_addr = "___tls_get_addr";
816         }
817     }
818   ret->target_id = bed->target_id;
819   ret->target_os = get_elf_x86_backend_data (abfd)->target_os;
820
821   ret->loc_hash_table = htab_try_create (1024,
822                                          _bfd_x86_elf_local_htab_hash,
823                                          _bfd_x86_elf_local_htab_eq,
824                                          NULL);
825   ret->loc_hash_memory = objalloc_create ();
826   if (!ret->loc_hash_table || !ret->loc_hash_memory)
827     {
828       elf_x86_link_hash_table_free (abfd);
829       return NULL;
830     }
831   ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
832
833   return &ret->elf.root;
834 }
835
836 /* Sort relocs into address order.  */
837
838 int
839 _bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
840 {
841   const arelent *a = * (const arelent **) ap;
842   const arelent *b = * (const arelent **) bp;
843
844   if (a->address > b->address)
845     return 1;
846   else if (a->address < b->address)
847     return -1;
848   else
849     return 0;
850 }
851
852 /* Mark symbol, NAME, as locally defined by linker if it is referenced
853    and not defined in a relocatable object file.  */
854
855 static void
856 elf_x86_linker_defined (struct bfd_link_info *info, const char *name)
857 {
858   struct elf_link_hash_entry *h;
859
860   h = elf_link_hash_lookup (elf_hash_table (info), name,
861                             FALSE, FALSE, FALSE);
862   if (h == NULL)
863     return;
864
865   while (h->root.type == bfd_link_hash_indirect)
866     h = (struct elf_link_hash_entry *) h->root.u.i.link;
867
868   if (h->root.type == bfd_link_hash_new
869       || h->root.type == bfd_link_hash_undefined
870       || h->root.type == bfd_link_hash_undefweak
871       || h->root.type == bfd_link_hash_common
872       || (!h->def_regular && h->def_dynamic))
873     {
874       elf_x86_hash_entry (h)->local_ref = 2;
875       elf_x86_hash_entry (h)->linker_def = 1;
876     }
877 }
878
879 /* Hide a linker-defined symbol, NAME, with hidden visibility.  */
880
881 static void
882 elf_x86_hide_linker_defined (struct bfd_link_info *info,
883                              const char *name)
884 {
885   struct elf_link_hash_entry *h;
886
887   h = elf_link_hash_lookup (elf_hash_table (info), name,
888                             FALSE, FALSE, FALSE);
889   if (h == NULL)
890     return;
891
892   while (h->root.type == bfd_link_hash_indirect)
893     h = (struct elf_link_hash_entry *) h->root.u.i.link;
894
895   if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
896       || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
897     _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
898 }
899
900 bfd_boolean
901 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
902 {
903   if (!bfd_link_relocatable (info))
904     {
905       /* Check for __tls_get_addr reference.  */
906       struct elf_x86_link_hash_table *htab;
907       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
908       htab = elf_x86_hash_table (info, bed->target_id);
909       if (htab)
910         {
911           struct elf_link_hash_entry *h;
912
913           h = elf_link_hash_lookup (elf_hash_table (info),
914                                     htab->tls_get_addr,
915                                     FALSE, FALSE, FALSE);
916           if (h != NULL)
917             {
918               elf_x86_hash_entry (h)->tls_get_addr = 1;
919
920               /* Check the versioned __tls_get_addr symbol.  */
921               while (h->root.type == bfd_link_hash_indirect)
922                 {
923                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
924                   elf_x86_hash_entry (h)->tls_get_addr = 1;
925                 }
926             }
927
928           /* "__ehdr_start" will be defined by linker as a hidden symbol
929              later if it is referenced and not defined.  */
930           elf_x86_linker_defined (info, "__ehdr_start");
931
932           if (bfd_link_executable (info))
933             {
934               /* References to __bss_start, _end and _edata should be
935                  locally resolved within executables.  */
936               elf_x86_linker_defined (info, "__bss_start");
937               elf_x86_linker_defined (info, "_end");
938               elf_x86_linker_defined (info, "_edata");
939             }
940           else
941             {
942               /* Hide hidden __bss_start, _end and _edata in shared
943                  libraries.  */
944               elf_x86_hide_linker_defined (info, "__bss_start");
945               elf_x86_hide_linker_defined (info, "_end");
946               elf_x86_hide_linker_defined (info, "_edata");
947             }
948         }
949     }
950
951   /* Invoke the regular ELF backend linker to do all the work.  */
952   return _bfd_elf_link_check_relocs (abfd, info);
953 }
954
955 /* Set the sizes of the dynamic sections.  */
956
957 bfd_boolean
958 _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd,
959                                     struct bfd_link_info *info)
960 {
961   struct elf_x86_link_hash_table *htab;
962   bfd *dynobj;
963   asection *s;
964   bfd_boolean relocs;
965   bfd *ibfd;
966   const struct elf_backend_data *bed
967     = get_elf_backend_data (output_bfd);
968
969   htab = elf_x86_hash_table (info, bed->target_id);
970   if (htab == NULL)
971     return FALSE;
972   dynobj = htab->elf.dynobj;
973   if (dynobj == NULL)
974     abort ();
975
976   /* Set up .got offsets for local syms, and space for local dynamic
977      relocs.  */
978   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
979     {
980       bfd_signed_vma *local_got;
981       bfd_signed_vma *end_local_got;
982       char *local_tls_type;
983       bfd_vma *local_tlsdesc_gotent;
984       bfd_size_type locsymcount;
985       Elf_Internal_Shdr *symtab_hdr;
986       asection *srel;
987
988       if (! is_x86_elf (ibfd, htab))
989         continue;
990
991       for (s = ibfd->sections; s != NULL; s = s->next)
992         {
993           struct elf_dyn_relocs *p;
994
995           for (p = ((struct elf_dyn_relocs *)
996                      elf_section_data (s)->local_dynrel);
997                p != NULL;
998                p = p->next)
999             {
1000               if (!bfd_is_abs_section (p->sec)
1001                   && bfd_is_abs_section (p->sec->output_section))
1002                 {
1003                   /* Input section has been discarded, either because
1004                      it is a copy of a linkonce section or due to
1005                      linker script /DISCARD/, so we'll be discarding
1006                      the relocs too.  */
1007                 }
1008               else if (htab->target_os == is_vxworks
1009                        && strcmp (p->sec->output_section->name,
1010                                   ".tls_vars") == 0)
1011                 {
1012                   /* Relocations in vxworks .tls_vars sections are
1013                      handled specially by the loader.  */
1014                 }
1015               else if (p->count != 0)
1016                 {
1017                   srel = elf_section_data (p->sec)->sreloc;
1018                   srel->size += p->count * htab->sizeof_reloc;
1019                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
1020                       && (info->flags & DF_TEXTREL) == 0)
1021                     {
1022                       info->flags |= DF_TEXTREL;
1023                       if ((info->warn_shared_textrel && bfd_link_pic (info))
1024                           || info->error_textrel)
1025                         /* xgettext:c-format */
1026                         info->callbacks->einfo
1027                           (_("%P: %pB: warning: relocation "
1028                              "in read-only section `%pA'\n"),
1029                            p->sec->owner, p->sec);
1030                     }
1031                 }
1032             }
1033         }
1034
1035       local_got = elf_local_got_refcounts (ibfd);
1036       if (!local_got)
1037         continue;
1038
1039       symtab_hdr = &elf_symtab_hdr (ibfd);
1040       locsymcount = symtab_hdr->sh_info;
1041       end_local_got = local_got + locsymcount;
1042       local_tls_type = elf_x86_local_got_tls_type (ibfd);
1043       local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
1044       s = htab->elf.sgot;
1045       srel = htab->elf.srelgot;
1046       for (; local_got < end_local_got;
1047            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1048         {
1049           *local_tlsdesc_gotent = (bfd_vma) -1;
1050           if (*local_got > 0)
1051             {
1052               if (GOT_TLS_GDESC_P (*local_tls_type))
1053                 {
1054                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
1055                     - elf_x86_compute_jump_table_size (htab);
1056                   htab->elf.sgotplt->size += 2 * htab->got_entry_size;
1057                   *local_got = (bfd_vma) -2;
1058                 }
1059               if (! GOT_TLS_GDESC_P (*local_tls_type)
1060                   || GOT_TLS_GD_P (*local_tls_type))
1061                 {
1062                   *local_got = s->size;
1063                   s->size += htab->got_entry_size;
1064                   if (GOT_TLS_GD_P (*local_tls_type)
1065                       || *local_tls_type == GOT_TLS_IE_BOTH)
1066                     s->size += htab->got_entry_size;
1067                 }
1068               if (bfd_link_pic (info)
1069                   || GOT_TLS_GD_ANY_P (*local_tls_type)
1070                   || (*local_tls_type & GOT_TLS_IE))
1071                 {
1072                   if (*local_tls_type == GOT_TLS_IE_BOTH)
1073                     srel->size += 2 * htab->sizeof_reloc;
1074                   else if (GOT_TLS_GD_P (*local_tls_type)
1075                            || ! GOT_TLS_GDESC_P (*local_tls_type))
1076                     srel->size += htab->sizeof_reloc;
1077                   if (GOT_TLS_GDESC_P (*local_tls_type))
1078                     {
1079                       htab->elf.srelplt->size += htab->sizeof_reloc;
1080                       if (bed->target_id == X86_64_ELF_DATA)
1081                         htab->tlsdesc_plt = (bfd_vma) -1;
1082                     }
1083                 }
1084             }
1085           else
1086             *local_got = (bfd_vma) -1;
1087         }
1088     }
1089
1090   if (htab->tls_ld_or_ldm_got.refcount > 0)
1091     {
1092       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1093          or R_X86_64_TLSLD relocs.  */
1094       htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
1095       htab->elf.sgot->size += 2 * htab->got_entry_size;
1096       htab->elf.srelgot->size += htab->sizeof_reloc;
1097     }
1098   else
1099     htab->tls_ld_or_ldm_got.offset = -1;
1100
1101   /* Allocate global sym .plt and .got entries, and space for global
1102      sym dynamic relocs.  */
1103   elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
1104                           info);
1105
1106   /* Allocate .plt and .got entries, and space for local symbols.  */
1107   htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
1108                  info);
1109
1110   /* For every jump slot reserved in the sgotplt, reloc_count is
1111      incremented.  However, when we reserve space for TLS descriptors,
1112      it's not incremented, so in order to compute the space reserved
1113      for them, it suffices to multiply the reloc count by the jump
1114      slot size.
1115
1116      PR ld/13302: We start next_irelative_index at the end of .rela.plt
1117      so that R_{386,X86_64}_IRELATIVE entries come last.  */
1118   if (htab->elf.srelplt)
1119     {
1120       htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
1121       htab->sgotplt_jump_table_size
1122         = elf_x86_compute_jump_table_size (htab);
1123       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
1124     }
1125   else if (htab->elf.irelplt)
1126     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
1127
1128   if (htab->tlsdesc_plt)
1129     {
1130       /* NB: tlsdesc_plt is set only for x86-64.  If we're not using
1131          lazy TLS relocations, don't generate the PLT and GOT entries
1132          they require.  */
1133       if ((info->flags & DF_BIND_NOW))
1134         htab->tlsdesc_plt = 0;
1135       else
1136         {
1137           htab->tlsdesc_got = htab->elf.sgot->size;
1138           htab->elf.sgot->size += htab->got_entry_size;
1139           /* Reserve room for the initial entry.
1140              FIXME: we could probably do away with it in this case.  */
1141           if (htab->elf.splt->size == 0)
1142             htab->elf.splt->size = htab->plt.plt_entry_size;
1143           htab->tlsdesc_plt = htab->elf.splt->size;
1144           htab->elf.splt->size += htab->plt.plt_entry_size;
1145         }
1146     }
1147
1148   if (htab->elf.sgotplt)
1149     {
1150       /* Don't allocate .got.plt section if there are no GOT nor PLT
1151          entries and there is no reference to _GLOBAL_OFFSET_TABLE_.  */
1152       if ((htab->elf.hgot == NULL
1153            || !htab->got_referenced)
1154           && (htab->elf.sgotplt->size == bed->got_header_size)
1155           && (htab->elf.splt == NULL
1156               || htab->elf.splt->size == 0)
1157           && (htab->elf.sgot == NULL
1158               || htab->elf.sgot->size == 0)
1159           && (htab->elf.iplt == NULL
1160               || htab->elf.iplt->size == 0)
1161           && (htab->elf.igotplt == NULL
1162               || htab->elf.igotplt->size == 0))
1163         {
1164           htab->elf.sgotplt->size = 0;
1165           /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
1166              isn't used.  */
1167           if (htab->elf.hgot != NULL && htab->target_os != is_solaris)
1168             {
1169               /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
1170                  table. */
1171               htab->elf.hgot->root.type = bfd_link_hash_undefined;
1172               htab->elf.hgot->root.u.undef.abfd
1173                 = htab->elf.hgot->root.u.def.section->owner;
1174               htab->elf.hgot->root.linker_def = 0;
1175               htab->elf.hgot->ref_regular = 0;
1176               htab->elf.hgot->def_regular = 0;
1177             }
1178         }
1179     }
1180
1181   if (_bfd_elf_eh_frame_present (info))
1182     {
1183       if (htab->plt_eh_frame != NULL
1184           && htab->elf.splt != NULL
1185           && htab->elf.splt->size != 0
1186           && !bfd_is_abs_section (htab->elf.splt->output_section))
1187         htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
1188
1189       if (htab->plt_got_eh_frame != NULL
1190           && htab->plt_got != NULL
1191           && htab->plt_got->size != 0
1192           && !bfd_is_abs_section (htab->plt_got->output_section))
1193         htab->plt_got_eh_frame->size
1194           = htab->non_lazy_plt->eh_frame_plt_size;
1195
1196       /* Unwind info for the second PLT and .plt.got sections are
1197          identical.  */
1198       if (htab->plt_second_eh_frame != NULL
1199           && htab->plt_second != NULL
1200           && htab->plt_second->size != 0
1201           && !bfd_is_abs_section (htab->plt_second->output_section))
1202         htab->plt_second_eh_frame->size
1203           = htab->non_lazy_plt->eh_frame_plt_size;
1204     }
1205
1206   /* We now have determined the sizes of the various dynamic sections.
1207      Allocate memory for them.  */
1208   relocs = FALSE;
1209   for (s = dynobj->sections; s != NULL; s = s->next)
1210     {
1211       bfd_boolean strip_section = TRUE;
1212
1213       if ((s->flags & SEC_LINKER_CREATED) == 0)
1214         continue;
1215
1216       if (s == htab->elf.splt
1217           || s == htab->elf.sgot)
1218         {
1219           /* Strip this section if we don't need it; see the
1220              comment below.  */
1221           /* We'd like to strip these sections if they aren't needed, but if
1222              we've exported dynamic symbols from them we must leave them.
1223              It's too late to tell BFD to get rid of the symbols.  */
1224
1225           if (htab->elf.hplt != NULL)
1226             strip_section = FALSE;
1227         }
1228       else if (s == htab->elf.sgotplt
1229                || s == htab->elf.iplt
1230                || s == htab->elf.igotplt
1231                || s == htab->plt_second
1232                || s == htab->plt_got
1233                || s == htab->plt_eh_frame
1234                || s == htab->plt_got_eh_frame
1235                || s == htab->plt_second_eh_frame
1236                || s == htab->elf.sdynbss
1237                || s == htab->elf.sdynrelro)
1238         {
1239           /* Strip these too.  */
1240         }
1241       else if (htab->is_reloc_section (bfd_get_section_name (dynobj, s)))
1242         {
1243           if (s->size != 0
1244               && s != htab->elf.srelplt
1245               && s != htab->srelplt2)
1246             relocs = TRUE;
1247
1248           /* We use the reloc_count field as a counter if we need
1249              to copy relocs into the output file.  */
1250           if (s != htab->elf.srelplt)
1251             s->reloc_count = 0;
1252         }
1253       else
1254         {
1255           /* It's not one of our sections, so don't allocate space.  */
1256           continue;
1257         }
1258
1259       if (s->size == 0)
1260         {
1261           /* If we don't need this section, strip it from the
1262              output file.  This is mostly to handle .rel.bss and
1263              .rel.plt.  We must create both sections in
1264              create_dynamic_sections, because they must be created
1265              before the linker maps input sections to output
1266              sections.  The linker does that before
1267              adjust_dynamic_symbol is called, and it is that
1268              function which decides whether anything needs to go
1269              into these sections.  */
1270           if (strip_section)
1271             s->flags |= SEC_EXCLUDE;
1272           continue;
1273         }
1274
1275       if ((s->flags & SEC_HAS_CONTENTS) == 0)
1276         continue;
1277
1278       /* NB: Initially, the iplt section has minimal alignment to
1279          avoid moving dot of the following section backwards when
1280          it is empty.  Update its section alignment now since it
1281          is non-empty.  */
1282       if (s == htab->elf.iplt)
1283         bfd_set_section_alignment (s->owner, s,
1284                                    htab->plt.iplt_alignment);
1285
1286       /* Allocate memory for the section contents.  We use bfd_zalloc
1287          here in case unused entries are not reclaimed before the
1288          section's contents are written out.  This should not happen,
1289          but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1290          reloc instead of garbage.  */
1291       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
1292       if (s->contents == NULL)
1293         return FALSE;
1294     }
1295
1296   if (htab->plt_eh_frame != NULL
1297       && htab->plt_eh_frame->contents != NULL)
1298     {
1299       memcpy (htab->plt_eh_frame->contents,
1300               htab->plt.eh_frame_plt,
1301               htab->plt_eh_frame->size);
1302       bfd_put_32 (dynobj, htab->elf.splt->size,
1303                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
1304     }
1305
1306   if (htab->plt_got_eh_frame != NULL
1307       && htab->plt_got_eh_frame->contents != NULL)
1308     {
1309       memcpy (htab->plt_got_eh_frame->contents,
1310               htab->non_lazy_plt->eh_frame_plt,
1311               htab->plt_got_eh_frame->size);
1312       bfd_put_32 (dynobj, htab->plt_got->size,
1313                   (htab->plt_got_eh_frame->contents
1314                    + PLT_FDE_LEN_OFFSET));
1315     }
1316
1317   if (htab->plt_second_eh_frame != NULL
1318       && htab->plt_second_eh_frame->contents != NULL)
1319     {
1320       memcpy (htab->plt_second_eh_frame->contents,
1321               htab->non_lazy_plt->eh_frame_plt,
1322               htab->plt_second_eh_frame->size);
1323       bfd_put_32 (dynobj, htab->plt_second->size,
1324                   (htab->plt_second_eh_frame->contents
1325                    + PLT_FDE_LEN_OFFSET));
1326     }
1327
1328   if (htab->elf.dynamic_sections_created)
1329     {
1330       /* Add some entries to the .dynamic section.  We fill in the
1331          values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1332          but we must add the entries now so that we get the correct
1333          size for the .dynamic section.  The DT_DEBUG entry is filled
1334          in by the dynamic linker and used by the debugger.  */
1335 #define add_dynamic_entry(TAG, VAL) \
1336   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1337
1338       if (bfd_link_executable (info))
1339         {
1340           if (!add_dynamic_entry (DT_DEBUG, 0))
1341             return FALSE;
1342         }
1343
1344       if (htab->elf.splt->size != 0)
1345         {
1346           /* DT_PLTGOT is used by prelink even if there is no PLT
1347              relocation.  */
1348           if (!add_dynamic_entry (DT_PLTGOT, 0))
1349             return FALSE;
1350         }
1351
1352       if (htab->elf.srelplt->size != 0)
1353         {
1354           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1355               || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc)
1356               || !add_dynamic_entry (DT_JMPREL, 0))
1357             return FALSE;
1358         }
1359
1360       if (htab->tlsdesc_plt
1361           && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
1362               || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
1363         return FALSE;
1364
1365       if (relocs)
1366         {
1367           if (!add_dynamic_entry (htab->dt_reloc, 0)
1368               || !add_dynamic_entry (htab->dt_reloc_sz, 0)
1369               || !add_dynamic_entry (htab->dt_reloc_ent,
1370                                      htab->sizeof_reloc))
1371             return FALSE;
1372
1373           /* If any dynamic relocs apply to a read-only section,
1374              then we need a DT_TEXTREL entry.  */
1375           if ((info->flags & DF_TEXTREL) == 0)
1376             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
1377
1378           if ((info->flags & DF_TEXTREL) != 0)
1379             {
1380               if (htab->readonly_dynrelocs_against_ifunc)
1381                 {
1382                   info->callbacks->einfo
1383                     (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1384                        " recompile with %s\n"),
1385                      bfd_link_dll (info) ? "-fPIC" : "-fPIE");
1386                   bfd_set_error (bfd_error_bad_value);
1387                   return FALSE;
1388                 }
1389
1390               if (!add_dynamic_entry (DT_TEXTREL, 0))
1391                 return FALSE;
1392             }
1393         }
1394       if (htab->target_os == is_vxworks
1395           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
1396         return FALSE;
1397     }
1398 #undef add_dynamic_entry
1399
1400   return TRUE;
1401 }
1402
1403 /* Finish up the x86 dynamic sections.  */
1404
1405 struct elf_x86_link_hash_table *
1406 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
1407                                       struct bfd_link_info *info)
1408 {
1409   struct elf_x86_link_hash_table *htab;
1410   const struct elf_backend_data *bed;
1411   bfd *dynobj;
1412   asection *sdyn;
1413   bfd_byte *dyncon, *dynconend;
1414   bfd_size_type sizeof_dyn;
1415
1416   bed = get_elf_backend_data (output_bfd);
1417   htab = elf_x86_hash_table (info, bed->target_id);
1418   if (htab == NULL)
1419     return htab;
1420
1421   dynobj = htab->elf.dynobj;
1422   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1423
1424   /* GOT is always created in setup_gnu_properties.  But it may not be
1425      needed.  .got.plt section may be needed for static IFUNC.  */
1426   if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
1427     {
1428       bfd_vma dynamic_addr;
1429
1430       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
1431         {
1432           _bfd_error_handler
1433             (_("discarded output section: `%pA'"), htab->elf.sgotplt);
1434           return NULL;
1435         }
1436
1437       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
1438         = htab->got_entry_size;
1439
1440       dynamic_addr = (sdyn == NULL
1441                       ? (bfd_vma) 0
1442                       : sdyn->output_section->vma + sdyn->output_offset);
1443
1444       /* Set the first entry in the global offset table to the address
1445          of the dynamic section.  Write GOT[1] and GOT[2], needed for
1446          the dynamic linker.  */
1447       if (htab->got_entry_size == 8)
1448         {
1449           bfd_put_64 (output_bfd, dynamic_addr,
1450                       htab->elf.sgotplt->contents);
1451           bfd_put_64 (output_bfd, (bfd_vma) 0,
1452                       htab->elf.sgotplt->contents + 8);
1453           bfd_put_64 (output_bfd, (bfd_vma) 0,
1454                       htab->elf.sgotplt->contents + 8*2);
1455         }
1456       else
1457         {
1458           bfd_put_32 (output_bfd, dynamic_addr,
1459                       htab->elf.sgotplt->contents);
1460           bfd_put_32 (output_bfd, 0,
1461                       htab->elf.sgotplt->contents + 4);
1462           bfd_put_32 (output_bfd, 0,
1463                       htab->elf.sgotplt->contents + 4*2);
1464         }
1465     }
1466
1467   if (!htab->elf.dynamic_sections_created)
1468     return htab;
1469
1470   if (sdyn == NULL || htab->elf.sgot == NULL)
1471     abort ();
1472
1473   sizeof_dyn = bed->s->sizeof_dyn;
1474   dyncon = sdyn->contents;
1475   dynconend = sdyn->contents + sdyn->size;
1476   for (; dyncon < dynconend; dyncon += sizeof_dyn)
1477     {
1478       Elf_Internal_Dyn dyn;
1479       asection *s;
1480
1481       (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
1482
1483       switch (dyn.d_tag)
1484         {
1485         default:
1486           if (htab->target_os == is_vxworks
1487               && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
1488             break;
1489           continue;
1490
1491         case DT_PLTGOT:
1492           s = htab->elf.sgotplt;
1493           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1494           break;
1495
1496         case DT_JMPREL:
1497           dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
1498           break;
1499
1500         case DT_PLTRELSZ:
1501           s = htab->elf.srelplt->output_section;
1502           dyn.d_un.d_val = s->size;
1503           break;
1504
1505         case DT_TLSDESC_PLT:
1506           s = htab->elf.splt;
1507           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1508             + htab->tlsdesc_plt;
1509           break;
1510
1511         case DT_TLSDESC_GOT:
1512           s = htab->elf.sgot;
1513           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1514             + htab->tlsdesc_got;
1515           break;
1516         }
1517
1518       (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
1519     }
1520
1521   if (htab->plt_got != NULL && htab->plt_got->size > 0)
1522     elf_section_data (htab->plt_got->output_section)
1523       ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1524
1525   if (htab->plt_second != NULL && htab->plt_second->size > 0)
1526     elf_section_data (htab->plt_second->output_section)
1527       ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1528
1529   /* Adjust .eh_frame for .plt section.  */
1530   if (htab->plt_eh_frame != NULL
1531       && htab->plt_eh_frame->contents != NULL)
1532     {
1533       if (htab->elf.splt != NULL
1534           && htab->elf.splt->size != 0
1535           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
1536           && htab->elf.splt->output_section != NULL
1537           && htab->plt_eh_frame->output_section != NULL)
1538         {
1539           bfd_vma plt_start = htab->elf.splt->output_section->vma;
1540           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
1541                                    + htab->plt_eh_frame->output_offset
1542                                    + PLT_FDE_START_OFFSET;
1543           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1544                              htab->plt_eh_frame->contents
1545                              + PLT_FDE_START_OFFSET);
1546         }
1547
1548       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1549         {
1550           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1551                                                  htab->plt_eh_frame,
1552                                                  htab->plt_eh_frame->contents))
1553             return NULL;
1554         }
1555     }
1556
1557   /* Adjust .eh_frame for .plt.got section.  */
1558   if (htab->plt_got_eh_frame != NULL
1559       && htab->plt_got_eh_frame->contents != NULL)
1560     {
1561       if (htab->plt_got != NULL
1562           && htab->plt_got->size != 0
1563           && (htab->plt_got->flags & SEC_EXCLUDE) == 0
1564           && htab->plt_got->output_section != NULL
1565           && htab->plt_got_eh_frame->output_section != NULL)
1566         {
1567           bfd_vma plt_start = htab->plt_got->output_section->vma;
1568           bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
1569                                    + htab->plt_got_eh_frame->output_offset
1570                                    + PLT_FDE_START_OFFSET;
1571           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1572                              htab->plt_got_eh_frame->contents
1573                              + PLT_FDE_START_OFFSET);
1574         }
1575       if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1576         {
1577           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1578                                                  htab->plt_got_eh_frame,
1579                                                  htab->plt_got_eh_frame->contents))
1580             return NULL;
1581         }
1582     }
1583
1584   /* Adjust .eh_frame for the second PLT section.  */
1585   if (htab->plt_second_eh_frame != NULL
1586       && htab->plt_second_eh_frame->contents != NULL)
1587     {
1588       if (htab->plt_second != NULL
1589           && htab->plt_second->size != 0
1590           && (htab->plt_second->flags & SEC_EXCLUDE) == 0
1591           && htab->plt_second->output_section != NULL
1592           && htab->plt_second_eh_frame->output_section != NULL)
1593         {
1594           bfd_vma plt_start = htab->plt_second->output_section->vma;
1595           bfd_vma eh_frame_start
1596             = (htab->plt_second_eh_frame->output_section->vma
1597                + htab->plt_second_eh_frame->output_offset
1598                + PLT_FDE_START_OFFSET);
1599           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1600                              htab->plt_second_eh_frame->contents
1601                              + PLT_FDE_START_OFFSET);
1602         }
1603       if (htab->plt_second_eh_frame->sec_info_type
1604           == SEC_INFO_TYPE_EH_FRAME)
1605         {
1606           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1607                                                  htab->plt_second_eh_frame,
1608                                                  htab->plt_second_eh_frame->contents))
1609             return NULL;
1610         }
1611     }
1612
1613   if (htab->elf.sgot && htab->elf.sgot->size > 0)
1614     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
1615       = htab->got_entry_size;
1616
1617   return htab;
1618 }
1619
1620
1621 bfd_boolean
1622 _bfd_x86_elf_always_size_sections (bfd *output_bfd,
1623                                    struct bfd_link_info *info)
1624 {
1625   asection *tls_sec = elf_hash_table (info)->tls_sec;
1626
1627   if (tls_sec)
1628     {
1629       struct elf_link_hash_entry *tlsbase;
1630
1631       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1632                                       "_TLS_MODULE_BASE_",
1633                                       FALSE, FALSE, FALSE);
1634
1635       if (tlsbase && tlsbase->type == STT_TLS)
1636         {
1637           struct elf_x86_link_hash_table *htab;
1638           struct bfd_link_hash_entry *bh = NULL;
1639           const struct elf_backend_data *bed
1640             = get_elf_backend_data (output_bfd);
1641
1642           htab = elf_x86_hash_table (info, bed->target_id);
1643           if (htab == NULL)
1644             return FALSE;
1645
1646           if (!(_bfd_generic_link_add_one_symbol
1647                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1648                  tls_sec, 0, NULL, FALSE,
1649                  bed->collect, &bh)))
1650             return FALSE;
1651
1652           htab->tls_module_base = bh;
1653
1654           tlsbase = (struct elf_link_hash_entry *)bh;
1655           tlsbase->def_regular = 1;
1656           tlsbase->other = STV_HIDDEN;
1657           tlsbase->root.linker_def = 1;
1658           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1659         }
1660     }
1661
1662   return TRUE;
1663 }
1664
1665 void
1666 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
1667                                      const Elf_Internal_Sym *isym,
1668                                      bfd_boolean definition,
1669                                      bfd_boolean dynamic ATTRIBUTE_UNUSED)
1670 {
1671   if (definition)
1672     {
1673       struct elf_x86_link_hash_entry *eh
1674         = (struct elf_x86_link_hash_entry *) h;
1675       eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
1676                            == STV_PROTECTED);
1677     }
1678 }
1679
1680 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1681
1682 void
1683 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
1684                                    struct elf_link_hash_entry *dir,
1685                                    struct elf_link_hash_entry *ind)
1686 {
1687   struct elf_x86_link_hash_entry *edir, *eind;
1688
1689   edir = (struct elf_x86_link_hash_entry *) dir;
1690   eind = (struct elf_x86_link_hash_entry *) ind;
1691
1692   if (eind->dyn_relocs != NULL)
1693     {
1694       if (edir->dyn_relocs != NULL)
1695         {
1696           struct elf_dyn_relocs **pp;
1697           struct elf_dyn_relocs *p;
1698
1699           /* Add reloc counts against the indirect sym to the direct sym
1700              list.  Merge any entries against the same section.  */
1701           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1702             {
1703               struct elf_dyn_relocs *q;
1704
1705               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1706                 if (q->sec == p->sec)
1707                   {
1708                     q->pc_count += p->pc_count;
1709                     q->count += p->count;
1710                     *pp = p->next;
1711                     break;
1712                   }
1713               if (q == NULL)
1714                 pp = &p->next;
1715             }
1716           *pp = edir->dyn_relocs;
1717         }
1718
1719       edir->dyn_relocs = eind->dyn_relocs;
1720       eind->dyn_relocs = NULL;
1721     }
1722
1723   if (ind->root.type == bfd_link_hash_indirect
1724       && dir->got.refcount <= 0)
1725     {
1726       edir->tls_type = eind->tls_type;
1727       eind->tls_type = GOT_UNKNOWN;
1728     }
1729
1730   /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1731      generate a R_386_COPY reloc.  */
1732   edir->gotoff_ref |= eind->gotoff_ref;
1733
1734   edir->zero_undefweak |= eind->zero_undefweak;
1735
1736   if (ELIMINATE_COPY_RELOCS
1737       && ind->root.type != bfd_link_hash_indirect
1738       && dir->dynamic_adjusted)
1739     {
1740       /* If called to transfer flags for a weakdef during processing
1741          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1742          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1743       if (dir->versioned != versioned_hidden)
1744         dir->ref_dynamic |= ind->ref_dynamic;
1745       dir->ref_regular |= ind->ref_regular;
1746       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1747       dir->needs_plt |= ind->needs_plt;
1748       dir->pointer_equality_needed |= ind->pointer_equality_needed;
1749     }
1750   else
1751     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1752 }
1753
1754 /* Remove undefined weak symbol from the dynamic symbol table if it
1755    is resolved to 0.   */
1756
1757 bfd_boolean
1758 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
1759                            struct elf_link_hash_entry *h)
1760 {
1761   if (h->dynindx != -1
1762       && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
1763     {
1764       h->dynindx = -1;
1765       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1766                               h->dynstr_index);
1767     }
1768   return TRUE;
1769 }
1770
1771 /* Change the STT_GNU_IFUNC symbol defined in position-dependent
1772    executable into the normal function symbol and set its address
1773    to its PLT entry, which should be resolved by R_*_IRELATIVE at
1774    run-time.  */
1775
1776 void
1777 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info,
1778                                       struct elf_x86_link_hash_table *htab,
1779                                       struct elf_link_hash_entry *h,
1780                                       Elf_Internal_Sym *sym)
1781 {
1782   if (bfd_link_pde (info)
1783       && h->def_regular
1784       && h->dynindx != -1
1785       && h->plt.offset != (bfd_vma) -1
1786       && h->type == STT_GNU_IFUNC
1787       && h->pointer_equality_needed)
1788     {
1789       asection *plt_s;
1790       bfd_vma plt_offset;
1791       bfd *output_bfd = info->output_bfd;
1792
1793       if (htab->plt_second)
1794         {
1795           struct elf_x86_link_hash_entry *eh
1796             = (struct elf_x86_link_hash_entry *) h;
1797
1798           plt_s = htab->plt_second;
1799           plt_offset = eh->plt_second.offset;
1800         }
1801       else
1802         {
1803           plt_s = htab->elf.splt;
1804           plt_offset = h->plt.offset;
1805         }
1806
1807       sym->st_size = 0;
1808       sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
1809       sym->st_shndx
1810         = _bfd_elf_section_from_bfd_section (output_bfd,
1811                                              plt_s->output_section);
1812       sym->st_value = (plt_s->output_section->vma
1813                        + plt_s->output_offset + plt_offset);
1814     }
1815 }
1816
1817 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
1818
1819 bfd_boolean
1820 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
1821 {
1822   if (h->plt.offset != (bfd_vma) -1
1823       && !h->def_regular
1824       && !h->pointer_equality_needed)
1825     return FALSE;
1826
1827   return _bfd_elf_hash_symbol (h);
1828 }
1829
1830 /* Adjust a symbol defined by a dynamic object and referenced by a
1831    regular object.  The current definition is in some section of the
1832    dynamic object, but we're not including those sections.  We have to
1833    change the definition to something the rest of the link can
1834    understand.  */
1835
1836 bfd_boolean
1837 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1838                                     struct elf_link_hash_entry *h)
1839 {
1840   struct elf_x86_link_hash_table *htab;
1841   asection *s, *srel;
1842   struct elf_x86_link_hash_entry *eh;
1843   struct elf_dyn_relocs *p;
1844   const struct elf_backend_data *bed
1845     = get_elf_backend_data (info->output_bfd);
1846
1847   /* STT_GNU_IFUNC symbol must go through PLT. */
1848   if (h->type == STT_GNU_IFUNC)
1849     {
1850       /* All local STT_GNU_IFUNC references must be treate as local
1851          calls via local PLT.  */
1852       if (h->ref_regular
1853           && SYMBOL_CALLS_LOCAL (info, h))
1854         {
1855           bfd_size_type pc_count = 0, count = 0;
1856           struct elf_dyn_relocs **pp;
1857
1858           eh = (struct elf_x86_link_hash_entry *) h;
1859           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1860             {
1861               pc_count += p->pc_count;
1862               p->count -= p->pc_count;
1863               p->pc_count = 0;
1864               count += p->count;
1865               if (p->count == 0)
1866                 *pp = p->next;
1867               else
1868                 pp = &p->next;
1869             }
1870
1871           if (pc_count || count)
1872             {
1873               h->non_got_ref = 1;
1874               if (pc_count)
1875                 {
1876                   /* Increment PLT reference count only for PC-relative
1877                      references.  */
1878                   h->needs_plt = 1;
1879                   if (h->plt.refcount <= 0)
1880                     h->plt.refcount = 1;
1881                   else
1882                     h->plt.refcount += 1;
1883                 }
1884             }
1885         }
1886
1887       if (h->plt.refcount <= 0)
1888         {
1889           h->plt.offset = (bfd_vma) -1;
1890           h->needs_plt = 0;
1891         }
1892       return TRUE;
1893     }
1894
1895   /* If this is a function, put it in the procedure linkage table.  We
1896      will fill in the contents of the procedure linkage table later,
1897      when we know the address of the .got section.  */
1898   if (h->type == STT_FUNC
1899       || h->needs_plt)
1900     {
1901       if (h->plt.refcount <= 0
1902           || SYMBOL_CALLS_LOCAL (info, h)
1903           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1904               && h->root.type == bfd_link_hash_undefweak))
1905         {
1906           /* This case can occur if we saw a PLT32 reloc in an input
1907              file, but the symbol was never referred to by a dynamic
1908              object, or if all references were garbage collected.  In
1909              such a case, we don't actually need to build a procedure
1910              linkage table, and we can just do a PC32 reloc instead.  */
1911           h->plt.offset = (bfd_vma) -1;
1912           h->needs_plt = 0;
1913         }
1914
1915       return TRUE;
1916     }
1917   else
1918     /* It's possible that we incorrectly decided a .plt reloc was needed
1919      * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1920        check_relocs.  We can't decide accurately between function and
1921        non-function syms in check-relocs;  Objects loaded later in
1922        the link may change h->type.  So fix it now.  */
1923     h->plt.offset = (bfd_vma) -1;
1924
1925   eh = (struct elf_x86_link_hash_entry *) h;
1926
1927   /* If this is a weak symbol, and there is a real definition, the
1928      processor independent code will have arranged for us to see the
1929      real definition first, and we can just use the same value.  */
1930   if (h->is_weakalias)
1931     {
1932       struct elf_link_hash_entry *def = weakdef (h);
1933       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1934       h->root.u.def.section = def->root.u.def.section;
1935       h->root.u.def.value = def->root.u.def.value;
1936       if (ELIMINATE_COPY_RELOCS
1937           || info->nocopyreloc
1938           || SYMBOL_NO_COPYRELOC (info, eh))
1939         {
1940           /* NB: needs_copy is always 0 for i386.  */
1941           h->non_got_ref = def->non_got_ref;
1942           eh->needs_copy = def->needs_copy;
1943         }
1944       return TRUE;
1945     }
1946
1947   /* This is a reference to a symbol defined by a dynamic object which
1948      is not a function.  */
1949
1950   /* If we are creating a shared library, we must presume that the
1951      only references to the symbol are via the global offset table.
1952      For such cases we need not do anything here; the relocations will
1953      be handled correctly by relocate_section.  */
1954   if (!bfd_link_executable (info))
1955     return TRUE;
1956
1957   /* If there are no references to this symbol that do not use the
1958      GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1959      reloc.  NB: gotoff_ref is always 0 for x86-64.  */
1960   if (!h->non_got_ref && !eh->gotoff_ref)
1961     return TRUE;
1962
1963   /* If -z nocopyreloc was given, we won't generate them either.  */
1964   if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
1965     {
1966       h->non_got_ref = 0;
1967       return TRUE;
1968     }
1969
1970   htab = elf_x86_hash_table (info, bed->target_id);
1971   if (htab == NULL)
1972     return FALSE;
1973
1974   /* If there aren't any dynamic relocs in read-only sections nor
1975      R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1976      avoid the copy reloc.  This doesn't work on VxWorks, where we can
1977      not have dynamic relocations (other than copy and jump slot
1978      relocations) in an executable.  */
1979   if (ELIMINATE_COPY_RELOCS
1980       && (bed->target_id == X86_64_ELF_DATA
1981           || (!eh->gotoff_ref
1982               && htab->target_os != is_vxworks)))
1983     {
1984       /* If we don't find any dynamic relocs in read-only sections,
1985          then we'll be keeping the dynamic relocs and avoiding the copy
1986          reloc.  */
1987       if (!readonly_dynrelocs (h))
1988         {
1989           h->non_got_ref = 0;
1990           return TRUE;
1991         }
1992     }
1993
1994   /* We must allocate the symbol in our .dynbss section, which will
1995      become part of the .bss section of the executable.  There will be
1996      an entry for this symbol in the .dynsym section.  The dynamic
1997      object will contain position independent code, so all references
1998      from the dynamic object to this symbol will go through the global
1999      offset table.  The dynamic linker will use the .dynsym entry to
2000      determine the address it must put in the global offset table, so
2001      both the dynamic object and the regular object will refer to the
2002      same memory location for the variable.  */
2003
2004   /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
2005      dynamic linker to copy the initial value out of the dynamic object
2006      and into the runtime process image.  */
2007   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2008     {
2009       s = htab->elf.sdynrelro;
2010       srel = htab->elf.sreldynrelro;
2011     }
2012   else
2013     {
2014       s = htab->elf.sdynbss;
2015       srel = htab->elf.srelbss;
2016     }
2017   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2018     {
2019       srel->size += htab->sizeof_reloc;
2020       h->needs_copy = 1;
2021     }
2022
2023   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2024 }
2025
2026 void
2027 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
2028                           struct elf_link_hash_entry *h,
2029                           bfd_boolean force_local)
2030 {
2031   if (h->root.type == bfd_link_hash_undefweak
2032       && info->nointerp
2033       && bfd_link_pie (info))
2034     {
2035       /* When there is no dynamic interpreter in PIE, make the undefined
2036          weak symbol dynamic so that PC relative branch to the undefined
2037          weak symbol will land to address 0.  */
2038       struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2039       if (h->plt.refcount > 0
2040           || eh->plt_got.refcount > 0)
2041         return;
2042     }
2043
2044   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2045 }
2046
2047 /* Return TRUE if a symbol is referenced locally.  It is similar to
2048    SYMBOL_REFERENCES_LOCAL, but it also checks version script.  It
2049    works in check_relocs.  */
2050
2051 bfd_boolean
2052 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
2053                                            struct elf_link_hash_entry *h)
2054 {
2055   struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2056   struct elf_x86_link_hash_table *htab
2057     = (struct elf_x86_link_hash_table *) info->hash;
2058
2059   if (eh->local_ref > 1)
2060     return TRUE;
2061
2062   if (eh->local_ref == 1)
2063     return FALSE;
2064
2065   /* Unversioned symbols defined in regular objects can be forced local
2066      by linker version script.  A weak undefined symbol is forced local
2067      if
2068      1. It has non-default visibility.  Or
2069      2. When building executable, there is no dynamic linker.  Or
2070      3. or "-z nodynamic-undefined-weak" is used.
2071    */
2072   if (SYMBOL_REFERENCES_LOCAL (info, h)
2073       || (h->root.type == bfd_link_hash_undefweak
2074           && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2075               || (bfd_link_executable (info)
2076                   && htab->interp == NULL)
2077               || info->dynamic_undefined_weak == 0))
2078       || ((h->def_regular || ELF_COMMON_DEF_P (h))
2079           && info->version_info != NULL
2080           && _bfd_elf_link_hide_sym_by_version (info, h)))
2081     {
2082       eh->local_ref = 2;
2083       return TRUE;
2084     }
2085
2086   eh->local_ref = 1;
2087   return FALSE;
2088 }
2089
2090 /* Return the section that should be marked against GC for a given
2091    relocation.  */
2092
2093 asection *
2094 _bfd_x86_elf_gc_mark_hook (asection *sec,
2095                            struct bfd_link_info *info,
2096                            Elf_Internal_Rela *rel,
2097                            struct elf_link_hash_entry *h,
2098                            Elf_Internal_Sym *sym)
2099 {
2100   /* Compiler should optimize this out.  */
2101   if (((unsigned int) R_X86_64_GNU_VTINHERIT
2102        != (unsigned int) R_386_GNU_VTINHERIT)
2103       || ((unsigned int) R_X86_64_GNU_VTENTRY
2104           != (unsigned int) R_386_GNU_VTENTRY))
2105     abort ();
2106
2107   if (h != NULL)
2108     switch (ELF32_R_TYPE (rel->r_info))
2109       {
2110       case R_X86_64_GNU_VTINHERIT:
2111       case R_X86_64_GNU_VTENTRY:
2112         return NULL;
2113       }
2114
2115   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2116 }
2117
2118 static bfd_vma
2119 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
2120                           bfd_vma off,
2121                           bfd_vma offset ATTRIBUTE_UNUSED,
2122                           bfd_vma got_addr)
2123 {
2124   return got_addr + off;
2125 }
2126
2127 static bfd_vma
2128 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
2129                             bfd_vma off,
2130                             bfd_vma offset,
2131                             bfd_vma got_addr ATTRIBUTE_UNUSED)
2132 {
2133   return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
2134 }
2135
2136 static bfd_boolean
2137 elf_i386_valid_plt_reloc_p (unsigned int type)
2138 {
2139   return (type == R_386_JUMP_SLOT
2140           || type == R_386_GLOB_DAT
2141           || type == R_386_IRELATIVE);
2142 }
2143
2144 static bfd_boolean
2145 elf_x86_64_valid_plt_reloc_p (unsigned int type)
2146 {
2147   return (type == R_X86_64_JUMP_SLOT
2148           || type == R_X86_64_GLOB_DAT
2149           || type == R_X86_64_IRELATIVE);
2150 }
2151
2152 long
2153 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
2154                                    long count,
2155                                    long relsize,
2156                                    bfd_vma got_addr,
2157                                    struct elf_x86_plt plts[],
2158                                    asymbol **dynsyms,
2159                                    asymbol **ret)
2160 {
2161   long size, i, n, len;
2162   int j;
2163   unsigned int plt_got_offset, plt_entry_size;
2164   asymbol *s;
2165   bfd_byte *plt_contents;
2166   long dynrelcount;
2167   arelent **dynrelbuf, *p;
2168   char *names;
2169   const struct elf_backend_data *bed;
2170   bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
2171                               bfd_vma);
2172   bfd_boolean (*valid_plt_reloc_p) (unsigned int);
2173
2174   if (count == 0)
2175     return -1;
2176
2177   dynrelbuf = (arelent **) bfd_malloc (relsize);
2178   if (dynrelbuf == NULL)
2179     return -1;
2180
2181   dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
2182                                                 dynsyms);
2183   if (dynrelcount <= 0)
2184     return -1;
2185
2186   /* Sort the relocs by address.  */
2187   qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
2188          _bfd_x86_elf_compare_relocs);
2189
2190   size = count * sizeof (asymbol);
2191
2192   /* Allocate space for @plt suffixes.  */
2193   n = 0;
2194   for (i = 0; i < dynrelcount; i++)
2195     {
2196       p = dynrelbuf[i];
2197       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2198       if (p->addend != 0)
2199         size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
2200     }
2201
2202   s = *ret = (asymbol *) bfd_zmalloc (size);
2203   if (s == NULL)
2204     goto bad_return;
2205
2206   bed = get_elf_backend_data (abfd);
2207
2208   if (bed->target_id == X86_64_ELF_DATA)
2209     {
2210       get_plt_got_vma = elf_x86_64_get_plt_got_vma;
2211       valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
2212     }
2213   else
2214     {
2215       get_plt_got_vma = elf_i386_get_plt_got_vma;
2216       valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
2217       if (got_addr)
2218         {
2219           /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2220              address.  */
2221           asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
2222           if (sec != NULL)
2223             got_addr = sec->vma;
2224           else
2225             {
2226               sec = bfd_get_section_by_name (abfd, ".got");
2227               if (sec != NULL)
2228                 got_addr = sec->vma;
2229             }
2230
2231           if (got_addr == (bfd_vma) -1)
2232             goto bad_return;
2233         }
2234     }
2235
2236   /* Check for each PLT section.  */
2237   names = (char *) (s + count);
2238   size = 0;
2239   n = 0;
2240   for (j = 0; plts[j].name != NULL; j++)
2241     if ((plt_contents = plts[j].contents) != NULL)
2242       {
2243         long k;
2244         bfd_vma offset;
2245         asection *plt;
2246         struct elf_x86_plt *plt_p = &plts[j];
2247
2248         plt_got_offset = plt_p->plt_got_offset;
2249         plt_entry_size = plt_p->plt_entry_size;
2250
2251         plt = plt_p->sec;
2252
2253         if ((plt_p->type & plt_lazy))
2254           {
2255             /* Skip PLT0 in lazy PLT.  */
2256             k = 1;
2257             offset = plt_entry_size;
2258           }
2259         else
2260           {
2261             k = 0;
2262             offset = 0;
2263           }
2264
2265         /* Check each PLT entry against dynamic relocations.  */
2266         for (; k < plt_p->count; k++)
2267           {
2268             int off;
2269             bfd_vma got_vma;
2270             long min, max, mid;
2271
2272             /* Get the GOT offset for i386 or the PC-relative offset
2273                for x86-64, a signed 32-bit integer.  */
2274             off = H_GET_32 (abfd, (plt_contents + offset
2275                                    + plt_got_offset));
2276             got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
2277
2278             /* Binary search.  */
2279             p = dynrelbuf[0];
2280             min = 0;
2281             max = dynrelcount;
2282             while ((min + 1) < max)
2283               {
2284                 arelent *r;
2285
2286                 mid = (min + max) / 2;
2287                 r = dynrelbuf[mid];
2288                 if (got_vma > r->address)
2289                   min = mid;
2290                 else if (got_vma < r->address)
2291                   max = mid;
2292                 else
2293                   {
2294                     p = r;
2295                     break;
2296                   }
2297               }
2298
2299             /* Skip unknown relocation.  PR 17512: file: bc9d6cf5.  */
2300             if (got_vma == p->address
2301                 && p->howto != NULL
2302                 && valid_plt_reloc_p (p->howto->type))
2303               {
2304                 *s = **p->sym_ptr_ptr;
2305                 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2306                    set.  Since we are defining a symbol, ensure one
2307                    of them is set.  */
2308                 if ((s->flags & BSF_LOCAL) == 0)
2309                   s->flags |= BSF_GLOBAL;
2310                 s->flags |= BSF_SYNTHETIC;
2311                 /* This is no longer a section symbol.  */
2312                 s->flags &= ~BSF_SECTION_SYM;
2313                 s->section = plt;
2314                 s->the_bfd = plt->owner;
2315                 s->value = offset;
2316                 s->udata.p = NULL;
2317                 s->name = names;
2318                 len = strlen ((*p->sym_ptr_ptr)->name);
2319                 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2320                 names += len;
2321                 if (p->addend != 0)
2322                   {
2323                     char buf[30], *a;
2324
2325                     memcpy (names, "+0x", sizeof ("+0x") - 1);
2326                     names += sizeof ("+0x") - 1;
2327                     bfd_sprintf_vma (abfd, buf, p->addend);
2328                     for (a = buf; *a == '0'; ++a)
2329                       ;
2330                     size = strlen (a);
2331                     memcpy (names, a, size);
2332                     names += size;
2333                   }
2334                 memcpy (names, "@plt", sizeof ("@plt"));
2335                 names += sizeof ("@plt");
2336                 n++;
2337                 s++;
2338                 /* There should be only one entry in PLT for a given
2339                    symbol.  Set howto to NULL after processing a PLT
2340                    entry to guard against corrupted PLT.  */
2341                 p->howto = NULL;
2342               }
2343             offset += plt_entry_size;
2344           }
2345       }
2346
2347   /* PLT entries with R_386_TLS_DESC relocations are skipped.  */
2348   if (n == 0)
2349     {
2350 bad_return:
2351       count = -1;
2352     }
2353   else
2354     count = n;
2355
2356   for (j = 0; plts[j].name != NULL; j++)
2357     if (plts[j].contents != NULL)
2358       free (plts[j].contents);
2359
2360   free (dynrelbuf);
2361
2362   return count;
2363 }
2364
2365 /* Parse x86 GNU properties.  */
2366
2367 enum elf_property_kind
2368 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
2369                                    bfd_byte *ptr, unsigned int datasz)
2370 {
2371   elf_property *prop;
2372
2373   if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2374       || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2375       || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
2376           && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2377       || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
2378           && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
2379       || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2380           && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2381     {
2382       if (datasz != 4)
2383         {
2384           _bfd_error_handler
2385             (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"),
2386              abfd, type, datasz);
2387           return property_corrupt;
2388         }
2389       prop = _bfd_elf_get_property (abfd, type, datasz);
2390       prop->u.number |= bfd_h_get_32 (abfd, ptr);
2391       prop->pr_kind = property_number;
2392       return property_number;
2393     }
2394
2395   return property_ignored;
2396 }
2397
2398 /* Merge x86 GNU property BPROP with APROP.  If APROP isn't NULL,
2399    return TRUE if APROP is updated.  Otherwise, return TRUE if BPROP
2400    should be merged with ABFD.  */
2401
2402 bfd_boolean
2403 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
2404                                    bfd *abfd ATTRIBUTE_UNUSED,
2405                                    bfd *bbfd ATTRIBUTE_UNUSED,
2406                                    elf_property *aprop,
2407                                    elf_property *bprop)
2408 {
2409   unsigned int number, features;
2410   bfd_boolean updated = FALSE;
2411   unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
2412
2413   if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2414       || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2415           && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2416     {
2417       if (aprop == NULL || bprop == NULL)
2418         {
2419           /* Only one of APROP and BPROP can be NULL.  */
2420           if (aprop != NULL)
2421             {
2422               /* Remove this property since the other input file doesn't
2423                  have it.  */
2424               aprop->pr_kind = property_remove;
2425               updated = TRUE;
2426             }
2427         }
2428       else
2429         {
2430           number = aprop->u.number;
2431           aprop->u.number = number | bprop->u.number;
2432           updated = number != (unsigned int) aprop->u.number;
2433         }
2434       return updated;
2435     }
2436   else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2437            || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO
2438                && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI))
2439     {
2440       if (aprop != NULL && bprop != NULL)
2441         {
2442           number = aprop->u.number;
2443           aprop->u.number = number | bprop->u.number;
2444           /* Remove the property if all bits are empty.  */
2445           if (aprop->u.number == 0)
2446             {
2447               aprop->pr_kind = property_remove;
2448               updated = TRUE;
2449             }
2450           else
2451             updated = number != (unsigned int) aprop->u.number;
2452         }
2453       else
2454         {
2455           /* Only one of APROP and BPROP can be NULL.  */
2456           if (aprop != NULL)
2457             {
2458               if (aprop->u.number == 0)
2459                 {
2460                   /* Remove APROP if all bits are empty.  */
2461                   aprop->pr_kind = property_remove;
2462                   updated = TRUE;
2463                 }
2464             }
2465           else
2466             {
2467               /* Return TRUE if APROP is NULL and all bits of BPROP
2468                  aren't empty to indicate that BPROP should be added
2469                  to ABFD.  */
2470               updated = bprop->u.number != 0;
2471             }
2472         }
2473       return updated;
2474     }
2475   else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO
2476            && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2477     {
2478       /* Only one of APROP and BPROP can be NULL:
2479          1. APROP & BPROP when both APROP and BPROP aren't NULL.
2480          2. If APROP is NULL, remove x86 feature.
2481          3. Otherwise, do nothing.
2482        */
2483       const struct elf_backend_data *bed
2484         = get_elf_backend_data (info->output_bfd);
2485       struct elf_x86_link_hash_table *htab
2486         = elf_x86_hash_table (info, bed->target_id);
2487       if (!htab)
2488         abort ();
2489       if (aprop != NULL && bprop != NULL)
2490         {
2491           features = 0;
2492           if (htab->params->ibt)
2493             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2494           if (htab->params->shstk)
2495             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2496           number = aprop->u.number;
2497           /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2498              GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
2499           aprop->u.number = (number & bprop->u.number) | features;
2500           updated = number != (unsigned int) aprop->u.number;
2501           /* Remove the property if all feature bits are cleared.  */
2502           if (aprop->u.number == 0)
2503             aprop->pr_kind = property_remove;
2504         }
2505       else
2506         {
2507           /* There should be no AND properties since some input doesn't
2508              have them.  Set IBT and SHSTK properties for -z ibt and -z
2509              shstk if needed.  */
2510           features = 0;
2511           if (htab->params->ibt)
2512             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2513           if (htab->params->shstk)
2514             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2515           if (features)
2516             {
2517               if (aprop != NULL)
2518                 {
2519                   updated = features != (unsigned int) aprop->u.number;
2520                   aprop->u.number = features;
2521                 }
2522               else
2523                 {
2524                   updated = TRUE;
2525                   bprop->u.number = features;
2526                 }
2527             }
2528           else if (aprop != NULL)
2529             {
2530               aprop->pr_kind = property_remove;
2531               updated = TRUE;
2532             }
2533         }
2534       return updated;
2535     }
2536   else
2537     {
2538       /* Never should happen.  */
2539       abort ();
2540     }
2541
2542   return updated;
2543 }
2544
2545 /* Set up x86 GNU properties.  Return the first relocatable ELF input
2546    with GNU properties if found.  Otherwise, return NULL.  */
2547
2548 bfd *
2549 _bfd_x86_elf_link_setup_gnu_properties
2550   (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
2551 {
2552   bfd_boolean normal_target;
2553   bfd_boolean lazy_plt;
2554   asection *sec, *pltsec;
2555   bfd *dynobj;
2556   bfd_boolean use_ibt_plt;
2557   unsigned int plt_alignment, features;
2558   struct elf_x86_link_hash_table *htab;
2559   bfd *pbfd;
2560   bfd *ebfd = NULL;
2561   elf_property *prop;
2562   const struct elf_backend_data *bed;
2563   unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
2564   unsigned int got_align;
2565
2566   /* Find a normal input file with GNU property note.  */
2567   for (pbfd = info->input_bfds;
2568        pbfd != NULL;
2569        pbfd = pbfd->link.next)
2570     if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
2571         && bfd_count_sections (pbfd) != 0)
2572       {
2573         ebfd = pbfd;
2574
2575         if (elf_properties (pbfd) != NULL)
2576           break;
2577       }
2578
2579   bed = get_elf_backend_data (info->output_bfd);
2580
2581   htab = elf_x86_hash_table (info, bed->target_id);
2582   if (htab == NULL)
2583     return pbfd;
2584
2585   features = 0;
2586   if (htab->params->ibt)
2587     {
2588       features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2589       htab->params->cet_report &= ~cet_report_ibt;
2590     }
2591   if (htab->params->shstk)
2592     {
2593       features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2594       htab->params->cet_report &= ~cet_report_shstk;
2595     }
2596   if (!(htab->params->cet_report & (cet_report_ibt | cet_report_shstk)))
2597     htab->params->cet_report = cet_report_none;
2598
2599   if (ebfd != NULL)
2600     {
2601       prop = NULL;
2602       if (features)
2603         {
2604           /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2605              GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
2606           prop = _bfd_elf_get_property (ebfd,
2607                                         GNU_PROPERTY_X86_FEATURE_1_AND,
2608                                         4);
2609           prop->u.number |= features;
2610           prop->pr_kind = property_number;
2611         }
2612
2613       /* Create the GNU property note section if needed.  */
2614       if (prop != NULL && pbfd == NULL)
2615         {
2616           sec = bfd_make_section_with_flags (ebfd,
2617                                              NOTE_GNU_PROPERTY_SECTION_NAME,
2618                                              (SEC_ALLOC
2619                                               | SEC_LOAD
2620                                               | SEC_IN_MEMORY
2621                                               | SEC_READONLY
2622                                               | SEC_HAS_CONTENTS
2623                                               | SEC_DATA));
2624           if (sec == NULL)
2625             info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
2626
2627           if (!bfd_set_section_alignment (ebfd, sec, class_align))
2628             {
2629 error_alignment:
2630               info->callbacks->einfo (_("%F%pA: failed to align section\n"),
2631                                       sec);
2632             }
2633
2634           elf_section_type (sec) = SHT_NOTE;
2635         }
2636     }
2637
2638   if (htab->params->cet_report)
2639     {
2640       /* Report missing IBT and SHSTK properties.  */
2641       bfd *abfd;
2642       const char *msg;
2643       elf_property_list *p;
2644       bfd_boolean missing_ibt, missing_shstk;
2645       bfd_boolean check_ibt
2646         = !!(htab->params->cet_report & cet_report_ibt);
2647       bfd_boolean check_shstk
2648         = !!(htab->params->cet_report & cet_report_shstk);
2649
2650       if ((htab->params->cet_report & cet_report_warning))
2651         msg = _("%P: %pB: warning: missing %s\n");
2652       else
2653         msg = _("%X%P: %pB: error: missing %s\n");
2654
2655       for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2656         if (!(abfd->flags & (DYNAMIC | BFD_PLUGIN | BFD_LINKER_CREATED))
2657             && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2658           {
2659             for (p = elf_properties (abfd); p; p = p->next)
2660               if (p->property.pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
2661                 break;
2662
2663             missing_ibt = check_ibt;
2664             missing_shstk = check_shstk;
2665             if (p)
2666               {
2667                 missing_ibt &= !(p->property.u.number
2668                                  & GNU_PROPERTY_X86_FEATURE_1_IBT);
2669                 missing_shstk &= !(p->property.u.number
2670                                    & GNU_PROPERTY_X86_FEATURE_1_SHSTK);
2671               }
2672             if (missing_ibt || missing_shstk)
2673               {
2674                 const char *missing;
2675                 if (missing_ibt && missing_shstk)
2676                   missing = _("IBT and SHSTK properties");
2677                 else if (missing_ibt)
2678                   missing = _("IBT property");
2679                 else
2680                   missing = _("SHSTK property");
2681                 info->callbacks->einfo (msg, abfd, missing);
2682               }
2683           }
2684     }
2685
2686   pbfd = _bfd_elf_link_setup_gnu_properties (info);
2687
2688   htab->r_info = init_table->r_info;
2689   htab->r_sym = init_table->r_sym;
2690
2691   if (bfd_link_relocatable (info))
2692     return pbfd;
2693
2694   htab->plt0_pad_byte = init_table->plt0_pad_byte;
2695
2696   use_ibt_plt = htab->params->ibtplt || htab->params->ibt;
2697   if (!use_ibt_plt && pbfd != NULL)
2698     {
2699       /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on.  */
2700       elf_property_list *p;
2701
2702       /* The property list is sorted in order of type.  */
2703       for (p = elf_properties (pbfd); p; p = p->next)
2704         {
2705           if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
2706             {
2707               use_ibt_plt = !!(p->property.u.number
2708                                & GNU_PROPERTY_X86_FEATURE_1_IBT);
2709               break;
2710             }
2711           else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
2712             break;
2713         }
2714     }
2715
2716   dynobj = htab->elf.dynobj;
2717
2718   /* Set htab->elf.dynobj here so that there is no need to check and
2719      set it in check_relocs.  */
2720   if (dynobj == NULL)
2721     {
2722       if (pbfd != NULL)
2723         {
2724           htab->elf.dynobj = pbfd;
2725           dynobj = pbfd;
2726         }
2727       else
2728         {
2729           bfd *abfd;
2730
2731           /* Find a normal input file to hold linker created
2732              sections.  */
2733           for (abfd = info->input_bfds;
2734                abfd != NULL;
2735                abfd = abfd->link.next)
2736             if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2737                 && (abfd->flags
2738                     & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
2739                 && bed->relocs_compatible (abfd->xvec,
2740                                            info->output_bfd->xvec))
2741               {
2742                 htab->elf.dynobj = abfd;
2743                 dynobj = abfd;
2744                 break;
2745               }
2746         }
2747     }
2748
2749   /* Return if there are no normal input files.  */
2750   if (dynobj == NULL)
2751     return pbfd;
2752
2753   /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2754      still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2755      canonical function address.  */
2756   htab->plt.has_plt0 = 1;
2757   normal_target = htab->target_os == is_normal;
2758
2759   if (normal_target)
2760     {
2761       if (use_ibt_plt)
2762         {
2763           htab->lazy_plt = init_table->lazy_ibt_plt;
2764           htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
2765         }
2766       else
2767         {
2768           htab->lazy_plt = init_table->lazy_plt;
2769           htab->non_lazy_plt = init_table->non_lazy_plt;
2770         }
2771     }
2772   else
2773     {
2774       htab->lazy_plt = init_table->lazy_plt;
2775       htab->non_lazy_plt = NULL;
2776     }
2777
2778   pltsec = htab->elf.splt;
2779
2780   /* If the non-lazy PLT is available, use it for all PLT entries if
2781      there are no PLT0 or no .plt section.  */
2782   if (htab->non_lazy_plt != NULL
2783       && (!htab->plt.has_plt0 || pltsec == NULL))
2784     {
2785       lazy_plt = FALSE;
2786       if (bfd_link_pic (info))
2787         htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
2788       else
2789         htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
2790       htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
2791       htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
2792       htab->plt.plt_got_insn_size
2793         = htab->non_lazy_plt->plt_got_insn_size;
2794       htab->plt.eh_frame_plt_size
2795         = htab->non_lazy_plt->eh_frame_plt_size;
2796       htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
2797     }
2798   else
2799     {
2800       lazy_plt = TRUE;
2801       if (bfd_link_pic (info))
2802         {
2803           htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
2804           htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
2805         }
2806       else
2807         {
2808           htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
2809           htab->plt.plt_entry = htab->lazy_plt->plt_entry;
2810         }
2811       htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
2812       htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
2813       htab->plt.plt_got_insn_size
2814         = htab->lazy_plt->plt_got_insn_size;
2815       htab->plt.eh_frame_plt_size
2816         = htab->lazy_plt->eh_frame_plt_size;
2817       htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
2818     }
2819
2820   if (htab->target_os == is_vxworks
2821       && !elf_vxworks_create_dynamic_sections (dynobj, info,
2822                                                &htab->srelplt2))
2823     {
2824       info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2825       return pbfd;
2826     }
2827
2828   /* Since create_dynamic_sections isn't always called, but GOT
2829      relocations need GOT relocations, create them here so that we
2830      don't need to do it in check_relocs.  */
2831   if (htab->elf.sgot == NULL
2832       && !_bfd_elf_create_got_section (dynobj, info))
2833     info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
2834
2835   got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
2836
2837   /* Align .got and .got.plt sections to their entry size.  Do it here
2838      instead of in create_dynamic_sections so that they are always
2839      properly aligned even if create_dynamic_sections isn't called.  */
2840   sec = htab->elf.sgot;
2841   if (!bfd_set_section_alignment (dynobj, sec, got_align))
2842     goto error_alignment;
2843
2844   sec = htab->elf.sgotplt;
2845   if (!bfd_set_section_alignment (dynobj, sec, got_align))
2846     goto error_alignment;
2847
2848   /* Create the ifunc sections here so that check_relocs can be
2849      simplified.  */
2850   if (!_bfd_elf_create_ifunc_sections (dynobj, info))
2851     info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
2852
2853   plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
2854
2855   if (pltsec != NULL)
2856     {
2857       /* Whe creating executable, set the contents of the .interp
2858          section to the interpreter.  */
2859       if (bfd_link_executable (info) && !info->nointerp)
2860         {
2861           asection *s = bfd_get_linker_section (dynobj, ".interp");
2862           if (s == NULL)
2863             abort ();
2864           s->size = htab->dynamic_interpreter_size;
2865           s->contents = (unsigned char *) htab->dynamic_interpreter;
2866           htab->interp = s;
2867         }
2868
2869       /* Don't change PLT section alignment for NaCl since it uses
2870          64-byte PLT entry and sets PLT section alignment to 32
2871          bytes.  Don't create additional PLT sections for NaCl.  */
2872       if (normal_target)
2873         {
2874           flagword pltflags = (bed->dynamic_sec_flags
2875                                | SEC_ALLOC
2876                                | SEC_CODE
2877                                | SEC_LOAD
2878                                | SEC_READONLY);
2879           unsigned int non_lazy_plt_alignment
2880             = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
2881
2882           sec = pltsec;
2883           if (!bfd_set_section_alignment (sec->owner, sec,
2884                                           plt_alignment))
2885             goto error_alignment;
2886
2887           /* Create the GOT procedure linkage table.  */
2888           sec = bfd_make_section_anyway_with_flags (dynobj,
2889                                                     ".plt.got",
2890                                                     pltflags);
2891           if (sec == NULL)
2892             info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
2893
2894           if (!bfd_set_section_alignment (dynobj, sec,
2895                                           non_lazy_plt_alignment))
2896             goto error_alignment;
2897
2898           htab->plt_got = sec;
2899
2900           if (lazy_plt)
2901             {
2902               sec = NULL;
2903
2904               if (use_ibt_plt)
2905                 {
2906                   /* Create the second PLT for Intel IBT support.  IBT
2907                      PLT is supported only for non-NaCl target and is
2908                      is needed only for lazy binding.  */
2909                   sec = bfd_make_section_anyway_with_flags (dynobj,
2910                                                             ".plt.sec",
2911                                                             pltflags);
2912                   if (sec == NULL)
2913                     info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
2914
2915                   if (!bfd_set_section_alignment (dynobj, sec,
2916                                                   plt_alignment))
2917                     goto error_alignment;
2918                 }
2919               else if (htab->params->bndplt && ABI_64_P (dynobj))
2920                 {
2921                   /* Create the second PLT for Intel MPX support.  MPX
2922                      PLT is supported only for non-NaCl target in 64-bit
2923                      mode and is needed only for lazy binding.  */
2924                   sec = bfd_make_section_anyway_with_flags (dynobj,
2925                                                             ".plt.sec",
2926                                                             pltflags);
2927                   if (sec == NULL)
2928                     info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n"));
2929
2930                   if (!bfd_set_section_alignment (dynobj, sec,
2931                                                   non_lazy_plt_alignment))
2932                     goto error_alignment;
2933                 }
2934
2935               htab->plt_second = sec;
2936             }
2937         }
2938
2939       if (!info->no_ld_generated_unwind_info)
2940         {
2941           flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2942                             | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2943                             | SEC_LINKER_CREATED);
2944
2945           sec = bfd_make_section_anyway_with_flags (dynobj,
2946                                                     ".eh_frame",
2947                                                     flags);
2948           if (sec == NULL)
2949             info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
2950
2951           if (!bfd_set_section_alignment (dynobj, sec, class_align))
2952             goto error_alignment;
2953
2954           htab->plt_eh_frame = sec;
2955
2956           if (htab->plt_got != NULL)
2957             {
2958               sec = bfd_make_section_anyway_with_flags (dynobj,
2959                                                         ".eh_frame",
2960                                                         flags);
2961               if (sec == NULL)
2962                 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
2963
2964               if (!bfd_set_section_alignment (dynobj, sec, class_align))
2965                 goto error_alignment;
2966
2967               htab->plt_got_eh_frame = sec;
2968             }
2969
2970           if (htab->plt_second != NULL)
2971             {
2972               sec = bfd_make_section_anyway_with_flags (dynobj,
2973                                                         ".eh_frame",
2974                                                         flags);
2975               if (sec == NULL)
2976                 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
2977
2978               if (!bfd_set_section_alignment (dynobj, sec, class_align))
2979                 goto error_alignment;
2980
2981               htab->plt_second_eh_frame = sec;
2982             }
2983         }
2984     }
2985
2986   /* The .iplt section is used for IFUNC symbols in static
2987      executables.  */
2988   sec = htab->elf.iplt;
2989   if (sec != NULL)
2990     {
2991       /* NB: Delay setting its alignment until we know it is non-empty.
2992          Otherwise an empty iplt section may change vma and lma of the
2993          following sections, which triggers moving dot of the following
2994          section backwards, resulting in a warning and section lma not
2995          being set properly.  It later leads to a "File truncated"
2996          error.  */
2997       if (!bfd_set_section_alignment (sec->owner, sec, 0))
2998         goto error_alignment;
2999
3000       htab->plt.iplt_alignment = (normal_target
3001                                   ? plt_alignment
3002                                   : bed->plt_alignment);
3003     }
3004
3005   return pbfd;
3006 }
3007
3008 /* Fix up x86 GNU properties.  */
3009
3010 void
3011 _bfd_x86_elf_link_fixup_gnu_properties
3012   (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3013    elf_property_list **listp)
3014 {
3015   elf_property_list *p;
3016
3017   for (p = *listp; p; p = p->next)
3018     {
3019       unsigned int type = p->property.pr_type;
3020       if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
3021           || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3022           || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
3023               && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
3024           || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
3025               && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
3026           || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
3027               && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
3028         {
3029           if (p->property.u.number == 0
3030               && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3031                   || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
3032                       && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
3033                   || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
3034                       && type <= GNU_PROPERTY_X86_UINT32_OR_HI)))
3035             {
3036               /* Remove empty property.  */
3037               *listp = p->next;
3038               continue;
3039             }
3040
3041           listp = &p->next;
3042         }
3043       else if (type > GNU_PROPERTY_HIPROC)
3044         {
3045           /* The property list is sorted in order of type.  */
3046           break;
3047         }
3048     }
3049 }
3050
3051 void
3052 _bfd_elf_linker_x86_set_options (struct bfd_link_info * info,
3053                                  struct elf_linker_x86_params *params)
3054 {
3055   const struct elf_backend_data *bed
3056     = get_elf_backend_data (info->output_bfd);
3057   struct elf_x86_link_hash_table *htab
3058     = elf_x86_hash_table (info, bed->target_id);
3059   if (htab != NULL)
3060     htab->params = params;
3061 }