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";
314 ret
->loc_hash_table
= htab_try_create (1024,
315 _bfd_x86_elf_local_htab_hash
,
316 _bfd_x86_elf_local_htab_eq
,
318 ret
->loc_hash_memory
= objalloc_create ();
319 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
321 elf_x86_link_hash_table_free (abfd
);
324 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
326 return &ret
->elf
.root
;
329 /* Sort relocs into address order. */
332 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
334 const arelent
*a
= * (const arelent
**) ap
;
335 const arelent
*b
= * (const arelent
**) bp
;
337 if (a
->address
> b
->address
)
339 else if (a
->address
< b
->address
)
346 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
348 if (!bfd_link_relocatable (info
))
350 /* Check for __tls_get_addr reference. */
351 struct elf_x86_link_hash_table
*htab
;
352 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
353 htab
= elf_x86_hash_table (info
, bed
->target_id
);
356 struct elf_link_hash_entry
*h
357 = elf_link_hash_lookup (elf_hash_table (info
),
359 FALSE
, FALSE
, FALSE
);
361 ((struct elf_x86_link_hash_entry
*) h
)->tls_get_addr
= 1;
365 /* Invoke the regular ELF backend linker to do all the work. */
366 return _bfd_elf_link_check_relocs (abfd
, info
);
370 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
371 struct bfd_link_info
*info
)
373 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
377 struct elf_link_hash_entry
*tlsbase
;
379 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
381 FALSE
, FALSE
, FALSE
);
383 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
385 struct elf_x86_link_hash_table
*htab
;
386 struct bfd_link_hash_entry
*bh
= NULL
;
387 const struct elf_backend_data
*bed
388 = get_elf_backend_data (output_bfd
);
390 htab
= elf_x86_hash_table (info
, bed
->target_id
);
394 if (!(_bfd_generic_link_add_one_symbol
395 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
396 tls_sec
, 0, NULL
, FALSE
,
400 htab
->tls_module_base
= bh
;
402 tlsbase
= (struct elf_link_hash_entry
*)bh
;
403 tlsbase
->def_regular
= 1;
404 tlsbase
->other
= STV_HIDDEN
;
405 tlsbase
->root
.linker_def
= 1;
406 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
414 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
415 const Elf_Internal_Sym
*isym
,
416 bfd_boolean definition
,
417 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
421 struct elf_x86_link_hash_entry
*eh
422 = (struct elf_x86_link_hash_entry
*) h
;
423 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
428 /* Copy the extra info we tack onto an elf_link_hash_entry. */
431 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
432 struct elf_link_hash_entry
*dir
,
433 struct elf_link_hash_entry
*ind
)
435 struct elf_x86_link_hash_entry
*edir
, *eind
;
437 edir
= (struct elf_x86_link_hash_entry
*) dir
;
438 eind
= (struct elf_x86_link_hash_entry
*) ind
;
440 if (eind
->dyn_relocs
!= NULL
)
442 if (edir
->dyn_relocs
!= NULL
)
444 struct elf_dyn_relocs
**pp
;
445 struct elf_dyn_relocs
*p
;
447 /* Add reloc counts against the indirect sym to the direct sym
448 list. Merge any entries against the same section. */
449 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
451 struct elf_dyn_relocs
*q
;
453 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
454 if (q
->sec
== p
->sec
)
456 q
->pc_count
+= p
->pc_count
;
457 q
->count
+= p
->count
;
464 *pp
= edir
->dyn_relocs
;
467 edir
->dyn_relocs
= eind
->dyn_relocs
;
468 eind
->dyn_relocs
= NULL
;
471 if (ind
->root
.type
== bfd_link_hash_indirect
472 && dir
->got
.refcount
<= 0)
474 edir
->tls_type
= eind
->tls_type
;
475 eind
->tls_type
= GOT_UNKNOWN
;
478 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
479 generate a R_386_COPY reloc. */
480 edir
->gotoff_ref
|= eind
->gotoff_ref
;
482 edir
->has_got_reloc
|= eind
->has_got_reloc
;
483 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
485 if (ELIMINATE_COPY_RELOCS
486 && ind
->root
.type
!= bfd_link_hash_indirect
487 && dir
->dynamic_adjusted
)
489 /* If called to transfer flags for a weakdef during processing
490 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
491 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
492 if (dir
->versioned
!= versioned_hidden
)
493 dir
->ref_dynamic
|= ind
->ref_dynamic
;
494 dir
->ref_regular
|= ind
->ref_regular
;
495 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
496 dir
->needs_plt
|= ind
->needs_plt
;
497 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
501 if (eind
->func_pointer_refcount
> 0)
503 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
504 eind
->func_pointer_refcount
= 0;
507 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
511 /* Remove undefined weak symbol from the dynamic symbol table if it
515 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
516 struct elf_link_hash_entry
*h
)
518 if (h
->dynindx
!= -1)
520 const struct elf_backend_data
*bed
521 = get_elf_backend_data (info
->output_bfd
);
522 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
524 elf_x86_hash_entry (h
)->has_got_reloc
,
525 elf_x86_hash_entry (h
)))
528 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
535 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
538 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
540 if (h
->plt
.offset
!= (bfd_vma
) -1
542 && !h
->pointer_equality_needed
)
545 return _bfd_elf_hash_symbol (h
);
548 /* Adjust a symbol defined by a dynamic object and referenced by a
549 regular object. The current definition is in some section of the
550 dynamic object, but we're not including those sections. We have to
551 change the definition to something the rest of the link can
555 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
556 struct elf_link_hash_entry
*h
)
558 struct elf_x86_link_hash_table
*htab
;
560 struct elf_x86_link_hash_entry
*eh
;
561 struct elf_dyn_relocs
*p
;
562 const struct elf_backend_data
*bed
563 = get_elf_backend_data (info
->output_bfd
);
565 /* STT_GNU_IFUNC symbol must go through PLT. */
566 if (h
->type
== STT_GNU_IFUNC
)
568 /* All local STT_GNU_IFUNC references must be treate as local
569 calls via local PLT. */
571 && SYMBOL_CALLS_LOCAL (info
, h
))
573 bfd_size_type pc_count
= 0, count
= 0;
574 struct elf_dyn_relocs
**pp
;
576 eh
= (struct elf_x86_link_hash_entry
*) h
;
577 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
579 pc_count
+= p
->pc_count
;
580 p
->count
-= p
->pc_count
;
589 if (pc_count
|| count
)
594 /* Increment PLT reference count only for PC-relative
597 if (h
->plt
.refcount
<= 0)
600 h
->plt
.refcount
+= 1;
605 if (h
->plt
.refcount
<= 0)
607 h
->plt
.offset
= (bfd_vma
) -1;
613 /* If this is a function, put it in the procedure linkage table. We
614 will fill in the contents of the procedure linkage table later,
615 when we know the address of the .got section. */
616 if (h
->type
== STT_FUNC
619 if (h
->plt
.refcount
<= 0
620 || SYMBOL_CALLS_LOCAL (info
, h
)
621 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
622 && h
->root
.type
== bfd_link_hash_undefweak
))
624 /* This case can occur if we saw a PLT32 reloc in an input
625 file, but the symbol was never referred to by a dynamic
626 object, or if all references were garbage collected. In
627 such a case, we don't actually need to build a procedure
628 linkage table, and we can just do a PC32 reloc instead. */
629 h
->plt
.offset
= (bfd_vma
) -1;
636 /* It's possible that we incorrectly decided a .plt reloc was needed
637 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
638 check_relocs. We can't decide accurately between function and
639 non-function syms in check-relocs; Objects loaded later in
640 the link may change h->type. So fix it now. */
641 h
->plt
.offset
= (bfd_vma
) -1;
643 eh
= (struct elf_x86_link_hash_entry
*) h
;
645 /* If this is a weak symbol, and there is a real definition, the
646 processor independent code will have arranged for us to see the
647 real definition first, and we can just use the same value. */
648 if (h
->u
.weakdef
!= NULL
)
650 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
651 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
652 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
653 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
654 if (ELIMINATE_COPY_RELOCS
656 || SYMBOL_NO_COPYRELOC (info
, eh
))
658 /* NB: needs_copy is always 0 for i386. */
659 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
660 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
665 /* This is a reference to a symbol defined by a dynamic object which
666 is not a function. */
668 /* If we are creating a shared library, we must presume that the
669 only references to the symbol are via the global offset table.
670 For such cases we need not do anything here; the relocations will
671 be handled correctly by relocate_section. */
672 if (!bfd_link_executable (info
))
675 /* If there are no references to this symbol that do not use the
676 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
677 reloc. NB: gotoff_ref is always 0 for x86-64. */
678 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
681 /* If -z nocopyreloc was given, we won't generate them either. */
682 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
688 htab
= elf_x86_hash_table (info
, bed
->target_id
);
692 /* If there aren't any dynamic relocs in read-only sections nor
693 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
694 avoid the copy reloc. This doesn't work on VxWorks, where we can
695 not have dynamic relocations (other than copy and jump slot
696 relocations) in an executable. */
697 if (ELIMINATE_COPY_RELOCS
698 && (bed
->target_id
== X86_64_ELF_DATA
700 && !htab
->is_vxworks
)))
702 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
704 s
= p
->sec
->output_section
;
705 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
709 /* If we didn't find any dynamic relocs in read-only sections,
710 then we'll be keeping the dynamic relocs and avoiding the copy
719 /* We must allocate the symbol in our .dynbss section, which will
720 become part of the .bss section of the executable. There will be
721 an entry for this symbol in the .dynsym section. The dynamic
722 object will contain position independent code, so all references
723 from the dynamic object to this symbol will go through the global
724 offset table. The dynamic linker will use the .dynsym entry to
725 determine the address it must put in the global offset table, so
726 both the dynamic object and the regular object will refer to the
727 same memory location for the variable. */
729 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
730 dynamic linker to copy the initial value out of the dynamic object
731 and into the runtime process image. */
732 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
734 s
= htab
->elf
.sdynrelro
;
735 srel
= htab
->elf
.sreldynrelro
;
739 s
= htab
->elf
.sdynbss
;
740 srel
= htab
->elf
.srelbss
;
742 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
744 srel
->size
+= htab
->sizeof_reloc
;
748 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
751 /* Return the section that should be marked against GC for a given
755 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
756 struct bfd_link_info
*info
,
757 Elf_Internal_Rela
*rel
,
758 struct elf_link_hash_entry
*h
,
759 Elf_Internal_Sym
*sym
)
761 /* Compiler should optimize this out. */
762 if (((unsigned int) R_X86_64_GNU_VTINHERIT
763 != (unsigned int) R_386_GNU_VTINHERIT
)
764 || ((unsigned int) R_X86_64_GNU_VTENTRY
765 != (unsigned int) R_386_GNU_VTENTRY
))
769 switch (ELF32_R_TYPE (rel
->r_info
))
771 case R_X86_64_GNU_VTINHERIT
:
772 case R_X86_64_GNU_VTENTRY
:
776 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
780 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
782 bfd_vma offset ATTRIBUTE_UNUSED
,
785 return got_addr
+ off
;
789 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
792 bfd_vma got_addr ATTRIBUTE_UNUSED
)
794 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
798 elf_i386_valid_plt_reloc_p (unsigned int type
)
800 return (type
== R_386_JUMP_SLOT
801 || type
== R_386_GLOB_DAT
802 || type
== R_386_IRELATIVE
);
806 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
808 return (type
== R_X86_64_JUMP_SLOT
809 || type
== R_X86_64_GLOB_DAT
810 || type
== R_X86_64_IRELATIVE
);
814 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
818 struct elf_x86_plt plts
[],
822 long size
, i
, n
, len
;
824 unsigned int plt_got_offset
, plt_entry_size
;
826 bfd_byte
*plt_contents
;
828 arelent
**dynrelbuf
, *p
;
830 const struct elf_backend_data
*bed
;
831 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
833 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
838 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
839 if (dynrelbuf
== NULL
)
842 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
845 /* Sort the relocs by address. */
846 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
847 _bfd_x86_elf_compare_relocs
);
849 size
= count
* sizeof (asymbol
);
851 /* Allocate space for @plt suffixes. */
853 for (i
= 0; i
< dynrelcount
; i
++)
856 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
858 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
861 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
865 bed
= get_elf_backend_data (abfd
);
867 if (bed
->target_id
== X86_64_ELF_DATA
)
869 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
870 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
874 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
875 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
878 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
880 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
885 sec
= bfd_get_section_by_name (abfd
, ".got");
890 if (got_addr
== (bfd_vma
) -1)
895 /* Check for each PLT section. */
896 names
= (char *) (s
+ count
);
899 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
900 if ((plt_contents
= plts
[j
].contents
) != NULL
)
905 struct elf_x86_plt
*plt_p
= &plts
[j
];
907 plt_got_offset
= plt_p
->plt_got_offset
;
908 plt_entry_size
= plt_p
->plt_entry_size
;
912 if ((plt_p
->type
& plt_lazy
))
914 /* Skip PLT0 in lazy PLT. */
916 offset
= plt_entry_size
;
924 /* Check each PLT entry against dynamic relocations. */
925 for (; k
< plt_p
->count
; k
++)
931 /* Get the GOT offset for i386 or the PC-relative offset
932 for x86-64, a signed 32-bit integer. */
933 off
= H_GET_32 (abfd
, (plt_contents
+ offset
935 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
941 while ((min
+ 1) < max
)
945 mid
= (min
+ max
) / 2;
947 if (got_vma
> r
->address
)
949 else if (got_vma
< r
->address
)
958 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
959 if (got_vma
== p
->address
961 && valid_plt_reloc_p (p
->howto
->type
))
963 *s
= **p
->sym_ptr_ptr
;
964 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
965 set. Since we are defining a symbol, ensure one
967 if ((s
->flags
& BSF_LOCAL
) == 0)
968 s
->flags
|= BSF_GLOBAL
;
969 s
->flags
|= BSF_SYNTHETIC
;
970 /* This is no longer a section symbol. */
971 s
->flags
&= ~BSF_SECTION_SYM
;
973 s
->the_bfd
= plt
->owner
;
977 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
978 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
984 memcpy (names
, "+0x", sizeof ("+0x") - 1);
985 names
+= sizeof ("+0x") - 1;
986 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
987 for (a
= buf
; *a
== '0'; ++a
)
990 memcpy (names
, a
, size
);
993 memcpy (names
, "@plt", sizeof ("@plt"));
994 names
+= sizeof ("@plt");
998 offset
+= plt_entry_size
;
1002 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
1011 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1012 if (plts
[j
].contents
!= NULL
)
1013 free (plts
[j
].contents
);
1020 /* Parse x86 GNU properties. */
1022 enum elf_property_kind
1023 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
1024 bfd_byte
*ptr
, unsigned int datasz
)
1030 case GNU_PROPERTY_X86_ISA_1_USED
:
1031 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
1032 case GNU_PROPERTY_X86_FEATURE_1_AND
:
1036 ((type
== GNU_PROPERTY_X86_ISA_1_USED
1037 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
1038 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
1039 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
1040 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
1042 return property_corrupt
;
1044 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
1045 /* Combine properties of the same type. */
1046 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
1047 prop
->pr_kind
= property_number
;
1051 return property_ignored
;
1054 return property_number
;
1057 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
1058 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
1059 should be merged with ABFD. */
1062 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
1063 bfd
*abfd ATTRIBUTE_UNUSED
,
1064 elf_property
*aprop
,
1065 elf_property
*bprop
)
1067 unsigned int number
, features
;
1068 bfd_boolean updated
= FALSE
;
1069 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
1073 case GNU_PROPERTY_X86_ISA_1_USED
:
1074 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
1075 if (aprop
!= NULL
&& bprop
!= NULL
)
1077 number
= aprop
->u
.number
;
1078 aprop
->u
.number
= number
| bprop
->u
.number
;
1079 updated
= number
!= (unsigned int) aprop
->u
.number
;
1083 /* Return TRUE if APROP is NULL to indicate that BPROP should
1084 be added to ABFD. */
1085 updated
= aprop
== NULL
;
1089 case GNU_PROPERTY_X86_FEATURE_1_AND
:
1090 /* Only one of APROP and BPROP can be NULL:
1091 1. APROP & BPROP when both APROP and BPROP aren't NULL.
1092 2. If APROP is NULL, remove x86 feature.
1093 3. Otherwise, do nothing.
1095 if (aprop
!= NULL
&& bprop
!= NULL
)
1099 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1101 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1102 number
= aprop
->u
.number
;
1103 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1104 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1105 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
1106 updated
= number
!= (unsigned int) aprop
->u
.number
;
1107 /* Remove the property if all feature bits are cleared. */
1108 if (aprop
->u
.number
== 0)
1109 aprop
->pr_kind
= property_remove
;
1115 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1117 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1120 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1121 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1124 number
= aprop
->u
.number
;
1125 aprop
->u
.number
= number
| features
;
1126 updated
= number
!= (unsigned int) aprop
->u
.number
;
1130 bprop
->u
.number
|= features
;
1134 else if (aprop
!= NULL
)
1136 aprop
->pr_kind
= property_remove
;
1143 /* Never should happen. */
1150 /* Set up x86 GNU properties. Return the first relocatable ELF input
1151 with GNU properties if found. Otherwise, return NULL. */
1154 _bfd_x86_elf_link_setup_gnu_properties
1155 (struct bfd_link_info
*info
,
1156 struct elf_x86_plt_layout_table
*plt_layout
)
1158 bfd_boolean normal_target
;
1159 bfd_boolean lazy_plt
;
1160 asection
*sec
, *pltsec
;
1162 bfd_boolean use_ibt_plt
;
1163 unsigned int plt_alignment
, features
;
1164 struct elf_x86_link_hash_table
*htab
;
1168 const struct elf_backend_data
*bed
;
1169 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
1170 unsigned int got_align
;
1174 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1176 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1178 /* Find a normal input file with GNU property note. */
1179 for (pbfd
= info
->input_bfds
;
1181 pbfd
= pbfd
->link
.next
)
1182 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
1183 && bfd_count_sections (pbfd
) != 0)
1187 if (elf_properties (pbfd
) != NULL
)
1191 if (ebfd
!= NULL
&& features
)
1193 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
1194 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1195 prop
= _bfd_elf_get_property (ebfd
,
1196 GNU_PROPERTY_X86_FEATURE_1_AND
,
1198 prop
->u
.number
|= features
;
1199 prop
->pr_kind
= property_number
;
1201 /* Create the GNU property note section if needed. */
1204 sec
= bfd_make_section_with_flags (ebfd
,
1205 NOTE_GNU_PROPERTY_SECTION_NAME
,
1213 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
1215 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
1218 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
1222 elf_section_type (sec
) = SHT_NOTE
;
1226 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
1228 if (bfd_link_relocatable (info
))
1231 bed
= get_elf_backend_data (info
->output_bfd
);
1233 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1237 htab
->is_vxworks
= plt_layout
->is_vxworks
;
1239 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
1240 if (!use_ibt_plt
&& pbfd
!= NULL
)
1242 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
1243 elf_property_list
*p
;
1245 /* The property list is sorted in order of type. */
1246 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
1248 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
1250 use_ibt_plt
= !!(p
->property
.u
.number
1251 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
1254 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
1259 dynobj
= htab
->elf
.dynobj
;
1261 /* Set htab->elf.dynobj here so that there is no need to check and
1262 set it in check_relocs. */
1267 htab
->elf
.dynobj
= pbfd
;
1274 /* Find a normal input file to hold linker created
1276 for (abfd
= info
->input_bfds
;
1278 abfd
= abfd
->link
.next
)
1279 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1281 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
1283 htab
->elf
.dynobj
= abfd
;
1290 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
1291 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
1292 canonical function address. */
1293 htab
->plt
.has_plt0
= 1;
1294 normal_target
= plt_layout
->normal_target
;
1300 htab
->lazy_plt
= plt_layout
->lazy_ibt_plt
;
1301 htab
->non_lazy_plt
= plt_layout
->non_lazy_ibt_plt
;
1305 htab
->lazy_plt
= plt_layout
->lazy_plt
;
1306 htab
->non_lazy_plt
= plt_layout
->non_lazy_plt
;
1311 htab
->lazy_plt
= plt_layout
->lazy_plt
;
1312 htab
->non_lazy_plt
= NULL
;
1315 pltsec
= htab
->elf
.splt
;
1317 /* If the non-lazy PLT is available, use it for all PLT entries if
1318 there are no PLT0 or no .plt section. */
1319 if (htab
->non_lazy_plt
!= NULL
1320 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
1323 if (bfd_link_pic (info
))
1324 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
1326 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
1327 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
1328 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
1329 htab
->plt
.plt_got_insn_size
1330 = htab
->non_lazy_plt
->plt_got_insn_size
;
1331 htab
->plt
.eh_frame_plt_size
1332 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1333 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
1338 if (bfd_link_pic (info
))
1340 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
1341 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
1345 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
1346 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
1348 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
1349 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
1350 htab
->plt
.plt_got_insn_size
1351 = htab
->lazy_plt
->plt_got_insn_size
;
1352 htab
->plt
.eh_frame_plt_size
1353 = htab
->lazy_plt
->eh_frame_plt_size
;
1354 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
1357 /* Return if there are no normal input files. */
1361 if (htab
->is_vxworks
1362 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1365 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
1369 /* Since create_dynamic_sections isn't always called, but GOT
1370 relocations need GOT relocations, create them here so that we
1371 don't need to do it in check_relocs. */
1372 if (htab
->elf
.sgot
== NULL
1373 && !_bfd_elf_create_got_section (dynobj
, info
))
1374 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
1376 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
1378 /* Align .got and .got.plt sections to their entry size. Do it here
1379 instead of in create_dynamic_sections so that they are always
1380 properly aligned even if create_dynamic_sections isn't called. */
1381 sec
= htab
->elf
.sgot
;
1382 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
1383 goto error_alignment
;
1385 sec
= htab
->elf
.sgotplt
;
1386 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
1387 goto error_alignment
;
1389 /* Create the ifunc sections here so that check_relocs can be
1391 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
1392 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
1394 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
1398 /* Whe creating executable, set the contents of the .interp
1399 section to the interpreter. */
1400 if (bfd_link_executable (info
) && !info
->nointerp
)
1402 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1405 s
->size
= htab
->dynamic_interpreter_size
;
1406 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1410 /* Don't change PLT section alignment for NaCl since it uses
1411 64-byte PLT entry and sets PLT section alignment to 32
1412 bytes. Don't create additional PLT sections for NaCl. */
1415 flagword pltflags
= (bed
->dynamic_sec_flags
1420 unsigned int non_lazy_plt_alignment
1421 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
1424 if (!bfd_set_section_alignment (sec
->owner
, sec
,
1426 goto error_alignment
;
1428 /* Create the GOT procedure linkage table. */
1429 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1433 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
1435 if (!bfd_set_section_alignment (dynobj
, sec
,
1436 non_lazy_plt_alignment
))
1437 goto error_alignment
;
1439 htab
->plt_got
= sec
;
1447 /* Create the second PLT for Intel IBT support. IBT
1448 PLT is supported only for non-NaCl target and is
1449 is needed only for lazy binding. */
1450 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1454 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
1456 if (!bfd_set_section_alignment (dynobj
, sec
,
1458 goto error_alignment
;
1460 else if (info
->bndplt
&& ABI_64_P (dynobj
))
1462 /* Create the second PLT for Intel MPX support. MPX
1463 PLT is supported only for non-NaCl target in 64-bit
1464 mode and is needed only for lazy binding. */
1465 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1469 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
1471 if (!bfd_set_section_alignment (dynobj
, sec
,
1472 non_lazy_plt_alignment
))
1473 goto error_alignment
;
1476 htab
->plt_second
= sec
;
1480 if (!info
->no_ld_generated_unwind_info
)
1482 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1483 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1484 | SEC_LINKER_CREATED
);
1486 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1490 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
1492 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1493 goto error_alignment
;
1495 htab
->plt_eh_frame
= sec
;
1497 if (htab
->plt_got
!= NULL
)
1499 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1503 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
1505 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1506 goto error_alignment
;
1508 htab
->plt_got_eh_frame
= sec
;
1511 if (htab
->plt_second
!= NULL
)
1513 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1517 info
->callbacks
->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
1519 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1520 goto error_alignment
;
1522 htab
->plt_second_eh_frame
= sec
;
1529 /* The .iplt section is used for IFUNC symbols in static
1531 sec
= htab
->elf
.iplt
;
1533 && !bfd_set_section_alignment (sec
->owner
, sec
,
1535 goto error_alignment
;