1 /* x86 specific support for ELF
2 Copyright (C) 2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
21 #include "elfxx-x86.h"
22 #include "elf-vxworks.h"
25 #include "elf/x86-64.h"
27 /* The name of the dynamic interpreter. This is put in the .interp
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"
35 _bfd_x86_elf_mkobject (bfd *abfd)
37 return bfd_elf_allocate_object (abfd,
38 sizeof (struct elf_x86_obj_tdata),
39 get_elf_backend_data (abfd)->target_id);
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. */
48 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
50 struct elf_x86_link_hash_table *htab;
51 struct bfd_link_hash_entry *base;
52 const struct elf_backend_data *bed;
54 if (!bfd_link_executable (info))
57 bed = get_elf_backend_data (info->output_bfd);
58 htab = elf_x86_hash_table (info, bed->target_id);
62 base = htab->tls_module_base;
66 base->u.def.value = htab->elf.tls_size;
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. */
74 _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info)
76 /* If tls_sec is NULL, we should have signalled an error already. */
77 if (elf_hash_table (info)->tls_sec == NULL)
79 return elf_hash_table (info)->tls_sec->vma;
82 /* Allocate space in .plt, .got and associated reloc sections for
86 elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
88 struct bfd_link_info *info;
89 struct elf_x86_link_hash_table *htab;
90 struct elf_x86_link_hash_entry *eh;
91 struct elf_dyn_relocs *p;
92 unsigned int plt_entry_size;
93 bfd_boolean resolved_to_zero;
94 const struct elf_backend_data *bed;
96 if (h->root.type == bfd_link_hash_indirect)
99 eh = (struct elf_x86_link_hash_entry *) h;
101 info = (struct bfd_link_info *) inf;
102 bed = get_elf_backend_data (info->output_bfd);
103 htab = elf_x86_hash_table (info, bed->target_id);
107 plt_entry_size = htab->plt.plt_entry_size;
109 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
111 /* We can't use the GOT PLT if pointer equality is needed since
112 finish_dynamic_symbol won't clear symbol value and the dynamic
113 linker won't update the GOT slot. We will get into an infinite
115 if (htab->plt_got != NULL
116 && h->type != STT_GNU_IFUNC
117 && !h->pointer_equality_needed
118 && h->plt.refcount > 0
119 && h->got.refcount > 0)
121 /* Don't use the regular PLT if there are both GOT and GOTPLT
123 h->plt.offset = (bfd_vma) -1;
125 /* Use the GOT PLT. */
126 eh->plt_got.refcount = 1;
129 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
130 here if it is defined and referenced in a non-shared object. */
131 if (h->type == STT_GNU_IFUNC
134 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
135 &htab->readonly_dynrelocs_against_ifunc,
139 htab->got_entry_size,
142 asection *s = htab->plt_second;
143 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
145 /* Use the second PLT section if it is created. */
146 eh->plt_second.offset = s->size;
148 /* Make room for this entry in the second PLT section. */
149 s->size += htab->non_lazy_plt->plt_entry_size;
157 /* Don't create the PLT entry if there are only function pointer
158 relocations which can be resolved at run-time. */
159 else if (htab->elf.dynamic_sections_created
160 && (h->plt.refcount > 0
161 || eh->plt_got.refcount > 0))
163 bfd_boolean use_plt_got = eh->plt_got.refcount > 0;
165 /* Make sure this symbol is output as a dynamic symbol.
166 Undefined weak syms won't yet be marked as dynamic. */
170 && h->root.type == bfd_link_hash_undefweak)
172 if (! bfd_elf_link_record_dynamic_symbol (info, h))
176 if (bfd_link_pic (info)
177 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
179 asection *s = htab->elf.splt;
180 asection *second_s = htab->plt_second;
181 asection *got_s = htab->plt_got;
183 /* If this is the first .plt entry, make room for the special
184 first entry. The .plt section is used by prelink to undo
185 prelinking for dynamic relocations. */
187 s->size = htab->plt.has_plt0 * plt_entry_size;
190 eh->plt_got.offset = got_s->size;
193 h->plt.offset = s->size;
195 eh->plt_second.offset = second_s->size;
198 /* If this symbol is not defined in a regular file, and we are
199 not generating a shared library, then set the symbol to this
200 location in the .plt. This is required to make function
201 pointers compare as equal between the normal executable and
202 the shared library. */
203 if (! bfd_link_pic (info)
208 /* We need to make a call to the entry of the GOT PLT
209 instead of regular PLT entry. */
210 h->root.u.def.section = got_s;
211 h->root.u.def.value = eh->plt_got.offset;
217 /* We need to make a call to the entry of the
218 second PLT instead of regular PLT entry. */
219 h->root.u.def.section = second_s;
220 h->root.u.def.value = eh->plt_second.offset;
224 h->root.u.def.section = s;
225 h->root.u.def.value = h->plt.offset;
230 /* Make room for this entry. */
232 got_s->size += htab->non_lazy_plt->plt_entry_size;
235 s->size += plt_entry_size;
237 second_s->size += htab->non_lazy_plt->plt_entry_size;
239 /* We also need to make an entry in the .got.plt section,
240 which will be placed in the .got section by the linker
242 htab->elf.sgotplt->size += htab->got_entry_size;
244 /* There should be no PLT relocation against resolved
245 undefined weak symbol in executable. */
246 if (!resolved_to_zero)
248 /* We also need to make an entry in the .rel.plt
250 htab->elf.srelplt->size += htab->sizeof_reloc;
251 htab->elf.srelplt->reloc_count++;
255 if (htab->target_os == is_vxworks && !bfd_link_pic (info))
257 /* VxWorks has a second set of relocations for each PLT entry
258 in executables. They go in a separate relocation section,
259 which is processed by the kernel loader. */
261 /* There are two relocations for the initial PLT entry: an
262 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
263 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
265 asection *srelplt2 = htab->srelplt2;
266 if (h->plt.offset == plt_entry_size)
267 srelplt2->size += (htab->sizeof_reloc * 2);
269 /* There are two extra relocations for each subsequent PLT entry:
270 an R_386_32 relocation for the GOT entry, and an R_386_32
271 relocation for the PLT entry. */
273 srelplt2->size += (htab->sizeof_reloc * 2);
278 eh->plt_got.offset = (bfd_vma) -1;
279 h->plt.offset = (bfd_vma) -1;
285 eh->plt_got.offset = (bfd_vma) -1;
286 h->plt.offset = (bfd_vma) -1;
290 eh->tlsdesc_got = (bfd_vma) -1;
292 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
293 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
294 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
295 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
296 if (h->got.refcount > 0
297 && bfd_link_executable (info)
299 && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
300 h->got.offset = (bfd_vma) -1;
301 else if (h->got.refcount > 0)
305 int tls_type = elf_x86_hash_entry (h)->tls_type;
307 /* Make sure this symbol is output as a dynamic symbol.
308 Undefined weak syms won't yet be marked as dynamic. */
312 && h->root.type == bfd_link_hash_undefweak)
314 if (! bfd_elf_link_record_dynamic_symbol (info, h))
319 if (GOT_TLS_GDESC_P (tls_type))
321 eh->tlsdesc_got = htab->elf.sgotplt->size
322 - elf_x86_compute_jump_table_size (htab);
323 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
324 h->got.offset = (bfd_vma) -2;
326 if (! GOT_TLS_GDESC_P (tls_type)
327 || GOT_TLS_GD_P (tls_type))
329 h->got.offset = s->size;
330 s->size += htab->got_entry_size;
331 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
333 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
334 s->size += htab->got_entry_size;
336 dyn = htab->elf.dynamic_sections_created;
337 /* R_386_TLS_IE_32 needs one dynamic relocation,
338 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
339 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
340 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
341 symbol and two if global. No dynamic relocation against
342 resolved undefined weak symbol in executable. */
343 if (tls_type == GOT_TLS_IE_BOTH)
344 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
345 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
346 || (tls_type & GOT_TLS_IE))
347 htab->elf.srelgot->size += htab->sizeof_reloc;
348 else if (GOT_TLS_GD_P (tls_type))
349 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
350 else if (! GOT_TLS_GDESC_P (tls_type)
351 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
352 && !resolved_to_zero)
353 || h->root.type != bfd_link_hash_undefweak)
354 && (bfd_link_pic (info)
355 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
356 htab->elf.srelgot->size += htab->sizeof_reloc;
357 if (GOT_TLS_GDESC_P (tls_type))
359 htab->elf.srelplt->size += htab->sizeof_reloc;
360 if (bed->target_id == X86_64_ELF_DATA)
361 htab->tlsdesc_plt = (bfd_vma) -1;
365 h->got.offset = (bfd_vma) -1;
367 if (eh->dyn_relocs == NULL)
370 /* In the shared -Bsymbolic case, discard space allocated for
371 dynamic pc-relative relocs against symbols which turn out to be
372 defined in regular objects. For the normal shared case, discard
373 space for pc-relative relocs that have become local due to symbol
374 visibility changes. */
376 if (bfd_link_pic (info))
378 /* Relocs that use pc_count are those that appear on a call
379 insn, or certain REL relocs that can generated via assembly.
380 We want calls to protected symbols to resolve directly to the
381 function rather than going via the plt. If people want
382 function pointer comparisons to work as expected then they
383 should avoid writing weird assembly. */
384 if (SYMBOL_CALLS_LOCAL (info, h))
386 struct elf_dyn_relocs **pp;
388 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
390 p->count -= p->pc_count;
399 if (htab->target_os == is_vxworks)
401 struct elf_dyn_relocs **pp;
402 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
404 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
411 /* Also discard relocs on undefined weak syms with non-default
412 visibility or in PIE. */
413 if (eh->dyn_relocs != NULL)
415 if (h->root.type == bfd_link_hash_undefweak)
417 /* Undefined weak symbol is never bound locally in shared
419 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
422 if (bed->target_id == I386_ELF_DATA
425 /* Keep dynamic non-GOT/non-PLT relocation so
426 that we can branch to 0 without PLT. */
427 struct elf_dyn_relocs **pp;
429 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
430 if (p->pc_count == 0)
434 /* Remove non-R_386_PC32 relocation. */
435 p->count = p->pc_count;
439 /* Make sure undefined weak symbols are output
440 as dynamic symbols in PIEs for dynamic non-GOT
441 non-PLT reloations. */
442 if (eh->dyn_relocs != NULL
443 && !bfd_elf_link_record_dynamic_symbol (info, h))
447 eh->dyn_relocs = NULL;
449 else if (h->dynindx == -1
451 && !bfd_elf_link_record_dynamic_symbol (info, h))
454 else if (bfd_link_executable (info)
455 && (h->needs_copy || eh->needs_copy)
459 /* NB: needs_copy is set only for x86-64. For PIE,
460 discard space for pc-relative relocs against symbols
461 which turn out to need copy relocs. */
462 struct elf_dyn_relocs **pp;
464 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
466 if (p->pc_count != 0)
474 else if (ELIMINATE_COPY_RELOCS)
476 /* For the non-shared case, discard space for relocs against
477 symbols which turn out to need copy relocs or are not
478 dynamic. Keep dynamic relocations for run-time function
479 pointer initialization. */
482 || (h->root.type == bfd_link_hash_undefweak
483 && !resolved_to_zero))
486 || (htab->elf.dynamic_sections_created
487 && (h->root.type == bfd_link_hash_undefweak
488 || h->root.type == bfd_link_hash_undefined))))
490 /* Make sure this symbol is output as a dynamic symbol.
491 Undefined weak syms won't yet be marked as dynamic. */
495 && h->root.type == bfd_link_hash_undefweak
496 && ! bfd_elf_link_record_dynamic_symbol (info, h))
499 /* If that succeeded, we know we'll be keeping all the
501 if (h->dynindx != -1)
505 eh->dyn_relocs = NULL;
510 /* Finally, allocate space. */
511 for (p = eh->dyn_relocs; p != NULL; p = p->next)
515 sreloc = elf_section_data (p->sec)->sreloc;
517 BFD_ASSERT (sreloc != NULL);
518 sreloc->size += p->count * htab->sizeof_reloc;
524 /* Find any dynamic relocs that apply to read-only sections. */
527 _bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry *h,
530 struct elf_x86_link_hash_entry *eh;
531 struct elf_dyn_relocs *p;
533 /* Skip local IFUNC symbols. */
534 if (h->forced_local && h->type == STT_GNU_IFUNC)
537 eh = (struct elf_x86_link_hash_entry *) h;
538 for (p = eh->dyn_relocs; p != NULL; p = p->next)
540 asection *s = p->sec->output_section;
542 if (s != NULL && (s->flags & SEC_READONLY) != 0)
544 struct bfd_link_info *info = (struct bfd_link_info *) inf;
546 info->flags |= DF_TEXTREL;
548 if ((info->warn_shared_textrel && bfd_link_pic (info))
549 || info->error_textrel)
550 /* xgettext:c-format */
551 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
552 p->sec->owner, h->root.root.string,
555 /* xgettext:c-format */
556 info->callbacks->minfo
557 (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
558 p->sec->owner, h->root.root.string, p->sec);
560 /* Not an error, just cut short the traversal. */
567 /* Allocate space in .plt, .got and associated reloc sections for
568 local dynamic relocs. */
571 elf_x86_allocate_local_dynreloc (void **slot, void *inf)
573 struct elf_link_hash_entry *h
574 = (struct elf_link_hash_entry *) *slot;
576 if (h->type != STT_GNU_IFUNC
580 || h->root.type != bfd_link_hash_defined)
583 return elf_x86_allocate_dynrelocs (h, inf);
586 /* Find and/or create a hash entry for local symbol. */
588 struct elf_link_hash_entry *
589 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
590 bfd *abfd, const Elf_Internal_Rela *rel,
593 struct elf_x86_link_hash_entry e, *ret;
594 asection *sec = abfd->sections;
595 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
596 htab->r_sym (rel->r_info));
599 e.elf.indx = sec->id;
600 e.elf.dynstr_index = htab->r_sym (rel->r_info);
601 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
602 create ? INSERT : NO_INSERT);
609 ret = (struct elf_x86_link_hash_entry *) *slot;
613 ret = (struct elf_x86_link_hash_entry *)
614 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
615 sizeof (struct elf_x86_link_hash_entry));
618 memset (ret, 0, sizeof (*ret));
619 ret->elf.indx = sec->id;
620 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
621 ret->elf.dynindx = -1;
622 ret->plt_got.offset = (bfd_vma) -1;
628 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
629 SYNC WITH _bfd_elf_link_hash_newfunc. */
631 struct bfd_hash_entry *
632 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
633 struct bfd_hash_table *table,
636 /* Allocate the structure if it has not already been allocated by a
640 entry = (struct bfd_hash_entry *)
641 bfd_hash_allocate (table,
642 sizeof (struct elf_x86_link_hash_entry));
647 /* Call the allocation method of the superclass. */
648 entry = _bfd_link_hash_newfunc (entry, table, string);
651 struct elf_x86_link_hash_entry *eh
652 = (struct elf_x86_link_hash_entry *) entry;
653 struct elf_link_hash_table *htab
654 = (struct elf_link_hash_table *) table;
656 memset (&eh->elf.size, 0,
657 (sizeof (struct elf_x86_link_hash_entry)
658 - offsetof (struct elf_link_hash_entry, size)));
659 /* Set local fields. */
661 eh->elf.dynindx = -1;
662 eh->elf.got = htab->init_got_refcount;
663 eh->elf.plt = htab->init_plt_refcount;
664 /* Assume that we have been called by a non-ELF symbol reader.
665 This flag is then reset by the code which reads an ELF input
666 file. This ensures that a symbol created by a non-ELF symbol
667 reader will have the flag set correctly. */
669 eh->plt_second.offset = (bfd_vma) -1;
670 eh->plt_got.offset = (bfd_vma) -1;
671 eh->tlsdesc_got = (bfd_vma) -1;
672 eh->zero_undefweak = 1;
678 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
679 for local symbol so that we can handle local STT_GNU_IFUNC symbols
680 as global symbol. We reuse indx and dynstr_index for local symbol
681 hash since they aren't used by global symbols in this backend. */
684 _bfd_x86_elf_local_htab_hash (const void *ptr)
686 struct elf_link_hash_entry *h
687 = (struct elf_link_hash_entry *) ptr;
688 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
691 /* Compare local hash entries. */
694 _bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
696 struct elf_link_hash_entry *h1
697 = (struct elf_link_hash_entry *) ptr1;
698 struct elf_link_hash_entry *h2
699 = (struct elf_link_hash_entry *) ptr2;
701 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
704 /* Destroy an x86 ELF linker hash table. */
707 elf_x86_link_hash_table_free (bfd *obfd)
709 struct elf_x86_link_hash_table *htab
710 = (struct elf_x86_link_hash_table *) obfd->link.hash;
712 if (htab->loc_hash_table)
713 htab_delete (htab->loc_hash_table);
714 if (htab->loc_hash_memory)
715 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
716 _bfd_elf_link_hash_table_free (obfd);
720 elf_i386_is_reloc_section (const char *secname)
722 return CONST_STRNEQ (secname, ".rel");
726 elf_x86_64_is_reloc_section (const char *secname)
728 return CONST_STRNEQ (secname, ".rela");
731 /* Create an x86 ELF linker hash table. */
733 struct bfd_link_hash_table *
734 _bfd_x86_elf_link_hash_table_create (bfd *abfd)
736 struct elf_x86_link_hash_table *ret;
737 const struct elf_backend_data *bed;
738 bfd_size_type amt = sizeof (struct elf_x86_link_hash_table);
740 ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
744 bed = get_elf_backend_data (abfd);
745 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
746 _bfd_x86_elf_link_hash_newfunc,
747 sizeof (struct elf_x86_link_hash_entry),
754 if (bed->target_id == X86_64_ELF_DATA)
756 ret->is_reloc_section = elf_x86_64_is_reloc_section;
757 ret->dt_reloc = DT_RELA;
758 ret->dt_reloc_sz = DT_RELASZ;
759 ret->dt_reloc_ent = DT_RELAENT;
760 ret->got_entry_size = 8;
761 ret->tls_get_addr = "__tls_get_addr";
765 ret->sizeof_reloc = sizeof (Elf64_External_Rela);
766 ret->pointer_r_type = R_X86_64_64;
767 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
768 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
772 if (bed->target_id == X86_64_ELF_DATA)
774 ret->sizeof_reloc = sizeof (Elf32_External_Rela);
775 ret->pointer_r_type = R_X86_64_32;
776 ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
777 ret->dynamic_interpreter_size
778 = sizeof ELFX32_DYNAMIC_INTERPRETER;
782 ret->is_reloc_section = elf_i386_is_reloc_section;
783 ret->dt_reloc = DT_REL;
784 ret->dt_reloc_sz = DT_RELSZ;
785 ret->dt_reloc_ent = DT_RELENT;
786 ret->sizeof_reloc = sizeof (Elf32_External_Rel);
787 ret->got_entry_size = 4;
788 ret->pointer_r_type = R_386_32;
789 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
790 ret->dynamic_interpreter_size
791 = sizeof ELF32_DYNAMIC_INTERPRETER;
792 ret->tls_get_addr = "___tls_get_addr";
795 ret->target_id = bed->target_id;
796 ret->target_os = get_elf_x86_backend_data (abfd)->target_os;
798 ret->loc_hash_table = htab_try_create (1024,
799 _bfd_x86_elf_local_htab_hash,
800 _bfd_x86_elf_local_htab_eq,
802 ret->loc_hash_memory = objalloc_create ();
803 if (!ret->loc_hash_table || !ret->loc_hash_memory)
805 elf_x86_link_hash_table_free (abfd);
808 ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
810 return &ret->elf.root;
813 /* Sort relocs into address order. */
816 _bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
818 const arelent *a = * (const arelent **) ap;
819 const arelent *b = * (const arelent **) bp;
821 if (a->address > b->address)
823 else if (a->address < b->address)
830 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
832 if (!bfd_link_relocatable (info))
834 /* Check for __tls_get_addr reference. */
835 struct elf_x86_link_hash_table *htab;
836 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
837 htab = elf_x86_hash_table (info, bed->target_id);
840 struct elf_link_hash_entry *h;
842 h = elf_link_hash_lookup (elf_hash_table (info),
844 FALSE, FALSE, FALSE);
846 elf_x86_hash_entry (h)->tls_get_addr = 1;
848 /* "__ehdr_start" will be defined by linker as a hidden symbol
849 later if it is referenced and not defined. */
850 h = elf_link_hash_lookup (elf_hash_table (info),
852 FALSE, FALSE, FALSE);
854 && (h->root.type == bfd_link_hash_new
855 || h->root.type == bfd_link_hash_undefined
856 || h->root.type == bfd_link_hash_undefweak
857 || h->root.type == bfd_link_hash_common))
859 elf_x86_hash_entry (h)->local_ref = 2;
860 elf_x86_hash_entry (h)->linker_def = 1;
865 /* Invoke the regular ELF backend linker to do all the work. */
866 return _bfd_elf_link_check_relocs (abfd, info);
869 /* Set the sizes of the dynamic sections. */
872 _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd,
873 struct bfd_link_info *info)
875 struct elf_x86_link_hash_table *htab;
880 const struct elf_backend_data *bed
881 = get_elf_backend_data (output_bfd);
883 htab = elf_x86_hash_table (info, bed->target_id);
886 dynobj = htab->elf.dynobj;
890 /* Set up .got offsets for local syms, and space for local dynamic
892 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
894 bfd_signed_vma *local_got;
895 bfd_signed_vma *end_local_got;
896 char *local_tls_type;
897 bfd_vma *local_tlsdesc_gotent;
898 bfd_size_type locsymcount;
899 Elf_Internal_Shdr *symtab_hdr;
902 if (! is_x86_elf (ibfd, htab))
905 for (s = ibfd->sections; s != NULL; s = s->next)
907 struct elf_dyn_relocs *p;
909 for (p = ((struct elf_dyn_relocs *)
910 elf_section_data (s)->local_dynrel);
914 if (!bfd_is_abs_section (p->sec)
915 && bfd_is_abs_section (p->sec->output_section))
917 /* Input section has been discarded, either because
918 it is a copy of a linkonce section or due to
919 linker script /DISCARD/, so we'll be discarding
922 else if (htab->target_os == is_vxworks
923 && strcmp (p->sec->output_section->name,
926 /* Relocations in vxworks .tls_vars sections are
927 handled specially by the loader. */
929 else if (p->count != 0)
931 srel = elf_section_data (p->sec)->sreloc;
932 srel->size += p->count * htab->sizeof_reloc;
933 if ((p->sec->output_section->flags & SEC_READONLY) != 0
934 && (info->flags & DF_TEXTREL) == 0)
936 info->flags |= DF_TEXTREL;
937 if ((info->warn_shared_textrel && bfd_link_pic (info))
938 || info->error_textrel)
939 /* xgettext:c-format */
940 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
941 p->sec->owner, p->sec);
947 local_got = elf_local_got_refcounts (ibfd);
951 symtab_hdr = &elf_symtab_hdr (ibfd);
952 locsymcount = symtab_hdr->sh_info;
953 end_local_got = local_got + locsymcount;
954 local_tls_type = elf_x86_local_got_tls_type (ibfd);
955 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
957 srel = htab->elf.srelgot;
958 for (; local_got < end_local_got;
959 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
961 *local_tlsdesc_gotent = (bfd_vma) -1;
964 if (GOT_TLS_GDESC_P (*local_tls_type))
966 *local_tlsdesc_gotent = htab->elf.sgotplt->size
967 - elf_x86_compute_jump_table_size (htab);
968 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
969 *local_got = (bfd_vma) -2;
971 if (! GOT_TLS_GDESC_P (*local_tls_type)
972 || GOT_TLS_GD_P (*local_tls_type))
974 *local_got = s->size;
975 s->size += htab->got_entry_size;
976 if (GOT_TLS_GD_P (*local_tls_type)
977 || *local_tls_type == GOT_TLS_IE_BOTH)
978 s->size += htab->got_entry_size;
980 if (bfd_link_pic (info)
981 || GOT_TLS_GD_ANY_P (*local_tls_type)
982 || (*local_tls_type & GOT_TLS_IE))
984 if (*local_tls_type == GOT_TLS_IE_BOTH)
985 srel->size += 2 * htab->sizeof_reloc;
986 else if (GOT_TLS_GD_P (*local_tls_type)
987 || ! GOT_TLS_GDESC_P (*local_tls_type))
988 srel->size += htab->sizeof_reloc;
989 if (GOT_TLS_GDESC_P (*local_tls_type))
991 htab->elf.srelplt->size += htab->sizeof_reloc;
992 if (bed->target_id == X86_64_ELF_DATA)
993 htab->tlsdesc_plt = (bfd_vma) -1;
998 *local_got = (bfd_vma) -1;
1002 if (htab->tls_ld_or_ldm_got.refcount > 0)
1004 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1005 or R_X86_64_TLSLD relocs. */
1006 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
1007 htab->elf.sgot->size += 2 * htab->got_entry_size;
1008 htab->elf.srelgot->size += htab->sizeof_reloc;
1011 htab->tls_ld_or_ldm_got.offset = -1;
1013 /* Allocate global sym .plt and .got entries, and space for global
1014 sym dynamic relocs. */
1015 elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
1018 /* Allocate .plt and .got entries, and space for local symbols. */
1019 htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
1022 /* For every jump slot reserved in the sgotplt, reloc_count is
1023 incremented. However, when we reserve space for TLS descriptors,
1024 it's not incremented, so in order to compute the space reserved
1025 for them, it suffices to multiply the reloc count by the jump
1028 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1029 so that R_{386,X86_64}_IRELATIVE entries come last. */
1030 if (htab->elf.srelplt)
1032 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
1033 htab->sgotplt_jump_table_size
1034 = elf_x86_compute_jump_table_size (htab);
1035 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
1037 else if (htab->elf.irelplt)
1038 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
1040 if (htab->tlsdesc_plt)
1042 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1043 lazy TLS relocations, don't generate the PLT and GOT entries
1045 if ((info->flags & DF_BIND_NOW))
1046 htab->tlsdesc_plt = 0;
1049 htab->tlsdesc_got = htab->elf.sgot->size;
1050 htab->elf.sgot->size += htab->got_entry_size;
1051 /* Reserve room for the initial entry.
1052 FIXME: we could probably do away with it in this case. */
1053 if (htab->elf.splt->size == 0)
1054 htab->elf.splt->size = htab->plt.plt_entry_size;
1055 htab->tlsdesc_plt = htab->elf.splt->size;
1056 htab->elf.splt->size += htab->plt.plt_entry_size;
1060 if (htab->elf.sgotplt)
1062 /* Don't allocate .got.plt section if there are no GOT nor PLT
1063 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1064 if ((htab->elf.hgot == NULL
1065 || !htab->elf.hgot->ref_regular_nonweak)
1066 && (htab->elf.sgotplt->size == bed->got_header_size)
1067 && (htab->elf.splt == NULL
1068 || htab->elf.splt->size == 0)
1069 && (htab->elf.sgot == NULL
1070 || htab->elf.sgot->size == 0)
1071 && (htab->elf.iplt == NULL
1072 || htab->elf.iplt->size == 0)
1073 && (htab->elf.igotplt == NULL
1074 || htab->elf.igotplt->size == 0))
1075 htab->elf.sgotplt->size = 0;
1078 if (_bfd_elf_eh_frame_present (info))
1080 if (htab->plt_eh_frame != NULL
1081 && htab->elf.splt != NULL
1082 && htab->elf.splt->size != 0
1083 && !bfd_is_abs_section (htab->elf.splt->output_section))
1084 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
1086 if (htab->plt_got_eh_frame != NULL
1087 && htab->plt_got != NULL
1088 && htab->plt_got->size != 0
1089 && !bfd_is_abs_section (htab->plt_got->output_section))
1090 htab->plt_got_eh_frame->size
1091 = htab->non_lazy_plt->eh_frame_plt_size;
1093 /* Unwind info for the second PLT and .plt.got sections are
1095 if (htab->plt_second_eh_frame != NULL
1096 && htab->plt_second != NULL
1097 && htab->plt_second->size != 0
1098 && !bfd_is_abs_section (htab->plt_second->output_section))
1099 htab->plt_second_eh_frame->size
1100 = htab->non_lazy_plt->eh_frame_plt_size;
1103 /* We now have determined the sizes of the various dynamic sections.
1104 Allocate memory for them. */
1106 for (s = dynobj->sections; s != NULL; s = s->next)
1108 bfd_boolean strip_section = TRUE;
1110 if ((s->flags & SEC_LINKER_CREATED) == 0)
1113 if (s == htab->elf.splt
1114 || s == htab->elf.sgot)
1116 /* Strip this section if we don't need it; see the
1118 /* We'd like to strip these sections if they aren't needed, but if
1119 we've exported dynamic symbols from them we must leave them.
1120 It's too late to tell BFD to get rid of the symbols. */
1122 if (htab->elf.hplt != NULL)
1123 strip_section = FALSE;
1125 else if (s == htab->elf.sgotplt
1126 || s == htab->elf.iplt
1127 || s == htab->elf.igotplt
1128 || s == htab->plt_second
1129 || s == htab->plt_got
1130 || s == htab->plt_eh_frame
1131 || s == htab->plt_got_eh_frame
1132 || s == htab->plt_second_eh_frame
1133 || s == htab->elf.sdynbss
1134 || s == htab->elf.sdynrelro)
1136 /* Strip these too. */
1138 else if (htab->is_reloc_section (bfd_get_section_name (dynobj, s)))
1141 && s != htab->elf.srelplt
1142 && s != htab->srelplt2)
1145 /* We use the reloc_count field as a counter if we need
1146 to copy relocs into the output file. */
1147 if (s != htab->elf.srelplt)
1152 /* It's not one of our sections, so don't allocate space. */
1158 /* If we don't need this section, strip it from the
1159 output file. This is mostly to handle .rel.bss and
1160 .rel.plt. We must create both sections in
1161 create_dynamic_sections, because they must be created
1162 before the linker maps input sections to output
1163 sections. The linker does that before
1164 adjust_dynamic_symbol is called, and it is that
1165 function which decides whether anything needs to go
1166 into these sections. */
1168 s->flags |= SEC_EXCLUDE;
1172 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1175 /* Allocate memory for the section contents. We use bfd_zalloc
1176 here in case unused entries are not reclaimed before the
1177 section's contents are written out. This should not happen,
1178 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1179 reloc instead of garbage. */
1180 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
1181 if (s->contents == NULL)
1185 if (htab->plt_eh_frame != NULL
1186 && htab->plt_eh_frame->contents != NULL)
1188 memcpy (htab->plt_eh_frame->contents,
1189 htab->plt.eh_frame_plt,
1190 htab->plt_eh_frame->size);
1191 bfd_put_32 (dynobj, htab->elf.splt->size,
1192 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
1195 if (htab->plt_got_eh_frame != NULL
1196 && htab->plt_got_eh_frame->contents != NULL)
1198 memcpy (htab->plt_got_eh_frame->contents,
1199 htab->non_lazy_plt->eh_frame_plt,
1200 htab->plt_got_eh_frame->size);
1201 bfd_put_32 (dynobj, htab->plt_got->size,
1202 (htab->plt_got_eh_frame->contents
1203 + PLT_FDE_LEN_OFFSET));
1206 if (htab->plt_second_eh_frame != NULL
1207 && htab->plt_second_eh_frame->contents != NULL)
1209 memcpy (htab->plt_second_eh_frame->contents,
1210 htab->non_lazy_plt->eh_frame_plt,
1211 htab->plt_second_eh_frame->size);
1212 bfd_put_32 (dynobj, htab->plt_second->size,
1213 (htab->plt_second_eh_frame->contents
1214 + PLT_FDE_LEN_OFFSET));
1217 if (htab->elf.dynamic_sections_created)
1219 /* Add some entries to the .dynamic section. We fill in the
1220 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1221 but we must add the entries now so that we get the correct
1222 size for the .dynamic section. The DT_DEBUG entry is filled
1223 in by the dynamic linker and used by the debugger. */
1224 #define add_dynamic_entry(TAG, VAL) \
1225 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1227 if (bfd_link_executable (info))
1229 if (!add_dynamic_entry (DT_DEBUG, 0))
1233 if (htab->elf.splt->size != 0)
1235 /* DT_PLTGOT is used by prelink even if there is no PLT
1237 if (!add_dynamic_entry (DT_PLTGOT, 0))
1241 if (htab->elf.srelplt->size != 0)
1243 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1244 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc)
1245 || !add_dynamic_entry (DT_JMPREL, 0))
1249 if (htab->tlsdesc_plt
1250 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
1251 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
1256 if (!add_dynamic_entry (htab->dt_reloc, 0)
1257 || !add_dynamic_entry (htab->dt_reloc_sz, 0)
1258 || !add_dynamic_entry (htab->dt_reloc_ent,
1259 htab->sizeof_reloc))
1262 /* If any dynamic relocs apply to a read-only section,
1263 then we need a DT_TEXTREL entry. */
1264 if ((info->flags & DF_TEXTREL) == 0)
1265 elf_link_hash_traverse (&htab->elf,
1266 _bfd_x86_elf_readonly_dynrelocs,
1269 if ((info->flags & DF_TEXTREL) != 0)
1271 if (htab->readonly_dynrelocs_against_ifunc)
1273 info->callbacks->einfo
1274 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
1275 bfd_set_error (bfd_error_bad_value);
1279 if (!add_dynamic_entry (DT_TEXTREL, 0))
1283 if (htab->target_os == is_vxworks
1284 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
1287 #undef add_dynamic_entry
1292 /* Finish up the x86 dynamic sections. */
1294 struct elf_x86_link_hash_table *
1295 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
1296 struct bfd_link_info *info)
1298 struct elf_x86_link_hash_table *htab;
1299 const struct elf_backend_data *bed;
1302 bfd_byte *dyncon, *dynconend;
1303 bfd_size_type sizeof_dyn;
1305 bed = get_elf_backend_data (output_bfd);
1306 htab = elf_x86_hash_table (info, bed->target_id);
1310 dynobj = htab->elf.dynobj;
1311 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1313 /* GOT is always created in setup_gnu_properties. But it may not be
1314 needed. .got.plt section may be needed for static IFUNC. */
1315 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
1317 bfd_vma dynamic_addr;
1319 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
1322 (_("discarded output section: `%A'"), htab->elf.sgotplt);
1326 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
1327 = htab->got_entry_size;
1329 dynamic_addr = (sdyn == NULL
1331 : sdyn->output_section->vma + sdyn->output_offset);
1333 /* Set the first entry in the global offset table to the address
1334 of the dynamic section. Write GOT[1] and GOT[2], needed for
1335 the dynamic linker. */
1336 if (htab->got_entry_size == 8)
1338 bfd_put_64 (output_bfd, dynamic_addr,
1339 htab->elf.sgotplt->contents);
1340 bfd_put_64 (output_bfd, (bfd_vma) 0,
1341 htab->elf.sgotplt->contents + 8);
1342 bfd_put_64 (output_bfd, (bfd_vma) 0,
1343 htab->elf.sgotplt->contents + 8*2);
1347 bfd_put_32 (output_bfd, dynamic_addr,
1348 htab->elf.sgotplt->contents);
1349 bfd_put_32 (output_bfd, 0,
1350 htab->elf.sgotplt->contents + 4);
1351 bfd_put_32 (output_bfd, 0,
1352 htab->elf.sgotplt->contents + 4*2);
1356 if (!htab->elf.dynamic_sections_created)
1359 if (sdyn == NULL || htab->elf.sgot == NULL)
1362 sizeof_dyn = bed->s->sizeof_dyn;
1363 dyncon = sdyn->contents;
1364 dynconend = sdyn->contents + sdyn->size;
1365 for (; dyncon < dynconend; dyncon += sizeof_dyn)
1367 Elf_Internal_Dyn dyn;
1370 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
1375 if (htab->target_os == is_vxworks
1376 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
1381 s = htab->elf.sgotplt;
1382 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1386 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
1390 s = htab->elf.srelplt->output_section;
1391 dyn.d_un.d_val = s->size;
1394 case DT_TLSDESC_PLT:
1396 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1397 + htab->tlsdesc_plt;
1400 case DT_TLSDESC_GOT:
1402 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1403 + htab->tlsdesc_got;
1407 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
1410 if (htab->plt_got != NULL && htab->plt_got->size > 0)
1411 elf_section_data (htab->plt_got->output_section)
1412 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1414 if (htab->plt_second != NULL && htab->plt_second->size > 0)
1415 elf_section_data (htab->plt_second->output_section)
1416 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1418 /* Adjust .eh_frame for .plt section. */
1419 if (htab->plt_eh_frame != NULL
1420 && htab->plt_eh_frame->contents != NULL)
1422 if (htab->elf.splt != NULL
1423 && htab->elf.splt->size != 0
1424 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
1425 && htab->elf.splt->output_section != NULL
1426 && htab->plt_eh_frame->output_section != NULL)
1428 bfd_vma plt_start = htab->elf.splt->output_section->vma;
1429 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
1430 + htab->plt_eh_frame->output_offset
1431 + PLT_FDE_START_OFFSET;
1432 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1433 htab->plt_eh_frame->contents
1434 + PLT_FDE_START_OFFSET);
1437 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1439 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1441 htab->plt_eh_frame->contents))
1446 /* Adjust .eh_frame for .plt.got section. */
1447 if (htab->plt_got_eh_frame != NULL
1448 && htab->plt_got_eh_frame->contents != NULL)
1450 if (htab->plt_got != NULL
1451 && htab->plt_got->size != 0
1452 && (htab->plt_got->flags & SEC_EXCLUDE) == 0
1453 && htab->plt_got->output_section != NULL
1454 && htab->plt_got_eh_frame->output_section != NULL)
1456 bfd_vma plt_start = htab->plt_got->output_section->vma;
1457 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
1458 + htab->plt_got_eh_frame->output_offset
1459 + PLT_FDE_START_OFFSET;
1460 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1461 htab->plt_got_eh_frame->contents
1462 + PLT_FDE_START_OFFSET);
1464 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1466 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1467 htab->plt_got_eh_frame,
1468 htab->plt_got_eh_frame->contents))
1473 /* Adjust .eh_frame for the second PLT section. */
1474 if (htab->plt_second_eh_frame != NULL
1475 && htab->plt_second_eh_frame->contents != NULL)
1477 if (htab->plt_second != NULL
1478 && htab->plt_second->size != 0
1479 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
1480 && htab->plt_second->output_section != NULL
1481 && htab->plt_second_eh_frame->output_section != NULL)
1483 bfd_vma plt_start = htab->plt_second->output_section->vma;
1484 bfd_vma eh_frame_start
1485 = (htab->plt_second_eh_frame->output_section->vma
1486 + htab->plt_second_eh_frame->output_offset
1487 + PLT_FDE_START_OFFSET);
1488 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1489 htab->plt_second_eh_frame->contents
1490 + PLT_FDE_START_OFFSET);
1492 if (htab->plt_second_eh_frame->sec_info_type
1493 == SEC_INFO_TYPE_EH_FRAME)
1495 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1496 htab->plt_second_eh_frame,
1497 htab->plt_second_eh_frame->contents))
1502 if (htab->elf.sgot && htab->elf.sgot->size > 0)
1503 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
1504 = htab->got_entry_size;
1511 _bfd_x86_elf_always_size_sections (bfd *output_bfd,
1512 struct bfd_link_info *info)
1514 asection *tls_sec = elf_hash_table (info)->tls_sec;
1518 struct elf_link_hash_entry *tlsbase;
1520 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1521 "_TLS_MODULE_BASE_",
1522 FALSE, FALSE, FALSE);
1524 if (tlsbase && tlsbase->type == STT_TLS)
1526 struct elf_x86_link_hash_table *htab;
1527 struct bfd_link_hash_entry *bh = NULL;
1528 const struct elf_backend_data *bed
1529 = get_elf_backend_data (output_bfd);
1531 htab = elf_x86_hash_table (info, bed->target_id);
1535 if (!(_bfd_generic_link_add_one_symbol
1536 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1537 tls_sec, 0, NULL, FALSE,
1538 bed->collect, &bh)))
1541 htab->tls_module_base = bh;
1543 tlsbase = (struct elf_link_hash_entry *)bh;
1544 tlsbase->def_regular = 1;
1545 tlsbase->other = STV_HIDDEN;
1546 tlsbase->root.linker_def = 1;
1547 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1555 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
1556 const Elf_Internal_Sym *isym,
1557 bfd_boolean definition,
1558 bfd_boolean dynamic ATTRIBUTE_UNUSED)
1562 struct elf_x86_link_hash_entry *eh
1563 = (struct elf_x86_link_hash_entry *) h;
1564 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
1569 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1572 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
1573 struct elf_link_hash_entry *dir,
1574 struct elf_link_hash_entry *ind)
1576 struct elf_x86_link_hash_entry *edir, *eind;
1578 edir = (struct elf_x86_link_hash_entry *) dir;
1579 eind = (struct elf_x86_link_hash_entry *) ind;
1581 if (eind->dyn_relocs != NULL)
1583 if (edir->dyn_relocs != NULL)
1585 struct elf_dyn_relocs **pp;
1586 struct elf_dyn_relocs *p;
1588 /* Add reloc counts against the indirect sym to the direct sym
1589 list. Merge any entries against the same section. */
1590 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1592 struct elf_dyn_relocs *q;
1594 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1595 if (q->sec == p->sec)
1597 q->pc_count += p->pc_count;
1598 q->count += p->count;
1605 *pp = edir->dyn_relocs;
1608 edir->dyn_relocs = eind->dyn_relocs;
1609 eind->dyn_relocs = NULL;
1612 if (ind->root.type == bfd_link_hash_indirect
1613 && dir->got.refcount <= 0)
1615 edir->tls_type = eind->tls_type;
1616 eind->tls_type = GOT_UNKNOWN;
1619 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1620 generate a R_386_COPY reloc. */
1621 edir->gotoff_ref |= eind->gotoff_ref;
1623 edir->zero_undefweak |= eind->zero_undefweak;
1625 if (ELIMINATE_COPY_RELOCS
1626 && ind->root.type != bfd_link_hash_indirect
1627 && dir->dynamic_adjusted)
1629 /* If called to transfer flags for a weakdef during processing
1630 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1631 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1632 if (dir->versioned != versioned_hidden)
1633 dir->ref_dynamic |= ind->ref_dynamic;
1634 dir->ref_regular |= ind->ref_regular;
1635 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1636 dir->needs_plt |= ind->needs_plt;
1637 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1640 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1643 /* Remove undefined weak symbol from the dynamic symbol table if it
1644 is resolved to 0. */
1647 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
1648 struct elf_link_hash_entry *h)
1650 if (h->dynindx != -1
1651 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
1654 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1660 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1663 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
1665 if (h->plt.offset != (bfd_vma) -1
1667 && !h->pointer_equality_needed)
1670 return _bfd_elf_hash_symbol (h);
1673 /* Adjust a symbol defined by a dynamic object and referenced by a
1674 regular object. The current definition is in some section of the
1675 dynamic object, but we're not including those sections. We have to
1676 change the definition to something the rest of the link can
1680 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1681 struct elf_link_hash_entry *h)
1683 struct elf_x86_link_hash_table *htab;
1685 struct elf_x86_link_hash_entry *eh;
1686 struct elf_dyn_relocs *p;
1687 const struct elf_backend_data *bed
1688 = get_elf_backend_data (info->output_bfd);
1690 /* STT_GNU_IFUNC symbol must go through PLT. */
1691 if (h->type == STT_GNU_IFUNC)
1693 /* All local STT_GNU_IFUNC references must be treate as local
1694 calls via local PLT. */
1696 && SYMBOL_CALLS_LOCAL (info, h))
1698 bfd_size_type pc_count = 0, count = 0;
1699 struct elf_dyn_relocs **pp;
1701 eh = (struct elf_x86_link_hash_entry *) h;
1702 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1704 pc_count += p->pc_count;
1705 p->count -= p->pc_count;
1714 if (pc_count || count)
1719 /* Increment PLT reference count only for PC-relative
1722 if (h->plt.refcount <= 0)
1723 h->plt.refcount = 1;
1725 h->plt.refcount += 1;
1730 if (h->plt.refcount <= 0)
1732 h->plt.offset = (bfd_vma) -1;
1738 /* If this is a function, put it in the procedure linkage table. We
1739 will fill in the contents of the procedure linkage table later,
1740 when we know the address of the .got section. */
1741 if (h->type == STT_FUNC
1744 if (h->plt.refcount <= 0
1745 || SYMBOL_CALLS_LOCAL (info, h)
1746 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1747 && h->root.type == bfd_link_hash_undefweak))
1749 /* This case can occur if we saw a PLT32 reloc in an input
1750 file, but the symbol was never referred to by a dynamic
1751 object, or if all references were garbage collected. In
1752 such a case, we don't actually need to build a procedure
1753 linkage table, and we can just do a PC32 reloc instead. */
1754 h->plt.offset = (bfd_vma) -1;
1761 /* It's possible that we incorrectly decided a .plt reloc was needed
1762 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1763 check_relocs. We can't decide accurately between function and
1764 non-function syms in check-relocs; Objects loaded later in
1765 the link may change h->type. So fix it now. */
1766 h->plt.offset = (bfd_vma) -1;
1768 eh = (struct elf_x86_link_hash_entry *) h;
1770 /* If this is a weak symbol, and there is a real definition, the
1771 processor independent code will have arranged for us to see the
1772 real definition first, and we can just use the same value. */
1773 if (h->is_weakalias)
1775 struct elf_link_hash_entry *def = weakdef (h);
1776 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1777 h->root.u.def.section = def->root.u.def.section;
1778 h->root.u.def.value = def->root.u.def.value;
1779 if (ELIMINATE_COPY_RELOCS
1780 || info->nocopyreloc
1781 || SYMBOL_NO_COPYRELOC (info, eh))
1783 /* NB: needs_copy is always 0 for i386. */
1784 h->non_got_ref = def->non_got_ref;
1785 eh->needs_copy = def->needs_copy;
1790 /* This is a reference to a symbol defined by a dynamic object which
1791 is not a function. */
1793 /* If we are creating a shared library, we must presume that the
1794 only references to the symbol are via the global offset table.
1795 For such cases we need not do anything here; the relocations will
1796 be handled correctly by relocate_section. */
1797 if (!bfd_link_executable (info))
1800 /* If there are no references to this symbol that do not use the
1801 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1802 reloc. NB: gotoff_ref is always 0 for x86-64. */
1803 if (!h->non_got_ref && !eh->gotoff_ref)
1806 /* If -z nocopyreloc was given, we won't generate them either. */
1807 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
1813 htab = elf_x86_hash_table (info, bed->target_id);
1817 /* If there aren't any dynamic relocs in read-only sections nor
1818 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1819 avoid the copy reloc. This doesn't work on VxWorks, where we can
1820 not have dynamic relocations (other than copy and jump slot
1821 relocations) in an executable. */
1822 if (ELIMINATE_COPY_RELOCS
1823 && (bed->target_id == X86_64_ELF_DATA
1825 && htab->target_os != is_vxworks)))
1827 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1829 s = p->sec->output_section;
1830 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1834 /* If we didn't find any dynamic relocs in read-only sections,
1835 then we'll be keeping the dynamic relocs and avoiding the copy
1844 /* We must allocate the symbol in our .dynbss section, which will
1845 become part of the .bss section of the executable. There will be
1846 an entry for this symbol in the .dynsym section. The dynamic
1847 object will contain position independent code, so all references
1848 from the dynamic object to this symbol will go through the global
1849 offset table. The dynamic linker will use the .dynsym entry to
1850 determine the address it must put in the global offset table, so
1851 both the dynamic object and the regular object will refer to the
1852 same memory location for the variable. */
1854 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1855 dynamic linker to copy the initial value out of the dynamic object
1856 and into the runtime process image. */
1857 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1859 s = htab->elf.sdynrelro;
1860 srel = htab->elf.sreldynrelro;
1864 s = htab->elf.sdynbss;
1865 srel = htab->elf.srelbss;
1867 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1869 srel->size += htab->sizeof_reloc;
1873 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1877 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
1878 struct elf_link_hash_entry *h,
1879 bfd_boolean force_local)
1881 if (h->root.type == bfd_link_hash_undefweak
1883 && bfd_link_pie (info))
1885 /* When there is no dynamic interpreter in PIE, make the undefined
1886 weak symbol dynamic so that PC relative branch to the undefined
1887 weak symbol will land to address 0. */
1888 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
1889 if (h->plt.refcount > 0
1890 || eh->plt_got.refcount > 0)
1894 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1897 /* Return TRUE if a symbol is referenced locally. It is similar to
1898 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
1899 works in check_relocs. */
1902 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
1903 struct elf_link_hash_entry *h)
1905 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
1906 struct elf_x86_link_hash_table *htab
1907 = (struct elf_x86_link_hash_table *) info->hash;
1909 if (eh->local_ref > 1)
1912 if (eh->local_ref == 1)
1915 /* Unversioned symbols defined in regular objects can be forced local
1916 by linker version script. A weak undefined symbol is forced local
1918 1. It has non-default visibility. Or
1919 2. When building executable, there is no dynamic linker. Or
1920 3. or "-z nodynamic-undefined-weak" is used.
1922 if (SYMBOL_REFERENCES_LOCAL (info, h)
1923 || (h->root.type == bfd_link_hash_undefweak
1924 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1925 || (bfd_link_executable (info)
1926 && htab->interp == NULL)
1927 || info->dynamic_undefined_weak == 0))
1928 || ((h->def_regular || ELF_COMMON_DEF_P (h))
1929 && h->versioned == unversioned
1930 && info->version_info != NULL
1931 && bfd_hide_sym_by_version (info->version_info,
1932 h->root.root.string)))
1942 /* Return the section that should be marked against GC for a given
1946 _bfd_x86_elf_gc_mark_hook (asection *sec,
1947 struct bfd_link_info *info,
1948 Elf_Internal_Rela *rel,
1949 struct elf_link_hash_entry *h,
1950 Elf_Internal_Sym *sym)
1952 /* Compiler should optimize this out. */
1953 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1954 != (unsigned int) R_386_GNU_VTINHERIT)
1955 || ((unsigned int) R_X86_64_GNU_VTENTRY
1956 != (unsigned int) R_386_GNU_VTENTRY))
1960 switch (ELF32_R_TYPE (rel->r_info))
1962 case R_X86_64_GNU_VTINHERIT:
1963 case R_X86_64_GNU_VTENTRY:
1967 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1971 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
1973 bfd_vma offset ATTRIBUTE_UNUSED,
1976 return got_addr + off;
1980 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
1983 bfd_vma got_addr ATTRIBUTE_UNUSED)
1985 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
1989 elf_i386_valid_plt_reloc_p (unsigned int type)
1991 return (type == R_386_JUMP_SLOT
1992 || type == R_386_GLOB_DAT
1993 || type == R_386_IRELATIVE);
1997 elf_x86_64_valid_plt_reloc_p (unsigned int type)
1999 return (type == R_X86_64_JUMP_SLOT
2000 || type == R_X86_64_GLOB_DAT
2001 || type == R_X86_64_IRELATIVE);
2005 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
2009 struct elf_x86_plt plts[],
2013 long size, i, n, len;
2015 unsigned int plt_got_offset, plt_entry_size;
2017 bfd_byte *plt_contents;
2019 arelent **dynrelbuf, *p;
2021 const struct elf_backend_data *bed;
2022 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
2024 bfd_boolean (*valid_plt_reloc_p) (unsigned int);
2029 dynrelbuf = (arelent **) bfd_malloc (relsize);
2030 if (dynrelbuf == NULL)
2033 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
2035 if (dynrelcount <= 0)
2038 /* Sort the relocs by address. */
2039 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
2040 _bfd_x86_elf_compare_relocs);
2042 size = count * sizeof (asymbol);
2044 /* Allocate space for @plt suffixes. */
2046 for (i = 0; i < dynrelcount; i++)
2049 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2051 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
2054 s = *ret = (asymbol *) bfd_zmalloc (size);
2058 bed = get_elf_backend_data (abfd);
2060 if (bed->target_id == X86_64_ELF_DATA)
2062 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
2063 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
2067 get_plt_got_vma = elf_i386_get_plt_got_vma;
2068 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
2071 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2073 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
2075 got_addr = sec->vma;
2078 sec = bfd_get_section_by_name (abfd, ".got");
2080 got_addr = sec->vma;
2083 if (got_addr == (bfd_vma) -1)
2088 /* Check for each PLT section. */
2089 names = (char *) (s + count);
2092 for (j = 0; plts[j].name != NULL; j++)
2093 if ((plt_contents = plts[j].contents) != NULL)
2098 struct elf_x86_plt *plt_p = &plts[j];
2100 plt_got_offset = plt_p->plt_got_offset;
2101 plt_entry_size = plt_p->plt_entry_size;
2105 if ((plt_p->type & plt_lazy))
2107 /* Skip PLT0 in lazy PLT. */
2109 offset = plt_entry_size;
2117 /* Check each PLT entry against dynamic relocations. */
2118 for (; k < plt_p->count; k++)
2124 /* Get the GOT offset for i386 or the PC-relative offset
2125 for x86-64, a signed 32-bit integer. */
2126 off = H_GET_32 (abfd, (plt_contents + offset
2128 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
2130 /* Binary search. */
2134 while ((min + 1) < max)
2138 mid = (min + max) / 2;
2140 if (got_vma > r->address)
2142 else if (got_vma < r->address)
2151 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2152 if (got_vma == p->address
2154 && valid_plt_reloc_p (p->howto->type))
2156 *s = **p->sym_ptr_ptr;
2157 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2158 set. Since we are defining a symbol, ensure one
2160 if ((s->flags & BSF_LOCAL) == 0)
2161 s->flags |= BSF_GLOBAL;
2162 s->flags |= BSF_SYNTHETIC;
2163 /* This is no longer a section symbol. */
2164 s->flags &= ~BSF_SECTION_SYM;
2166 s->the_bfd = plt->owner;
2170 len = strlen ((*p->sym_ptr_ptr)->name);
2171 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2177 memcpy (names, "+0x", sizeof ("+0x") - 1);
2178 names += sizeof ("+0x") - 1;
2179 bfd_sprintf_vma (abfd, buf, p->addend);
2180 for (a = buf; *a == '0'; ++a)
2183 memcpy (names, a, size);
2186 memcpy (names, "@plt", sizeof ("@plt"));
2187 names += sizeof ("@plt");
2190 /* There should be only one entry in PLT for a given
2191 symbol. Set howto to NULL after processing a PLT
2192 entry to guard against corrupted PLT. */
2195 offset += plt_entry_size;
2199 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2208 for (j = 0; plts[j].name != NULL; j++)
2209 if (plts[j].contents != NULL)
2210 free (plts[j].contents);
2217 /* Parse x86 GNU properties. */
2219 enum elf_property_kind
2220 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
2221 bfd_byte *ptr, unsigned int datasz)
2227 case GNU_PROPERTY_X86_ISA_1_USED:
2228 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2229 case GNU_PROPERTY_X86_FEATURE_1_AND:
2233 ((type == GNU_PROPERTY_X86_ISA_1_USED
2234 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
2235 : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
2236 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
2237 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
2239 return property_corrupt;
2241 prop = _bfd_elf_get_property (abfd, type, datasz);
2242 /* Combine properties of the same type. */
2243 prop->u.number |= bfd_h_get_32 (abfd, ptr);
2244 prop->pr_kind = property_number;
2248 return property_ignored;
2251 return property_number;
2254 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2255 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2256 should be merged with ABFD. */
2259 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
2260 bfd *abfd ATTRIBUTE_UNUSED,
2261 elf_property *aprop,
2262 elf_property *bprop)
2264 unsigned int number, features;
2265 bfd_boolean updated = FALSE;
2266 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
2270 case GNU_PROPERTY_X86_ISA_1_USED:
2271 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2272 if (aprop != NULL && bprop != NULL)
2274 number = aprop->u.number;
2275 aprop->u.number = number | bprop->u.number;
2276 updated = number != (unsigned int) aprop->u.number;
2280 /* Return TRUE if APROP is NULL to indicate that BPROP should
2281 be added to ABFD. */
2282 updated = aprop == NULL;
2286 case GNU_PROPERTY_X86_FEATURE_1_AND:
2287 /* Only one of APROP and BPROP can be NULL:
2288 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2289 2. If APROP is NULL, remove x86 feature.
2290 3. Otherwise, do nothing.
2292 if (aprop != NULL && bprop != NULL)
2296 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2298 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2299 number = aprop->u.number;
2300 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2301 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2302 aprop->u.number = (number & bprop->u.number) | features;
2303 updated = number != (unsigned int) aprop->u.number;
2304 /* Remove the property if all feature bits are cleared. */
2305 if (aprop->u.number == 0)
2306 aprop->pr_kind = property_remove;
2312 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2314 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2317 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2318 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2321 number = aprop->u.number;
2322 aprop->u.number = number | features;
2323 updated = number != (unsigned int) aprop->u.number;
2327 bprop->u.number |= features;
2331 else if (aprop != NULL)
2333 aprop->pr_kind = property_remove;
2340 /* Never should happen. */
2347 /* Set up x86 GNU properties. Return the first relocatable ELF input
2348 with GNU properties if found. Otherwise, return NULL. */
2351 _bfd_x86_elf_link_setup_gnu_properties
2352 (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
2354 bfd_boolean normal_target;
2355 bfd_boolean lazy_plt;
2356 asection *sec, *pltsec;
2358 bfd_boolean use_ibt_plt;
2359 unsigned int plt_alignment, features;
2360 struct elf_x86_link_hash_table *htab;
2364 const struct elf_backend_data *bed;
2365 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
2366 unsigned int got_align;
2370 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2372 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2374 /* Find a normal input file with GNU property note. */
2375 for (pbfd = info->input_bfds;
2377 pbfd = pbfd->link.next)
2378 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
2379 && bfd_count_sections (pbfd) != 0)
2383 if (elf_properties (pbfd) != NULL)
2387 if (ebfd != NULL && features)
2389 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2390 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2391 prop = _bfd_elf_get_property (ebfd,
2392 GNU_PROPERTY_X86_FEATURE_1_AND,
2394 prop->u.number |= features;
2395 prop->pr_kind = property_number;
2397 /* Create the GNU property note section if needed. */
2400 sec = bfd_make_section_with_flags (ebfd,
2401 NOTE_GNU_PROPERTY_SECTION_NAME,
2409 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
2411 if (!bfd_set_section_alignment (ebfd, sec, class_align))
2414 info->callbacks->einfo (_("%F%A: failed to align section\n"),
2418 elf_section_type (sec) = SHT_NOTE;
2422 pbfd = _bfd_elf_link_setup_gnu_properties (info);
2424 bed = get_elf_backend_data (info->output_bfd);
2426 htab = elf_x86_hash_table (info, bed->target_id);
2430 htab->r_info = init_table->r_info;
2431 htab->r_sym = init_table->r_sym;
2433 if (bfd_link_relocatable (info))
2436 htab->plt0_pad_byte = init_table->plt0_pad_byte;
2438 use_ibt_plt = info->ibtplt || info->ibt;
2439 if (!use_ibt_plt && pbfd != NULL)
2441 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2442 elf_property_list *p;
2444 /* The property list is sorted in order of type. */
2445 for (p = elf_properties (pbfd); p; p = p->next)
2447 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
2449 use_ibt_plt = !!(p->property.u.number
2450 & GNU_PROPERTY_X86_FEATURE_1_IBT);
2453 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
2458 dynobj = htab->elf.dynobj;
2460 /* Set htab->elf.dynobj here so that there is no need to check and
2461 set it in check_relocs. */
2466 htab->elf.dynobj = pbfd;
2473 /* Find a normal input file to hold linker created
2475 for (abfd = info->input_bfds;
2477 abfd = abfd->link.next)
2478 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2480 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0)
2482 htab->elf.dynobj = abfd;
2489 /* Return if there are no normal input files. */
2493 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2494 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2495 canonical function address. */
2496 htab->plt.has_plt0 = 1;
2497 normal_target = htab->target_os == is_normal;
2503 htab->lazy_plt = init_table->lazy_ibt_plt;
2504 htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
2508 htab->lazy_plt = init_table->lazy_plt;
2509 htab->non_lazy_plt = init_table->non_lazy_plt;
2514 htab->lazy_plt = init_table->lazy_plt;
2515 htab->non_lazy_plt = NULL;
2518 pltsec = htab->elf.splt;
2520 /* If the non-lazy PLT is available, use it for all PLT entries if
2521 there are no PLT0 or no .plt section. */
2522 if (htab->non_lazy_plt != NULL
2523 && (!htab->plt.has_plt0 || pltsec == NULL))
2526 if (bfd_link_pic (info))
2527 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
2529 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
2530 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
2531 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
2532 htab->plt.plt_got_insn_size
2533 = htab->non_lazy_plt->plt_got_insn_size;
2534 htab->plt.eh_frame_plt_size
2535 = htab->non_lazy_plt->eh_frame_plt_size;
2536 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
2541 if (bfd_link_pic (info))
2543 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
2544 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
2548 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
2549 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
2551 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
2552 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
2553 htab->plt.plt_got_insn_size
2554 = htab->lazy_plt->plt_got_insn_size;
2555 htab->plt.eh_frame_plt_size
2556 = htab->lazy_plt->eh_frame_plt_size;
2557 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
2560 if (htab->target_os == is_vxworks
2561 && !elf_vxworks_create_dynamic_sections (dynobj, info,
2564 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2568 /* Since create_dynamic_sections isn't always called, but GOT
2569 relocations need GOT relocations, create them here so that we
2570 don't need to do it in check_relocs. */
2571 if (htab->elf.sgot == NULL
2572 && !_bfd_elf_create_got_section (dynobj, info))
2573 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
2575 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
2577 /* Align .got and .got.plt sections to their entry size. Do it here
2578 instead of in create_dynamic_sections so that they are always
2579 properly aligned even if create_dynamic_sections isn't called. */
2580 sec = htab->elf.sgot;
2581 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2582 goto error_alignment;
2584 sec = htab->elf.sgotplt;
2585 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2586 goto error_alignment;
2588 /* Create the ifunc sections here so that check_relocs can be
2590 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
2591 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
2593 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
2597 /* Whe creating executable, set the contents of the .interp
2598 section to the interpreter. */
2599 if (bfd_link_executable (info) && !info->nointerp)
2601 asection *s = bfd_get_linker_section (dynobj, ".interp");
2604 s->size = htab->dynamic_interpreter_size;
2605 s->contents = (unsigned char *) htab->dynamic_interpreter;
2609 /* Don't change PLT section alignment for NaCl since it uses
2610 64-byte PLT entry and sets PLT section alignment to 32
2611 bytes. Don't create additional PLT sections for NaCl. */
2614 flagword pltflags = (bed->dynamic_sec_flags
2619 unsigned int non_lazy_plt_alignment
2620 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
2623 if (!bfd_set_section_alignment (sec->owner, sec,
2625 goto error_alignment;
2627 /* Create the GOT procedure linkage table. */
2628 sec = bfd_make_section_anyway_with_flags (dynobj,
2632 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
2634 if (!bfd_set_section_alignment (dynobj, sec,
2635 non_lazy_plt_alignment))
2636 goto error_alignment;
2638 htab->plt_got = sec;
2646 /* Create the second PLT for Intel IBT support. IBT
2647 PLT is supported only for non-NaCl target and is
2648 is needed only for lazy binding. */
2649 sec = bfd_make_section_anyway_with_flags (dynobj,
2653 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
2655 if (!bfd_set_section_alignment (dynobj, sec,
2657 goto error_alignment;
2659 else if (info->bndplt && ABI_64_P (dynobj))
2661 /* Create the second PLT for Intel MPX support. MPX
2662 PLT is supported only for non-NaCl target in 64-bit
2663 mode and is needed only for lazy binding. */
2664 sec = bfd_make_section_anyway_with_flags (dynobj,
2668 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n"));
2670 if (!bfd_set_section_alignment (dynobj, sec,
2671 non_lazy_plt_alignment))
2672 goto error_alignment;
2675 htab->plt_second = sec;
2679 if (!info->no_ld_generated_unwind_info)
2681 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2682 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2683 | SEC_LINKER_CREATED);
2685 sec = bfd_make_section_anyway_with_flags (dynobj,
2689 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
2691 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2692 goto error_alignment;
2694 htab->plt_eh_frame = sec;
2696 if (htab->plt_got != NULL)
2698 sec = bfd_make_section_anyway_with_flags (dynobj,
2702 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
2704 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2705 goto error_alignment;
2707 htab->plt_got_eh_frame = sec;
2710 if (htab->plt_second != NULL)
2712 sec = bfd_make_section_anyway_with_flags (dynobj,
2716 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
2718 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2719 goto error_alignment;
2721 htab->plt_second_eh_frame = sec;
2728 /* The .iplt section is used for IFUNC symbols in static
2730 sec = htab->elf.iplt;
2732 && !bfd_set_section_alignment (sec->owner, sec,
2734 goto error_alignment;