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