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 -fPIC\n"));
1385                   bfd_set_error (bfd_error_bad_value);
1386                   return FALSE;
1387                 }
1388
1389               if (!add_dynamic_entry (DT_TEXTREL, 0))
1390                 return FALSE;
1391             }
1392         }
1393       if (htab->target_os == is_vxworks
1394           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
1395         return FALSE;
1396     }
1397 #undef add_dynamic_entry
1398
1399   return TRUE;
1400 }
1401
1402 /* Finish up the x86 dynamic sections.  */
1403
1404 struct elf_x86_link_hash_table *
1405 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
1406                                       struct bfd_link_info *info)
1407 {
1408   struct elf_x86_link_hash_table *htab;
1409   const struct elf_backend_data *bed;
1410   bfd *dynobj;
1411   asection *sdyn;
1412   bfd_byte *dyncon, *dynconend;
1413   bfd_size_type sizeof_dyn;
1414
1415   bed = get_elf_backend_data (output_bfd);
1416   htab = elf_x86_hash_table (info, bed->target_id);
1417   if (htab == NULL)
1418     return htab;
1419
1420   dynobj = htab->elf.dynobj;
1421   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1422
1423   /* GOT is always created in setup_gnu_properties.  But it may not be
1424      needed.  .got.plt section may be needed for static IFUNC.  */
1425   if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
1426     {
1427       bfd_vma dynamic_addr;
1428
1429       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
1430         {
1431           _bfd_error_handler
1432             (_("discarded output section: `%pA'"), htab->elf.sgotplt);
1433           return NULL;
1434         }
1435
1436       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
1437         = htab->got_entry_size;
1438
1439       dynamic_addr = (sdyn == NULL
1440                       ? (bfd_vma) 0
1441                       : sdyn->output_section->vma + sdyn->output_offset);
1442
1443       /* Set the first entry in the global offset table to the address
1444          of the dynamic section.  Write GOT[1] and GOT[2], needed for
1445          the dynamic linker.  */
1446       if (htab->got_entry_size == 8)
1447         {
1448           bfd_put_64 (output_bfd, dynamic_addr,
1449                       htab->elf.sgotplt->contents);
1450           bfd_put_64 (output_bfd, (bfd_vma) 0,
1451                       htab->elf.sgotplt->contents + 8);
1452           bfd_put_64 (output_bfd, (bfd_vma) 0,
1453                       htab->elf.sgotplt->contents + 8*2);
1454         }
1455       else
1456         {
1457           bfd_put_32 (output_bfd, dynamic_addr,
1458                       htab->elf.sgotplt->contents);
1459           bfd_put_32 (output_bfd, 0,
1460                       htab->elf.sgotplt->contents + 4);
1461           bfd_put_32 (output_bfd, 0,
1462                       htab->elf.sgotplt->contents + 4*2);
1463         }
1464     }
1465
1466   if (!htab->elf.dynamic_sections_created)
1467     return htab;
1468
1469   if (sdyn == NULL || htab->elf.sgot == NULL)
1470     abort ();
1471
1472   sizeof_dyn = bed->s->sizeof_dyn;
1473   dyncon = sdyn->contents;
1474   dynconend = sdyn->contents + sdyn->size;
1475   for (; dyncon < dynconend; dyncon += sizeof_dyn)
1476     {
1477       Elf_Internal_Dyn dyn;
1478       asection *s;
1479
1480       (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
1481
1482       switch (dyn.d_tag)
1483         {
1484         default:
1485           if (htab->target_os == is_vxworks
1486               && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
1487             break;
1488           continue;
1489
1490         case DT_PLTGOT:
1491           s = htab->elf.sgotplt;
1492           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1493           break;
1494
1495         case DT_JMPREL:
1496           dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
1497           break;
1498
1499         case DT_PLTRELSZ:
1500           s = htab->elf.srelplt->output_section;
1501           dyn.d_un.d_val = s->size;
1502           break;
1503
1504         case DT_TLSDESC_PLT:
1505           s = htab->elf.splt;
1506           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1507             + htab->tlsdesc_plt;
1508           break;
1509
1510         case DT_TLSDESC_GOT:
1511           s = htab->elf.sgot;
1512           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1513             + htab->tlsdesc_got;
1514           break;
1515         }
1516
1517       (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
1518     }
1519
1520   if (htab->plt_got != NULL && htab->plt_got->size > 0)
1521     elf_section_data (htab->plt_got->output_section)
1522       ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1523
1524   if (htab->plt_second != NULL && htab->plt_second->size > 0)
1525     elf_section_data (htab->plt_second->output_section)
1526       ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1527
1528   /* Adjust .eh_frame for .plt section.  */
1529   if (htab->plt_eh_frame != NULL
1530       && htab->plt_eh_frame->contents != NULL)
1531     {
1532       if (htab->elf.splt != NULL
1533           && htab->elf.splt->size != 0
1534           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
1535           && htab->elf.splt->output_section != NULL
1536           && htab->plt_eh_frame->output_section != NULL)
1537         {
1538           bfd_vma plt_start = htab->elf.splt->output_section->vma;
1539           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
1540                                    + htab->plt_eh_frame->output_offset
1541                                    + PLT_FDE_START_OFFSET;
1542           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1543                              htab->plt_eh_frame->contents
1544                              + PLT_FDE_START_OFFSET);
1545         }
1546
1547       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1548         {
1549           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1550                                                  htab->plt_eh_frame,
1551                                                  htab->plt_eh_frame->contents))
1552             return NULL;
1553         }
1554     }
1555
1556   /* Adjust .eh_frame for .plt.got section.  */
1557   if (htab->plt_got_eh_frame != NULL
1558       && htab->plt_got_eh_frame->contents != NULL)
1559     {
1560       if (htab->plt_got != NULL
1561           && htab->plt_got->size != 0
1562           && (htab->plt_got->flags & SEC_EXCLUDE) == 0
1563           && htab->plt_got->output_section != NULL
1564           && htab->plt_got_eh_frame->output_section != NULL)
1565         {
1566           bfd_vma plt_start = htab->plt_got->output_section->vma;
1567           bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
1568                                    + htab->plt_got_eh_frame->output_offset
1569                                    + PLT_FDE_START_OFFSET;
1570           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1571                              htab->plt_got_eh_frame->contents
1572                              + PLT_FDE_START_OFFSET);
1573         }
1574       if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1575         {
1576           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1577                                                  htab->plt_got_eh_frame,
1578                                                  htab->plt_got_eh_frame->contents))
1579             return NULL;
1580         }
1581     }
1582
1583   /* Adjust .eh_frame for the second PLT section.  */
1584   if (htab->plt_second_eh_frame != NULL
1585       && htab->plt_second_eh_frame->contents != NULL)
1586     {
1587       if (htab->plt_second != NULL
1588           && htab->plt_second->size != 0
1589           && (htab->plt_second->flags & SEC_EXCLUDE) == 0
1590           && htab->plt_second->output_section != NULL
1591           && htab->plt_second_eh_frame->output_section != NULL)
1592         {
1593           bfd_vma plt_start = htab->plt_second->output_section->vma;
1594           bfd_vma eh_frame_start
1595             = (htab->plt_second_eh_frame->output_section->vma
1596                + htab->plt_second_eh_frame->output_offset
1597                + PLT_FDE_START_OFFSET);
1598           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1599                              htab->plt_second_eh_frame->contents
1600                              + PLT_FDE_START_OFFSET);
1601         }
1602       if (htab->plt_second_eh_frame->sec_info_type
1603           == SEC_INFO_TYPE_EH_FRAME)
1604         {
1605           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1606                                                  htab->plt_second_eh_frame,
1607                                                  htab->plt_second_eh_frame->contents))
1608             return NULL;
1609         }
1610     }
1611
1612   if (htab->elf.sgot && htab->elf.sgot->size > 0)
1613     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
1614       = htab->got_entry_size;
1615
1616   return htab;
1617 }
1618
1619
1620 bfd_boolean
1621 _bfd_x86_elf_always_size_sections (bfd *output_bfd,
1622                                    struct bfd_link_info *info)
1623 {
1624   asection *tls_sec = elf_hash_table (info)->tls_sec;
1625
1626   if (tls_sec)
1627     {
1628       struct elf_link_hash_entry *tlsbase;
1629
1630       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1631                                       "_TLS_MODULE_BASE_",
1632                                       FALSE, FALSE, FALSE);
1633
1634       if (tlsbase && tlsbase->type == STT_TLS)
1635         {
1636           struct elf_x86_link_hash_table *htab;
1637           struct bfd_link_hash_entry *bh = NULL;
1638           const struct elf_backend_data *bed
1639             = get_elf_backend_data (output_bfd);
1640
1641           htab = elf_x86_hash_table (info, bed->target_id);
1642           if (htab == NULL)
1643             return FALSE;
1644
1645           if (!(_bfd_generic_link_add_one_symbol
1646                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1647                  tls_sec, 0, NULL, FALSE,
1648                  bed->collect, &bh)))
1649             return FALSE;
1650
1651           htab->tls_module_base = bh;
1652
1653           tlsbase = (struct elf_link_hash_entry *)bh;
1654           tlsbase->def_regular = 1;
1655           tlsbase->other = STV_HIDDEN;
1656           tlsbase->root.linker_def = 1;
1657           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1658         }
1659     }
1660
1661   return TRUE;
1662 }
1663
1664 void
1665 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
1666                                      const Elf_Internal_Sym *isym,
1667                                      bfd_boolean definition,
1668                                      bfd_boolean dynamic ATTRIBUTE_UNUSED)
1669 {
1670   if (definition)
1671     {
1672       struct elf_x86_link_hash_entry *eh
1673         = (struct elf_x86_link_hash_entry *) h;
1674       eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
1675                            == STV_PROTECTED);
1676     }
1677 }
1678
1679 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1680
1681 void
1682 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
1683                                    struct elf_link_hash_entry *dir,
1684                                    struct elf_link_hash_entry *ind)
1685 {
1686   struct elf_x86_link_hash_entry *edir, *eind;
1687
1688   edir = (struct elf_x86_link_hash_entry *) dir;
1689   eind = (struct elf_x86_link_hash_entry *) ind;
1690
1691   if (eind->dyn_relocs != NULL)
1692     {
1693       if (edir->dyn_relocs != NULL)
1694         {
1695           struct elf_dyn_relocs **pp;
1696           struct elf_dyn_relocs *p;
1697
1698           /* Add reloc counts against the indirect sym to the direct sym
1699              list.  Merge any entries against the same section.  */
1700           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1701             {
1702               struct elf_dyn_relocs *q;
1703
1704               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1705                 if (q->sec == p->sec)
1706                   {
1707                     q->pc_count += p->pc_count;
1708                     q->count += p->count;
1709                     *pp = p->next;
1710                     break;
1711                   }
1712               if (q == NULL)
1713                 pp = &p->next;
1714             }
1715           *pp = edir->dyn_relocs;
1716         }
1717
1718       edir->dyn_relocs = eind->dyn_relocs;
1719       eind->dyn_relocs = NULL;
1720     }
1721
1722   if (ind->root.type == bfd_link_hash_indirect
1723       && dir->got.refcount <= 0)
1724     {
1725       edir->tls_type = eind->tls_type;
1726       eind->tls_type = GOT_UNKNOWN;
1727     }
1728
1729   /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1730      generate a R_386_COPY reloc.  */
1731   edir->gotoff_ref |= eind->gotoff_ref;
1732
1733   edir->zero_undefweak |= eind->zero_undefweak;
1734
1735   if (ELIMINATE_COPY_RELOCS
1736       && ind->root.type != bfd_link_hash_indirect
1737       && dir->dynamic_adjusted)
1738     {
1739       /* If called to transfer flags for a weakdef during processing
1740          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1741          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1742       if (dir->versioned != versioned_hidden)
1743         dir->ref_dynamic |= ind->ref_dynamic;
1744       dir->ref_regular |= ind->ref_regular;
1745       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1746       dir->needs_plt |= ind->needs_plt;
1747       dir->pointer_equality_needed |= ind->pointer_equality_needed;
1748     }
1749   else
1750     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1751 }
1752
1753 /* Remove undefined weak symbol from the dynamic symbol table if it
1754    is resolved to 0.   */
1755
1756 bfd_boolean
1757 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
1758                            struct elf_link_hash_entry *h)
1759 {
1760   if (h->dynindx != -1
1761       && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
1762     {
1763       h->dynindx = -1;
1764       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1765                               h->dynstr_index);
1766     }
1767   return TRUE;
1768 }
1769
1770 /* Change the STT_GNU_IFUNC symbol defined in position-dependent
1771    executable into the normal function symbol and set its address
1772    to its PLT entry, which should be resolved by R_*_IRELATIVE at
1773    run-time.  */
1774
1775 void
1776 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info,
1777                                       struct elf_x86_link_hash_table *htab,
1778                                       struct elf_link_hash_entry *h,
1779                                       Elf_Internal_Sym *sym)
1780 {
1781   if (bfd_link_pde (info)
1782       && h->def_regular
1783       && h->dynindx != -1
1784       && h->plt.offset != (bfd_vma) -1
1785       && h->type == STT_GNU_IFUNC
1786       && h->pointer_equality_needed)
1787     {
1788       asection *plt_s;
1789       bfd_vma plt_offset;
1790       bfd *output_bfd = info->output_bfd;
1791
1792       if (htab->plt_second)
1793         {
1794           struct elf_x86_link_hash_entry *eh
1795             = (struct elf_x86_link_hash_entry *) h;
1796
1797           plt_s = htab->plt_second;
1798           plt_offset = eh->plt_second.offset;
1799         }
1800       else
1801         {
1802           plt_s = htab->elf.splt;
1803           plt_offset = h->plt.offset;
1804         }
1805
1806       sym->st_size = 0;
1807       sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
1808       sym->st_shndx
1809         = _bfd_elf_section_from_bfd_section (output_bfd,
1810                                              plt_s->output_section);
1811       sym->st_value = (plt_s->output_section->vma
1812                        + plt_s->output_offset + plt_offset);
1813     }
1814 }
1815
1816 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
1817
1818 bfd_boolean
1819 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
1820 {
1821   if (h->plt.offset != (bfd_vma) -1
1822       && !h->def_regular
1823       && !h->pointer_equality_needed)
1824     return FALSE;
1825
1826   return _bfd_elf_hash_symbol (h);
1827 }
1828
1829 /* Adjust a symbol defined by a dynamic object and referenced by a
1830    regular object.  The current definition is in some section of the
1831    dynamic object, but we're not including those sections.  We have to
1832    change the definition to something the rest of the link can
1833    understand.  */
1834
1835 bfd_boolean
1836 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1837                                     struct elf_link_hash_entry *h)
1838 {
1839   struct elf_x86_link_hash_table *htab;
1840   asection *s, *srel;
1841   struct elf_x86_link_hash_entry *eh;
1842   struct elf_dyn_relocs *p;
1843   const struct elf_backend_data *bed
1844     = get_elf_backend_data (info->output_bfd);
1845
1846   /* STT_GNU_IFUNC symbol must go through PLT. */
1847   if (h->type == STT_GNU_IFUNC)
1848     {
1849       /* All local STT_GNU_IFUNC references must be treate as local
1850          calls via local PLT.  */
1851       if (h->ref_regular
1852           && SYMBOL_CALLS_LOCAL (info, h))
1853         {
1854           bfd_size_type pc_count = 0, count = 0;
1855           struct elf_dyn_relocs **pp;
1856
1857           eh = (struct elf_x86_link_hash_entry *) h;
1858           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1859             {
1860               pc_count += p->pc_count;
1861               p->count -= p->pc_count;
1862               p->pc_count = 0;
1863               count += p->count;
1864               if (p->count == 0)
1865                 *pp = p->next;
1866               else
1867                 pp = &p->next;
1868             }
1869
1870           if (pc_count || count)
1871             {
1872               h->non_got_ref = 1;
1873               if (pc_count)
1874                 {
1875                   /* Increment PLT reference count only for PC-relative
1876                      references.  */
1877                   h->needs_plt = 1;
1878                   if (h->plt.refcount <= 0)
1879                     h->plt.refcount = 1;
1880                   else
1881                     h->plt.refcount += 1;
1882                 }
1883             }
1884         }
1885
1886       if (h->plt.refcount <= 0)
1887         {
1888           h->plt.offset = (bfd_vma) -1;
1889           h->needs_plt = 0;
1890         }
1891       return TRUE;
1892     }
1893
1894   /* If this is a function, put it in the procedure linkage table.  We
1895      will fill in the contents of the procedure linkage table later,
1896      when we know the address of the .got section.  */
1897   if (h->type == STT_FUNC
1898       || h->needs_plt)
1899     {
1900       if (h->plt.refcount <= 0
1901           || SYMBOL_CALLS_LOCAL (info, h)
1902           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1903               && h->root.type == bfd_link_hash_undefweak))
1904         {
1905           /* This case can occur if we saw a PLT32 reloc in an input
1906              file, but the symbol was never referred to by a dynamic
1907              object, or if all references were garbage collected.  In
1908              such a case, we don't actually need to build a procedure
1909              linkage table, and we can just do a PC32 reloc instead.  */
1910           h->plt.offset = (bfd_vma) -1;
1911           h->needs_plt = 0;
1912         }
1913
1914       return TRUE;
1915     }
1916   else
1917     /* It's possible that we incorrectly decided a .plt reloc was needed
1918      * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1919        check_relocs.  We can't decide accurately between function and
1920        non-function syms in check-relocs;  Objects loaded later in
1921        the link may change h->type.  So fix it now.  */
1922     h->plt.offset = (bfd_vma) -1;
1923
1924   eh = (struct elf_x86_link_hash_entry *) h;
1925
1926   /* If this is a weak symbol, and there is a real definition, the
1927      processor independent code will have arranged for us to see the
1928      real definition first, and we can just use the same value.  */
1929   if (h->is_weakalias)
1930     {
1931       struct elf_link_hash_entry *def = weakdef (h);
1932       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1933       h->root.u.def.section = def->root.u.def.section;
1934       h->root.u.def.value = def->root.u.def.value;
1935       if (ELIMINATE_COPY_RELOCS
1936           || info->nocopyreloc
1937           || SYMBOL_NO_COPYRELOC (info, eh))
1938         {
1939           /* NB: needs_copy is always 0 for i386.  */
1940           h->non_got_ref = def->non_got_ref;
1941           eh->needs_copy = def->needs_copy;
1942         }
1943       return TRUE;
1944     }
1945
1946   /* This is a reference to a symbol defined by a dynamic object which
1947      is not a function.  */
1948
1949   /* If we are creating a shared library, we must presume that the
1950      only references to the symbol are via the global offset table.
1951      For such cases we need not do anything here; the relocations will
1952      be handled correctly by relocate_section.  */
1953   if (!bfd_link_executable (info))
1954     return TRUE;
1955
1956   /* If there are no references to this symbol that do not use the
1957      GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1958      reloc.  NB: gotoff_ref is always 0 for x86-64.  */
1959   if (!h->non_got_ref && !eh->gotoff_ref)
1960     return TRUE;
1961
1962   /* If -z nocopyreloc was given, we won't generate them either.  */
1963   if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
1964     {
1965       h->non_got_ref = 0;
1966       return TRUE;
1967     }
1968
1969   htab = elf_x86_hash_table (info, bed->target_id);
1970   if (htab == NULL)
1971     return FALSE;
1972
1973   /* If there aren't any dynamic relocs in read-only sections nor
1974      R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1975      avoid the copy reloc.  This doesn't work on VxWorks, where we can
1976      not have dynamic relocations (other than copy and jump slot
1977      relocations) in an executable.  */
1978   if (ELIMINATE_COPY_RELOCS
1979       && (bed->target_id == X86_64_ELF_DATA
1980           || (!eh->gotoff_ref
1981               && htab->target_os != is_vxworks)))
1982     {
1983       /* If we don't find any dynamic relocs in read-only sections,
1984          then we'll be keeping the dynamic relocs and avoiding the copy
1985          reloc.  */
1986       if (!readonly_dynrelocs (h))
1987         {
1988           h->non_got_ref = 0;
1989           return TRUE;
1990         }
1991     }
1992
1993   /* We must allocate the symbol in our .dynbss section, which will
1994      become part of the .bss section of the executable.  There will be
1995      an entry for this symbol in the .dynsym section.  The dynamic
1996      object will contain position independent code, so all references
1997      from the dynamic object to this symbol will go through the global
1998      offset table.  The dynamic linker will use the .dynsym entry to
1999      determine the address it must put in the global offset table, so
2000      both the dynamic object and the regular object will refer to the
2001      same memory location for the variable.  */
2002
2003   /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
2004      dynamic linker to copy the initial value out of the dynamic object
2005      and into the runtime process image.  */
2006   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2007     {
2008       s = htab->elf.sdynrelro;
2009       srel = htab->elf.sreldynrelro;
2010     }
2011   else
2012     {
2013       s = htab->elf.sdynbss;
2014       srel = htab->elf.srelbss;
2015     }
2016   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2017     {
2018       srel->size += htab->sizeof_reloc;
2019       h->needs_copy = 1;
2020     }
2021
2022   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2023 }
2024
2025 void
2026 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
2027                           struct elf_link_hash_entry *h,
2028                           bfd_boolean force_local)
2029 {
2030   if (h->root.type == bfd_link_hash_undefweak
2031       && info->nointerp
2032       && bfd_link_pie (info))
2033     {
2034       /* When there is no dynamic interpreter in PIE, make the undefined
2035          weak symbol dynamic so that PC relative branch to the undefined
2036          weak symbol will land to address 0.  */
2037       struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2038       if (h->plt.refcount > 0
2039           || eh->plt_got.refcount > 0)
2040         return;
2041     }
2042
2043   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2044 }
2045
2046 /* Return TRUE if a symbol is referenced locally.  It is similar to
2047    SYMBOL_REFERENCES_LOCAL, but it also checks version script.  It
2048    works in check_relocs.  */
2049
2050 bfd_boolean
2051 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
2052                                            struct elf_link_hash_entry *h)
2053 {
2054   struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2055   struct elf_x86_link_hash_table *htab
2056     = (struct elf_x86_link_hash_table *) info->hash;
2057
2058   if (eh->local_ref > 1)
2059     return TRUE;
2060
2061   if (eh->local_ref == 1)
2062     return FALSE;
2063
2064   /* Unversioned symbols defined in regular objects can be forced local
2065      by linker version script.  A weak undefined symbol is forced local
2066      if
2067      1. It has non-default visibility.  Or
2068      2. When building executable, there is no dynamic linker.  Or
2069      3. or "-z nodynamic-undefined-weak" is used.
2070    */
2071   if (SYMBOL_REFERENCES_LOCAL (info, h)
2072       || (h->root.type == bfd_link_hash_undefweak
2073           && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2074               || (bfd_link_executable (info)
2075                   && htab->interp == NULL)
2076               || info->dynamic_undefined_weak == 0))
2077       || ((h->def_regular || ELF_COMMON_DEF_P (h))
2078           && info->version_info != NULL
2079           && _bfd_elf_link_hide_sym_by_version (info, h)))
2080     {
2081       eh->local_ref = 2;
2082       return TRUE;
2083     }
2084
2085   eh->local_ref = 1;
2086   return FALSE;
2087 }
2088
2089 /* Return the section that should be marked against GC for a given
2090    relocation.  */
2091
2092 asection *
2093 _bfd_x86_elf_gc_mark_hook (asection *sec,
2094                            struct bfd_link_info *info,
2095                            Elf_Internal_Rela *rel,
2096                            struct elf_link_hash_entry *h,
2097                            Elf_Internal_Sym *sym)
2098 {
2099   /* Compiler should optimize this out.  */
2100   if (((unsigned int) R_X86_64_GNU_VTINHERIT
2101        != (unsigned int) R_386_GNU_VTINHERIT)
2102       || ((unsigned int) R_X86_64_GNU_VTENTRY
2103           != (unsigned int) R_386_GNU_VTENTRY))
2104     abort ();
2105
2106   if (h != NULL)
2107     switch (ELF32_R_TYPE (rel->r_info))
2108       {
2109       case R_X86_64_GNU_VTINHERIT:
2110       case R_X86_64_GNU_VTENTRY:
2111         return NULL;
2112       }
2113
2114   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2115 }
2116
2117 static bfd_vma
2118 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
2119                           bfd_vma off,
2120                           bfd_vma offset ATTRIBUTE_UNUSED,
2121                           bfd_vma got_addr)
2122 {
2123   return got_addr + off;
2124 }
2125
2126 static bfd_vma
2127 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
2128                             bfd_vma off,
2129                             bfd_vma offset,
2130                             bfd_vma got_addr ATTRIBUTE_UNUSED)
2131 {
2132   return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
2133 }
2134
2135 static bfd_boolean
2136 elf_i386_valid_plt_reloc_p (unsigned int type)
2137 {
2138   return (type == R_386_JUMP_SLOT
2139           || type == R_386_GLOB_DAT
2140           || type == R_386_IRELATIVE);
2141 }
2142
2143 static bfd_boolean
2144 elf_x86_64_valid_plt_reloc_p (unsigned int type)
2145 {
2146   return (type == R_X86_64_JUMP_SLOT
2147           || type == R_X86_64_GLOB_DAT
2148           || type == R_X86_64_IRELATIVE);
2149 }
2150
2151 long
2152 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
2153                                    long count,
2154                                    long relsize,
2155                                    bfd_vma got_addr,
2156                                    struct elf_x86_plt plts[],
2157                                    asymbol **dynsyms,
2158                                    asymbol **ret)
2159 {
2160   long size, i, n, len;
2161   int j;
2162   unsigned int plt_got_offset, plt_entry_size;
2163   asymbol *s;
2164   bfd_byte *plt_contents;
2165   long dynrelcount;
2166   arelent **dynrelbuf, *p;
2167   char *names;
2168   const struct elf_backend_data *bed;
2169   bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
2170                               bfd_vma);
2171   bfd_boolean (*valid_plt_reloc_p) (unsigned int);
2172
2173   if (count == 0)
2174     return -1;
2175
2176   dynrelbuf = (arelent **) bfd_malloc (relsize);
2177   if (dynrelbuf == NULL)
2178     return -1;
2179
2180   dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
2181                                                 dynsyms);
2182   if (dynrelcount <= 0)
2183     return -1;
2184
2185   /* Sort the relocs by address.  */
2186   qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
2187          _bfd_x86_elf_compare_relocs);
2188
2189   size = count * sizeof (asymbol);
2190
2191   /* Allocate space for @plt suffixes.  */
2192   n = 0;
2193   for (i = 0; i < dynrelcount; i++)
2194     {
2195       p = dynrelbuf[i];
2196       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2197       if (p->addend != 0)
2198         size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
2199     }
2200
2201   s = *ret = (asymbol *) bfd_zmalloc (size);
2202   if (s == NULL)
2203     goto bad_return;
2204
2205   bed = get_elf_backend_data (abfd);
2206
2207   if (bed->target_id == X86_64_ELF_DATA)
2208     {
2209       get_plt_got_vma = elf_x86_64_get_plt_got_vma;
2210       valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
2211     }
2212   else
2213     {
2214       get_plt_got_vma = elf_i386_get_plt_got_vma;
2215       valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
2216       if (got_addr)
2217         {
2218           /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2219              address.  */
2220           asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
2221           if (sec != NULL)
2222             got_addr = sec->vma;
2223           else
2224             {
2225               sec = bfd_get_section_by_name (abfd, ".got");
2226               if (sec != NULL)
2227                 got_addr = sec->vma;
2228             }
2229
2230           if (got_addr == (bfd_vma) -1)
2231             goto bad_return;
2232         }
2233     }
2234
2235   /* Check for each PLT section.  */
2236   names = (char *) (s + count);
2237   size = 0;
2238   n = 0;
2239   for (j = 0; plts[j].name != NULL; j++)
2240     if ((plt_contents = plts[j].contents) != NULL)
2241       {
2242         long k;
2243         bfd_vma offset;
2244         asection *plt;
2245         struct elf_x86_plt *plt_p = &plts[j];
2246
2247         plt_got_offset = plt_p->plt_got_offset;
2248         plt_entry_size = plt_p->plt_entry_size;
2249
2250         plt = plt_p->sec;
2251
2252         if ((plt_p->type & plt_lazy))
2253           {
2254             /* Skip PLT0 in lazy PLT.  */
2255             k = 1;
2256             offset = plt_entry_size;
2257           }
2258         else
2259           {
2260             k = 0;
2261             offset = 0;
2262           }
2263
2264         /* Check each PLT entry against dynamic relocations.  */
2265         for (; k < plt_p->count; k++)
2266           {
2267             int off;
2268             bfd_vma got_vma;
2269             long min, max, mid;
2270
2271             /* Get the GOT offset for i386 or the PC-relative offset
2272                for x86-64, a signed 32-bit integer.  */
2273             off = H_GET_32 (abfd, (plt_contents + offset
2274                                    + plt_got_offset));
2275             got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
2276
2277             /* Binary search.  */
2278             p = dynrelbuf[0];
2279             min = 0;
2280             max = dynrelcount;
2281             while ((min + 1) < max)
2282               {
2283                 arelent *r;
2284
2285                 mid = (min + max) / 2;
2286                 r = dynrelbuf[mid];
2287                 if (got_vma > r->address)
2288                   min = mid;
2289                 else if (got_vma < r->address)
2290                   max = mid;
2291                 else
2292                   {
2293                     p = r;
2294                     break;
2295                   }
2296               }
2297
2298             /* Skip unknown relocation.  PR 17512: file: bc9d6cf5.  */
2299             if (got_vma == p->address
2300                 && p->howto != NULL
2301                 && valid_plt_reloc_p (p->howto->type))
2302               {
2303                 *s = **p->sym_ptr_ptr;
2304                 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2305                    set.  Since we are defining a symbol, ensure one
2306                    of them is set.  */
2307                 if ((s->flags & BSF_LOCAL) == 0)
2308                   s->flags |= BSF_GLOBAL;
2309                 s->flags |= BSF_SYNTHETIC;
2310                 /* This is no longer a section symbol.  */
2311                 s->flags &= ~BSF_SECTION_SYM;
2312                 s->section = plt;
2313                 s->the_bfd = plt->owner;
2314                 s->value = offset;
2315                 s->udata.p = NULL;
2316                 s->name = names;
2317                 len = strlen ((*p->sym_ptr_ptr)->name);
2318                 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2319                 names += len;
2320                 if (p->addend != 0)
2321                   {
2322                     char buf[30], *a;
2323
2324                     memcpy (names, "+0x", sizeof ("+0x") - 1);
2325                     names += sizeof ("+0x") - 1;
2326                     bfd_sprintf_vma (abfd, buf, p->addend);
2327                     for (a = buf; *a == '0'; ++a)
2328                       ;
2329                     size = strlen (a);
2330                     memcpy (names, a, size);
2331                     names += size;
2332                   }
2333                 memcpy (names, "@plt", sizeof ("@plt"));
2334                 names += sizeof ("@plt");
2335                 n++;
2336                 s++;
2337                 /* There should be only one entry in PLT for a given
2338                    symbol.  Set howto to NULL after processing a PLT
2339                    entry to guard against corrupted PLT.  */
2340                 p->howto = NULL;
2341               }
2342             offset += plt_entry_size;
2343           }
2344       }
2345
2346   /* PLT entries with R_386_TLS_DESC relocations are skipped.  */
2347   if (n == 0)
2348     {
2349 bad_return:
2350       count = -1;
2351     }
2352   else
2353     count = n;
2354
2355   for (j = 0; plts[j].name != NULL; j++)
2356     if (plts[j].contents != NULL)
2357       free (plts[j].contents);
2358
2359   free (dynrelbuf);
2360
2361   return count;
2362 }
2363
2364 /* Parse x86 GNU properties.  */
2365
2366 enum elf_property_kind
2367 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
2368                                    bfd_byte *ptr, unsigned int datasz)
2369 {
2370   elf_property *prop;
2371
2372   if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2373       || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2374       || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
2375           && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2376       || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
2377           && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
2378       || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2379           && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2380     {
2381       if (datasz != 4)
2382         {
2383           _bfd_error_handler
2384             (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"),
2385              abfd, type, datasz);
2386           return property_corrupt;
2387         }
2388       prop = _bfd_elf_get_property (abfd, type, datasz);
2389       prop->u.number |= bfd_h_get_32 (abfd, ptr);
2390       prop->pr_kind = property_number;
2391       return property_number;
2392     }
2393
2394   return property_ignored;
2395 }
2396
2397 /* Merge x86 GNU property BPROP with APROP.  If APROP isn't NULL,
2398    return TRUE if APROP is updated.  Otherwise, return TRUE if BPROP
2399    should be merged with ABFD.  */
2400
2401 bfd_boolean
2402 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
2403                                    bfd *abfd ATTRIBUTE_UNUSED,
2404                                    elf_property *aprop,
2405                                    elf_property *bprop)
2406 {
2407   unsigned int number, features;
2408   bfd_boolean updated = FALSE;
2409   unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
2410
2411   if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2412       || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2413           && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2414     {
2415       if (aprop == NULL || bprop == NULL)
2416         {
2417           /* Only one of APROP and BPROP can be NULL.  */
2418           if (aprop != NULL)
2419             {
2420               /* Remove this property since the other input file doesn't
2421                  have it.  */
2422               aprop->pr_kind = property_remove;
2423               updated = TRUE;
2424             }
2425         }
2426       else
2427         {
2428           number = aprop->u.number;
2429           aprop->u.number = number | bprop->u.number;
2430           updated = number != (unsigned int) aprop->u.number;
2431         }
2432       return updated;
2433     }
2434   else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2435            || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO
2436                && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI))
2437     {
2438       if (aprop != NULL && bprop != NULL)
2439         {
2440           number = aprop->u.number;
2441           aprop->u.number = number | bprop->u.number;
2442           /* Remove the property if all bits are empty.  */
2443           if (aprop->u.number == 0)
2444             {
2445               aprop->pr_kind = property_remove;
2446               updated = TRUE;
2447             }
2448           else
2449             updated = number != (unsigned int) aprop->u.number;
2450         }
2451       else
2452         {
2453           /* Only one of APROP and BPROP can be NULL.  */
2454           if (aprop != NULL)
2455             {
2456               if (aprop->u.number == 0)
2457                 {
2458                   /* Remove APROP if all bits are empty.  */
2459                   aprop->pr_kind = property_remove;
2460                   updated = TRUE;
2461                 }
2462             }
2463           else
2464             {
2465               /* Return TRUE if APROP is NULL and all bits of BPROP
2466                  aren't empty to indicate that BPROP should be added
2467                  to ABFD.  */
2468               updated = bprop->u.number != 0;
2469             }
2470         }
2471       return updated;
2472     }
2473   else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO
2474            && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2475     {
2476       /* Only one of APROP and BPROP can be NULL:
2477          1. APROP & BPROP when both APROP and BPROP aren't NULL.
2478          2. If APROP is NULL, remove x86 feature.
2479          3. Otherwise, do nothing.
2480        */
2481       if (aprop != NULL && bprop != NULL)
2482         {
2483           features = 0;
2484           if (info->ibt)
2485             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2486           if (info->shstk)
2487             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2488           number = aprop->u.number;
2489           /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2490              GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
2491           aprop->u.number = (number & bprop->u.number) | features;
2492           updated = number != (unsigned int) aprop->u.number;
2493           /* Remove the property if all feature bits are cleared.  */
2494           if (aprop->u.number == 0)
2495             aprop->pr_kind = property_remove;
2496         }
2497       else
2498         {
2499           features = 0;
2500           if (info->ibt)
2501             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2502           if (info->shstk)
2503             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2504           if (features)
2505             {
2506               /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2507                  GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
2508               if (aprop != NULL)
2509                 {
2510                   number = aprop->u.number;
2511                   aprop->u.number = number | features;
2512                   updated = number != (unsigned int) aprop->u.number;
2513                 }
2514               else
2515                 {
2516                   bprop->u.number |= features;
2517                   updated = TRUE;
2518                 }
2519             }
2520           else if (aprop != NULL)
2521             {
2522               aprop->pr_kind = property_remove;
2523               updated = TRUE;
2524             }
2525         }
2526       return updated;
2527     }
2528   else
2529     {
2530       /* Never should happen.  */
2531       abort ();
2532     }
2533
2534   return updated;
2535 }
2536
2537 /* Set up x86 GNU properties.  Return the first relocatable ELF input
2538    with GNU properties if found.  Otherwise, return NULL.  */
2539
2540 bfd *
2541 _bfd_x86_elf_link_setup_gnu_properties
2542   (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
2543 {
2544   bfd_boolean normal_target;
2545   bfd_boolean lazy_plt;
2546   asection *sec, *pltsec;
2547   bfd *dynobj;
2548   bfd_boolean use_ibt_plt;
2549   unsigned int plt_alignment, features;
2550   struct elf_x86_link_hash_table *htab;
2551   bfd *pbfd;
2552   bfd *ebfd = NULL;
2553   elf_property *prop;
2554   const struct elf_backend_data *bed;
2555   unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
2556   unsigned int got_align;
2557
2558   features = 0;
2559   if (info->ibt)
2560     features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2561   if (info->shstk)
2562     features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2563
2564   /* Find a normal input file with GNU property note.  */
2565   for (pbfd = info->input_bfds;
2566        pbfd != NULL;
2567        pbfd = pbfd->link.next)
2568     if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
2569         && bfd_count_sections (pbfd) != 0)
2570       {
2571         ebfd = pbfd;
2572
2573         if (elf_properties (pbfd) != NULL)
2574           break;
2575       }
2576
2577   bed = get_elf_backend_data (info->output_bfd);
2578
2579   htab = elf_x86_hash_table (info, bed->target_id);
2580   if (htab == NULL)
2581     return pbfd;
2582
2583   if (ebfd != NULL)
2584     {
2585       prop = NULL;
2586       if (features)
2587         {
2588           /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2589              GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
2590           prop = _bfd_elf_get_property (ebfd,
2591                                         GNU_PROPERTY_X86_FEATURE_1_AND,
2592                                         4);
2593           prop->u.number |= features;
2594           prop->pr_kind = property_number;
2595         }
2596
2597       /* Create the GNU property note section if needed.  */
2598       if (prop != NULL && pbfd == NULL)
2599         {
2600           sec = bfd_make_section_with_flags (ebfd,
2601                                              NOTE_GNU_PROPERTY_SECTION_NAME,
2602                                              (SEC_ALLOC
2603                                               | SEC_LOAD
2604                                               | SEC_IN_MEMORY
2605                                               | SEC_READONLY
2606                                               | SEC_HAS_CONTENTS
2607                                               | SEC_DATA));
2608           if (sec == NULL)
2609             info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
2610
2611           if (!bfd_set_section_alignment (ebfd, sec, class_align))
2612             {
2613 error_alignment:
2614               info->callbacks->einfo (_("%F%pA: failed to align section\n"),
2615                                       sec);
2616             }
2617
2618           elf_section_type (sec) = SHT_NOTE;
2619         }
2620     }
2621
2622   pbfd = _bfd_elf_link_setup_gnu_properties (info);
2623
2624   htab->r_info = init_table->r_info;
2625   htab->r_sym = init_table->r_sym;
2626
2627   if (bfd_link_relocatable (info))
2628     return pbfd;
2629
2630   htab->plt0_pad_byte = init_table->plt0_pad_byte;
2631
2632   use_ibt_plt = info->ibtplt || info->ibt;
2633   if (!use_ibt_plt && pbfd != NULL)
2634     {
2635       /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on.  */
2636       elf_property_list *p;
2637
2638       /* The property list is sorted in order of type.  */
2639       for (p = elf_properties (pbfd); p; p = p->next)
2640         {
2641           if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
2642             {
2643               use_ibt_plt = !!(p->property.u.number
2644                                & GNU_PROPERTY_X86_FEATURE_1_IBT);
2645               break;
2646             }
2647           else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
2648             break;
2649         }
2650     }
2651
2652   dynobj = htab->elf.dynobj;
2653
2654   /* Set htab->elf.dynobj here so that there is no need to check and
2655      set it in check_relocs.  */
2656   if (dynobj == NULL)
2657     {
2658       if (pbfd != NULL)
2659         {
2660           htab->elf.dynobj = pbfd;
2661           dynobj = pbfd;
2662         }
2663       else
2664         {
2665           bfd *abfd;
2666
2667           /* Find a normal input file to hold linker created
2668              sections.  */
2669           for (abfd = info->input_bfds;
2670                abfd != NULL;
2671                abfd = abfd->link.next)
2672             if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2673                 && (abfd->flags
2674                     & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
2675                 && bed->relocs_compatible (abfd->xvec,
2676                                            info->output_bfd->xvec))
2677               {
2678                 htab->elf.dynobj = abfd;
2679                 dynobj = abfd;
2680                 break;
2681               }
2682         }
2683     }
2684
2685   /* Return if there are no normal input files.  */
2686   if (dynobj == NULL)
2687     return pbfd;
2688
2689   /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2690      still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2691      canonical function address.  */
2692   htab->plt.has_plt0 = 1;
2693   normal_target = htab->target_os == is_normal;
2694
2695   if (normal_target)
2696     {
2697       if (use_ibt_plt)
2698         {
2699           htab->lazy_plt = init_table->lazy_ibt_plt;
2700           htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
2701         }
2702       else
2703         {
2704           htab->lazy_plt = init_table->lazy_plt;
2705           htab->non_lazy_plt = init_table->non_lazy_plt;
2706         }
2707     }
2708   else
2709     {
2710       htab->lazy_plt = init_table->lazy_plt;
2711       htab->non_lazy_plt = NULL;
2712     }
2713
2714   pltsec = htab->elf.splt;
2715
2716   /* If the non-lazy PLT is available, use it for all PLT entries if
2717      there are no PLT0 or no .plt section.  */
2718   if (htab->non_lazy_plt != NULL
2719       && (!htab->plt.has_plt0 || pltsec == NULL))
2720     {
2721       lazy_plt = FALSE;
2722       if (bfd_link_pic (info))
2723         htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
2724       else
2725         htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
2726       htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
2727       htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
2728       htab->plt.plt_got_insn_size
2729         = htab->non_lazy_plt->plt_got_insn_size;
2730       htab->plt.eh_frame_plt_size
2731         = htab->non_lazy_plt->eh_frame_plt_size;
2732       htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
2733     }
2734   else
2735     {
2736       lazy_plt = TRUE;
2737       if (bfd_link_pic (info))
2738         {
2739           htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
2740           htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
2741         }
2742       else
2743         {
2744           htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
2745           htab->plt.plt_entry = htab->lazy_plt->plt_entry;
2746         }
2747       htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
2748       htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
2749       htab->plt.plt_got_insn_size
2750         = htab->lazy_plt->plt_got_insn_size;
2751       htab->plt.eh_frame_plt_size
2752         = htab->lazy_plt->eh_frame_plt_size;
2753       htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
2754     }
2755
2756   if (htab->target_os == is_vxworks
2757       && !elf_vxworks_create_dynamic_sections (dynobj, info,
2758                                                &htab->srelplt2))
2759     {
2760       info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2761       return pbfd;
2762     }
2763
2764   /* Since create_dynamic_sections isn't always called, but GOT
2765      relocations need GOT relocations, create them here so that we
2766      don't need to do it in check_relocs.  */
2767   if (htab->elf.sgot == NULL
2768       && !_bfd_elf_create_got_section (dynobj, info))
2769     info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
2770
2771   got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
2772
2773   /* Align .got and .got.plt sections to their entry size.  Do it here
2774      instead of in create_dynamic_sections so that they are always
2775      properly aligned even if create_dynamic_sections isn't called.  */
2776   sec = htab->elf.sgot;
2777   if (!bfd_set_section_alignment (dynobj, sec, got_align))
2778     goto error_alignment;
2779
2780   sec = htab->elf.sgotplt;
2781   if (!bfd_set_section_alignment (dynobj, sec, got_align))
2782     goto error_alignment;
2783
2784   /* Create the ifunc sections here so that check_relocs can be
2785      simplified.  */
2786   if (!_bfd_elf_create_ifunc_sections (dynobj, info))
2787     info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
2788
2789   plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
2790
2791   if (pltsec != NULL)
2792     {
2793       /* Whe creating executable, set the contents of the .interp
2794          section to the interpreter.  */
2795       if (bfd_link_executable (info) && !info->nointerp)
2796         {
2797           asection *s = bfd_get_linker_section (dynobj, ".interp");
2798           if (s == NULL)
2799             abort ();
2800           s->size = htab->dynamic_interpreter_size;
2801           s->contents = (unsigned char *) htab->dynamic_interpreter;
2802           htab->interp = s;
2803         }
2804
2805       /* Don't change PLT section alignment for NaCl since it uses
2806          64-byte PLT entry and sets PLT section alignment to 32
2807          bytes.  Don't create additional PLT sections for NaCl.  */
2808       if (normal_target)
2809         {
2810           flagword pltflags = (bed->dynamic_sec_flags
2811                                | SEC_ALLOC
2812                                | SEC_CODE
2813                                | SEC_LOAD
2814                                | SEC_READONLY);
2815           unsigned int non_lazy_plt_alignment
2816             = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
2817
2818           sec = pltsec;
2819           if (!bfd_set_section_alignment (sec->owner, sec,
2820                                           plt_alignment))
2821             goto error_alignment;
2822
2823           /* Create the GOT procedure linkage table.  */
2824           sec = bfd_make_section_anyway_with_flags (dynobj,
2825                                                     ".plt.got",
2826                                                     pltflags);
2827           if (sec == NULL)
2828             info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
2829
2830           if (!bfd_set_section_alignment (dynobj, sec,
2831                                           non_lazy_plt_alignment))
2832             goto error_alignment;
2833
2834           htab->plt_got = sec;
2835
2836           if (lazy_plt)
2837             {
2838               sec = NULL;
2839
2840               if (use_ibt_plt)
2841                 {
2842                   /* Create the second PLT for Intel IBT support.  IBT
2843                      PLT is supported only for non-NaCl target and is
2844                      is needed only for lazy binding.  */
2845                   sec = bfd_make_section_anyway_with_flags (dynobj,
2846                                                             ".plt.sec",
2847                                                             pltflags);
2848                   if (sec == NULL)
2849                     info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
2850
2851                   if (!bfd_set_section_alignment (dynobj, sec,
2852                                                   plt_alignment))
2853                     goto error_alignment;
2854                 }
2855               else if (info->bndplt && ABI_64_P (dynobj))
2856                 {
2857                   /* Create the second PLT for Intel MPX support.  MPX
2858                      PLT is supported only for non-NaCl target in 64-bit
2859                      mode and is needed only for lazy binding.  */
2860                   sec = bfd_make_section_anyway_with_flags (dynobj,
2861                                                             ".plt.sec",
2862                                                             pltflags);
2863                   if (sec == NULL)
2864                     info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n"));
2865
2866                   if (!bfd_set_section_alignment (dynobj, sec,
2867                                                   non_lazy_plt_alignment))
2868                     goto error_alignment;
2869                 }
2870
2871               htab->plt_second = sec;
2872             }
2873         }
2874
2875       if (!info->no_ld_generated_unwind_info)
2876         {
2877           flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2878                             | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2879                             | SEC_LINKER_CREATED);
2880
2881           sec = bfd_make_section_anyway_with_flags (dynobj,
2882                                                     ".eh_frame",
2883                                                     flags);
2884           if (sec == NULL)
2885             info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
2886
2887           if (!bfd_set_section_alignment (dynobj, sec, class_align))
2888             goto error_alignment;
2889
2890           htab->plt_eh_frame = sec;
2891
2892           if (htab->plt_got != NULL)
2893             {
2894               sec = bfd_make_section_anyway_with_flags (dynobj,
2895                                                         ".eh_frame",
2896                                                         flags);
2897               if (sec == NULL)
2898                 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
2899
2900               if (!bfd_set_section_alignment (dynobj, sec, class_align))
2901                 goto error_alignment;
2902
2903               htab->plt_got_eh_frame = sec;
2904             }
2905
2906           if (htab->plt_second != NULL)
2907             {
2908               sec = bfd_make_section_anyway_with_flags (dynobj,
2909                                                         ".eh_frame",
2910                                                         flags);
2911               if (sec == NULL)
2912                 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
2913
2914               if (!bfd_set_section_alignment (dynobj, sec, class_align))
2915                 goto error_alignment;
2916
2917               htab->plt_second_eh_frame = sec;
2918             }
2919         }
2920     }
2921
2922   /* The .iplt section is used for IFUNC symbols in static
2923      executables.  */
2924   sec = htab->elf.iplt;
2925   if (sec != NULL)
2926     {
2927       /* NB: Delay setting its alignment until we know it is non-empty.
2928          Otherwise an empty iplt section may change vma and lma of the
2929          following sections, which triggers moving dot of the following
2930          section backwards, resulting in a warning and section lma not
2931          being set properly.  It later leads to a "File truncated"
2932          error.  */
2933       if (!bfd_set_section_alignment (sec->owner, sec, 0))
2934         goto error_alignment;
2935
2936       htab->plt.iplt_alignment = (normal_target
2937                                   ? plt_alignment
2938                                   : bed->plt_alignment);
2939     }
2940
2941   return pbfd;
2942 }
2943
2944 /* Fix up x86 GNU properties.  */
2945
2946 void
2947 _bfd_x86_elf_link_fixup_gnu_properties
2948   (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2949    elf_property_list **listp)
2950 {
2951   elf_property_list *p;
2952
2953   for (p = *listp; p; p = p->next)
2954     {
2955       unsigned int type = p->property.pr_type;
2956       if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2957           || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2958           || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
2959               && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2960           || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
2961               && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
2962           || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2963               && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2964         {
2965           if (p->property.u.number == 0
2966               && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2967                   || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
2968                       && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2969                   || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
2970                       && type <= GNU_PROPERTY_X86_UINT32_OR_HI)))
2971             {
2972               /* Remove empty property.  */
2973               *listp = p->next;
2974               continue;
2975             }
2976
2977           listp = &p->next;
2978         }
2979       else if (type > GNU_PROPERTY_HIPROC)
2980         {
2981           /* The property list is sorted in order of type.  */
2982           break;
2983         }
2984     }
2985 }