1 /* x86 specific support for ELF
2 Copyright (C) 2017-2018 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;
184 /* If this is the first .plt entry, make room for the special
185 first entry. The .plt section is used by prelink to undo
186 prelinking for dynamic relocations. */
188 s->size = htab->plt.has_plt0 * plt_entry_size;
191 eh->plt_got.offset = got_s->size;
194 h->plt.offset = s->size;
196 eh->plt_second.offset = second_s->size;
199 /* If this symbol is not defined in a regular file, and we are
200 generating PDE, then set the symbol to this location in the
201 .plt. This is required to make function pointers compare
202 as equal between PDE and the shared library.
204 NB: If PLT is PC-relative, we can use the .plt in PIE for
208 else if (htab->pcrel_plt)
209 use_plt = ! bfd_link_dll (info);
211 use_plt = bfd_link_pde (info);
216 /* We need to make a call to the entry of the GOT PLT
217 instead of regular PLT entry. */
218 h->root.u.def.section = got_s;
219 h->root.u.def.value = eh->plt_got.offset;
225 /* We need to make a call to the entry of the
226 second PLT instead of regular PLT entry. */
227 h->root.u.def.section = second_s;
228 h->root.u.def.value = eh->plt_second.offset;
232 h->root.u.def.section = s;
233 h->root.u.def.value = h->plt.offset;
238 /* Make room for this entry. */
240 got_s->size += htab->non_lazy_plt->plt_entry_size;
243 s->size += plt_entry_size;
245 second_s->size += htab->non_lazy_plt->plt_entry_size;
247 /* We also need to make an entry in the .got.plt section,
248 which will be placed in the .got section by the linker
250 htab->elf.sgotplt->size += htab->got_entry_size;
252 /* There should be no PLT relocation against resolved
253 undefined weak symbol in executable. */
254 if (!resolved_to_zero)
256 /* We also need to make an entry in the .rel.plt
258 htab->elf.srelplt->size += htab->sizeof_reloc;
259 htab->elf.srelplt->reloc_count++;
263 if (htab->target_os == is_vxworks && !bfd_link_pic (info))
265 /* VxWorks has a second set of relocations for each PLT entry
266 in executables. They go in a separate relocation section,
267 which is processed by the kernel loader. */
269 /* There are two relocations for the initial PLT entry: an
270 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
271 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
273 asection *srelplt2 = htab->srelplt2;
274 if (h->plt.offset == plt_entry_size)
275 srelplt2->size += (htab->sizeof_reloc * 2);
277 /* There are two extra relocations for each subsequent PLT entry:
278 an R_386_32 relocation for the GOT entry, and an R_386_32
279 relocation for the PLT entry. */
281 srelplt2->size += (htab->sizeof_reloc * 2);
286 eh->plt_got.offset = (bfd_vma) -1;
287 h->plt.offset = (bfd_vma) -1;
293 eh->plt_got.offset = (bfd_vma) -1;
294 h->plt.offset = (bfd_vma) -1;
298 eh->tlsdesc_got = (bfd_vma) -1;
300 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
301 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
302 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
303 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
304 if (h->got.refcount > 0
305 && bfd_link_executable (info)
307 && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
308 h->got.offset = (bfd_vma) -1;
309 else if (h->got.refcount > 0)
313 int tls_type = elf_x86_hash_entry (h)->tls_type;
315 /* Make sure this symbol is output as a dynamic symbol.
316 Undefined weak syms won't yet be marked as dynamic. */
320 && h->root.type == bfd_link_hash_undefweak)
322 if (! bfd_elf_link_record_dynamic_symbol (info, h))
327 if (GOT_TLS_GDESC_P (tls_type))
329 eh->tlsdesc_got = htab->elf.sgotplt->size
330 - elf_x86_compute_jump_table_size (htab);
331 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
332 h->got.offset = (bfd_vma) -2;
334 if (! GOT_TLS_GDESC_P (tls_type)
335 || GOT_TLS_GD_P (tls_type))
337 h->got.offset = s->size;
338 s->size += htab->got_entry_size;
339 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
341 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
342 s->size += htab->got_entry_size;
344 dyn = htab->elf.dynamic_sections_created;
345 /* R_386_TLS_IE_32 needs one dynamic relocation,
346 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
347 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
348 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
349 symbol and two if global. No dynamic relocation against
350 resolved undefined weak symbol in executable. */
351 if (tls_type == GOT_TLS_IE_BOTH)
352 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
353 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
354 || (tls_type & GOT_TLS_IE))
355 htab->elf.srelgot->size += htab->sizeof_reloc;
356 else if (GOT_TLS_GD_P (tls_type))
357 htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
358 else if (! GOT_TLS_GDESC_P (tls_type)
359 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
360 && !resolved_to_zero)
361 || h->root.type != bfd_link_hash_undefweak)
362 && (bfd_link_pic (info)
363 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
364 htab->elf.srelgot->size += htab->sizeof_reloc;
365 if (GOT_TLS_GDESC_P (tls_type))
367 htab->elf.srelplt->size += htab->sizeof_reloc;
368 if (bed->target_id == X86_64_ELF_DATA)
369 htab->tlsdesc_plt = (bfd_vma) -1;
373 h->got.offset = (bfd_vma) -1;
375 if (eh->dyn_relocs == NULL)
378 /* In the shared -Bsymbolic case, discard space allocated for
379 dynamic pc-relative relocs against symbols which turn out to be
380 defined in regular objects. For the normal shared case, discard
381 space for pc-relative relocs that have become local due to symbol
382 visibility changes. */
384 if (bfd_link_pic (info))
386 /* Relocs that use pc_count are those that appear on a call
387 insn, or certain REL relocs that can generated via assembly.
388 We want calls to protected symbols to resolve directly to the
389 function rather than going via the plt. If people want
390 function pointer comparisons to work as expected then they
391 should avoid writing weird assembly. */
392 if (SYMBOL_CALLS_LOCAL (info, h))
394 struct elf_dyn_relocs **pp;
396 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
398 p->count -= p->pc_count;
407 if (htab->target_os == is_vxworks)
409 struct elf_dyn_relocs **pp;
410 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
412 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
419 /* Also discard relocs on undefined weak syms with non-default
420 visibility or in PIE. */
421 if (eh->dyn_relocs != NULL)
423 if (h->root.type == bfd_link_hash_undefweak)
425 /* Undefined weak symbol is never bound locally in shared
427 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
430 if (bed->target_id == I386_ELF_DATA
433 /* Keep dynamic non-GOT/non-PLT relocation so
434 that we can branch to 0 without PLT. */
435 struct elf_dyn_relocs **pp;
437 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
438 if (p->pc_count == 0)
442 /* Remove non-R_386_PC32 relocation. */
443 p->count = p->pc_count;
447 /* Make sure undefined weak symbols are output
448 as dynamic symbols in PIEs for dynamic non-GOT
449 non-PLT reloations. */
450 if (eh->dyn_relocs != NULL
451 && !bfd_elf_link_record_dynamic_symbol (info, h))
455 eh->dyn_relocs = NULL;
457 else if (h->dynindx == -1
459 && !bfd_elf_link_record_dynamic_symbol (info, h))
462 else if (bfd_link_executable (info)
463 && (h->needs_copy || eh->needs_copy)
467 /* NB: needs_copy is set only for x86-64. For PIE,
468 discard space for pc-relative relocs against symbols
469 which turn out to need copy relocs. */
470 struct elf_dyn_relocs **pp;
472 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
474 if (p->pc_count != 0)
482 else if (ELIMINATE_COPY_RELOCS)
484 /* For the non-shared case, discard space for relocs against
485 symbols which turn out to need copy relocs or are not
486 dynamic. Keep dynamic relocations for run-time function
487 pointer initialization. */
490 || (h->root.type == bfd_link_hash_undefweak
491 && !resolved_to_zero))
494 || (htab->elf.dynamic_sections_created
495 && (h->root.type == bfd_link_hash_undefweak
496 || h->root.type == bfd_link_hash_undefined))))
498 /* Make sure this symbol is output as a dynamic symbol.
499 Undefined weak syms won't yet be marked as dynamic. */
503 && h->root.type == bfd_link_hash_undefweak
504 && ! bfd_elf_link_record_dynamic_symbol (info, h))
507 /* If that succeeded, we know we'll be keeping all the
509 if (h->dynindx != -1)
513 eh->dyn_relocs = NULL;
518 /* Finally, allocate space. */
519 for (p = eh->dyn_relocs; p != NULL; p = p->next)
523 sreloc = elf_section_data (p->sec)->sreloc;
525 BFD_ASSERT (sreloc != NULL);
526 sreloc->size += p->count * htab->sizeof_reloc;
532 /* Find dynamic relocs for H that apply to read-only sections. */
535 readonly_dynrelocs (struct elf_link_hash_entry *h)
537 struct elf_dyn_relocs *p;
539 for (p = elf_x86_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
541 asection *s = p->sec->output_section;
543 if (s != NULL && (s->flags & SEC_READONLY) != 0)
549 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
550 read-only sections. */
553 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
557 if (h->root.type == bfd_link_hash_indirect)
560 /* Skip local IFUNC symbols. */
561 if (h->forced_local && h->type == STT_GNU_IFUNC)
564 sec = readonly_dynrelocs (h);
567 struct bfd_link_info *info = (struct bfd_link_info *) inf;
569 info->flags |= DF_TEXTREL;
570 /* xgettext:c-format */
571 info->callbacks->minfo (_("%pB: dynamic relocation against `%pT' "
572 "in read-only section `%pA'\n"),
573 sec->owner, h->root.root.string, sec);
575 if ((info->warn_shared_textrel && bfd_link_pic (info))
576 || info->error_textrel)
577 /* xgettext:c-format */
578 info->callbacks->einfo (_("%P: %pB: warning: relocation against `%s' "
579 "in read-only section `%pA'\n"),
580 sec->owner, h->root.root.string, sec);
582 /* Not an error, just cut short the traversal. */
588 /* Allocate space in .plt, .got and associated reloc sections for
589 local dynamic relocs. */
592 elf_x86_allocate_local_dynreloc (void **slot, void *inf)
594 struct elf_link_hash_entry *h
595 = (struct elf_link_hash_entry *) *slot;
597 if (h->type != STT_GNU_IFUNC
601 || h->root.type != bfd_link_hash_defined)
604 return elf_x86_allocate_dynrelocs (h, inf);
607 /* Find and/or create a hash entry for local symbol. */
609 struct elf_link_hash_entry *
610 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
611 bfd *abfd, const Elf_Internal_Rela *rel,
614 struct elf_x86_link_hash_entry e, *ret;
615 asection *sec = abfd->sections;
616 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
617 htab->r_sym (rel->r_info));
620 e.elf.indx = sec->id;
621 e.elf.dynstr_index = htab->r_sym (rel->r_info);
622 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
623 create ? INSERT : NO_INSERT);
630 ret = (struct elf_x86_link_hash_entry *) *slot;
634 ret = (struct elf_x86_link_hash_entry *)
635 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
636 sizeof (struct elf_x86_link_hash_entry));
639 memset (ret, 0, sizeof (*ret));
640 ret->elf.indx = sec->id;
641 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
642 ret->elf.dynindx = -1;
643 ret->plt_got.offset = (bfd_vma) -1;
649 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
650 SYNC WITH _bfd_elf_link_hash_newfunc. */
652 struct bfd_hash_entry *
653 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
654 struct bfd_hash_table *table,
657 /* Allocate the structure if it has not already been allocated by a
661 entry = (struct bfd_hash_entry *)
662 bfd_hash_allocate (table,
663 sizeof (struct elf_x86_link_hash_entry));
668 /* Call the allocation method of the superclass. */
669 entry = _bfd_link_hash_newfunc (entry, table, string);
672 struct elf_x86_link_hash_entry *eh
673 = (struct elf_x86_link_hash_entry *) entry;
674 struct elf_link_hash_table *htab
675 = (struct elf_link_hash_table *) table;
677 memset (&eh->elf.size, 0,
678 (sizeof (struct elf_x86_link_hash_entry)
679 - offsetof (struct elf_link_hash_entry, size)));
680 /* Set local fields. */
682 eh->elf.dynindx = -1;
683 eh->elf.got = htab->init_got_refcount;
684 eh->elf.plt = htab->init_plt_refcount;
685 /* Assume that we have been called by a non-ELF symbol reader.
686 This flag is then reset by the code which reads an ELF input
687 file. This ensures that a symbol created by a non-ELF symbol
688 reader will have the flag set correctly. */
690 eh->plt_second.offset = (bfd_vma) -1;
691 eh->plt_got.offset = (bfd_vma) -1;
692 eh->tlsdesc_got = (bfd_vma) -1;
693 eh->zero_undefweak = 1;
699 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
700 for local symbol so that we can handle local STT_GNU_IFUNC symbols
701 as global symbol. We reuse indx and dynstr_index for local symbol
702 hash since they aren't used by global symbols in this backend. */
705 _bfd_x86_elf_local_htab_hash (const void *ptr)
707 struct elf_link_hash_entry *h
708 = (struct elf_link_hash_entry *) ptr;
709 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
712 /* Compare local hash entries. */
715 _bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
717 struct elf_link_hash_entry *h1
718 = (struct elf_link_hash_entry *) ptr1;
719 struct elf_link_hash_entry *h2
720 = (struct elf_link_hash_entry *) ptr2;
722 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
725 /* Destroy an x86 ELF linker hash table. */
728 elf_x86_link_hash_table_free (bfd *obfd)
730 struct elf_x86_link_hash_table *htab
731 = (struct elf_x86_link_hash_table *) obfd->link.hash;
733 if (htab->loc_hash_table)
734 htab_delete (htab->loc_hash_table);
735 if (htab->loc_hash_memory)
736 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
737 _bfd_elf_link_hash_table_free (obfd);
741 elf_i386_is_reloc_section (const char *secname)
743 return CONST_STRNEQ (secname, ".rel");
747 elf_x86_64_is_reloc_section (const char *secname)
749 return CONST_STRNEQ (secname, ".rela");
752 /* Create an x86 ELF linker hash table. */
754 struct bfd_link_hash_table *
755 _bfd_x86_elf_link_hash_table_create (bfd *abfd)
757 struct elf_x86_link_hash_table *ret;
758 const struct elf_backend_data *bed;
759 bfd_size_type amt = sizeof (struct elf_x86_link_hash_table);
761 ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
765 bed = get_elf_backend_data (abfd);
766 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
767 _bfd_x86_elf_link_hash_newfunc,
768 sizeof (struct elf_x86_link_hash_entry),
775 if (bed->target_id == X86_64_ELF_DATA)
777 ret->is_reloc_section = elf_x86_64_is_reloc_section;
778 ret->dt_reloc = DT_RELA;
779 ret->dt_reloc_sz = DT_RELASZ;
780 ret->dt_reloc_ent = DT_RELAENT;
781 ret->got_entry_size = 8;
782 ret->pcrel_plt = TRUE;
783 ret->tls_get_addr = "__tls_get_addr";
787 ret->sizeof_reloc = sizeof (Elf64_External_Rela);
788 ret->pointer_r_type = R_X86_64_64;
789 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
790 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
794 if (bed->target_id == X86_64_ELF_DATA)
796 ret->sizeof_reloc = sizeof (Elf32_External_Rela);
797 ret->pointer_r_type = R_X86_64_32;
798 ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
799 ret->dynamic_interpreter_size
800 = sizeof ELFX32_DYNAMIC_INTERPRETER;
804 ret->is_reloc_section = elf_i386_is_reloc_section;
805 ret->dt_reloc = DT_REL;
806 ret->dt_reloc_sz = DT_RELSZ;
807 ret->dt_reloc_ent = DT_RELENT;
808 ret->sizeof_reloc = sizeof (Elf32_External_Rel);
809 ret->got_entry_size = 4;
810 ret->pcrel_plt = FALSE;
811 ret->pointer_r_type = R_386_32;
812 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
813 ret->dynamic_interpreter_size
814 = sizeof ELF32_DYNAMIC_INTERPRETER;
815 ret->tls_get_addr = "___tls_get_addr";
818 ret->target_id = bed->target_id;
819 ret->target_os = get_elf_x86_backend_data (abfd)->target_os;
821 ret->loc_hash_table = htab_try_create (1024,
822 _bfd_x86_elf_local_htab_hash,
823 _bfd_x86_elf_local_htab_eq,
825 ret->loc_hash_memory = objalloc_create ();
826 if (!ret->loc_hash_table || !ret->loc_hash_memory)
828 elf_x86_link_hash_table_free (abfd);
831 ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
833 return &ret->elf.root;
836 /* Sort relocs into address order. */
839 _bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
841 const arelent *a = * (const arelent **) ap;
842 const arelent *b = * (const arelent **) bp;
844 if (a->address > b->address)
846 else if (a->address < b->address)
852 /* Mark symbol, NAME, as locally defined by linker if it is referenced
853 and not defined in a relocatable object file. */
856 elf_x86_linker_defined (struct bfd_link_info *info, const char *name)
858 struct elf_link_hash_entry *h;
860 h = elf_link_hash_lookup (elf_hash_table (info), name,
861 FALSE, FALSE, FALSE);
865 while (h->root.type == bfd_link_hash_indirect)
866 h = (struct elf_link_hash_entry *) h->root.u.i.link;
868 if (h->root.type == bfd_link_hash_new
869 || h->root.type == bfd_link_hash_undefined
870 || h->root.type == bfd_link_hash_undefweak
871 || h->root.type == bfd_link_hash_common
872 || (!h->def_regular && h->def_dynamic))
874 elf_x86_hash_entry (h)->local_ref = 2;
875 elf_x86_hash_entry (h)->linker_def = 1;
880 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
882 if (!bfd_link_relocatable (info))
884 /* Check for __tls_get_addr reference. */
885 struct elf_x86_link_hash_table *htab;
886 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
887 htab = elf_x86_hash_table (info, bed->target_id);
890 struct elf_link_hash_entry *h;
892 h = elf_link_hash_lookup (elf_hash_table (info),
894 FALSE, FALSE, FALSE);
897 elf_x86_hash_entry (h)->tls_get_addr = 1;
899 /* Check the versioned __tls_get_addr symbol. */
900 while (h->root.type == bfd_link_hash_indirect)
902 h = (struct elf_link_hash_entry *) h->root.u.i.link;
903 elf_x86_hash_entry (h)->tls_get_addr = 1;
907 /* "__ehdr_start" will be defined by linker as a hidden symbol
908 later if it is referenced and not defined. */
909 elf_x86_linker_defined (info, "__ehdr_start");
911 if (bfd_link_executable (info))
913 /* References to __bss_start, _end and _edata should be
914 locally resolved within executables. */
915 elf_x86_linker_defined (info, "__bss_start");
916 elf_x86_linker_defined (info, "_end");
917 elf_x86_linker_defined (info, "_edata");
922 /* Invoke the regular ELF backend linker to do all the work. */
923 return _bfd_elf_link_check_relocs (abfd, info);
926 /* Set the sizes of the dynamic sections. */
929 _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd,
930 struct bfd_link_info *info)
932 struct elf_x86_link_hash_table *htab;
937 const struct elf_backend_data *bed
938 = get_elf_backend_data (output_bfd);
940 htab = elf_x86_hash_table (info, bed->target_id);
943 dynobj = htab->elf.dynobj;
947 /* Set up .got offsets for local syms, and space for local dynamic
949 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
951 bfd_signed_vma *local_got;
952 bfd_signed_vma *end_local_got;
953 char *local_tls_type;
954 bfd_vma *local_tlsdesc_gotent;
955 bfd_size_type locsymcount;
956 Elf_Internal_Shdr *symtab_hdr;
959 if (! is_x86_elf (ibfd, htab))
962 for (s = ibfd->sections; s != NULL; s = s->next)
964 struct elf_dyn_relocs *p;
966 for (p = ((struct elf_dyn_relocs *)
967 elf_section_data (s)->local_dynrel);
971 if (!bfd_is_abs_section (p->sec)
972 && bfd_is_abs_section (p->sec->output_section))
974 /* Input section has been discarded, either because
975 it is a copy of a linkonce section or due to
976 linker script /DISCARD/, so we'll be discarding
979 else if (htab->target_os == is_vxworks
980 && strcmp (p->sec->output_section->name,
983 /* Relocations in vxworks .tls_vars sections are
984 handled specially by the loader. */
986 else if (p->count != 0)
988 srel = elf_section_data (p->sec)->sreloc;
989 srel->size += p->count * htab->sizeof_reloc;
990 if ((p->sec->output_section->flags & SEC_READONLY) != 0
991 && (info->flags & DF_TEXTREL) == 0)
993 info->flags |= DF_TEXTREL;
994 if ((info->warn_shared_textrel && bfd_link_pic (info))
995 || info->error_textrel)
996 /* xgettext:c-format */
997 info->callbacks->einfo
998 (_("%P: %pB: warning: relocation "
999 "in read-only section `%pA'\n"),
1000 p->sec->owner, p->sec);
1006 local_got = elf_local_got_refcounts (ibfd);
1010 symtab_hdr = &elf_symtab_hdr (ibfd);
1011 locsymcount = symtab_hdr->sh_info;
1012 end_local_got = local_got + locsymcount;
1013 local_tls_type = elf_x86_local_got_tls_type (ibfd);
1014 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
1016 srel = htab->elf.srelgot;
1017 for (; local_got < end_local_got;
1018 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1020 *local_tlsdesc_gotent = (bfd_vma) -1;
1023 if (GOT_TLS_GDESC_P (*local_tls_type))
1025 *local_tlsdesc_gotent = htab->elf.sgotplt->size
1026 - elf_x86_compute_jump_table_size (htab);
1027 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
1028 *local_got = (bfd_vma) -2;
1030 if (! GOT_TLS_GDESC_P (*local_tls_type)
1031 || GOT_TLS_GD_P (*local_tls_type))
1033 *local_got = s->size;
1034 s->size += htab->got_entry_size;
1035 if (GOT_TLS_GD_P (*local_tls_type)
1036 || *local_tls_type == GOT_TLS_IE_BOTH)
1037 s->size += htab->got_entry_size;
1039 if (bfd_link_pic (info)
1040 || GOT_TLS_GD_ANY_P (*local_tls_type)
1041 || (*local_tls_type & GOT_TLS_IE))
1043 if (*local_tls_type == GOT_TLS_IE_BOTH)
1044 srel->size += 2 * htab->sizeof_reloc;
1045 else if (GOT_TLS_GD_P (*local_tls_type)
1046 || ! GOT_TLS_GDESC_P (*local_tls_type))
1047 srel->size += htab->sizeof_reloc;
1048 if (GOT_TLS_GDESC_P (*local_tls_type))
1050 htab->elf.srelplt->size += htab->sizeof_reloc;
1051 if (bed->target_id == X86_64_ELF_DATA)
1052 htab->tlsdesc_plt = (bfd_vma) -1;
1057 *local_got = (bfd_vma) -1;
1061 if (htab->tls_ld_or_ldm_got.refcount > 0)
1063 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1064 or R_X86_64_TLSLD relocs. */
1065 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
1066 htab->elf.sgot->size += 2 * htab->got_entry_size;
1067 htab->elf.srelgot->size += htab->sizeof_reloc;
1070 htab->tls_ld_or_ldm_got.offset = -1;
1072 /* Allocate global sym .plt and .got entries, and space for global
1073 sym dynamic relocs. */
1074 elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
1077 /* Allocate .plt and .got entries, and space for local symbols. */
1078 htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
1081 /* For every jump slot reserved in the sgotplt, reloc_count is
1082 incremented. However, when we reserve space for TLS descriptors,
1083 it's not incremented, so in order to compute the space reserved
1084 for them, it suffices to multiply the reloc count by the jump
1087 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1088 so that R_{386,X86_64}_IRELATIVE entries come last. */
1089 if (htab->elf.srelplt)
1091 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
1092 htab->sgotplt_jump_table_size
1093 = elf_x86_compute_jump_table_size (htab);
1094 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
1096 else if (htab->elf.irelplt)
1097 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
1099 if (htab->tlsdesc_plt)
1101 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1102 lazy TLS relocations, don't generate the PLT and GOT entries
1104 if ((info->flags & DF_BIND_NOW))
1105 htab->tlsdesc_plt = 0;
1108 htab->tlsdesc_got = htab->elf.sgot->size;
1109 htab->elf.sgot->size += htab->got_entry_size;
1110 /* Reserve room for the initial entry.
1111 FIXME: we could probably do away with it in this case. */
1112 if (htab->elf.splt->size == 0)
1113 htab->elf.splt->size = htab->plt.plt_entry_size;
1114 htab->tlsdesc_plt = htab->elf.splt->size;
1115 htab->elf.splt->size += htab->plt.plt_entry_size;
1119 if (htab->elf.sgotplt)
1121 /* Don't allocate .got.plt section if there are no GOT nor PLT
1122 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1123 if ((htab->elf.hgot == NULL
1124 || !htab->got_referenced)
1125 && (htab->elf.sgotplt->size == bed->got_header_size)
1126 && (htab->elf.splt == NULL
1127 || htab->elf.splt->size == 0)
1128 && (htab->elf.sgot == NULL
1129 || htab->elf.sgot->size == 0)
1130 && (htab->elf.iplt == NULL
1131 || htab->elf.iplt->size == 0)
1132 && (htab->elf.igotplt == NULL
1133 || htab->elf.igotplt->size == 0))
1135 htab->elf.sgotplt->size = 0;
1136 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
1138 if (htab->elf.hgot != NULL && htab->target_os != is_solaris)
1140 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
1142 htab->elf.hgot->root.type = bfd_link_hash_undefined;
1143 htab->elf.hgot->root.u.undef.abfd
1144 = htab->elf.hgot->root.u.def.section->owner;
1145 htab->elf.hgot->root.linker_def = 0;
1146 htab->elf.hgot->ref_regular = 0;
1147 htab->elf.hgot->def_regular = 0;
1152 if (_bfd_elf_eh_frame_present (info))
1154 if (htab->plt_eh_frame != NULL
1155 && htab->elf.splt != NULL
1156 && htab->elf.splt->size != 0
1157 && !bfd_is_abs_section (htab->elf.splt->output_section))
1158 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
1160 if (htab->plt_got_eh_frame != NULL
1161 && htab->plt_got != NULL
1162 && htab->plt_got->size != 0
1163 && !bfd_is_abs_section (htab->plt_got->output_section))
1164 htab->plt_got_eh_frame->size
1165 = htab->non_lazy_plt->eh_frame_plt_size;
1167 /* Unwind info for the second PLT and .plt.got sections are
1169 if (htab->plt_second_eh_frame != NULL
1170 && htab->plt_second != NULL
1171 && htab->plt_second->size != 0
1172 && !bfd_is_abs_section (htab->plt_second->output_section))
1173 htab->plt_second_eh_frame->size
1174 = htab->non_lazy_plt->eh_frame_plt_size;
1177 /* We now have determined the sizes of the various dynamic sections.
1178 Allocate memory for them. */
1180 for (s = dynobj->sections; s != NULL; s = s->next)
1182 bfd_boolean strip_section = TRUE;
1184 if ((s->flags & SEC_LINKER_CREATED) == 0)
1187 if (s == htab->elf.splt
1188 || s == htab->elf.sgot)
1190 /* Strip this section if we don't need it; see the
1192 /* We'd like to strip these sections if they aren't needed, but if
1193 we've exported dynamic symbols from them we must leave them.
1194 It's too late to tell BFD to get rid of the symbols. */
1196 if (htab->elf.hplt != NULL)
1197 strip_section = FALSE;
1199 else if (s == htab->elf.sgotplt
1200 || s == htab->elf.iplt
1201 || s == htab->elf.igotplt
1202 || s == htab->plt_second
1203 || s == htab->plt_got
1204 || s == htab->plt_eh_frame
1205 || s == htab->plt_got_eh_frame
1206 || s == htab->plt_second_eh_frame
1207 || s == htab->elf.sdynbss
1208 || s == htab->elf.sdynrelro)
1210 /* Strip these too. */
1212 else if (htab->is_reloc_section (bfd_get_section_name (dynobj, s)))
1215 && s != htab->elf.srelplt
1216 && s != htab->srelplt2)
1219 /* We use the reloc_count field as a counter if we need
1220 to copy relocs into the output file. */
1221 if (s != htab->elf.srelplt)
1226 /* It's not one of our sections, so don't allocate space. */
1232 /* If we don't need this section, strip it from the
1233 output file. This is mostly to handle .rel.bss and
1234 .rel.plt. We must create both sections in
1235 create_dynamic_sections, because they must be created
1236 before the linker maps input sections to output
1237 sections. The linker does that before
1238 adjust_dynamic_symbol is called, and it is that
1239 function which decides whether anything needs to go
1240 into these sections. */
1242 s->flags |= SEC_EXCLUDE;
1246 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1249 /* Allocate memory for the section contents. We use bfd_zalloc
1250 here in case unused entries are not reclaimed before the
1251 section's contents are written out. This should not happen,
1252 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1253 reloc instead of garbage. */
1254 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
1255 if (s->contents == NULL)
1259 if (htab->plt_eh_frame != NULL
1260 && htab->plt_eh_frame->contents != NULL)
1262 memcpy (htab->plt_eh_frame->contents,
1263 htab->plt.eh_frame_plt,
1264 htab->plt_eh_frame->size);
1265 bfd_put_32 (dynobj, htab->elf.splt->size,
1266 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
1269 if (htab->plt_got_eh_frame != NULL
1270 && htab->plt_got_eh_frame->contents != NULL)
1272 memcpy (htab->plt_got_eh_frame->contents,
1273 htab->non_lazy_plt->eh_frame_plt,
1274 htab->plt_got_eh_frame->size);
1275 bfd_put_32 (dynobj, htab->plt_got->size,
1276 (htab->plt_got_eh_frame->contents
1277 + PLT_FDE_LEN_OFFSET));
1280 if (htab->plt_second_eh_frame != NULL
1281 && htab->plt_second_eh_frame->contents != NULL)
1283 memcpy (htab->plt_second_eh_frame->contents,
1284 htab->non_lazy_plt->eh_frame_plt,
1285 htab->plt_second_eh_frame->size);
1286 bfd_put_32 (dynobj, htab->plt_second->size,
1287 (htab->plt_second_eh_frame->contents
1288 + PLT_FDE_LEN_OFFSET));
1291 if (htab->elf.dynamic_sections_created)
1293 /* Add some entries to the .dynamic section. We fill in the
1294 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1295 but we must add the entries now so that we get the correct
1296 size for the .dynamic section. The DT_DEBUG entry is filled
1297 in by the dynamic linker and used by the debugger. */
1298 #define add_dynamic_entry(TAG, VAL) \
1299 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1301 if (bfd_link_executable (info))
1303 if (!add_dynamic_entry (DT_DEBUG, 0))
1307 if (htab->elf.splt->size != 0)
1309 /* DT_PLTGOT is used by prelink even if there is no PLT
1311 if (!add_dynamic_entry (DT_PLTGOT, 0))
1315 if (htab->elf.srelplt->size != 0)
1317 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1318 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc)
1319 || !add_dynamic_entry (DT_JMPREL, 0))
1323 if (htab->tlsdesc_plt
1324 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
1325 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
1330 if (!add_dynamic_entry (htab->dt_reloc, 0)
1331 || !add_dynamic_entry (htab->dt_reloc_sz, 0)
1332 || !add_dynamic_entry (htab->dt_reloc_ent,
1333 htab->sizeof_reloc))
1336 /* If any dynamic relocs apply to a read-only section,
1337 then we need a DT_TEXTREL entry. */
1338 if ((info->flags & DF_TEXTREL) == 0)
1339 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
1341 if ((info->flags & DF_TEXTREL) != 0)
1343 if (htab->readonly_dynrelocs_against_ifunc)
1345 info->callbacks->einfo
1346 (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1347 " recompile with -fPIC\n"));
1348 bfd_set_error (bfd_error_bad_value);
1352 if (!add_dynamic_entry (DT_TEXTREL, 0))
1356 if (htab->target_os == is_vxworks
1357 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
1360 #undef add_dynamic_entry
1365 /* Finish up the x86 dynamic sections. */
1367 struct elf_x86_link_hash_table *
1368 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
1369 struct bfd_link_info *info)
1371 struct elf_x86_link_hash_table *htab;
1372 const struct elf_backend_data *bed;
1375 bfd_byte *dyncon, *dynconend;
1376 bfd_size_type sizeof_dyn;
1378 bed = get_elf_backend_data (output_bfd);
1379 htab = elf_x86_hash_table (info, bed->target_id);
1383 dynobj = htab->elf.dynobj;
1384 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1386 /* GOT is always created in setup_gnu_properties. But it may not be
1387 needed. .got.plt section may be needed for static IFUNC. */
1388 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
1390 bfd_vma dynamic_addr;
1392 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
1395 (_("discarded output section: `%pA'"), htab->elf.sgotplt);
1399 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
1400 = htab->got_entry_size;
1402 dynamic_addr = (sdyn == NULL
1404 : sdyn->output_section->vma + sdyn->output_offset);
1406 /* Set the first entry in the global offset table to the address
1407 of the dynamic section. Write GOT[1] and GOT[2], needed for
1408 the dynamic linker. */
1409 if (htab->got_entry_size == 8)
1411 bfd_put_64 (output_bfd, dynamic_addr,
1412 htab->elf.sgotplt->contents);
1413 bfd_put_64 (output_bfd, (bfd_vma) 0,
1414 htab->elf.sgotplt->contents + 8);
1415 bfd_put_64 (output_bfd, (bfd_vma) 0,
1416 htab->elf.sgotplt->contents + 8*2);
1420 bfd_put_32 (output_bfd, dynamic_addr,
1421 htab->elf.sgotplt->contents);
1422 bfd_put_32 (output_bfd, 0,
1423 htab->elf.sgotplt->contents + 4);
1424 bfd_put_32 (output_bfd, 0,
1425 htab->elf.sgotplt->contents + 4*2);
1429 if (!htab->elf.dynamic_sections_created)
1432 if (sdyn == NULL || htab->elf.sgot == NULL)
1435 sizeof_dyn = bed->s->sizeof_dyn;
1436 dyncon = sdyn->contents;
1437 dynconend = sdyn->contents + sdyn->size;
1438 for (; dyncon < dynconend; dyncon += sizeof_dyn)
1440 Elf_Internal_Dyn dyn;
1443 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
1448 if (htab->target_os == is_vxworks
1449 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
1454 s = htab->elf.sgotplt;
1455 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1459 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
1463 s = htab->elf.srelplt->output_section;
1464 dyn.d_un.d_val = s->size;
1467 case DT_TLSDESC_PLT:
1469 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1470 + htab->tlsdesc_plt;
1473 case DT_TLSDESC_GOT:
1475 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1476 + htab->tlsdesc_got;
1480 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
1483 if (htab->plt_got != NULL && htab->plt_got->size > 0)
1484 elf_section_data (htab->plt_got->output_section)
1485 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1487 if (htab->plt_second != NULL && htab->plt_second->size > 0)
1488 elf_section_data (htab->plt_second->output_section)
1489 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1491 /* Adjust .eh_frame for .plt section. */
1492 if (htab->plt_eh_frame != NULL
1493 && htab->plt_eh_frame->contents != NULL)
1495 if (htab->elf.splt != NULL
1496 && htab->elf.splt->size != 0
1497 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
1498 && htab->elf.splt->output_section != NULL
1499 && htab->plt_eh_frame->output_section != NULL)
1501 bfd_vma plt_start = htab->elf.splt->output_section->vma;
1502 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
1503 + htab->plt_eh_frame->output_offset
1504 + PLT_FDE_START_OFFSET;
1505 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1506 htab->plt_eh_frame->contents
1507 + PLT_FDE_START_OFFSET);
1510 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1512 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1514 htab->plt_eh_frame->contents))
1519 /* Adjust .eh_frame for .plt.got section. */
1520 if (htab->plt_got_eh_frame != NULL
1521 && htab->plt_got_eh_frame->contents != NULL)
1523 if (htab->plt_got != NULL
1524 && htab->plt_got->size != 0
1525 && (htab->plt_got->flags & SEC_EXCLUDE) == 0
1526 && htab->plt_got->output_section != NULL
1527 && htab->plt_got_eh_frame->output_section != NULL)
1529 bfd_vma plt_start = htab->plt_got->output_section->vma;
1530 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
1531 + htab->plt_got_eh_frame->output_offset
1532 + PLT_FDE_START_OFFSET;
1533 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1534 htab->plt_got_eh_frame->contents
1535 + PLT_FDE_START_OFFSET);
1537 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1539 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1540 htab->plt_got_eh_frame,
1541 htab->plt_got_eh_frame->contents))
1546 /* Adjust .eh_frame for the second PLT section. */
1547 if (htab->plt_second_eh_frame != NULL
1548 && htab->plt_second_eh_frame->contents != NULL)
1550 if (htab->plt_second != NULL
1551 && htab->plt_second->size != 0
1552 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
1553 && htab->plt_second->output_section != NULL
1554 && htab->plt_second_eh_frame->output_section != NULL)
1556 bfd_vma plt_start = htab->plt_second->output_section->vma;
1557 bfd_vma eh_frame_start
1558 = (htab->plt_second_eh_frame->output_section->vma
1559 + htab->plt_second_eh_frame->output_offset
1560 + PLT_FDE_START_OFFSET);
1561 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1562 htab->plt_second_eh_frame->contents
1563 + PLT_FDE_START_OFFSET);
1565 if (htab->plt_second_eh_frame->sec_info_type
1566 == SEC_INFO_TYPE_EH_FRAME)
1568 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1569 htab->plt_second_eh_frame,
1570 htab->plt_second_eh_frame->contents))
1575 if (htab->elf.sgot && htab->elf.sgot->size > 0)
1576 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
1577 = htab->got_entry_size;
1584 _bfd_x86_elf_always_size_sections (bfd *output_bfd,
1585 struct bfd_link_info *info)
1587 asection *tls_sec = elf_hash_table (info)->tls_sec;
1591 struct elf_link_hash_entry *tlsbase;
1593 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1594 "_TLS_MODULE_BASE_",
1595 FALSE, FALSE, FALSE);
1597 if (tlsbase && tlsbase->type == STT_TLS)
1599 struct elf_x86_link_hash_table *htab;
1600 struct bfd_link_hash_entry *bh = NULL;
1601 const struct elf_backend_data *bed
1602 = get_elf_backend_data (output_bfd);
1604 htab = elf_x86_hash_table (info, bed->target_id);
1608 if (!(_bfd_generic_link_add_one_symbol
1609 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1610 tls_sec, 0, NULL, FALSE,
1611 bed->collect, &bh)))
1614 htab->tls_module_base = bh;
1616 tlsbase = (struct elf_link_hash_entry *)bh;
1617 tlsbase->def_regular = 1;
1618 tlsbase->other = STV_HIDDEN;
1619 tlsbase->root.linker_def = 1;
1620 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1628 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
1629 const Elf_Internal_Sym *isym,
1630 bfd_boolean definition,
1631 bfd_boolean dynamic ATTRIBUTE_UNUSED)
1635 struct elf_x86_link_hash_entry *eh
1636 = (struct elf_x86_link_hash_entry *) h;
1637 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
1642 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1645 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
1646 struct elf_link_hash_entry *dir,
1647 struct elf_link_hash_entry *ind)
1649 struct elf_x86_link_hash_entry *edir, *eind;
1651 edir = (struct elf_x86_link_hash_entry *) dir;
1652 eind = (struct elf_x86_link_hash_entry *) ind;
1654 if (eind->dyn_relocs != NULL)
1656 if (edir->dyn_relocs != NULL)
1658 struct elf_dyn_relocs **pp;
1659 struct elf_dyn_relocs *p;
1661 /* Add reloc counts against the indirect sym to the direct sym
1662 list. Merge any entries against the same section. */
1663 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1665 struct elf_dyn_relocs *q;
1667 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1668 if (q->sec == p->sec)
1670 q->pc_count += p->pc_count;
1671 q->count += p->count;
1678 *pp = edir->dyn_relocs;
1681 edir->dyn_relocs = eind->dyn_relocs;
1682 eind->dyn_relocs = NULL;
1685 if (ind->root.type == bfd_link_hash_indirect
1686 && dir->got.refcount <= 0)
1688 edir->tls_type = eind->tls_type;
1689 eind->tls_type = GOT_UNKNOWN;
1692 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1693 generate a R_386_COPY reloc. */
1694 edir->gotoff_ref |= eind->gotoff_ref;
1696 edir->zero_undefweak |= eind->zero_undefweak;
1698 if (ELIMINATE_COPY_RELOCS
1699 && ind->root.type != bfd_link_hash_indirect
1700 && dir->dynamic_adjusted)
1702 /* If called to transfer flags for a weakdef during processing
1703 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1704 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1705 if (dir->versioned != versioned_hidden)
1706 dir->ref_dynamic |= ind->ref_dynamic;
1707 dir->ref_regular |= ind->ref_regular;
1708 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1709 dir->needs_plt |= ind->needs_plt;
1710 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1713 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1716 /* Remove undefined weak symbol from the dynamic symbol table if it
1717 is resolved to 0. */
1720 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
1721 struct elf_link_hash_entry *h)
1723 if (h->dynindx != -1
1724 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
1727 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1733 /* Change the STT_GNU_IFUNC symbol defined in position-dependent
1734 executable into the normal function symbol and set its address
1735 to its PLT entry, which should be resolved by R_*_IRELATIVE at
1739 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info,
1740 struct elf_x86_link_hash_table *htab,
1741 struct elf_link_hash_entry *h,
1742 Elf_Internal_Sym *sym)
1744 if (bfd_link_pde (info)
1747 && h->plt.offset != (bfd_vma) -1
1748 && h->type == STT_GNU_IFUNC
1749 && h->pointer_equality_needed)
1753 bfd *output_bfd = info->output_bfd;
1755 if (htab->plt_second)
1757 struct elf_x86_link_hash_entry *eh
1758 = (struct elf_x86_link_hash_entry *) h;
1760 plt_s = htab->plt_second;
1761 plt_offset = eh->plt_second.offset;
1765 plt_s = htab->elf.splt;
1766 plt_offset = h->plt.offset;
1770 sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
1772 = _bfd_elf_section_from_bfd_section (output_bfd,
1773 plt_s->output_section);
1774 sym->st_value = (plt_s->output_section->vma
1775 + plt_s->output_offset + plt_offset);
1779 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1782 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
1784 if (h->plt.offset != (bfd_vma) -1
1786 && !h->pointer_equality_needed)
1789 return _bfd_elf_hash_symbol (h);
1792 /* Adjust a symbol defined by a dynamic object and referenced by a
1793 regular object. The current definition is in some section of the
1794 dynamic object, but we're not including those sections. We have to
1795 change the definition to something the rest of the link can
1799 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1800 struct elf_link_hash_entry *h)
1802 struct elf_x86_link_hash_table *htab;
1804 struct elf_x86_link_hash_entry *eh;
1805 struct elf_dyn_relocs *p;
1806 const struct elf_backend_data *bed
1807 = get_elf_backend_data (info->output_bfd);
1809 /* STT_GNU_IFUNC symbol must go through PLT. */
1810 if (h->type == STT_GNU_IFUNC)
1812 /* All local STT_GNU_IFUNC references must be treate as local
1813 calls via local PLT. */
1815 && SYMBOL_CALLS_LOCAL (info, h))
1817 bfd_size_type pc_count = 0, count = 0;
1818 struct elf_dyn_relocs **pp;
1820 eh = (struct elf_x86_link_hash_entry *) h;
1821 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1823 pc_count += p->pc_count;
1824 p->count -= p->pc_count;
1833 if (pc_count || count)
1838 /* Increment PLT reference count only for PC-relative
1841 if (h->plt.refcount <= 0)
1842 h->plt.refcount = 1;
1844 h->plt.refcount += 1;
1849 if (h->plt.refcount <= 0)
1851 h->plt.offset = (bfd_vma) -1;
1857 /* If this is a function, put it in the procedure linkage table. We
1858 will fill in the contents of the procedure linkage table later,
1859 when we know the address of the .got section. */
1860 if (h->type == STT_FUNC
1863 if (h->plt.refcount <= 0
1864 || SYMBOL_CALLS_LOCAL (info, h)
1865 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1866 && h->root.type == bfd_link_hash_undefweak))
1868 /* This case can occur if we saw a PLT32 reloc in an input
1869 file, but the symbol was never referred to by a dynamic
1870 object, or if all references were garbage collected. In
1871 such a case, we don't actually need to build a procedure
1872 linkage table, and we can just do a PC32 reloc instead. */
1873 h->plt.offset = (bfd_vma) -1;
1880 /* It's possible that we incorrectly decided a .plt reloc was needed
1881 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1882 check_relocs. We can't decide accurately between function and
1883 non-function syms in check-relocs; Objects loaded later in
1884 the link may change h->type. So fix it now. */
1885 h->plt.offset = (bfd_vma) -1;
1887 eh = (struct elf_x86_link_hash_entry *) h;
1889 /* If this is a weak symbol, and there is a real definition, the
1890 processor independent code will have arranged for us to see the
1891 real definition first, and we can just use the same value. */
1892 if (h->is_weakalias)
1894 struct elf_link_hash_entry *def = weakdef (h);
1895 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1896 h->root.u.def.section = def->root.u.def.section;
1897 h->root.u.def.value = def->root.u.def.value;
1898 if (ELIMINATE_COPY_RELOCS
1899 || info->nocopyreloc
1900 || SYMBOL_NO_COPYRELOC (info, eh))
1902 /* NB: needs_copy is always 0 for i386. */
1903 h->non_got_ref = def->non_got_ref;
1904 eh->needs_copy = def->needs_copy;
1909 /* This is a reference to a symbol defined by a dynamic object which
1910 is not a function. */
1912 /* If we are creating a shared library, we must presume that the
1913 only references to the symbol are via the global offset table.
1914 For such cases we need not do anything here; the relocations will
1915 be handled correctly by relocate_section. */
1916 if (!bfd_link_executable (info))
1919 /* If there are no references to this symbol that do not use the
1920 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1921 reloc. NB: gotoff_ref is always 0 for x86-64. */
1922 if (!h->non_got_ref && !eh->gotoff_ref)
1925 /* If -z nocopyreloc was given, we won't generate them either. */
1926 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
1932 htab = elf_x86_hash_table (info, bed->target_id);
1936 /* If there aren't any dynamic relocs in read-only sections nor
1937 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1938 avoid the copy reloc. This doesn't work on VxWorks, where we can
1939 not have dynamic relocations (other than copy and jump slot
1940 relocations) in an executable. */
1941 if (ELIMINATE_COPY_RELOCS
1942 && (bed->target_id == X86_64_ELF_DATA
1944 && htab->target_os != is_vxworks)))
1946 /* If we don't find any dynamic relocs in read-only sections,
1947 then we'll be keeping the dynamic relocs and avoiding the copy
1949 if (!readonly_dynrelocs (h))
1956 /* We must allocate the symbol in our .dynbss section, which will
1957 become part of the .bss section of the executable. There will be
1958 an entry for this symbol in the .dynsym section. The dynamic
1959 object will contain position independent code, so all references
1960 from the dynamic object to this symbol will go through the global
1961 offset table. The dynamic linker will use the .dynsym entry to
1962 determine the address it must put in the global offset table, so
1963 both the dynamic object and the regular object will refer to the
1964 same memory location for the variable. */
1966 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1967 dynamic linker to copy the initial value out of the dynamic object
1968 and into the runtime process image. */
1969 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1971 s = htab->elf.sdynrelro;
1972 srel = htab->elf.sreldynrelro;
1976 s = htab->elf.sdynbss;
1977 srel = htab->elf.srelbss;
1979 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1981 srel->size += htab->sizeof_reloc;
1985 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1989 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
1990 struct elf_link_hash_entry *h,
1991 bfd_boolean force_local)
1993 if (h->root.type == bfd_link_hash_undefweak
1995 && bfd_link_pie (info))
1997 /* When there is no dynamic interpreter in PIE, make the undefined
1998 weak symbol dynamic so that PC relative branch to the undefined
1999 weak symbol will land to address 0. */
2000 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2001 if (h->plt.refcount > 0
2002 || eh->plt_got.refcount > 0)
2006 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2009 /* Return TRUE if a symbol is referenced locally. It is similar to
2010 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
2011 works in check_relocs. */
2014 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
2015 struct elf_link_hash_entry *h)
2017 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2018 struct elf_x86_link_hash_table *htab
2019 = (struct elf_x86_link_hash_table *) info->hash;
2021 if (eh->local_ref > 1)
2024 if (eh->local_ref == 1)
2027 /* Unversioned symbols defined in regular objects can be forced local
2028 by linker version script. A weak undefined symbol is forced local
2030 1. It has non-default visibility. Or
2031 2. When building executable, there is no dynamic linker. Or
2032 3. or "-z nodynamic-undefined-weak" is used.
2034 if (SYMBOL_REFERENCES_LOCAL (info, h)
2035 || (h->root.type == bfd_link_hash_undefweak
2036 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2037 || (bfd_link_executable (info)
2038 && htab->interp == NULL)
2039 || info->dynamic_undefined_weak == 0))
2040 || ((h->def_regular || ELF_COMMON_DEF_P (h))
2041 && info->version_info != NULL
2042 && _bfd_elf_link_hide_sym_by_version (info, h)))
2052 /* Return the section that should be marked against GC for a given
2056 _bfd_x86_elf_gc_mark_hook (asection *sec,
2057 struct bfd_link_info *info,
2058 Elf_Internal_Rela *rel,
2059 struct elf_link_hash_entry *h,
2060 Elf_Internal_Sym *sym)
2062 /* Compiler should optimize this out. */
2063 if (((unsigned int) R_X86_64_GNU_VTINHERIT
2064 != (unsigned int) R_386_GNU_VTINHERIT)
2065 || ((unsigned int) R_X86_64_GNU_VTENTRY
2066 != (unsigned int) R_386_GNU_VTENTRY))
2070 switch (ELF32_R_TYPE (rel->r_info))
2072 case R_X86_64_GNU_VTINHERIT:
2073 case R_X86_64_GNU_VTENTRY:
2077 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2081 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
2083 bfd_vma offset ATTRIBUTE_UNUSED,
2086 return got_addr + off;
2090 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
2093 bfd_vma got_addr ATTRIBUTE_UNUSED)
2095 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
2099 elf_i386_valid_plt_reloc_p (unsigned int type)
2101 return (type == R_386_JUMP_SLOT
2102 || type == R_386_GLOB_DAT
2103 || type == R_386_IRELATIVE);
2107 elf_x86_64_valid_plt_reloc_p (unsigned int type)
2109 return (type == R_X86_64_JUMP_SLOT
2110 || type == R_X86_64_GLOB_DAT
2111 || type == R_X86_64_IRELATIVE);
2115 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
2119 struct elf_x86_plt plts[],
2123 long size, i, n, len;
2125 unsigned int plt_got_offset, plt_entry_size;
2127 bfd_byte *plt_contents;
2129 arelent **dynrelbuf, *p;
2131 const struct elf_backend_data *bed;
2132 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
2134 bfd_boolean (*valid_plt_reloc_p) (unsigned int);
2139 dynrelbuf = (arelent **) bfd_malloc (relsize);
2140 if (dynrelbuf == NULL)
2143 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
2145 if (dynrelcount <= 0)
2148 /* Sort the relocs by address. */
2149 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
2150 _bfd_x86_elf_compare_relocs);
2152 size = count * sizeof (asymbol);
2154 /* Allocate space for @plt suffixes. */
2156 for (i = 0; i < dynrelcount; i++)
2159 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2161 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
2164 s = *ret = (asymbol *) bfd_zmalloc (size);
2168 bed = get_elf_backend_data (abfd);
2170 if (bed->target_id == X86_64_ELF_DATA)
2172 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
2173 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
2177 get_plt_got_vma = elf_i386_get_plt_got_vma;
2178 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
2181 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2183 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
2185 got_addr = sec->vma;
2188 sec = bfd_get_section_by_name (abfd, ".got");
2190 got_addr = sec->vma;
2193 if (got_addr == (bfd_vma) -1)
2198 /* Check for each PLT section. */
2199 names = (char *) (s + count);
2202 for (j = 0; plts[j].name != NULL; j++)
2203 if ((plt_contents = plts[j].contents) != NULL)
2208 struct elf_x86_plt *plt_p = &plts[j];
2210 plt_got_offset = plt_p->plt_got_offset;
2211 plt_entry_size = plt_p->plt_entry_size;
2215 if ((plt_p->type & plt_lazy))
2217 /* Skip PLT0 in lazy PLT. */
2219 offset = plt_entry_size;
2227 /* Check each PLT entry against dynamic relocations. */
2228 for (; k < plt_p->count; k++)
2234 /* Get the GOT offset for i386 or the PC-relative offset
2235 for x86-64, a signed 32-bit integer. */
2236 off = H_GET_32 (abfd, (plt_contents + offset
2238 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
2240 /* Binary search. */
2244 while ((min + 1) < max)
2248 mid = (min + max) / 2;
2250 if (got_vma > r->address)
2252 else if (got_vma < r->address)
2261 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2262 if (got_vma == p->address
2264 && valid_plt_reloc_p (p->howto->type))
2266 *s = **p->sym_ptr_ptr;
2267 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2268 set. Since we are defining a symbol, ensure one
2270 if ((s->flags & BSF_LOCAL) == 0)
2271 s->flags |= BSF_GLOBAL;
2272 s->flags |= BSF_SYNTHETIC;
2273 /* This is no longer a section symbol. */
2274 s->flags &= ~BSF_SECTION_SYM;
2276 s->the_bfd = plt->owner;
2280 len = strlen ((*p->sym_ptr_ptr)->name);
2281 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2287 memcpy (names, "+0x", sizeof ("+0x") - 1);
2288 names += sizeof ("+0x") - 1;
2289 bfd_sprintf_vma (abfd, buf, p->addend);
2290 for (a = buf; *a == '0'; ++a)
2293 memcpy (names, a, size);
2296 memcpy (names, "@plt", sizeof ("@plt"));
2297 names += sizeof ("@plt");
2300 /* There should be only one entry in PLT for a given
2301 symbol. Set howto to NULL after processing a PLT
2302 entry to guard against corrupted PLT. */
2305 offset += plt_entry_size;
2309 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2318 for (j = 0; plts[j].name != NULL; j++)
2319 if (plts[j].contents != NULL)
2320 free (plts[j].contents);
2327 /* Parse x86 GNU properties. */
2329 enum elf_property_kind
2330 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
2331 bfd_byte *ptr, unsigned int datasz)
2337 case GNU_PROPERTY_X86_ISA_1_USED:
2338 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2339 case GNU_PROPERTY_X86_FEATURE_1_AND:
2343 ((type == GNU_PROPERTY_X86_ISA_1_USED
2344 ? _("error: %pB: <corrupt x86 ISA used size: 0x%x>")
2345 : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
2346 ? _("error: %pB: <corrupt x86 ISA needed size: 0x%x>")
2347 : _("error: %pB: <corrupt x86 feature size: 0x%x>"))),
2349 return property_corrupt;
2351 prop = _bfd_elf_get_property (abfd, type, datasz);
2352 /* Combine properties of the same type. */
2353 prop->u.number |= bfd_h_get_32 (abfd, ptr);
2354 prop->pr_kind = property_number;
2358 return property_ignored;
2361 return property_number;
2364 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2365 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2366 should be merged with ABFD. */
2369 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
2370 bfd *abfd ATTRIBUTE_UNUSED,
2371 elf_property *aprop,
2372 elf_property *bprop)
2374 unsigned int number, features;
2375 bfd_boolean updated = FALSE;
2376 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
2380 case GNU_PROPERTY_X86_ISA_1_USED:
2381 case GNU_PROPERTY_X86_ISA_1_NEEDED:
2382 if (aprop != NULL && bprop != NULL)
2384 number = aprop->u.number;
2385 aprop->u.number = number | bprop->u.number;
2386 updated = number != (unsigned int) aprop->u.number;
2390 /* Return TRUE if APROP is NULL to indicate that BPROP should
2391 be added to ABFD. */
2392 updated = aprop == NULL;
2396 case GNU_PROPERTY_X86_FEATURE_1_AND:
2397 /* Only one of APROP and BPROP can be NULL:
2398 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2399 2. If APROP is NULL, remove x86 feature.
2400 3. Otherwise, do nothing.
2402 if (aprop != NULL && bprop != NULL)
2406 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2408 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2409 number = aprop->u.number;
2410 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2411 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2412 aprop->u.number = (number & bprop->u.number) | features;
2413 updated = number != (unsigned int) aprop->u.number;
2414 /* Remove the property if all feature bits are cleared. */
2415 if (aprop->u.number == 0)
2416 aprop->pr_kind = property_remove;
2422 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2424 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2427 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2428 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2431 number = aprop->u.number;
2432 aprop->u.number = number | features;
2433 updated = number != (unsigned int) aprop->u.number;
2437 bprop->u.number |= features;
2441 else if (aprop != NULL)
2443 aprop->pr_kind = property_remove;
2450 /* Never should happen. */
2457 /* Set up x86 GNU properties. Return the first relocatable ELF input
2458 with GNU properties if found. Otherwise, return NULL. */
2461 _bfd_x86_elf_link_setup_gnu_properties
2462 (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
2464 bfd_boolean normal_target;
2465 bfd_boolean lazy_plt;
2466 asection *sec, *pltsec;
2468 bfd_boolean use_ibt_plt;
2469 unsigned int plt_alignment, features;
2470 struct elf_x86_link_hash_table *htab;
2474 const struct elf_backend_data *bed;
2475 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
2476 unsigned int got_align;
2480 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2482 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2484 /* Find a normal input file with GNU property note. */
2485 for (pbfd = info->input_bfds;
2487 pbfd = pbfd->link.next)
2488 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
2489 && bfd_count_sections (pbfd) != 0)
2493 if (elf_properties (pbfd) != NULL)
2497 if (ebfd != NULL && features)
2499 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2500 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2501 prop = _bfd_elf_get_property (ebfd,
2502 GNU_PROPERTY_X86_FEATURE_1_AND,
2504 prop->u.number |= features;
2505 prop->pr_kind = property_number;
2507 /* Create the GNU property note section if needed. */
2510 sec = bfd_make_section_with_flags (ebfd,
2511 NOTE_GNU_PROPERTY_SECTION_NAME,
2519 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
2521 if (!bfd_set_section_alignment (ebfd, sec, class_align))
2524 info->callbacks->einfo (_("%F%pA: failed to align section\n"),
2528 elf_section_type (sec) = SHT_NOTE;
2532 pbfd = _bfd_elf_link_setup_gnu_properties (info);
2534 bed = get_elf_backend_data (info->output_bfd);
2536 htab = elf_x86_hash_table (info, bed->target_id);
2540 htab->r_info = init_table->r_info;
2541 htab->r_sym = init_table->r_sym;
2543 if (bfd_link_relocatable (info))
2546 htab->plt0_pad_byte = init_table->plt0_pad_byte;
2548 use_ibt_plt = info->ibtplt || info->ibt;
2549 if (!use_ibt_plt && pbfd != NULL)
2551 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2552 elf_property_list *p;
2554 /* The property list is sorted in order of type. */
2555 for (p = elf_properties (pbfd); p; p = p->next)
2557 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
2559 use_ibt_plt = !!(p->property.u.number
2560 & GNU_PROPERTY_X86_FEATURE_1_IBT);
2563 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
2568 dynobj = htab->elf.dynobj;
2570 /* Set htab->elf.dynobj here so that there is no need to check and
2571 set it in check_relocs. */
2576 htab->elf.dynobj = pbfd;
2583 /* Find a normal input file to hold linker created
2585 for (abfd = info->input_bfds;
2587 abfd = abfd->link.next)
2588 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2590 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
2591 && bed->relocs_compatible (abfd->xvec,
2592 info->output_bfd->xvec))
2594 htab->elf.dynobj = abfd;
2601 /* Return if there are no normal input files. */
2605 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2606 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2607 canonical function address. */
2608 htab->plt.has_plt0 = 1;
2609 normal_target = htab->target_os == is_normal;
2615 htab->lazy_plt = init_table->lazy_ibt_plt;
2616 htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
2620 htab->lazy_plt = init_table->lazy_plt;
2621 htab->non_lazy_plt = init_table->non_lazy_plt;
2626 htab->lazy_plt = init_table->lazy_plt;
2627 htab->non_lazy_plt = NULL;
2630 pltsec = htab->elf.splt;
2632 /* If the non-lazy PLT is available, use it for all PLT entries if
2633 there are no PLT0 or no .plt section. */
2634 if (htab->non_lazy_plt != NULL
2635 && (!htab->plt.has_plt0 || pltsec == NULL))
2638 if (bfd_link_pic (info))
2639 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
2641 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
2642 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
2643 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
2644 htab->plt.plt_got_insn_size
2645 = htab->non_lazy_plt->plt_got_insn_size;
2646 htab->plt.eh_frame_plt_size
2647 = htab->non_lazy_plt->eh_frame_plt_size;
2648 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
2653 if (bfd_link_pic (info))
2655 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
2656 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
2660 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
2661 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
2663 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
2664 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
2665 htab->plt.plt_got_insn_size
2666 = htab->lazy_plt->plt_got_insn_size;
2667 htab->plt.eh_frame_plt_size
2668 = htab->lazy_plt->eh_frame_plt_size;
2669 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
2672 if (htab->target_os == is_vxworks
2673 && !elf_vxworks_create_dynamic_sections (dynobj, info,
2676 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2680 /* Since create_dynamic_sections isn't always called, but GOT
2681 relocations need GOT relocations, create them here so that we
2682 don't need to do it in check_relocs. */
2683 if (htab->elf.sgot == NULL
2684 && !_bfd_elf_create_got_section (dynobj, info))
2685 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
2687 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
2689 /* Align .got and .got.plt sections to their entry size. Do it here
2690 instead of in create_dynamic_sections so that they are always
2691 properly aligned even if create_dynamic_sections isn't called. */
2692 sec = htab->elf.sgot;
2693 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2694 goto error_alignment;
2696 sec = htab->elf.sgotplt;
2697 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2698 goto error_alignment;
2700 /* Create the ifunc sections here so that check_relocs can be
2702 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
2703 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
2705 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
2709 /* Whe creating executable, set the contents of the .interp
2710 section to the interpreter. */
2711 if (bfd_link_executable (info) && !info->nointerp)
2713 asection *s = bfd_get_linker_section (dynobj, ".interp");
2716 s->size = htab->dynamic_interpreter_size;
2717 s->contents = (unsigned char *) htab->dynamic_interpreter;
2721 /* Don't change PLT section alignment for NaCl since it uses
2722 64-byte PLT entry and sets PLT section alignment to 32
2723 bytes. Don't create additional PLT sections for NaCl. */
2726 flagword pltflags = (bed->dynamic_sec_flags
2731 unsigned int non_lazy_plt_alignment
2732 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
2735 if (!bfd_set_section_alignment (sec->owner, sec,
2737 goto error_alignment;
2739 /* Create the GOT procedure linkage table. */
2740 sec = bfd_make_section_anyway_with_flags (dynobj,
2744 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
2746 if (!bfd_set_section_alignment (dynobj, sec,
2747 non_lazy_plt_alignment))
2748 goto error_alignment;
2750 htab->plt_got = sec;
2758 /* Create the second PLT for Intel IBT support. IBT
2759 PLT is supported only for non-NaCl target and is
2760 is needed only for lazy binding. */
2761 sec = bfd_make_section_anyway_with_flags (dynobj,
2765 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
2767 if (!bfd_set_section_alignment (dynobj, sec,
2769 goto error_alignment;
2771 else if (info->bndplt && ABI_64_P (dynobj))
2773 /* Create the second PLT for Intel MPX support. MPX
2774 PLT is supported only for non-NaCl target in 64-bit
2775 mode and is needed only for lazy binding. */
2776 sec = bfd_make_section_anyway_with_flags (dynobj,
2780 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n"));
2782 if (!bfd_set_section_alignment (dynobj, sec,
2783 non_lazy_plt_alignment))
2784 goto error_alignment;
2787 htab->plt_second = sec;
2791 if (!info->no_ld_generated_unwind_info)
2793 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2794 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2795 | SEC_LINKER_CREATED);
2797 sec = bfd_make_section_anyway_with_flags (dynobj,
2801 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
2803 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2804 goto error_alignment;
2806 htab->plt_eh_frame = sec;
2808 if (htab->plt_got != NULL)
2810 sec = bfd_make_section_anyway_with_flags (dynobj,
2814 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
2816 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2817 goto error_alignment;
2819 htab->plt_got_eh_frame = sec;
2822 if (htab->plt_second != NULL)
2824 sec = bfd_make_section_anyway_with_flags (dynobj,
2828 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
2830 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2831 goto error_alignment;
2833 htab->plt_second_eh_frame = sec;
2840 /* The .iplt section is used for IFUNC symbols in static
2842 sec = htab->elf.iplt;
2844 && !bfd_set_section_alignment (sec->owner, sec,
2846 goto error_alignment;