1 /* x86 specific support for ELF
2 Copyright (C) 2017-2019 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;
879 /* Hide a linker-defined symbol, NAME, with hidden visibility. */
882 elf_x86_hide_linker_defined (struct bfd_link_info *info,
885 struct elf_link_hash_entry *h;
887 h = elf_link_hash_lookup (elf_hash_table (info), name,
888 FALSE, FALSE, FALSE);
892 while (h->root.type == bfd_link_hash_indirect)
893 h = (struct elf_link_hash_entry *) h->root.u.i.link;
895 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
896 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
897 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
901 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
903 if (!bfd_link_relocatable (info))
905 /* Check for __tls_get_addr reference. */
906 struct elf_x86_link_hash_table *htab;
907 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
908 htab = elf_x86_hash_table (info, bed->target_id);
911 struct elf_link_hash_entry *h;
913 h = elf_link_hash_lookup (elf_hash_table (info),
915 FALSE, FALSE, FALSE);
918 elf_x86_hash_entry (h)->tls_get_addr = 1;
920 /* Check the versioned __tls_get_addr symbol. */
921 while (h->root.type == bfd_link_hash_indirect)
923 h = (struct elf_link_hash_entry *) h->root.u.i.link;
924 elf_x86_hash_entry (h)->tls_get_addr = 1;
928 /* "__ehdr_start" will be defined by linker as a hidden symbol
929 later if it is referenced and not defined. */
930 elf_x86_linker_defined (info, "__ehdr_start");
932 if (bfd_link_executable (info))
934 /* References to __bss_start, _end and _edata should be
935 locally resolved within executables. */
936 elf_x86_linker_defined (info, "__bss_start");
937 elf_x86_linker_defined (info, "_end");
938 elf_x86_linker_defined (info, "_edata");
942 /* Hide hidden __bss_start, _end and _edata in shared
944 elf_x86_hide_linker_defined (info, "__bss_start");
945 elf_x86_hide_linker_defined (info, "_end");
946 elf_x86_hide_linker_defined (info, "_edata");
951 /* Invoke the regular ELF backend linker to do all the work. */
952 return _bfd_elf_link_check_relocs (abfd, info);
955 /* Set the sizes of the dynamic sections. */
958 _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd,
959 struct bfd_link_info *info)
961 struct elf_x86_link_hash_table *htab;
966 const struct elf_backend_data *bed
967 = get_elf_backend_data (output_bfd);
969 htab = elf_x86_hash_table (info, bed->target_id);
972 dynobj = htab->elf.dynobj;
976 /* Set up .got offsets for local syms, and space for local dynamic
978 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
980 bfd_signed_vma *local_got;
981 bfd_signed_vma *end_local_got;
982 char *local_tls_type;
983 bfd_vma *local_tlsdesc_gotent;
984 bfd_size_type locsymcount;
985 Elf_Internal_Shdr *symtab_hdr;
988 if (! is_x86_elf (ibfd, htab))
991 for (s = ibfd->sections; s != NULL; s = s->next)
993 struct elf_dyn_relocs *p;
995 for (p = ((struct elf_dyn_relocs *)
996 elf_section_data (s)->local_dynrel);
1000 if (!bfd_is_abs_section (p->sec)
1001 && bfd_is_abs_section (p->sec->output_section))
1003 /* Input section has been discarded, either because
1004 it is a copy of a linkonce section or due to
1005 linker script /DISCARD/, so we'll be discarding
1008 else if (htab->target_os == is_vxworks
1009 && strcmp (p->sec->output_section->name,
1012 /* Relocations in vxworks .tls_vars sections are
1013 handled specially by the loader. */
1015 else if (p->count != 0)
1017 srel = elf_section_data (p->sec)->sreloc;
1018 srel->size += p->count * htab->sizeof_reloc;
1019 if ((p->sec->output_section->flags & SEC_READONLY) != 0
1020 && (info->flags & DF_TEXTREL) == 0)
1022 info->flags |= DF_TEXTREL;
1023 if ((info->warn_shared_textrel && bfd_link_pic (info))
1024 || info->error_textrel)
1025 /* xgettext:c-format */
1026 info->callbacks->einfo
1027 (_("%P: %pB: warning: relocation "
1028 "in read-only section `%pA'\n"),
1029 p->sec->owner, p->sec);
1035 local_got = elf_local_got_refcounts (ibfd);
1039 symtab_hdr = &elf_symtab_hdr (ibfd);
1040 locsymcount = symtab_hdr->sh_info;
1041 end_local_got = local_got + locsymcount;
1042 local_tls_type = elf_x86_local_got_tls_type (ibfd);
1043 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
1045 srel = htab->elf.srelgot;
1046 for (; local_got < end_local_got;
1047 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1049 *local_tlsdesc_gotent = (bfd_vma) -1;
1052 if (GOT_TLS_GDESC_P (*local_tls_type))
1054 *local_tlsdesc_gotent = htab->elf.sgotplt->size
1055 - elf_x86_compute_jump_table_size (htab);
1056 htab->elf.sgotplt->size += 2 * htab->got_entry_size;
1057 *local_got = (bfd_vma) -2;
1059 if (! GOT_TLS_GDESC_P (*local_tls_type)
1060 || GOT_TLS_GD_P (*local_tls_type))
1062 *local_got = s->size;
1063 s->size += htab->got_entry_size;
1064 if (GOT_TLS_GD_P (*local_tls_type)
1065 || *local_tls_type == GOT_TLS_IE_BOTH)
1066 s->size += htab->got_entry_size;
1068 if (bfd_link_pic (info)
1069 || GOT_TLS_GD_ANY_P (*local_tls_type)
1070 || (*local_tls_type & GOT_TLS_IE))
1072 if (*local_tls_type == GOT_TLS_IE_BOTH)
1073 srel->size += 2 * htab->sizeof_reloc;
1074 else if (GOT_TLS_GD_P (*local_tls_type)
1075 || ! GOT_TLS_GDESC_P (*local_tls_type))
1076 srel->size += htab->sizeof_reloc;
1077 if (GOT_TLS_GDESC_P (*local_tls_type))
1079 htab->elf.srelplt->size += htab->sizeof_reloc;
1080 if (bed->target_id == X86_64_ELF_DATA)
1081 htab->tlsdesc_plt = (bfd_vma) -1;
1086 *local_got = (bfd_vma) -1;
1090 if (htab->tls_ld_or_ldm_got.refcount > 0)
1092 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1093 or R_X86_64_TLSLD relocs. */
1094 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
1095 htab->elf.sgot->size += 2 * htab->got_entry_size;
1096 htab->elf.srelgot->size += htab->sizeof_reloc;
1099 htab->tls_ld_or_ldm_got.offset = -1;
1101 /* Allocate global sym .plt and .got entries, and space for global
1102 sym dynamic relocs. */
1103 elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
1106 /* Allocate .plt and .got entries, and space for local symbols. */
1107 htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
1110 /* For every jump slot reserved in the sgotplt, reloc_count is
1111 incremented. However, when we reserve space for TLS descriptors,
1112 it's not incremented, so in order to compute the space reserved
1113 for them, it suffices to multiply the reloc count by the jump
1116 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1117 so that R_{386,X86_64}_IRELATIVE entries come last. */
1118 if (htab->elf.srelplt)
1120 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
1121 htab->sgotplt_jump_table_size
1122 = elf_x86_compute_jump_table_size (htab);
1123 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
1125 else if (htab->elf.irelplt)
1126 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
1128 if (htab->tlsdesc_plt)
1130 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1131 lazy TLS relocations, don't generate the PLT and GOT entries
1133 if ((info->flags & DF_BIND_NOW))
1134 htab->tlsdesc_plt = 0;
1137 htab->tlsdesc_got = htab->elf.sgot->size;
1138 htab->elf.sgot->size += htab->got_entry_size;
1139 /* Reserve room for the initial entry.
1140 FIXME: we could probably do away with it in this case. */
1141 if (htab->elf.splt->size == 0)
1142 htab->elf.splt->size = htab->plt.plt_entry_size;
1143 htab->tlsdesc_plt = htab->elf.splt->size;
1144 htab->elf.splt->size += htab->plt.plt_entry_size;
1148 if (htab->elf.sgotplt)
1150 /* Don't allocate .got.plt section if there are no GOT nor PLT
1151 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1152 if ((htab->elf.hgot == NULL
1153 || !htab->got_referenced)
1154 && (htab->elf.sgotplt->size == bed->got_header_size)
1155 && (htab->elf.splt == NULL
1156 || htab->elf.splt->size == 0)
1157 && (htab->elf.sgot == NULL
1158 || htab->elf.sgot->size == 0)
1159 && (htab->elf.iplt == NULL
1160 || htab->elf.iplt->size == 0)
1161 && (htab->elf.igotplt == NULL
1162 || htab->elf.igotplt->size == 0))
1164 htab->elf.sgotplt->size = 0;
1165 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
1167 if (htab->elf.hgot != NULL && htab->target_os != is_solaris)
1169 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
1171 htab->elf.hgot->root.type = bfd_link_hash_undefined;
1172 htab->elf.hgot->root.u.undef.abfd
1173 = htab->elf.hgot->root.u.def.section->owner;
1174 htab->elf.hgot->root.linker_def = 0;
1175 htab->elf.hgot->ref_regular = 0;
1176 htab->elf.hgot->def_regular = 0;
1181 if (_bfd_elf_eh_frame_present (info))
1183 if (htab->plt_eh_frame != NULL
1184 && htab->elf.splt != NULL
1185 && htab->elf.splt->size != 0
1186 && !bfd_is_abs_section (htab->elf.splt->output_section))
1187 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
1189 if (htab->plt_got_eh_frame != NULL
1190 && htab->plt_got != NULL
1191 && htab->plt_got->size != 0
1192 && !bfd_is_abs_section (htab->plt_got->output_section))
1193 htab->plt_got_eh_frame->size
1194 = htab->non_lazy_plt->eh_frame_plt_size;
1196 /* Unwind info for the second PLT and .plt.got sections are
1198 if (htab->plt_second_eh_frame != NULL
1199 && htab->plt_second != NULL
1200 && htab->plt_second->size != 0
1201 && !bfd_is_abs_section (htab->plt_second->output_section))
1202 htab->plt_second_eh_frame->size
1203 = htab->non_lazy_plt->eh_frame_plt_size;
1206 /* We now have determined the sizes of the various dynamic sections.
1207 Allocate memory for them. */
1209 for (s = dynobj->sections; s != NULL; s = s->next)
1211 bfd_boolean strip_section = TRUE;
1213 if ((s->flags & SEC_LINKER_CREATED) == 0)
1216 if (s == htab->elf.splt
1217 || s == htab->elf.sgot)
1219 /* Strip this section if we don't need it; see the
1221 /* We'd like to strip these sections if they aren't needed, but if
1222 we've exported dynamic symbols from them we must leave them.
1223 It's too late to tell BFD to get rid of the symbols. */
1225 if (htab->elf.hplt != NULL)
1226 strip_section = FALSE;
1228 else if (s == htab->elf.sgotplt
1229 || s == htab->elf.iplt
1230 || s == htab->elf.igotplt
1231 || s == htab->plt_second
1232 || s == htab->plt_got
1233 || s == htab->plt_eh_frame
1234 || s == htab->plt_got_eh_frame
1235 || s == htab->plt_second_eh_frame
1236 || s == htab->elf.sdynbss
1237 || s == htab->elf.sdynrelro)
1239 /* Strip these too. */
1241 else if (htab->is_reloc_section (bfd_get_section_name (dynobj, s)))
1244 && s != htab->elf.srelplt
1245 && s != htab->srelplt2)
1248 /* We use the reloc_count field as a counter if we need
1249 to copy relocs into the output file. */
1250 if (s != htab->elf.srelplt)
1255 /* It's not one of our sections, so don't allocate space. */
1261 /* If we don't need this section, strip it from the
1262 output file. This is mostly to handle .rel.bss and
1263 .rel.plt. We must create both sections in
1264 create_dynamic_sections, because they must be created
1265 before the linker maps input sections to output
1266 sections. The linker does that before
1267 adjust_dynamic_symbol is called, and it is that
1268 function which decides whether anything needs to go
1269 into these sections. */
1271 s->flags |= SEC_EXCLUDE;
1275 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1278 /* NB: Initially, the iplt section has minimal alignment to
1279 avoid moving dot of the following section backwards when
1280 it is empty. Update its section alignment now since it
1282 if (s == htab->elf.iplt)
1283 bfd_set_section_alignment (s->owner, s,
1284 htab->plt.iplt_alignment);
1286 /* Allocate memory for the section contents. We use bfd_zalloc
1287 here in case unused entries are not reclaimed before the
1288 section's contents are written out. This should not happen,
1289 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1290 reloc instead of garbage. */
1291 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
1292 if (s->contents == NULL)
1296 if (htab->plt_eh_frame != NULL
1297 && htab->plt_eh_frame->contents != NULL)
1299 memcpy (htab->plt_eh_frame->contents,
1300 htab->plt.eh_frame_plt,
1301 htab->plt_eh_frame->size);
1302 bfd_put_32 (dynobj, htab->elf.splt->size,
1303 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
1306 if (htab->plt_got_eh_frame != NULL
1307 && htab->plt_got_eh_frame->contents != NULL)
1309 memcpy (htab->plt_got_eh_frame->contents,
1310 htab->non_lazy_plt->eh_frame_plt,
1311 htab->plt_got_eh_frame->size);
1312 bfd_put_32 (dynobj, htab->plt_got->size,
1313 (htab->plt_got_eh_frame->contents
1314 + PLT_FDE_LEN_OFFSET));
1317 if (htab->plt_second_eh_frame != NULL
1318 && htab->plt_second_eh_frame->contents != NULL)
1320 memcpy (htab->plt_second_eh_frame->contents,
1321 htab->non_lazy_plt->eh_frame_plt,
1322 htab->plt_second_eh_frame->size);
1323 bfd_put_32 (dynobj, htab->plt_second->size,
1324 (htab->plt_second_eh_frame->contents
1325 + PLT_FDE_LEN_OFFSET));
1328 if (htab->elf.dynamic_sections_created)
1330 /* Add some entries to the .dynamic section. We fill in the
1331 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1332 but we must add the entries now so that we get the correct
1333 size for the .dynamic section. The DT_DEBUG entry is filled
1334 in by the dynamic linker and used by the debugger. */
1335 #define add_dynamic_entry(TAG, VAL) \
1336 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1338 if (bfd_link_executable (info))
1340 if (!add_dynamic_entry (DT_DEBUG, 0))
1344 if (htab->elf.splt->size != 0)
1346 /* DT_PLTGOT is used by prelink even if there is no PLT
1348 if (!add_dynamic_entry (DT_PLTGOT, 0))
1352 if (htab->elf.srelplt->size != 0)
1354 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1355 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc)
1356 || !add_dynamic_entry (DT_JMPREL, 0))
1360 if (htab->tlsdesc_plt
1361 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
1362 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
1367 if (!add_dynamic_entry (htab->dt_reloc, 0)
1368 || !add_dynamic_entry (htab->dt_reloc_sz, 0)
1369 || !add_dynamic_entry (htab->dt_reloc_ent,
1370 htab->sizeof_reloc))
1373 /* If any dynamic relocs apply to a read-only section,
1374 then we need a DT_TEXTREL entry. */
1375 if ((info->flags & DF_TEXTREL) == 0)
1376 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
1378 if ((info->flags & DF_TEXTREL) != 0)
1380 if (htab->readonly_dynrelocs_against_ifunc)
1382 info->callbacks->einfo
1383 (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1384 " recompile with -fPIC\n"));
1385 bfd_set_error (bfd_error_bad_value);
1389 if (!add_dynamic_entry (DT_TEXTREL, 0))
1393 if (htab->target_os == is_vxworks
1394 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
1397 #undef add_dynamic_entry
1402 /* Finish up the x86 dynamic sections. */
1404 struct elf_x86_link_hash_table *
1405 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
1406 struct bfd_link_info *info)
1408 struct elf_x86_link_hash_table *htab;
1409 const struct elf_backend_data *bed;
1412 bfd_byte *dyncon, *dynconend;
1413 bfd_size_type sizeof_dyn;
1415 bed = get_elf_backend_data (output_bfd);
1416 htab = elf_x86_hash_table (info, bed->target_id);
1420 dynobj = htab->elf.dynobj;
1421 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1423 /* GOT is always created in setup_gnu_properties. But it may not be
1424 needed. .got.plt section may be needed for static IFUNC. */
1425 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
1427 bfd_vma dynamic_addr;
1429 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
1432 (_("discarded output section: `%pA'"), htab->elf.sgotplt);
1436 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
1437 = htab->got_entry_size;
1439 dynamic_addr = (sdyn == NULL
1441 : sdyn->output_section->vma + sdyn->output_offset);
1443 /* Set the first entry in the global offset table to the address
1444 of the dynamic section. Write GOT[1] and GOT[2], needed for
1445 the dynamic linker. */
1446 if (htab->got_entry_size == 8)
1448 bfd_put_64 (output_bfd, dynamic_addr,
1449 htab->elf.sgotplt->contents);
1450 bfd_put_64 (output_bfd, (bfd_vma) 0,
1451 htab->elf.sgotplt->contents + 8);
1452 bfd_put_64 (output_bfd, (bfd_vma) 0,
1453 htab->elf.sgotplt->contents + 8*2);
1457 bfd_put_32 (output_bfd, dynamic_addr,
1458 htab->elf.sgotplt->contents);
1459 bfd_put_32 (output_bfd, 0,
1460 htab->elf.sgotplt->contents + 4);
1461 bfd_put_32 (output_bfd, 0,
1462 htab->elf.sgotplt->contents + 4*2);
1466 if (!htab->elf.dynamic_sections_created)
1469 if (sdyn == NULL || htab->elf.sgot == NULL)
1472 sizeof_dyn = bed->s->sizeof_dyn;
1473 dyncon = sdyn->contents;
1474 dynconend = sdyn->contents + sdyn->size;
1475 for (; dyncon < dynconend; dyncon += sizeof_dyn)
1477 Elf_Internal_Dyn dyn;
1480 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
1485 if (htab->target_os == is_vxworks
1486 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
1491 s = htab->elf.sgotplt;
1492 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1496 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
1500 s = htab->elf.srelplt->output_section;
1501 dyn.d_un.d_val = s->size;
1504 case DT_TLSDESC_PLT:
1506 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1507 + htab->tlsdesc_plt;
1510 case DT_TLSDESC_GOT:
1512 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
1513 + htab->tlsdesc_got;
1517 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
1520 if (htab->plt_got != NULL && htab->plt_got->size > 0)
1521 elf_section_data (htab->plt_got->output_section)
1522 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1524 if (htab->plt_second != NULL && htab->plt_second->size > 0)
1525 elf_section_data (htab->plt_second->output_section)
1526 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
1528 /* Adjust .eh_frame for .plt section. */
1529 if (htab->plt_eh_frame != NULL
1530 && htab->plt_eh_frame->contents != NULL)
1532 if (htab->elf.splt != NULL
1533 && htab->elf.splt->size != 0
1534 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
1535 && htab->elf.splt->output_section != NULL
1536 && htab->plt_eh_frame->output_section != NULL)
1538 bfd_vma plt_start = htab->elf.splt->output_section->vma;
1539 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
1540 + htab->plt_eh_frame->output_offset
1541 + PLT_FDE_START_OFFSET;
1542 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1543 htab->plt_eh_frame->contents
1544 + PLT_FDE_START_OFFSET);
1547 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1549 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1551 htab->plt_eh_frame->contents))
1556 /* Adjust .eh_frame for .plt.got section. */
1557 if (htab->plt_got_eh_frame != NULL
1558 && htab->plt_got_eh_frame->contents != NULL)
1560 if (htab->plt_got != NULL
1561 && htab->plt_got->size != 0
1562 && (htab->plt_got->flags & SEC_EXCLUDE) == 0
1563 && htab->plt_got->output_section != NULL
1564 && htab->plt_got_eh_frame->output_section != NULL)
1566 bfd_vma plt_start = htab->plt_got->output_section->vma;
1567 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
1568 + htab->plt_got_eh_frame->output_offset
1569 + PLT_FDE_START_OFFSET;
1570 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1571 htab->plt_got_eh_frame->contents
1572 + PLT_FDE_START_OFFSET);
1574 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
1576 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1577 htab->plt_got_eh_frame,
1578 htab->plt_got_eh_frame->contents))
1583 /* Adjust .eh_frame for the second PLT section. */
1584 if (htab->plt_second_eh_frame != NULL
1585 && htab->plt_second_eh_frame->contents != NULL)
1587 if (htab->plt_second != NULL
1588 && htab->plt_second->size != 0
1589 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
1590 && htab->plt_second->output_section != NULL
1591 && htab->plt_second_eh_frame->output_section != NULL)
1593 bfd_vma plt_start = htab->plt_second->output_section->vma;
1594 bfd_vma eh_frame_start
1595 = (htab->plt_second_eh_frame->output_section->vma
1596 + htab->plt_second_eh_frame->output_offset
1597 + PLT_FDE_START_OFFSET);
1598 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
1599 htab->plt_second_eh_frame->contents
1600 + PLT_FDE_START_OFFSET);
1602 if (htab->plt_second_eh_frame->sec_info_type
1603 == SEC_INFO_TYPE_EH_FRAME)
1605 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
1606 htab->plt_second_eh_frame,
1607 htab->plt_second_eh_frame->contents))
1612 if (htab->elf.sgot && htab->elf.sgot->size > 0)
1613 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
1614 = htab->got_entry_size;
1621 _bfd_x86_elf_always_size_sections (bfd *output_bfd,
1622 struct bfd_link_info *info)
1624 asection *tls_sec = elf_hash_table (info)->tls_sec;
1628 struct elf_link_hash_entry *tlsbase;
1630 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1631 "_TLS_MODULE_BASE_",
1632 FALSE, FALSE, FALSE);
1634 if (tlsbase && tlsbase->type == STT_TLS)
1636 struct elf_x86_link_hash_table *htab;
1637 struct bfd_link_hash_entry *bh = NULL;
1638 const struct elf_backend_data *bed
1639 = get_elf_backend_data (output_bfd);
1641 htab = elf_x86_hash_table (info, bed->target_id);
1645 if (!(_bfd_generic_link_add_one_symbol
1646 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1647 tls_sec, 0, NULL, FALSE,
1648 bed->collect, &bh)))
1651 htab->tls_module_base = bh;
1653 tlsbase = (struct elf_link_hash_entry *)bh;
1654 tlsbase->def_regular = 1;
1655 tlsbase->other = STV_HIDDEN;
1656 tlsbase->root.linker_def = 1;
1657 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1665 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
1666 const Elf_Internal_Sym *isym,
1667 bfd_boolean definition,
1668 bfd_boolean dynamic ATTRIBUTE_UNUSED)
1672 struct elf_x86_link_hash_entry *eh
1673 = (struct elf_x86_link_hash_entry *) h;
1674 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
1679 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1682 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
1683 struct elf_link_hash_entry *dir,
1684 struct elf_link_hash_entry *ind)
1686 struct elf_x86_link_hash_entry *edir, *eind;
1688 edir = (struct elf_x86_link_hash_entry *) dir;
1689 eind = (struct elf_x86_link_hash_entry *) ind;
1691 if (eind->dyn_relocs != NULL)
1693 if (edir->dyn_relocs != NULL)
1695 struct elf_dyn_relocs **pp;
1696 struct elf_dyn_relocs *p;
1698 /* Add reloc counts against the indirect sym to the direct sym
1699 list. Merge any entries against the same section. */
1700 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1702 struct elf_dyn_relocs *q;
1704 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1705 if (q->sec == p->sec)
1707 q->pc_count += p->pc_count;
1708 q->count += p->count;
1715 *pp = edir->dyn_relocs;
1718 edir->dyn_relocs = eind->dyn_relocs;
1719 eind->dyn_relocs = NULL;
1722 if (ind->root.type == bfd_link_hash_indirect
1723 && dir->got.refcount <= 0)
1725 edir->tls_type = eind->tls_type;
1726 eind->tls_type = GOT_UNKNOWN;
1729 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1730 generate a R_386_COPY reloc. */
1731 edir->gotoff_ref |= eind->gotoff_ref;
1733 edir->zero_undefweak |= eind->zero_undefweak;
1735 if (ELIMINATE_COPY_RELOCS
1736 && ind->root.type != bfd_link_hash_indirect
1737 && dir->dynamic_adjusted)
1739 /* If called to transfer flags for a weakdef during processing
1740 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1741 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1742 if (dir->versioned != versioned_hidden)
1743 dir->ref_dynamic |= ind->ref_dynamic;
1744 dir->ref_regular |= ind->ref_regular;
1745 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1746 dir->needs_plt |= ind->needs_plt;
1747 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1750 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1753 /* Remove undefined weak symbol from the dynamic symbol table if it
1754 is resolved to 0. */
1757 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
1758 struct elf_link_hash_entry *h)
1760 if (h->dynindx != -1
1761 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
1764 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1770 /* Change the STT_GNU_IFUNC symbol defined in position-dependent
1771 executable into the normal function symbol and set its address
1772 to its PLT entry, which should be resolved by R_*_IRELATIVE at
1776 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info,
1777 struct elf_x86_link_hash_table *htab,
1778 struct elf_link_hash_entry *h,
1779 Elf_Internal_Sym *sym)
1781 if (bfd_link_pde (info)
1784 && h->plt.offset != (bfd_vma) -1
1785 && h->type == STT_GNU_IFUNC
1786 && h->pointer_equality_needed)
1790 bfd *output_bfd = info->output_bfd;
1792 if (htab->plt_second)
1794 struct elf_x86_link_hash_entry *eh
1795 = (struct elf_x86_link_hash_entry *) h;
1797 plt_s = htab->plt_second;
1798 plt_offset = eh->plt_second.offset;
1802 plt_s = htab->elf.splt;
1803 plt_offset = h->plt.offset;
1807 sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
1809 = _bfd_elf_section_from_bfd_section (output_bfd,
1810 plt_s->output_section);
1811 sym->st_value = (plt_s->output_section->vma
1812 + plt_s->output_offset + plt_offset);
1816 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1819 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
1821 if (h->plt.offset != (bfd_vma) -1
1823 && !h->pointer_equality_needed)
1826 return _bfd_elf_hash_symbol (h);
1829 /* Adjust a symbol defined by a dynamic object and referenced by a
1830 regular object. The current definition is in some section of the
1831 dynamic object, but we're not including those sections. We have to
1832 change the definition to something the rest of the link can
1836 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1837 struct elf_link_hash_entry *h)
1839 struct elf_x86_link_hash_table *htab;
1841 struct elf_x86_link_hash_entry *eh;
1842 struct elf_dyn_relocs *p;
1843 const struct elf_backend_data *bed
1844 = get_elf_backend_data (info->output_bfd);
1846 /* STT_GNU_IFUNC symbol must go through PLT. */
1847 if (h->type == STT_GNU_IFUNC)
1849 /* All local STT_GNU_IFUNC references must be treate as local
1850 calls via local PLT. */
1852 && SYMBOL_CALLS_LOCAL (info, h))
1854 bfd_size_type pc_count = 0, count = 0;
1855 struct elf_dyn_relocs **pp;
1857 eh = (struct elf_x86_link_hash_entry *) h;
1858 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1860 pc_count += p->pc_count;
1861 p->count -= p->pc_count;
1870 if (pc_count || count)
1875 /* Increment PLT reference count only for PC-relative
1878 if (h->plt.refcount <= 0)
1879 h->plt.refcount = 1;
1881 h->plt.refcount += 1;
1886 if (h->plt.refcount <= 0)
1888 h->plt.offset = (bfd_vma) -1;
1894 /* If this is a function, put it in the procedure linkage table. We
1895 will fill in the contents of the procedure linkage table later,
1896 when we know the address of the .got section. */
1897 if (h->type == STT_FUNC
1900 if (h->plt.refcount <= 0
1901 || SYMBOL_CALLS_LOCAL (info, h)
1902 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1903 && h->root.type == bfd_link_hash_undefweak))
1905 /* This case can occur if we saw a PLT32 reloc in an input
1906 file, but the symbol was never referred to by a dynamic
1907 object, or if all references were garbage collected. In
1908 such a case, we don't actually need to build a procedure
1909 linkage table, and we can just do a PC32 reloc instead. */
1910 h->plt.offset = (bfd_vma) -1;
1917 /* It's possible that we incorrectly decided a .plt reloc was needed
1918 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1919 check_relocs. We can't decide accurately between function and
1920 non-function syms in check-relocs; Objects loaded later in
1921 the link may change h->type. So fix it now. */
1922 h->plt.offset = (bfd_vma) -1;
1924 eh = (struct elf_x86_link_hash_entry *) h;
1926 /* If this is a weak symbol, and there is a real definition, the
1927 processor independent code will have arranged for us to see the
1928 real definition first, and we can just use the same value. */
1929 if (h->is_weakalias)
1931 struct elf_link_hash_entry *def = weakdef (h);
1932 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1933 h->root.u.def.section = def->root.u.def.section;
1934 h->root.u.def.value = def->root.u.def.value;
1935 if (ELIMINATE_COPY_RELOCS
1936 || info->nocopyreloc
1937 || SYMBOL_NO_COPYRELOC (info, eh))
1939 /* NB: needs_copy is always 0 for i386. */
1940 h->non_got_ref = def->non_got_ref;
1941 eh->needs_copy = def->needs_copy;
1946 /* This is a reference to a symbol defined by a dynamic object which
1947 is not a function. */
1949 /* If we are creating a shared library, we must presume that the
1950 only references to the symbol are via the global offset table.
1951 For such cases we need not do anything here; the relocations will
1952 be handled correctly by relocate_section. */
1953 if (!bfd_link_executable (info))
1956 /* If there are no references to this symbol that do not use the
1957 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1958 reloc. NB: gotoff_ref is always 0 for x86-64. */
1959 if (!h->non_got_ref && !eh->gotoff_ref)
1962 /* If -z nocopyreloc was given, we won't generate them either. */
1963 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
1969 htab = elf_x86_hash_table (info, bed->target_id);
1973 /* If there aren't any dynamic relocs in read-only sections nor
1974 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1975 avoid the copy reloc. This doesn't work on VxWorks, where we can
1976 not have dynamic relocations (other than copy and jump slot
1977 relocations) in an executable. */
1978 if (ELIMINATE_COPY_RELOCS
1979 && (bed->target_id == X86_64_ELF_DATA
1981 && htab->target_os != is_vxworks)))
1983 /* If we don't find any dynamic relocs in read-only sections,
1984 then we'll be keeping the dynamic relocs and avoiding the copy
1986 if (!readonly_dynrelocs (h))
1993 /* We must allocate the symbol in our .dynbss section, which will
1994 become part of the .bss section of the executable. There will be
1995 an entry for this symbol in the .dynsym section. The dynamic
1996 object will contain position independent code, so all references
1997 from the dynamic object to this symbol will go through the global
1998 offset table. The dynamic linker will use the .dynsym entry to
1999 determine the address it must put in the global offset table, so
2000 both the dynamic object and the regular object will refer to the
2001 same memory location for the variable. */
2003 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
2004 dynamic linker to copy the initial value out of the dynamic object
2005 and into the runtime process image. */
2006 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2008 s = htab->elf.sdynrelro;
2009 srel = htab->elf.sreldynrelro;
2013 s = htab->elf.sdynbss;
2014 srel = htab->elf.srelbss;
2016 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2018 srel->size += htab->sizeof_reloc;
2022 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2026 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
2027 struct elf_link_hash_entry *h,
2028 bfd_boolean force_local)
2030 if (h->root.type == bfd_link_hash_undefweak
2032 && bfd_link_pie (info))
2034 /* When there is no dynamic interpreter in PIE, make the undefined
2035 weak symbol dynamic so that PC relative branch to the undefined
2036 weak symbol will land to address 0. */
2037 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2038 if (h->plt.refcount > 0
2039 || eh->plt_got.refcount > 0)
2043 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2046 /* Return TRUE if a symbol is referenced locally. It is similar to
2047 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
2048 works in check_relocs. */
2051 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
2052 struct elf_link_hash_entry *h)
2054 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
2055 struct elf_x86_link_hash_table *htab
2056 = (struct elf_x86_link_hash_table *) info->hash;
2058 if (eh->local_ref > 1)
2061 if (eh->local_ref == 1)
2064 /* Unversioned symbols defined in regular objects can be forced local
2065 by linker version script. A weak undefined symbol is forced local
2067 1. It has non-default visibility. Or
2068 2. When building executable, there is no dynamic linker. Or
2069 3. or "-z nodynamic-undefined-weak" is used.
2071 if (SYMBOL_REFERENCES_LOCAL (info, h)
2072 || (h->root.type == bfd_link_hash_undefweak
2073 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2074 || (bfd_link_executable (info)
2075 && htab->interp == NULL)
2076 || info->dynamic_undefined_weak == 0))
2077 || ((h->def_regular || ELF_COMMON_DEF_P (h))
2078 && info->version_info != NULL
2079 && _bfd_elf_link_hide_sym_by_version (info, h)))
2089 /* Return the section that should be marked against GC for a given
2093 _bfd_x86_elf_gc_mark_hook (asection *sec,
2094 struct bfd_link_info *info,
2095 Elf_Internal_Rela *rel,
2096 struct elf_link_hash_entry *h,
2097 Elf_Internal_Sym *sym)
2099 /* Compiler should optimize this out. */
2100 if (((unsigned int) R_X86_64_GNU_VTINHERIT
2101 != (unsigned int) R_386_GNU_VTINHERIT)
2102 || ((unsigned int) R_X86_64_GNU_VTENTRY
2103 != (unsigned int) R_386_GNU_VTENTRY))
2107 switch (ELF32_R_TYPE (rel->r_info))
2109 case R_X86_64_GNU_VTINHERIT:
2110 case R_X86_64_GNU_VTENTRY:
2114 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2118 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
2120 bfd_vma offset ATTRIBUTE_UNUSED,
2123 return got_addr + off;
2127 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
2130 bfd_vma got_addr ATTRIBUTE_UNUSED)
2132 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
2136 elf_i386_valid_plt_reloc_p (unsigned int type)
2138 return (type == R_386_JUMP_SLOT
2139 || type == R_386_GLOB_DAT
2140 || type == R_386_IRELATIVE);
2144 elf_x86_64_valid_plt_reloc_p (unsigned int type)
2146 return (type == R_X86_64_JUMP_SLOT
2147 || type == R_X86_64_GLOB_DAT
2148 || type == R_X86_64_IRELATIVE);
2152 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
2156 struct elf_x86_plt plts[],
2160 long size, i, n, len;
2162 unsigned int plt_got_offset, plt_entry_size;
2164 bfd_byte *plt_contents;
2166 arelent **dynrelbuf, *p;
2168 const struct elf_backend_data *bed;
2169 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
2171 bfd_boolean (*valid_plt_reloc_p) (unsigned int);
2176 dynrelbuf = (arelent **) bfd_malloc (relsize);
2177 if (dynrelbuf == NULL)
2180 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
2182 if (dynrelcount <= 0)
2185 /* Sort the relocs by address. */
2186 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
2187 _bfd_x86_elf_compare_relocs);
2189 size = count * sizeof (asymbol);
2191 /* Allocate space for @plt suffixes. */
2193 for (i = 0; i < dynrelcount; i++)
2196 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
2198 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
2201 s = *ret = (asymbol *) bfd_zmalloc (size);
2205 bed = get_elf_backend_data (abfd);
2207 if (bed->target_id == X86_64_ELF_DATA)
2209 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
2210 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
2214 get_plt_got_vma = elf_i386_get_plt_got_vma;
2215 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
2218 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2220 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
2222 got_addr = sec->vma;
2225 sec = bfd_get_section_by_name (abfd, ".got");
2227 got_addr = sec->vma;
2230 if (got_addr == (bfd_vma) -1)
2235 /* Check for each PLT section. */
2236 names = (char *) (s + count);
2239 for (j = 0; plts[j].name != NULL; j++)
2240 if ((plt_contents = plts[j].contents) != NULL)
2245 struct elf_x86_plt *plt_p = &plts[j];
2247 plt_got_offset = plt_p->plt_got_offset;
2248 plt_entry_size = plt_p->plt_entry_size;
2252 if ((plt_p->type & plt_lazy))
2254 /* Skip PLT0 in lazy PLT. */
2256 offset = plt_entry_size;
2264 /* Check each PLT entry against dynamic relocations. */
2265 for (; k < plt_p->count; k++)
2271 /* Get the GOT offset for i386 or the PC-relative offset
2272 for x86-64, a signed 32-bit integer. */
2273 off = H_GET_32 (abfd, (plt_contents + offset
2275 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
2277 /* Binary search. */
2281 while ((min + 1) < max)
2285 mid = (min + max) / 2;
2287 if (got_vma > r->address)
2289 else if (got_vma < r->address)
2298 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2299 if (got_vma == p->address
2301 && valid_plt_reloc_p (p->howto->type))
2303 *s = **p->sym_ptr_ptr;
2304 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2305 set. Since we are defining a symbol, ensure one
2307 if ((s->flags & BSF_LOCAL) == 0)
2308 s->flags |= BSF_GLOBAL;
2309 s->flags |= BSF_SYNTHETIC;
2310 /* This is no longer a section symbol. */
2311 s->flags &= ~BSF_SECTION_SYM;
2313 s->the_bfd = plt->owner;
2317 len = strlen ((*p->sym_ptr_ptr)->name);
2318 memcpy (names, (*p->sym_ptr_ptr)->name, len);
2324 memcpy (names, "+0x", sizeof ("+0x") - 1);
2325 names += sizeof ("+0x") - 1;
2326 bfd_sprintf_vma (abfd, buf, p->addend);
2327 for (a = buf; *a == '0'; ++a)
2330 memcpy (names, a, size);
2333 memcpy (names, "@plt", sizeof ("@plt"));
2334 names += sizeof ("@plt");
2337 /* There should be only one entry in PLT for a given
2338 symbol. Set howto to NULL after processing a PLT
2339 entry to guard against corrupted PLT. */
2342 offset += plt_entry_size;
2346 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2355 for (j = 0; plts[j].name != NULL; j++)
2356 if (plts[j].contents != NULL)
2357 free (plts[j].contents);
2364 /* Parse x86 GNU properties. */
2366 enum elf_property_kind
2367 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
2368 bfd_byte *ptr, unsigned int datasz)
2372 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2373 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2374 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
2375 && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2376 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
2377 && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
2378 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2379 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2384 (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"),
2385 abfd, type, datasz);
2386 return property_corrupt;
2388 prop = _bfd_elf_get_property (abfd, type, datasz);
2389 prop->u.number |= bfd_h_get_32 (abfd, ptr);
2390 prop->pr_kind = property_number;
2391 return property_number;
2394 return property_ignored;
2397 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2398 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2399 should be merged with ABFD. */
2402 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
2403 bfd *abfd ATTRIBUTE_UNUSED,
2404 bfd *bbfd ATTRIBUTE_UNUSED,
2405 elf_property *aprop,
2406 elf_property *bprop)
2408 unsigned int number, features;
2409 bfd_boolean updated = FALSE;
2410 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
2412 if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2413 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2414 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2416 if (aprop == NULL || bprop == NULL)
2418 /* Only one of APROP and BPROP can be NULL. */
2421 /* Remove this property since the other input file doesn't
2423 aprop->pr_kind = property_remove;
2429 number = aprop->u.number;
2430 aprop->u.number = number | bprop->u.number;
2431 updated = number != (unsigned int) aprop->u.number;
2435 else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2436 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO
2437 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI))
2439 if (aprop != NULL && bprop != NULL)
2441 number = aprop->u.number;
2442 aprop->u.number = number | bprop->u.number;
2443 /* Remove the property if all bits are empty. */
2444 if (aprop->u.number == 0)
2446 aprop->pr_kind = property_remove;
2450 updated = number != (unsigned int) aprop->u.number;
2454 /* Only one of APROP and BPROP can be NULL. */
2457 if (aprop->u.number == 0)
2459 /* Remove APROP if all bits are empty. */
2460 aprop->pr_kind = property_remove;
2466 /* Return TRUE if APROP is NULL and all bits of BPROP
2467 aren't empty to indicate that BPROP should be added
2469 updated = bprop->u.number != 0;
2474 else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO
2475 && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2477 /* Only one of APROP and BPROP can be NULL:
2478 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2479 2. If APROP is NULL, remove x86 feature.
2480 3. Otherwise, do nothing.
2482 const struct elf_backend_data *bed
2483 = get_elf_backend_data (info->output_bfd);
2484 struct elf_x86_link_hash_table *htab
2485 = elf_x86_hash_table (info, bed->target_id);
2488 if (aprop != NULL && bprop != NULL)
2491 if (htab->params->ibt)
2492 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2493 if (htab->params->shstk)
2494 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2495 number = aprop->u.number;
2496 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2497 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2498 aprop->u.number = (number & bprop->u.number) | features;
2499 updated = number != (unsigned int) aprop->u.number;
2500 /* Remove the property if all feature bits are cleared. */
2501 if (aprop->u.number == 0)
2502 aprop->pr_kind = property_remove;
2506 /* There should be no AND properties since some input doesn't
2507 have them. Set IBT and SHSTK properties for -z ibt and -z
2510 if (htab->params->ibt)
2511 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2512 if (htab->params->shstk)
2513 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2518 updated = features != (unsigned int) aprop->u.number;
2519 aprop->u.number = features;
2524 bprop->u.number = features;
2527 else if (aprop != NULL)
2529 aprop->pr_kind = property_remove;
2537 /* Never should happen. */
2544 /* Set up x86 GNU properties. Return the first relocatable ELF input
2545 with GNU properties if found. Otherwise, return NULL. */
2548 _bfd_x86_elf_link_setup_gnu_properties
2549 (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
2551 bfd_boolean normal_target;
2552 bfd_boolean lazy_plt;
2553 asection *sec, *pltsec;
2555 bfd_boolean use_ibt_plt;
2556 unsigned int plt_alignment, features;
2557 struct elf_x86_link_hash_table *htab;
2561 const struct elf_backend_data *bed;
2562 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
2563 unsigned int got_align;
2565 /* Find a normal input file with GNU property note. */
2566 for (pbfd = info->input_bfds;
2568 pbfd = pbfd->link.next)
2569 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
2570 && bfd_count_sections (pbfd) != 0)
2574 if (elf_properties (pbfd) != NULL)
2578 bed = get_elf_backend_data (info->output_bfd);
2580 htab = elf_x86_hash_table (info, bed->target_id);
2585 if (htab->params->ibt)
2586 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
2587 if (htab->params->shstk)
2588 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
2595 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2596 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2597 prop = _bfd_elf_get_property (ebfd,
2598 GNU_PROPERTY_X86_FEATURE_1_AND,
2600 prop->u.number |= features;
2601 prop->pr_kind = property_number;
2604 /* Create the GNU property note section if needed. */
2605 if (prop != NULL && pbfd == NULL)
2607 sec = bfd_make_section_with_flags (ebfd,
2608 NOTE_GNU_PROPERTY_SECTION_NAME,
2616 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
2618 if (!bfd_set_section_alignment (ebfd, sec, class_align))
2621 info->callbacks->einfo (_("%F%pA: failed to align section\n"),
2625 elf_section_type (sec) = SHT_NOTE;
2629 pbfd = _bfd_elf_link_setup_gnu_properties (info);
2631 htab->r_info = init_table->r_info;
2632 htab->r_sym = init_table->r_sym;
2634 if (bfd_link_relocatable (info))
2637 htab->plt0_pad_byte = init_table->plt0_pad_byte;
2639 use_ibt_plt = htab->params->ibtplt || htab->params->ibt;
2640 if (!use_ibt_plt && pbfd != NULL)
2642 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2643 elf_property_list *p;
2645 /* The property list is sorted in order of type. */
2646 for (p = elf_properties (pbfd); p; p = p->next)
2648 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
2650 use_ibt_plt = !!(p->property.u.number
2651 & GNU_PROPERTY_X86_FEATURE_1_IBT);
2654 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
2659 dynobj = htab->elf.dynobj;
2661 /* Set htab->elf.dynobj here so that there is no need to check and
2662 set it in check_relocs. */
2667 htab->elf.dynobj = pbfd;
2674 /* Find a normal input file to hold linker created
2676 for (abfd = info->input_bfds;
2678 abfd = abfd->link.next)
2679 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2681 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
2682 && bed->relocs_compatible (abfd->xvec,
2683 info->output_bfd->xvec))
2685 htab->elf.dynobj = abfd;
2692 /* Return if there are no normal input files. */
2696 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2697 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2698 canonical function address. */
2699 htab->plt.has_plt0 = 1;
2700 normal_target = htab->target_os == is_normal;
2706 htab->lazy_plt = init_table->lazy_ibt_plt;
2707 htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
2711 htab->lazy_plt = init_table->lazy_plt;
2712 htab->non_lazy_plt = init_table->non_lazy_plt;
2717 htab->lazy_plt = init_table->lazy_plt;
2718 htab->non_lazy_plt = NULL;
2721 pltsec = htab->elf.splt;
2723 /* If the non-lazy PLT is available, use it for all PLT entries if
2724 there are no PLT0 or no .plt section. */
2725 if (htab->non_lazy_plt != NULL
2726 && (!htab->plt.has_plt0 || pltsec == NULL))
2729 if (bfd_link_pic (info))
2730 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
2732 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
2733 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
2734 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
2735 htab->plt.plt_got_insn_size
2736 = htab->non_lazy_plt->plt_got_insn_size;
2737 htab->plt.eh_frame_plt_size
2738 = htab->non_lazy_plt->eh_frame_plt_size;
2739 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
2744 if (bfd_link_pic (info))
2746 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
2747 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
2751 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
2752 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
2754 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
2755 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
2756 htab->plt.plt_got_insn_size
2757 = htab->lazy_plt->plt_got_insn_size;
2758 htab->plt.eh_frame_plt_size
2759 = htab->lazy_plt->eh_frame_plt_size;
2760 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
2763 if (htab->target_os == is_vxworks
2764 && !elf_vxworks_create_dynamic_sections (dynobj, info,
2767 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2771 /* Since create_dynamic_sections isn't always called, but GOT
2772 relocations need GOT relocations, create them here so that we
2773 don't need to do it in check_relocs. */
2774 if (htab->elf.sgot == NULL
2775 && !_bfd_elf_create_got_section (dynobj, info))
2776 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
2778 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
2780 /* Align .got and .got.plt sections to their entry size. Do it here
2781 instead of in create_dynamic_sections so that they are always
2782 properly aligned even if create_dynamic_sections isn't called. */
2783 sec = htab->elf.sgot;
2784 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2785 goto error_alignment;
2787 sec = htab->elf.sgotplt;
2788 if (!bfd_set_section_alignment (dynobj, sec, got_align))
2789 goto error_alignment;
2791 /* Create the ifunc sections here so that check_relocs can be
2793 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
2794 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
2796 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
2800 /* Whe creating executable, set the contents of the .interp
2801 section to the interpreter. */
2802 if (bfd_link_executable (info) && !info->nointerp)
2804 asection *s = bfd_get_linker_section (dynobj, ".interp");
2807 s->size = htab->dynamic_interpreter_size;
2808 s->contents = (unsigned char *) htab->dynamic_interpreter;
2812 /* Don't change PLT section alignment for NaCl since it uses
2813 64-byte PLT entry and sets PLT section alignment to 32
2814 bytes. Don't create additional PLT sections for NaCl. */
2817 flagword pltflags = (bed->dynamic_sec_flags
2822 unsigned int non_lazy_plt_alignment
2823 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
2826 if (!bfd_set_section_alignment (sec->owner, sec,
2828 goto error_alignment;
2830 /* Create the GOT procedure linkage table. */
2831 sec = bfd_make_section_anyway_with_flags (dynobj,
2835 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
2837 if (!bfd_set_section_alignment (dynobj, sec,
2838 non_lazy_plt_alignment))
2839 goto error_alignment;
2841 htab->plt_got = sec;
2849 /* Create the second PLT for Intel IBT support. IBT
2850 PLT is supported only for non-NaCl target and is
2851 is needed only for lazy binding. */
2852 sec = bfd_make_section_anyway_with_flags (dynobj,
2856 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
2858 if (!bfd_set_section_alignment (dynobj, sec,
2860 goto error_alignment;
2862 else if (htab->params->bndplt && ABI_64_P (dynobj))
2864 /* Create the second PLT for Intel MPX support. MPX
2865 PLT is supported only for non-NaCl target in 64-bit
2866 mode and is needed only for lazy binding. */
2867 sec = bfd_make_section_anyway_with_flags (dynobj,
2871 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n"));
2873 if (!bfd_set_section_alignment (dynobj, sec,
2874 non_lazy_plt_alignment))
2875 goto error_alignment;
2878 htab->plt_second = sec;
2882 if (!info->no_ld_generated_unwind_info)
2884 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2885 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2886 | SEC_LINKER_CREATED);
2888 sec = bfd_make_section_anyway_with_flags (dynobj,
2892 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
2894 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2895 goto error_alignment;
2897 htab->plt_eh_frame = sec;
2899 if (htab->plt_got != NULL)
2901 sec = bfd_make_section_anyway_with_flags (dynobj,
2905 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
2907 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2908 goto error_alignment;
2910 htab->plt_got_eh_frame = sec;
2913 if (htab->plt_second != NULL)
2915 sec = bfd_make_section_anyway_with_flags (dynobj,
2919 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
2921 if (!bfd_set_section_alignment (dynobj, sec, class_align))
2922 goto error_alignment;
2924 htab->plt_second_eh_frame = sec;
2929 /* The .iplt section is used for IFUNC symbols in static
2931 sec = htab->elf.iplt;
2934 /* NB: Delay setting its alignment until we know it is non-empty.
2935 Otherwise an empty iplt section may change vma and lma of the
2936 following sections, which triggers moving dot of the following
2937 section backwards, resulting in a warning and section lma not
2938 being set properly. It later leads to a "File truncated"
2940 if (!bfd_set_section_alignment (sec->owner, sec, 0))
2941 goto error_alignment;
2943 htab->plt.iplt_alignment = (normal_target
2945 : bed->plt_alignment);
2951 /* Fix up x86 GNU properties. */
2954 _bfd_x86_elf_link_fixup_gnu_properties
2955 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2956 elf_property_list **listp)
2958 elf_property_list *p;
2960 for (p = *listp; p; p = p->next)
2962 unsigned int type = p->property.pr_type;
2963 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2964 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2965 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
2966 && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2967 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
2968 && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
2969 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2970 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
2972 if (p->property.u.number == 0
2973 && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2974 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
2975 && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
2976 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
2977 && type <= GNU_PROPERTY_X86_UINT32_OR_HI)))
2979 /* Remove empty property. */
2986 else if (type > GNU_PROPERTY_HIPROC)
2988 /* The property list is sorted in order of type. */
2995 _bfd_elf_linker_x86_set_options (struct bfd_link_info * info,
2996 struct elf_linker_x86_params *params)
2998 const struct elf_backend_data *bed
2999 = get_elf_backend_data (info->output_bfd);
3000 struct elf_x86_link_hash_table *htab
3001 = elf_x86_hash_table (info, bed->target_id);
3003 htab->params = params;