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
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
281 ret
->got_entry_size
= 8;
282 ret
->pointer_r_type
= R_X86_64_64
;
283 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
284 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
285 ret
->tls_get_addr
= "__tls_get_addr";
290 ret
->r_info
= elf32_r_info
;
291 ret
->r_sym
= elf32_r_sym
;
292 if (bed
->target_id
== X86_64_ELF_DATA
)
294 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
295 ret
->got_entry_size
= 8;
296 ret
->pointer_r_type
= R_X86_64_32
;
297 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
298 ret
->dynamic_interpreter_size
299 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
300 ret
->tls_get_addr
= "__tls_get_addr";
304 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
305 ret
->got_entry_size
= 4;
306 ret
->pointer_r_type
= R_386_32
;
307 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
308 ret
->dynamic_interpreter_size
309 = sizeof ELF32_DYNAMIC_INTERPRETER
;
310 ret
->tls_get_addr
= "___tls_get_addr";
313 ret
->target_id
= bed
->target_id
;
315 ret
->loc_hash_table
= htab_try_create (1024,
316 _bfd_x86_elf_local_htab_hash
,
317 _bfd_x86_elf_local_htab_eq
,
319 ret
->loc_hash_memory
= objalloc_create ();
320 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
322 elf_x86_link_hash_table_free (abfd
);
325 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
327 return &ret
->elf
.root
;
330 /* Sort relocs into address order. */
333 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
335 const arelent
*a
= * (const arelent
**) ap
;
336 const arelent
*b
= * (const arelent
**) bp
;
338 if (a
->address
> b
->address
)
340 else if (a
->address
< b
->address
)
347 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
349 if (!bfd_link_relocatable (info
))
351 /* Check for __tls_get_addr reference. */
352 struct elf_x86_link_hash_table
*htab
;
353 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
354 htab
= elf_x86_hash_table (info
, bed
->target_id
);
357 struct elf_link_hash_entry
*h
358 = elf_link_hash_lookup (elf_hash_table (info
),
360 FALSE
, FALSE
, FALSE
);
362 ((struct elf_x86_link_hash_entry
*) h
)->tls_get_addr
= 1;
366 /* Invoke the regular ELF backend linker to do all the work. */
367 return _bfd_elf_link_check_relocs (abfd
, info
);
371 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
372 struct bfd_link_info
*info
)
374 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
378 struct elf_link_hash_entry
*tlsbase
;
380 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
382 FALSE
, FALSE
, FALSE
);
384 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
386 struct elf_x86_link_hash_table
*htab
;
387 struct bfd_link_hash_entry
*bh
= NULL
;
388 const struct elf_backend_data
*bed
389 = get_elf_backend_data (output_bfd
);
391 htab
= elf_x86_hash_table (info
, bed
->target_id
);
395 if (!(_bfd_generic_link_add_one_symbol
396 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
397 tls_sec
, 0, NULL
, FALSE
,
401 htab
->tls_module_base
= bh
;
403 tlsbase
= (struct elf_link_hash_entry
*)bh
;
404 tlsbase
->def_regular
= 1;
405 tlsbase
->other
= STV_HIDDEN
;
406 tlsbase
->root
.linker_def
= 1;
407 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
415 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
416 const Elf_Internal_Sym
*isym
,
417 bfd_boolean definition
,
418 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
422 struct elf_x86_link_hash_entry
*eh
423 = (struct elf_x86_link_hash_entry
*) h
;
424 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
429 /* Copy the extra info we tack onto an elf_link_hash_entry. */
432 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
433 struct elf_link_hash_entry
*dir
,
434 struct elf_link_hash_entry
*ind
)
436 struct elf_x86_link_hash_entry
*edir
, *eind
;
438 edir
= (struct elf_x86_link_hash_entry
*) dir
;
439 eind
= (struct elf_x86_link_hash_entry
*) ind
;
441 if (eind
->dyn_relocs
!= NULL
)
443 if (edir
->dyn_relocs
!= NULL
)
445 struct elf_dyn_relocs
**pp
;
446 struct elf_dyn_relocs
*p
;
448 /* Add reloc counts against the indirect sym to the direct sym
449 list. Merge any entries against the same section. */
450 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
452 struct elf_dyn_relocs
*q
;
454 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
455 if (q
->sec
== p
->sec
)
457 q
->pc_count
+= p
->pc_count
;
458 q
->count
+= p
->count
;
465 *pp
= edir
->dyn_relocs
;
468 edir
->dyn_relocs
= eind
->dyn_relocs
;
469 eind
->dyn_relocs
= NULL
;
472 if (ind
->root
.type
== bfd_link_hash_indirect
473 && dir
->got
.refcount
<= 0)
475 edir
->tls_type
= eind
->tls_type
;
476 eind
->tls_type
= GOT_UNKNOWN
;
479 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
480 generate a R_386_COPY reloc. */
481 edir
->gotoff_ref
|= eind
->gotoff_ref
;
483 edir
->has_got_reloc
|= eind
->has_got_reloc
;
484 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
486 if (ELIMINATE_COPY_RELOCS
487 && ind
->root
.type
!= bfd_link_hash_indirect
488 && dir
->dynamic_adjusted
)
490 /* If called to transfer flags for a weakdef during processing
491 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
492 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
493 if (dir
->versioned
!= versioned_hidden
)
494 dir
->ref_dynamic
|= ind
->ref_dynamic
;
495 dir
->ref_regular
|= ind
->ref_regular
;
496 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
497 dir
->needs_plt
|= ind
->needs_plt
;
498 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
502 if (eind
->func_pointer_refcount
> 0)
504 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
505 eind
->func_pointer_refcount
= 0;
508 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
512 /* Remove undefined weak symbol from the dynamic symbol table if it
516 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
517 struct elf_link_hash_entry
*h
)
519 if (h
->dynindx
!= -1)
521 const struct elf_backend_data
*bed
522 = get_elf_backend_data (info
->output_bfd
);
523 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
525 elf_x86_hash_entry (h
)->has_got_reloc
,
526 elf_x86_hash_entry (h
)))
529 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
536 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
539 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
541 if (h
->plt
.offset
!= (bfd_vma
) -1
543 && !h
->pointer_equality_needed
)
546 return _bfd_elf_hash_symbol (h
);
549 /* Adjust a symbol defined by a dynamic object and referenced by a
550 regular object. The current definition is in some section of the
551 dynamic object, but we're not including those sections. We have to
552 change the definition to something the rest of the link can
556 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
557 struct elf_link_hash_entry
*h
)
559 struct elf_x86_link_hash_table
*htab
;
561 struct elf_x86_link_hash_entry
*eh
;
562 struct elf_dyn_relocs
*p
;
563 const struct elf_backend_data
*bed
564 = get_elf_backend_data (info
->output_bfd
);
566 /* STT_GNU_IFUNC symbol must go through PLT. */
567 if (h
->type
== STT_GNU_IFUNC
)
569 /* All local STT_GNU_IFUNC references must be treate as local
570 calls via local PLT. */
572 && SYMBOL_CALLS_LOCAL (info
, h
))
574 bfd_size_type pc_count
= 0, count
= 0;
575 struct elf_dyn_relocs
**pp
;
577 eh
= (struct elf_x86_link_hash_entry
*) h
;
578 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
580 pc_count
+= p
->pc_count
;
581 p
->count
-= p
->pc_count
;
590 if (pc_count
|| count
)
595 /* Increment PLT reference count only for PC-relative
598 if (h
->plt
.refcount
<= 0)
601 h
->plt
.refcount
+= 1;
606 if (h
->plt
.refcount
<= 0)
608 h
->plt
.offset
= (bfd_vma
) -1;
614 /* If this is a function, put it in the procedure linkage table. We
615 will fill in the contents of the procedure linkage table later,
616 when we know the address of the .got section. */
617 if (h
->type
== STT_FUNC
620 if (h
->plt
.refcount
<= 0
621 || SYMBOL_CALLS_LOCAL (info
, h
)
622 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
623 && h
->root
.type
== bfd_link_hash_undefweak
))
625 /* This case can occur if we saw a PLT32 reloc in an input
626 file, but the symbol was never referred to by a dynamic
627 object, or if all references were garbage collected. In
628 such a case, we don't actually need to build a procedure
629 linkage table, and we can just do a PC32 reloc instead. */
630 h
->plt
.offset
= (bfd_vma
) -1;
637 /* It's possible that we incorrectly decided a .plt reloc was needed
638 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
639 check_relocs. We can't decide accurately between function and
640 non-function syms in check-relocs; Objects loaded later in
641 the link may change h->type. So fix it now. */
642 h
->plt
.offset
= (bfd_vma
) -1;
644 eh
= (struct elf_x86_link_hash_entry
*) h
;
646 /* If this is a weak symbol, and there is a real definition, the
647 processor independent code will have arranged for us to see the
648 real definition first, and we can just use the same value. */
649 if (h
->u
.weakdef
!= NULL
)
651 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
652 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
653 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
654 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
655 if (ELIMINATE_COPY_RELOCS
657 || SYMBOL_NO_COPYRELOC (info
, eh
))
659 /* NB: needs_copy is always 0 for i386. */
660 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
661 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
666 /* This is a reference to a symbol defined by a dynamic object which
667 is not a function. */
669 /* If we are creating a shared library, we must presume that the
670 only references to the symbol are via the global offset table.
671 For such cases we need not do anything here; the relocations will
672 be handled correctly by relocate_section. */
673 if (!bfd_link_executable (info
))
676 /* If there are no references to this symbol that do not use the
677 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
678 reloc. NB: gotoff_ref is always 0 for x86-64. */
679 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
682 /* If -z nocopyreloc was given, we won't generate them either. */
683 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
689 htab
= elf_x86_hash_table (info
, bed
->target_id
);
693 /* If there aren't any dynamic relocs in read-only sections nor
694 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
695 avoid the copy reloc. This doesn't work on VxWorks, where we can
696 not have dynamic relocations (other than copy and jump slot
697 relocations) in an executable. */
698 if (ELIMINATE_COPY_RELOCS
699 && (bed
->target_id
== X86_64_ELF_DATA
701 && !htab
->is_vxworks
)))
703 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
705 s
= p
->sec
->output_section
;
706 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
710 /* If we didn't find any dynamic relocs in read-only sections,
711 then we'll be keeping the dynamic relocs and avoiding the copy
720 /* We must allocate the symbol in our .dynbss section, which will
721 become part of the .bss section of the executable. There will be
722 an entry for this symbol in the .dynsym section. The dynamic
723 object will contain position independent code, so all references
724 from the dynamic object to this symbol will go through the global
725 offset table. The dynamic linker will use the .dynsym entry to
726 determine the address it must put in the global offset table, so
727 both the dynamic object and the regular object will refer to the
728 same memory location for the variable. */
730 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
731 dynamic linker to copy the initial value out of the dynamic object
732 and into the runtime process image. */
733 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
735 s
= htab
->elf
.sdynrelro
;
736 srel
= htab
->elf
.sreldynrelro
;
740 s
= htab
->elf
.sdynbss
;
741 srel
= htab
->elf
.srelbss
;
743 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
745 srel
->size
+= htab
->sizeof_reloc
;
749 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
752 /* Return the section that should be marked against GC for a given
756 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
757 struct bfd_link_info
*info
,
758 Elf_Internal_Rela
*rel
,
759 struct elf_link_hash_entry
*h
,
760 Elf_Internal_Sym
*sym
)
762 /* Compiler should optimize this out. */
763 if (((unsigned int) R_X86_64_GNU_VTINHERIT
764 != (unsigned int) R_386_GNU_VTINHERIT
)
765 || ((unsigned int) R_X86_64_GNU_VTENTRY
766 != (unsigned int) R_386_GNU_VTENTRY
))
770 switch (ELF32_R_TYPE (rel
->r_info
))
772 case R_X86_64_GNU_VTINHERIT
:
773 case R_X86_64_GNU_VTENTRY
:
777 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
781 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
783 bfd_vma offset ATTRIBUTE_UNUSED
,
786 return got_addr
+ off
;
790 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
793 bfd_vma got_addr ATTRIBUTE_UNUSED
)
795 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
799 elf_i386_valid_plt_reloc_p (unsigned int type
)
801 return (type
== R_386_JUMP_SLOT
802 || type
== R_386_GLOB_DAT
803 || type
== R_386_IRELATIVE
);
807 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
809 return (type
== R_X86_64_JUMP_SLOT
810 || type
== R_X86_64_GLOB_DAT
811 || type
== R_X86_64_IRELATIVE
);
815 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
819 struct elf_x86_plt plts
[],
823 long size
, i
, n
, len
;
825 unsigned int plt_got_offset
, plt_entry_size
;
827 bfd_byte
*plt_contents
;
829 arelent
**dynrelbuf
, *p
;
831 const struct elf_backend_data
*bed
;
832 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
834 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
839 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
840 if (dynrelbuf
== NULL
)
843 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
846 /* Sort the relocs by address. */
847 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
848 _bfd_x86_elf_compare_relocs
);
850 size
= count
* sizeof (asymbol
);
852 /* Allocate space for @plt suffixes. */
854 for (i
= 0; i
< dynrelcount
; i
++)
857 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
859 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
862 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
866 bed
= get_elf_backend_data (abfd
);
868 if (bed
->target_id
== X86_64_ELF_DATA
)
870 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
871 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
875 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
876 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
879 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
881 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
886 sec
= bfd_get_section_by_name (abfd
, ".got");
891 if (got_addr
== (bfd_vma
) -1)
896 /* Check for each PLT section. */
897 names
= (char *) (s
+ count
);
900 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
901 if ((plt_contents
= plts
[j
].contents
) != NULL
)
906 struct elf_x86_plt
*plt_p
= &plts
[j
];
908 plt_got_offset
= plt_p
->plt_got_offset
;
909 plt_entry_size
= plt_p
->plt_entry_size
;
913 if ((plt_p
->type
& plt_lazy
))
915 /* Skip PLT0 in lazy PLT. */
917 offset
= plt_entry_size
;
925 /* Check each PLT entry against dynamic relocations. */
926 for (; k
< plt_p
->count
; k
++)
932 /* Get the GOT offset for i386 or the PC-relative offset
933 for x86-64, a signed 32-bit integer. */
934 off
= H_GET_32 (abfd
, (plt_contents
+ offset
936 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
942 while ((min
+ 1) < max
)
946 mid
= (min
+ max
) / 2;
948 if (got_vma
> r
->address
)
950 else if (got_vma
< r
->address
)
959 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
960 if (got_vma
== p
->address
962 && valid_plt_reloc_p (p
->howto
->type
))
964 *s
= **p
->sym_ptr_ptr
;
965 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
966 set. Since we are defining a symbol, ensure one
968 if ((s
->flags
& BSF_LOCAL
) == 0)
969 s
->flags
|= BSF_GLOBAL
;
970 s
->flags
|= BSF_SYNTHETIC
;
971 /* This is no longer a section symbol. */
972 s
->flags
&= ~BSF_SECTION_SYM
;
974 s
->the_bfd
= plt
->owner
;
978 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
979 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
985 memcpy (names
, "+0x", sizeof ("+0x") - 1);
986 names
+= sizeof ("+0x") - 1;
987 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
988 for (a
= buf
; *a
== '0'; ++a
)
991 memcpy (names
, a
, size
);
994 memcpy (names
, "@plt", sizeof ("@plt"));
995 names
+= sizeof ("@plt");
999 offset
+= plt_entry_size
;
1003 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
1012 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1013 if (plts
[j
].contents
!= NULL
)
1014 free (plts
[j
].contents
);
1021 /* Parse x86 GNU properties. */
1023 enum elf_property_kind
1024 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
1025 bfd_byte
*ptr
, unsigned int datasz
)
1031 case GNU_PROPERTY_X86_ISA_1_USED
:
1032 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
1033 case GNU_PROPERTY_X86_FEATURE_1_AND
:
1037 ((type
== GNU_PROPERTY_X86_ISA_1_USED
1038 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
1039 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
1040 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
1041 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
1043 return property_corrupt
;
1045 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
1046 /* Combine properties of the same type. */
1047 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
1048 prop
->pr_kind
= property_number
;
1052 return property_ignored
;
1055 return property_number
;
1058 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
1059 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
1060 should be merged with ABFD. */
1063 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
1064 bfd
*abfd ATTRIBUTE_UNUSED
,
1065 elf_property
*aprop
,
1066 elf_property
*bprop
)
1068 unsigned int number
, features
;
1069 bfd_boolean updated
= FALSE
;
1070 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
1074 case GNU_PROPERTY_X86_ISA_1_USED
:
1075 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
1076 if (aprop
!= NULL
&& bprop
!= NULL
)
1078 number
= aprop
->u
.number
;
1079 aprop
->u
.number
= number
| bprop
->u
.number
;
1080 updated
= number
!= (unsigned int) aprop
->u
.number
;
1084 /* Return TRUE if APROP is NULL to indicate that BPROP should
1085 be added to ABFD. */
1086 updated
= aprop
== NULL
;
1090 case GNU_PROPERTY_X86_FEATURE_1_AND
:
1091 /* Only one of APROP and BPROP can be NULL:
1092 1. APROP & BPROP when both APROP and BPROP aren't NULL.
1093 2. If APROP is NULL, remove x86 feature.
1094 3. Otherwise, do nothing.
1096 if (aprop
!= NULL
&& bprop
!= NULL
)
1100 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1102 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1103 number
= aprop
->u
.number
;
1104 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1105 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1106 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
1107 updated
= number
!= (unsigned int) aprop
->u
.number
;
1108 /* Remove the property if all feature bits are cleared. */
1109 if (aprop
->u
.number
== 0)
1110 aprop
->pr_kind
= property_remove
;
1116 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1118 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1121 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1122 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1125 number
= aprop
->u
.number
;
1126 aprop
->u
.number
= number
| features
;
1127 updated
= number
!= (unsigned int) aprop
->u
.number
;
1131 bprop
->u
.number
|= features
;
1135 else if (aprop
!= NULL
)
1137 aprop
->pr_kind
= property_remove
;
1144 /* Never should happen. */
1151 /* Set up x86 GNU properties. Return the first relocatable ELF input
1152 with GNU properties if found. Otherwise, return NULL. */
1155 _bfd_x86_elf_link_setup_gnu_properties
1156 (struct bfd_link_info
*info
,
1157 struct elf_x86_plt_layout_table
*plt_layout
)
1159 bfd_boolean normal_target
;
1160 bfd_boolean lazy_plt
;
1161 asection
*sec
, *pltsec
;
1163 bfd_boolean use_ibt_plt
;
1164 unsigned int plt_alignment
, features
;
1165 struct elf_x86_link_hash_table
*htab
;
1169 const struct elf_backend_data
*bed
;
1170 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
1171 unsigned int got_align
;
1175 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1177 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1179 /* Find a normal input file with GNU property note. */
1180 for (pbfd
= info
->input_bfds
;
1182 pbfd
= pbfd
->link
.next
)
1183 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
1184 && bfd_count_sections (pbfd
) != 0)
1188 if (elf_properties (pbfd
) != NULL
)
1192 if (ebfd
!= NULL
&& features
)
1194 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
1195 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1196 prop
= _bfd_elf_get_property (ebfd
,
1197 GNU_PROPERTY_X86_FEATURE_1_AND
,
1199 prop
->u
.number
|= features
;
1200 prop
->pr_kind
= property_number
;
1202 /* Create the GNU property note section if needed. */
1205 sec
= bfd_make_section_with_flags (ebfd
,
1206 NOTE_GNU_PROPERTY_SECTION_NAME
,
1214 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
1216 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
1219 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
1223 elf_section_type (sec
) = SHT_NOTE
;
1227 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
1229 if (bfd_link_relocatable (info
))
1232 bed
= get_elf_backend_data (info
->output_bfd
);
1234 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1238 htab
->is_vxworks
= plt_layout
->is_vxworks
;
1240 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
1241 if (!use_ibt_plt
&& pbfd
!= NULL
)
1243 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
1244 elf_property_list
*p
;
1246 /* The property list is sorted in order of type. */
1247 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
1249 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
1251 use_ibt_plt
= !!(p
->property
.u
.number
1252 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
1255 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
1260 dynobj
= htab
->elf
.dynobj
;
1262 /* Set htab->elf.dynobj here so that there is no need to check and
1263 set it in check_relocs. */
1268 htab
->elf
.dynobj
= pbfd
;
1275 /* Find a normal input file to hold linker created
1277 for (abfd
= info
->input_bfds
;
1279 abfd
= abfd
->link
.next
)
1280 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1282 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
1284 htab
->elf
.dynobj
= abfd
;
1291 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
1292 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
1293 canonical function address. */
1294 htab
->plt
.has_plt0
= 1;
1295 normal_target
= plt_layout
->normal_target
;
1301 htab
->lazy_plt
= plt_layout
->lazy_ibt_plt
;
1302 htab
->non_lazy_plt
= plt_layout
->non_lazy_ibt_plt
;
1306 htab
->lazy_plt
= plt_layout
->lazy_plt
;
1307 htab
->non_lazy_plt
= plt_layout
->non_lazy_plt
;
1312 htab
->lazy_plt
= plt_layout
->lazy_plt
;
1313 htab
->non_lazy_plt
= NULL
;
1316 pltsec
= htab
->elf
.splt
;
1318 /* If the non-lazy PLT is available, use it for all PLT entries if
1319 there are no PLT0 or no .plt section. */
1320 if (htab
->non_lazy_plt
!= NULL
1321 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
1324 if (bfd_link_pic (info
))
1325 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
1327 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
1328 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
1329 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
1330 htab
->plt
.plt_got_insn_size
1331 = htab
->non_lazy_plt
->plt_got_insn_size
;
1332 htab
->plt
.eh_frame_plt_size
1333 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1334 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
1339 if (bfd_link_pic (info
))
1341 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
1342 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
1346 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
1347 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
1349 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
1350 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
1351 htab
->plt
.plt_got_insn_size
1352 = htab
->lazy_plt
->plt_got_insn_size
;
1353 htab
->plt
.eh_frame_plt_size
1354 = htab
->lazy_plt
->eh_frame_plt_size
;
1355 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
1358 /* Return if there are no normal input files. */
1362 if (htab
->is_vxworks
1363 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1366 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
1370 /* Since create_dynamic_sections isn't always called, but GOT
1371 relocations need GOT relocations, create them here so that we
1372 don't need to do it in check_relocs. */
1373 if (htab
->elf
.sgot
== NULL
1374 && !_bfd_elf_create_got_section (dynobj
, info
))
1375 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
1377 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
1379 /* Align .got and .got.plt sections to their entry size. Do it here
1380 instead of in create_dynamic_sections so that they are always
1381 properly aligned even if create_dynamic_sections isn't called. */
1382 sec
= htab
->elf
.sgot
;
1383 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
1384 goto error_alignment
;
1386 sec
= htab
->elf
.sgotplt
;
1387 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
1388 goto error_alignment
;
1390 /* Create the ifunc sections here so that check_relocs can be
1392 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
1393 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
1395 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
1399 /* Whe creating executable, set the contents of the .interp
1400 section to the interpreter. */
1401 if (bfd_link_executable (info
) && !info
->nointerp
)
1403 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1406 s
->size
= htab
->dynamic_interpreter_size
;
1407 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1411 /* Don't change PLT section alignment for NaCl since it uses
1412 64-byte PLT entry and sets PLT section alignment to 32
1413 bytes. Don't create additional PLT sections for NaCl. */
1416 flagword pltflags
= (bed
->dynamic_sec_flags
1421 unsigned int non_lazy_plt_alignment
1422 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
1425 if (!bfd_set_section_alignment (sec
->owner
, sec
,
1427 goto error_alignment
;
1429 /* Create the GOT procedure linkage table. */
1430 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1434 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
1436 if (!bfd_set_section_alignment (dynobj
, sec
,
1437 non_lazy_plt_alignment
))
1438 goto error_alignment
;
1440 htab
->plt_got
= sec
;
1448 /* Create the second PLT for Intel IBT support. IBT
1449 PLT is supported only for non-NaCl target and is
1450 is needed only for lazy binding. */
1451 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1455 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
1457 if (!bfd_set_section_alignment (dynobj
, sec
,
1459 goto error_alignment
;
1461 else if (info
->bndplt
&& ABI_64_P (dynobj
))
1463 /* Create the second PLT for Intel MPX support. MPX
1464 PLT is supported only for non-NaCl target in 64-bit
1465 mode and is needed only for lazy binding. */
1466 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1470 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
1472 if (!bfd_set_section_alignment (dynobj
, sec
,
1473 non_lazy_plt_alignment
))
1474 goto error_alignment
;
1477 htab
->plt_second
= sec
;
1481 if (!info
->no_ld_generated_unwind_info
)
1483 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1484 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1485 | SEC_LINKER_CREATED
);
1487 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1491 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
1493 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1494 goto error_alignment
;
1496 htab
->plt_eh_frame
= sec
;
1498 if (htab
->plt_got
!= NULL
)
1500 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1504 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
1506 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1507 goto error_alignment
;
1509 htab
->plt_got_eh_frame
= sec
;
1512 if (htab
->plt_second
!= NULL
)
1514 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1518 info
->callbacks
->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
1520 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1521 goto error_alignment
;
1523 htab
->plt_second_eh_frame
= sec
;
1530 /* The .iplt section is used for IFUNC symbols in static
1532 sec
= htab
->elf
.iplt
;
1534 && !bfd_set_section_alignment (sec
->owner
, sec
,
1536 goto error_alignment
;