1 /* x86 specific support for ELF
2 Copyright (C) 2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
21 #include "elfxx-x86.h"
22 #include "elf-vxworks.h"
25 #include "elf/x86-64.h"
27 /* The name of the dynamic interpreter. This is put in the .interp
30 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
31 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
32 #define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
35 _bfd_x86_elf_mkobject (bfd *abfd)
37 return bfd_elf_allocate_object (abfd,
38 sizeof (struct elf_x86_obj_tdata),
39 get_elf_backend_data (abfd)->target_id);
42 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
43 executables. Rather than setting it to the beginning of the TLS
44 section, we have to set it to the end. This function may be called
45 multiple times, it is idempotent. */
48 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
50 struct elf_x86_link_hash_table *htab;
51 struct bfd_link_hash_entry *base;
52 const struct elf_backend_data *bed;
54 if (!bfd_link_executable (info))
57 bed = get_elf_backend_data (info->output_bfd);
58 htab = elf_x86_hash_table (info, bed->target_id);
62 base = htab->tls_module_base;
66 base->u.def.value = htab->elf.tls_size;
69 /* Return the base VMA address which should be subtracted from real addresses
70 when resolving @dtpoff relocation.
71 This is PT_TLS segment p_vaddr. */
74 _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info)
76 /* If tls_sec is NULL, we should have signalled an error already. */
77 if (elf_hash_table (info)->tls_sec == NULL)
79 return elf_hash_table (info)->tls_sec->vma;
82 /* Find any dynamic relocs that apply to read-only sections. */
85 _bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry *h,
88 struct elf_x86_link_hash_entry *eh;
89 struct elf_dyn_relocs *p;
91 /* Skip local IFUNC symbols. */
92 if (h->forced_local && h->type == STT_GNU_IFUNC)
95 eh = (struct elf_x86_link_hash_entry *) h;
96 for (p = eh->dyn_relocs; p != NULL; p = p->next)
98 asection *s = p->sec->output_section;
100 if (s != NULL && (s->flags & SEC_READONLY) != 0)
102 struct bfd_link_info *info = (struct bfd_link_info *) inf;
104 info->flags |= DF_TEXTREL;
106 if ((info->warn_shared_textrel && bfd_link_pic (info))
107 || info->error_textrel)
108 /* xgettext:c-format */
109 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
110 p->sec->owner, h->root.root.string,
113 /* Not an error, just cut short the traversal. */
120 /* Find and/or create a hash entry for local symbol. */
122 struct elf_link_hash_entry *
123 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
124 bfd *abfd, const Elf_Internal_Rela *rel,
127 struct elf_x86_link_hash_entry e, *ret;
128 asection *sec = abfd->sections;
129 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
130 htab->r_sym (rel->r_info));
133 e.elf.indx = sec->id;
134 e.elf.dynstr_index = htab->r_sym (rel->r_info);
135 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
136 create ? INSERT : NO_INSERT);
143 ret = (struct elf_x86_link_hash_entry *) *slot;
147 ret = (struct elf_x86_link_hash_entry *)
148 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
149 sizeof (struct elf_x86_link_hash_entry));
152 memset (ret, 0, sizeof (*ret));
153 ret->elf.indx = sec->id;
154 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
155 ret->elf.dynindx = -1;
156 ret->plt_got.offset = (bfd_vma) -1;
162 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
163 SYNC WITH _bfd_elf_link_hash_newfunc. */
165 struct bfd_hash_entry *
166 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
167 struct bfd_hash_table *table,
170 /* Allocate the structure if it has not already been allocated by a
174 entry = (struct bfd_hash_entry *)
175 bfd_hash_allocate (table,
176 sizeof (struct elf_x86_link_hash_entry));
181 /* Call the allocation method of the superclass. */
182 entry = _bfd_link_hash_newfunc (entry, table, string);
185 struct elf_x86_link_hash_entry *eh
186 = (struct elf_x86_link_hash_entry *) entry;
187 struct elf_link_hash_table *htab
188 = (struct elf_link_hash_table *) table;
190 memset (&eh->elf.size, 0,
191 (sizeof (struct elf_x86_link_hash_entry)
192 - offsetof (struct elf_link_hash_entry, size)));
193 /* Set local fields. */
195 eh->elf.dynindx = -1;
196 eh->elf.got = htab->init_got_refcount;
197 eh->elf.plt = htab->init_plt_refcount;
198 /* Assume that we have been called by a non-ELF symbol reader.
199 This flag is then reset by the code which reads an ELF input
200 file. This ensures that a symbol created by a non-ELF symbol
201 reader will have the flag set correctly. */
203 eh->plt_second.offset = (bfd_vma) -1;
204 eh->plt_got.offset = (bfd_vma) -1;
205 eh->tlsdesc_got = (bfd_vma) -1;
211 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
212 for local symbol so that we can handle local STT_GNU_IFUNC symbols
213 as global symbol. We reuse indx and dynstr_index for local symbol
214 hash since they aren't used by global symbols in this backend. */
217 _bfd_x86_elf_local_htab_hash (const void *ptr)
219 struct elf_link_hash_entry *h
220 = (struct elf_link_hash_entry *) ptr;
221 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
224 /* Compare local hash entries. */
227 _bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
229 struct elf_link_hash_entry *h1
230 = (struct elf_link_hash_entry *) ptr1;
231 struct elf_link_hash_entry *h2
232 = (struct elf_link_hash_entry *) ptr2;
234 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
237 /* Destroy an x86 ELF linker hash table. */
240 elf_x86_link_hash_table_free (bfd *obfd)
242 struct elf_x86_link_hash_table *htab
243 = (struct elf_x86_link_hash_table *) obfd->link.hash;
245 if (htab->loc_hash_table)
246 htab_delete (htab->loc_hash_table);
247 if (htab->loc_hash_memory)
248 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
249 _bfd_elf_link_hash_table_free (obfd);
252 /* Create an x86 ELF linker hash table. */
254 struct bfd_link_hash_table *
255 _bfd_x86_elf_link_hash_table_create (bfd *abfd)
257 struct elf_x86_link_hash_table *ret;
258 const struct elf_backend_data *bed;
259 bfd_size_type amt = sizeof (struct elf_x86_link_hash_table);
261 ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
265 bed = get_elf_backend_data (abfd);
266 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
267 _bfd_x86_elf_link_hash_newfunc,
268 sizeof (struct elf_x86_link_hash_entry),
278 ret->r_info = elf64_r_info;
279 ret->r_sym = elf64_r_sym;
280 ret->pointer_r_type = R_X86_64_64;
281 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
282 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
283 ret->tls_get_addr = "__tls_get_addr";
288 ret->r_info = elf32_r_info;
289 ret->r_sym = elf32_r_sym;
290 if (bed->target_id == X86_64_ELF_DATA)
292 ret->pointer_r_type = R_X86_64_32;
293 ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
294 ret->dynamic_interpreter_size
295 = sizeof ELFX32_DYNAMIC_INTERPRETER;
296 ret->tls_get_addr = "__tls_get_addr";
300 ret->pointer_r_type = R_386_32;
301 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
302 ret->dynamic_interpreter_size
303 = sizeof ELF32_DYNAMIC_INTERPRETER;
304 ret->tls_get_addr = "___tls_get_addr";
308 ret->loc_hash_table = htab_try_create (1024,
309 _bfd_x86_elf_local_htab_hash,
310 _bfd_x86_elf_local_htab_eq,
312 ret->loc_hash_memory = objalloc_create ();
313 if (!ret->loc_hash_table || !ret->loc_hash_memory)
315 elf_x86_link_hash_table_free (abfd);
318 ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
320 return &ret->elf.root;
323 /* Sort relocs into address order. */
326 _bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
328 const arelent *a = * (const arelent **) ap;
329 const arelent *b = * (const arelent **) bp;
331 if (a->address > b->address)
333 else if (a->address < b->address)
340 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
342 if (!bfd_link_relocatable (info))
344 /* Check for __tls_get_addr reference. */
345 struct elf_x86_link_hash_table *htab;
346 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
347 htab = elf_x86_hash_table (info, bed->target_id);
350 struct elf_link_hash_entry *h
351 = elf_link_hash_lookup (elf_hash_table (info),
353 FALSE, FALSE, FALSE);
355 ((struct elf_x86_link_hash_entry *) h)->tls_get_addr = 1;
359 /* Invoke the regular ELF backend linker to do all the work. */
360 return _bfd_elf_link_check_relocs (abfd, info);
364 _bfd_x86_elf_always_size_sections (bfd *output_bfd,
365 struct bfd_link_info *info)
367 asection *tls_sec = elf_hash_table (info)->tls_sec;
371 struct elf_link_hash_entry *tlsbase;
373 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
375 FALSE, FALSE, FALSE);
377 if (tlsbase && tlsbase->type == STT_TLS)
379 struct elf_x86_link_hash_table *htab;
380 struct bfd_link_hash_entry *bh = NULL;
381 const struct elf_backend_data *bed
382 = get_elf_backend_data (output_bfd);
384 htab = elf_x86_hash_table (info, bed->target_id);
388 if (!(_bfd_generic_link_add_one_symbol
389 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
390 tls_sec, 0, NULL, FALSE,
394 htab->tls_module_base = bh;
396 tlsbase = (struct elf_link_hash_entry *)bh;
397 tlsbase->def_regular = 1;
398 tlsbase->other = STV_HIDDEN;
399 tlsbase->root.linker_def = 1;
400 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
408 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
409 const Elf_Internal_Sym *isym,
410 bfd_boolean definition,
411 bfd_boolean dynamic ATTRIBUTE_UNUSED)
415 struct elf_x86_link_hash_entry *eh
416 = (struct elf_x86_link_hash_entry *) h;
417 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
422 /* Copy the extra info we tack onto an elf_link_hash_entry. */
425 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
426 struct elf_link_hash_entry *dir,
427 struct elf_link_hash_entry *ind)
429 struct elf_x86_link_hash_entry *edir, *eind;
431 edir = (struct elf_x86_link_hash_entry *) dir;
432 eind = (struct elf_x86_link_hash_entry *) ind;
434 if (eind->dyn_relocs != NULL)
436 if (edir->dyn_relocs != NULL)
438 struct elf_dyn_relocs **pp;
439 struct elf_dyn_relocs *p;
441 /* Add reloc counts against the indirect sym to the direct sym
442 list. Merge any entries against the same section. */
443 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
445 struct elf_dyn_relocs *q;
447 for (q = edir->dyn_relocs; q != NULL; q = q->next)
448 if (q->sec == p->sec)
450 q->pc_count += p->pc_count;
451 q->count += p->count;
458 *pp = edir->dyn_relocs;
461 edir->dyn_relocs = eind->dyn_relocs;
462 eind->dyn_relocs = NULL;
465 if (ind->root.type == bfd_link_hash_indirect
466 && dir->got.refcount <= 0)
468 edir->tls_type = eind->tls_type;
469 eind->tls_type = GOT_UNKNOWN;
472 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
473 generate a R_386_COPY reloc. */
474 edir->gotoff_ref |= eind->gotoff_ref;
476 edir->has_got_reloc |= eind->has_got_reloc;
477 edir->has_non_got_reloc |= eind->has_non_got_reloc;
479 if (ELIMINATE_COPY_RELOCS
480 && ind->root.type != bfd_link_hash_indirect
481 && dir->dynamic_adjusted)
483 /* If called to transfer flags for a weakdef during processing
484 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
485 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
486 if (dir->versioned != versioned_hidden)
487 dir->ref_dynamic |= ind->ref_dynamic;
488 dir->ref_regular |= ind->ref_regular;
489 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
490 dir->needs_plt |= ind->needs_plt;
491 dir->pointer_equality_needed |= ind->pointer_equality_needed;
495 if (eind->func_pointer_refcount > 0)
497 edir->func_pointer_refcount += eind->func_pointer_refcount;
498 eind->func_pointer_refcount = 0;
501 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
505 /* Remove undefined weak symbol from the dynamic symbol table if it
509 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
510 struct elf_link_hash_entry *h)
512 if (h->dynindx != -1)
514 const struct elf_backend_data *bed
515 = get_elf_backend_data (info->output_bfd);
516 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
518 elf_x86_hash_entry (h)->has_got_reloc,
519 elf_x86_hash_entry (h)))
522 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
529 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
532 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
534 if (h->plt.offset != (bfd_vma) -1
536 && !h->pointer_equality_needed)
539 return _bfd_elf_hash_symbol (h);
542 /* Adjust a symbol defined by a dynamic object and referenced by a
543 regular object. The current definition is in some section of the
544 dynamic object, but we're not including those sections. We have to
545 change the definition to something the rest of the link can
549 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
550 struct elf_link_hash_entry *h)
552 struct elf_x86_link_hash_table *htab;
554 struct elf_x86_link_hash_entry *eh;
555 struct elf_dyn_relocs *p;
556 const struct elf_backend_data *bed
557 = get_elf_backend_data (info->output_bfd);
559 /* STT_GNU_IFUNC symbol must go through PLT. */
560 if (h->type == STT_GNU_IFUNC)
562 /* All local STT_GNU_IFUNC references must be treate as local
563 calls via local PLT. */
565 && SYMBOL_CALLS_LOCAL (info, h))
567 bfd_size_type pc_count = 0, count = 0;
568 struct elf_dyn_relocs **pp;
570 eh = (struct elf_x86_link_hash_entry *) h;
571 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
573 pc_count += p->pc_count;
574 p->count -= p->pc_count;
583 if (pc_count || count)
588 /* Increment PLT reference count only for PC-relative
591 if (h->plt.refcount <= 0)
594 h->plt.refcount += 1;
599 if (h->plt.refcount <= 0)
601 h->plt.offset = (bfd_vma) -1;
607 /* If this is a function, put it in the procedure linkage table. We
608 will fill in the contents of the procedure linkage table later,
609 when we know the address of the .got section. */
610 if (h->type == STT_FUNC
613 if (h->plt.refcount <= 0
614 || SYMBOL_CALLS_LOCAL (info, h)
615 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
616 && h->root.type == bfd_link_hash_undefweak))
618 /* This case can occur if we saw a PLT32 reloc in an input
619 file, but the symbol was never referred to by a dynamic
620 object, or if all references were garbage collected. In
621 such a case, we don't actually need to build a procedure
622 linkage table, and we can just do a PC32 reloc instead. */
623 h->plt.offset = (bfd_vma) -1;
630 /* It's possible that we incorrectly decided a .plt reloc was needed
631 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
632 check_relocs. We can't decide accurately between function and
633 non-function syms in check-relocs; Objects loaded later in
634 the link may change h->type. So fix it now. */
635 h->plt.offset = (bfd_vma) -1;
637 eh = (struct elf_x86_link_hash_entry *) h;
639 /* If this is a weak symbol, and there is a real definition, the
640 processor independent code will have arranged for us to see the
641 real definition first, and we can just use the same value. */
642 if (h->u.weakdef != NULL)
644 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
645 || h->u.weakdef->root.type == bfd_link_hash_defweak);
646 h->root.u.def.section = h->u.weakdef->root.u.def.section;
647 h->root.u.def.value = h->u.weakdef->root.u.def.value;
648 if (ELIMINATE_COPY_RELOCS
650 || SYMBOL_NO_COPYRELOC (info, eh))
652 /* NB: needs_copy is always 0 for i386. */
653 h->non_got_ref = h->u.weakdef->non_got_ref;
654 eh->needs_copy = h->u.weakdef->needs_copy;
659 /* This is a reference to a symbol defined by a dynamic object which
660 is not a function. */
662 /* If we are creating a shared library, we must presume that the
663 only references to the symbol are via the global offset table.
664 For such cases we need not do anything here; the relocations will
665 be handled correctly by relocate_section. */
666 if (!bfd_link_executable (info))
669 /* If there are no references to this symbol that do not use the
670 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
671 reloc. NB: gotoff_ref is always 0 for x86-64. */
672 if (!h->non_got_ref && !eh->gotoff_ref)
675 /* If -z nocopyreloc was given, we won't generate them either. */
676 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
682 htab = elf_x86_hash_table (info, bed->target_id);
686 /* If there aren't any dynamic relocs in read-only sections nor
687 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
688 avoid the copy reloc. This doesn't work on VxWorks, where we can
689 not have dynamic relocations (other than copy and jump slot
690 relocations) in an executable. */
691 if (ELIMINATE_COPY_RELOCS
692 && (bed->target_id == X86_64_ELF_DATA
694 && !htab->is_vxworks)))
696 for (p = eh->dyn_relocs; p != NULL; p = p->next)
698 s = p->sec->output_section;
699 if (s != NULL && (s->flags & SEC_READONLY) != 0)
703 /* If we didn't find any dynamic relocs in read-only sections,
704 then we'll be keeping the dynamic relocs and avoiding the copy
713 /* We must allocate the symbol in our .dynbss section, which will
714 become part of the .bss section of the executable. There will be
715 an entry for this symbol in the .dynsym section. The dynamic
716 object will contain position independent code, so all references
717 from the dynamic object to this symbol will go through the global
718 offset table. The dynamic linker will use the .dynsym entry to
719 determine the address it must put in the global offset table, so
720 both the dynamic object and the regular object will refer to the
721 same memory location for the variable. */
723 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
724 dynamic linker to copy the initial value out of the dynamic object
725 and into the runtime process image. */
726 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
728 s = htab->elf.sdynrelro;
729 srel = htab->elf.sreldynrelro;
733 s = htab->elf.sdynbss;
734 srel = htab->elf.srelbss;
736 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
738 srel->size += ((bed->target_id == I386_ELF_DATA)
739 ? sizeof (Elf32_External_Rel)
740 : bed->s->sizeof_rela);
744 return _bfd_elf_adjust_dynamic_copy (info, h, s);
748 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
750 bfd_vma offset ATTRIBUTE_UNUSED,
753 return got_addr + off;
757 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
760 bfd_vma got_addr ATTRIBUTE_UNUSED)
762 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
766 elf_i386_valid_plt_reloc_p (unsigned int type)
768 return (type == R_386_JUMP_SLOT
769 || type == R_386_GLOB_DAT
770 || type == R_386_IRELATIVE);
774 elf_x86_64_valid_plt_reloc_p (unsigned int type)
776 return (type == R_X86_64_JUMP_SLOT
777 || type == R_X86_64_GLOB_DAT
778 || type == R_X86_64_IRELATIVE);
782 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
786 struct elf_x86_plt plts[],
790 long size, i, n, len;
792 unsigned int plt_got_offset, plt_entry_size;
794 bfd_byte *plt_contents;
796 arelent **dynrelbuf, *p;
798 const struct elf_backend_data *bed;
799 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
801 bfd_boolean (*valid_plt_reloc_p) (unsigned int);
806 dynrelbuf = (arelent **) bfd_malloc (relsize);
807 if (dynrelbuf == NULL)
810 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
813 /* Sort the relocs by address. */
814 qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
815 _bfd_x86_elf_compare_relocs);
817 size = count * sizeof (asymbol);
819 /* Allocate space for @plt suffixes. */
821 for (i = 0; i < dynrelcount; i++)
824 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
826 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
829 s = *ret = (asymbol *) bfd_zmalloc (size);
833 bed = get_elf_backend_data (abfd);
835 if (bed->target_id == X86_64_ELF_DATA)
837 get_plt_got_vma = elf_x86_64_get_plt_got_vma;
838 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
842 get_plt_got_vma = elf_i386_get_plt_got_vma;
843 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
846 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
848 asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
853 sec = bfd_get_section_by_name (abfd, ".got");
858 if (got_addr == (bfd_vma) -1)
863 /* Check for each PLT section. */
864 names = (char *) (s + count);
867 for (j = 0; plts[j].name != NULL; j++)
868 if ((plt_contents = plts[j].contents) != NULL)
873 struct elf_x86_plt *plt_p = &plts[j];
875 plt_got_offset = plt_p->plt_got_offset;
876 plt_entry_size = plt_p->plt_entry_size;
880 if ((plt_p->type & plt_lazy))
882 /* Skip PLT0 in lazy PLT. */
884 offset = plt_entry_size;
892 /* Check each PLT entry against dynamic relocations. */
893 for (; k < plt_p->count; k++)
899 /* Get the GOT offset for i386 or the PC-relative offset
900 for x86-64, a signed 32-bit integer. */
901 off = H_GET_32 (abfd, (plt_contents + offset
903 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
909 while ((min + 1) < max)
913 mid = (min + max) / 2;
915 if (got_vma > r->address)
917 else if (got_vma < r->address)
926 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
927 if (got_vma == p->address
929 && valid_plt_reloc_p (p->howto->type))
931 *s = **p->sym_ptr_ptr;
932 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
933 set. Since we are defining a symbol, ensure one
935 if ((s->flags & BSF_LOCAL) == 0)
936 s->flags |= BSF_GLOBAL;
937 s->flags |= BSF_SYNTHETIC;
938 /* This is no longer a section symbol. */
939 s->flags &= ~BSF_SECTION_SYM;
941 s->the_bfd = plt->owner;
945 len = strlen ((*p->sym_ptr_ptr)->name);
946 memcpy (names, (*p->sym_ptr_ptr)->name, len);
952 memcpy (names, "+0x", sizeof ("+0x") - 1);
953 names += sizeof ("+0x") - 1;
954 bfd_sprintf_vma (abfd, buf, p->addend);
955 for (a = buf; *a == '0'; ++a)
958 memcpy (names, a, size);
961 memcpy (names, "@plt", sizeof ("@plt"));
962 names += sizeof ("@plt");
966 offset += plt_entry_size;
970 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
979 for (j = 0; plts[j].name != NULL; j++)
980 if (plts[j].contents != NULL)
981 free (plts[j].contents);
988 /* Parse x86 GNU properties. */
990 enum elf_property_kind
991 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
992 bfd_byte *ptr, unsigned int datasz)
998 case GNU_PROPERTY_X86_ISA_1_USED:
999 case GNU_PROPERTY_X86_ISA_1_NEEDED:
1000 case GNU_PROPERTY_X86_FEATURE_1_AND:
1004 ((type == GNU_PROPERTY_X86_ISA_1_USED
1005 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
1006 : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
1007 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
1008 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
1010 return property_corrupt;
1012 prop = _bfd_elf_get_property (abfd, type, datasz);
1013 /* Combine properties of the same type. */
1014 prop->u.number |= bfd_h_get_32 (abfd, ptr);
1015 prop->pr_kind = property_number;
1019 return property_ignored;
1022 return property_number;
1025 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
1026 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
1027 should be merged with ABFD. */
1030 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
1031 bfd *abfd ATTRIBUTE_UNUSED,
1032 elf_property *aprop,
1033 elf_property *bprop)
1035 unsigned int number, features;
1036 bfd_boolean updated = FALSE;
1037 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
1041 case GNU_PROPERTY_X86_ISA_1_USED:
1042 case GNU_PROPERTY_X86_ISA_1_NEEDED:
1043 if (aprop != NULL && bprop != NULL)
1045 number = aprop->u.number;
1046 aprop->u.number = number | bprop->u.number;
1047 updated = number != (unsigned int) aprop->u.number;
1051 /* Return TRUE if APROP is NULL to indicate that BPROP should
1052 be added to ABFD. */
1053 updated = aprop == NULL;
1057 case GNU_PROPERTY_X86_FEATURE_1_AND:
1058 /* Only one of APROP and BPROP can be NULL:
1059 1. APROP & BPROP when both APROP and BPROP aren't NULL.
1060 2. If APROP is NULL, remove x86 feature.
1061 3. Otherwise, do nothing.
1063 if (aprop != NULL && bprop != NULL)
1067 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1069 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1070 number = aprop->u.number;
1071 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1072 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1073 aprop->u.number = (number & bprop->u.number) | features;
1074 updated = number != (unsigned int) aprop->u.number;
1075 /* Remove the property if all feature bits are cleared. */
1076 if (aprop->u.number == 0)
1077 aprop->pr_kind = property_remove;
1083 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1085 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1088 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1089 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1092 number = aprop->u.number;
1093 aprop->u.number = number | features;
1094 updated = number != (unsigned int) aprop->u.number;
1098 bprop->u.number |= features;
1102 else if (aprop != NULL)
1104 aprop->pr_kind = property_remove;
1111 /* Never should happen. */
1118 /* Set up x86 GNU properties. Return the first relocatable ELF input
1119 with GNU properties if found. Otherwise, return NULL. */
1122 _bfd_x86_elf_link_setup_gnu_properties
1123 (struct bfd_link_info *info,
1124 struct elf_x86_plt_layout_table *plt_layout)
1126 bfd_boolean normal_target;
1127 bfd_boolean lazy_plt;
1128 asection *sec, *pltsec;
1130 bfd_boolean use_ibt_plt;
1131 unsigned int plt_alignment, features;
1132 struct elf_x86_link_hash_table *htab;
1136 const struct elf_backend_data *bed;
1137 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
1138 unsigned int got_align;
1142 features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1144 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1146 /* Find a normal input file with GNU property note. */
1147 for (pbfd = info->input_bfds;
1149 pbfd = pbfd->link.next)
1150 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
1151 && bfd_count_sections (pbfd) != 0)
1155 if (elf_properties (pbfd) != NULL)
1159 if (ebfd != NULL && features)
1161 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
1162 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1163 prop = _bfd_elf_get_property (ebfd,
1164 GNU_PROPERTY_X86_FEATURE_1_AND,
1166 prop->u.number |= features;
1167 prop->pr_kind = property_number;
1169 /* Create the GNU property note section if needed. */
1172 sec = bfd_make_section_with_flags (ebfd,
1173 NOTE_GNU_PROPERTY_SECTION_NAME,
1181 info->callbacks->einfo (_("%F: failed to create GNU property section\n"));
1183 if (!bfd_set_section_alignment (ebfd, sec, class_align))
1186 info->callbacks->einfo (_("%F%A: failed to align section\n"),
1190 elf_section_type (sec) = SHT_NOTE;
1194 pbfd = _bfd_elf_link_setup_gnu_properties (info);
1196 if (bfd_link_relocatable (info))
1199 bed = get_elf_backend_data (info->output_bfd);
1201 htab = elf_x86_hash_table (info, bed->target_id);
1205 htab->is_vxworks = plt_layout->is_vxworks;
1207 use_ibt_plt = info->ibtplt || info->ibt;
1208 if (!use_ibt_plt && pbfd != NULL)
1210 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
1211 elf_property_list *p;
1213 /* The property list is sorted in order of type. */
1214 for (p = elf_properties (pbfd); p; p = p->next)
1216 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
1218 use_ibt_plt = !!(p->property.u.number
1219 & GNU_PROPERTY_X86_FEATURE_1_IBT);
1222 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
1227 dynobj = htab->elf.dynobj;
1229 /* Set htab->elf.dynobj here so that there is no need to check and
1230 set it in check_relocs. */
1235 htab->elf.dynobj = pbfd;
1242 /* Find a normal input file to hold linker created
1244 for (abfd = info->input_bfds;
1246 abfd = abfd->link.next)
1247 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1249 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0)
1251 htab->elf.dynobj = abfd;
1258 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
1259 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
1260 canonical function address. */
1261 htab->plt.has_plt0 = 1;
1262 normal_target = plt_layout->normal_target;
1268 htab->lazy_plt = plt_layout->lazy_ibt_plt;
1269 htab->non_lazy_plt = plt_layout->non_lazy_ibt_plt;
1273 htab->lazy_plt = plt_layout->lazy_plt;
1274 htab->non_lazy_plt = plt_layout->non_lazy_plt;
1279 htab->lazy_plt = plt_layout->lazy_plt;
1280 htab->non_lazy_plt = NULL;
1283 pltsec = htab->elf.splt;
1285 /* If the non-lazy PLT is available, use it for all PLT entries if
1286 there are no PLT0 or no .plt section. */
1287 if (htab->non_lazy_plt != NULL
1288 && (!htab->plt.has_plt0 || pltsec == NULL))
1291 if (bfd_link_pic (info))
1292 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
1294 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
1295 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
1296 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
1297 htab->plt.plt_got_insn_size
1298 = htab->non_lazy_plt->plt_got_insn_size;
1299 htab->plt.eh_frame_plt_size
1300 = htab->non_lazy_plt->eh_frame_plt_size;
1301 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
1306 if (bfd_link_pic (info))
1308 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
1309 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
1313 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
1314 htab->plt.plt_entry = htab->lazy_plt->plt_entry;
1316 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
1317 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
1318 htab->plt.plt_got_insn_size
1319 = htab->lazy_plt->plt_got_insn_size;
1320 htab->plt.eh_frame_plt_size
1321 = htab->lazy_plt->eh_frame_plt_size;
1322 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
1325 /* Return if there are no normal input files. */
1329 if (htab->is_vxworks
1330 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1333 info->callbacks->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
1337 /* Since create_dynamic_sections isn't always called, but GOT
1338 relocations need GOT relocations, create them here so that we
1339 don't need to do it in check_relocs. */
1340 if (htab->elf.sgot == NULL
1341 && !_bfd_elf_create_got_section (dynobj, info))
1342 info->callbacks->einfo (_("%F: failed to create GOT sections\n"));
1344 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
1346 /* Align .got and .got.plt sections to their entry size. Do it here
1347 instead of in create_dynamic_sections so that they are always
1348 properly aligned even if create_dynamic_sections isn't called. */
1349 sec = htab->elf.sgot;
1350 if (!bfd_set_section_alignment (dynobj, sec, got_align))
1351 goto error_alignment;
1353 sec = htab->elf.sgotplt;
1354 if (!bfd_set_section_alignment (dynobj, sec, got_align))
1355 goto error_alignment;
1357 /* Create the ifunc sections here so that check_relocs can be
1359 if (!_bfd_elf_create_ifunc_sections (dynobj, info))
1360 info->callbacks->einfo (_("%F: failed to create ifunc sections\n"));
1362 plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
1366 /* Whe creating executable, set the contents of the .interp
1367 section to the interpreter. */
1368 if (bfd_link_executable (info) && !info->nointerp)
1370 asection *s = bfd_get_linker_section (dynobj, ".interp");
1373 s->size = htab->dynamic_interpreter_size;
1374 s->contents = (unsigned char *) htab->dynamic_interpreter;
1378 /* Don't change PLT section alignment for NaCl since it uses
1379 64-byte PLT entry and sets PLT section alignment to 32
1380 bytes. Don't create additional PLT sections for NaCl. */
1383 flagword pltflags = (bed->dynamic_sec_flags
1388 unsigned int non_lazy_plt_alignment
1389 = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
1392 if (!bfd_set_section_alignment (sec->owner, sec,
1394 goto error_alignment;
1396 /* Create the GOT procedure linkage table. */
1397 sec = bfd_make_section_anyway_with_flags (dynobj,
1401 info->callbacks->einfo (_("%F: failed to create GOT PLT section\n"));
1403 if (!bfd_set_section_alignment (dynobj, sec,
1404 non_lazy_plt_alignment))
1405 goto error_alignment;
1407 htab->plt_got = sec;
1415 /* Create the second PLT for Intel IBT support. IBT
1416 PLT is supported only for non-NaCl target and is
1417 is needed only for lazy binding. */
1418 sec = bfd_make_section_anyway_with_flags (dynobj,
1422 info->callbacks->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
1424 if (!bfd_set_section_alignment (dynobj, sec,
1426 goto error_alignment;
1428 else if (info->bndplt && ABI_64_P (dynobj))
1430 /* Create the second PLT for Intel MPX support. MPX
1431 PLT is supported only for non-NaCl target in 64-bit
1432 mode and is needed only for lazy binding. */
1433 sec = bfd_make_section_anyway_with_flags (dynobj,
1437 info->callbacks->einfo (_("%F: failed to create BND PLT section\n"));
1439 if (!bfd_set_section_alignment (dynobj, sec,
1440 non_lazy_plt_alignment))
1441 goto error_alignment;
1444 htab->plt_second = sec;
1448 if (!info->no_ld_generated_unwind_info)
1450 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1451 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1452 | SEC_LINKER_CREATED);
1454 sec = bfd_make_section_anyway_with_flags (dynobj,
1458 info->callbacks->einfo (_("%F: failed to create PLT .eh_frame section\n"));
1460 if (!bfd_set_section_alignment (dynobj, sec, class_align))
1461 goto error_alignment;
1463 htab->plt_eh_frame = sec;
1465 if (htab->plt_got != NULL)
1467 sec = bfd_make_section_anyway_with_flags (dynobj,
1471 info->callbacks->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
1473 if (!bfd_set_section_alignment (dynobj, sec, class_align))
1474 goto error_alignment;
1476 htab->plt_got_eh_frame = sec;
1479 if (htab->plt_second != NULL)
1481 sec = bfd_make_section_anyway_with_flags (dynobj,
1485 info->callbacks->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
1487 if (!bfd_set_section_alignment (dynobj, sec, class_align))
1488 goto error_alignment;
1490 htab->plt_second_eh_frame = sec;
1497 /* The .iplt section is used for IFUNC symbols in static
1499 sec = htab->elf.iplt;
1501 && !bfd_set_section_alignment (sec->owner, sec,
1503 goto error_alignment;