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 /* Allocate space in .plt, .got and associated reloc sections for
86 _bfd_x86_elf_allocate_dynrelocs (struct elf_link_hash_entry
*h
,
89 struct bfd_link_info
*info
;
90 struct elf_x86_link_hash_table
*htab
;
91 struct elf_x86_link_hash_entry
*eh
;
92 struct elf_dyn_relocs
*p
;
93 unsigned int plt_entry_size
;
94 bfd_boolean resolved_to_zero
;
95 const struct elf_backend_data
*bed
;
97 if (h
->root
.type
== bfd_link_hash_indirect
)
100 eh
= (struct elf_x86_link_hash_entry
*) h
;
102 info
= (struct bfd_link_info
*) inf
;
103 bed
= get_elf_backend_data (info
->output_bfd
);
104 htab
= elf_x86_hash_table (info
, bed
->target_id
);
108 plt_entry_size
= htab
->plt
.plt_entry_size
;
110 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
115 /* Clear the reference count of function pointer relocations if
116 symbol isn't a normal function. */
117 if (h
->type
!= STT_FUNC
)
118 eh
->func_pointer_refcount
= 0;
120 /* We can't use the GOT PLT if pointer equality is needed since
121 finish_dynamic_symbol won't clear symbol value and the dynamic
122 linker won't update the GOT slot. We will get into an infinite
124 if (htab
->plt_got
!= NULL
125 && h
->type
!= STT_GNU_IFUNC
126 && !h
->pointer_equality_needed
127 && h
->plt
.refcount
> 0
128 && h
->got
.refcount
> 0)
130 /* Don't use the regular PLT if there are both GOT and GOTPLT
132 h
->plt
.offset
= (bfd_vma
) -1;
134 /* Use the GOT PLT. */
135 eh
->plt_got
.refcount
= 1;
138 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
139 here if it is defined and referenced in a non-shared object. */
140 if (h
->type
== STT_GNU_IFUNC
143 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
144 &htab
->readonly_dynrelocs_against_ifunc
,
148 htab
->got_entry_size
,
151 asection
*s
= htab
->plt_second
;
152 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
154 /* Use the second PLT section if it is created. */
155 eh
->plt_second
.offset
= s
->size
;
157 /* Make room for this entry in the second PLT section. */
158 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
166 /* Don't create the PLT entry if there are only function pointer
167 relocations which can be resolved at run-time. */
168 else if (htab
->elf
.dynamic_sections_created
169 && (h
->plt
.refcount
> eh
->func_pointer_refcount
170 || eh
->plt_got
.refcount
> 0))
172 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
174 /* Clear the reference count of function pointer relocations
176 eh
->func_pointer_refcount
= 0;
178 /* Make sure this symbol is output as a dynamic symbol.
179 Undefined weak syms won't yet be marked as dynamic. */
183 && h
->root
.type
== bfd_link_hash_undefweak
)
185 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
189 if (bfd_link_pic (info
)
190 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
192 asection
*s
= htab
->elf
.splt
;
193 asection
*second_s
= htab
->plt_second
;
194 asection
*got_s
= htab
->plt_got
;
196 /* If this is the first .plt entry, make room for the special
197 first entry. The .plt section is used by prelink to undo
198 prelinking for dynamic relocations. */
200 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
203 eh
->plt_got
.offset
= got_s
->size
;
206 h
->plt
.offset
= s
->size
;
208 eh
->plt_second
.offset
= second_s
->size
;
211 /* If this symbol is not defined in a regular file, and we are
212 not generating a shared library, then set the symbol to this
213 location in the .plt. This is required to make function
214 pointers compare as equal between the normal executable and
215 the shared library. */
216 if (! bfd_link_pic (info
)
221 /* We need to make a call to the entry of the GOT PLT
222 instead of regular PLT entry. */
223 h
->root
.u
.def
.section
= got_s
;
224 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
230 /* We need to make a call to the entry of the
231 second PLT instead of regular PLT entry. */
232 h
->root
.u
.def
.section
= second_s
;
233 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
237 h
->root
.u
.def
.section
= s
;
238 h
->root
.u
.def
.value
= h
->plt
.offset
;
243 /* Make room for this entry. */
245 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
248 s
->size
+= plt_entry_size
;
250 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
252 /* We also need to make an entry in the .got.plt section,
253 which will be placed in the .got section by the linker
255 htab
->elf
.sgotplt
->size
+= htab
->got_entry_size
;
257 /* There should be no PLT relocation against resolved
258 undefined weak symbol in executable. */
259 if (!resolved_to_zero
)
261 /* We also need to make an entry in the .rel.plt
263 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
264 htab
->elf
.srelplt
->reloc_count
++;
268 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
270 /* VxWorks has a second set of relocations for each PLT entry
271 in executables. They go in a separate relocation section,
272 which is processed by the kernel loader. */
274 /* There are two relocations for the initial PLT entry: an
275 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
276 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
278 asection
*srelplt2
= htab
->srelplt2
;
279 if (h
->plt
.offset
== plt_entry_size
)
280 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
282 /* There are two extra relocations for each subsequent PLT entry:
283 an R_386_32 relocation for the GOT entry, and an R_386_32
284 relocation for the PLT entry. */
286 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
291 eh
->plt_got
.offset
= (bfd_vma
) -1;
292 h
->plt
.offset
= (bfd_vma
) -1;
298 eh
->plt_got
.offset
= (bfd_vma
) -1;
299 h
->plt
.offset
= (bfd_vma
) -1;
303 eh
->tlsdesc_got
= (bfd_vma
) -1;
305 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
306 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
307 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
308 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
309 if (h
->got
.refcount
> 0
310 && bfd_link_executable (info
)
312 && (elf_x86_hash_entry (h
)->tls_type
& GOT_TLS_IE
))
313 h
->got
.offset
= (bfd_vma
) -1;
314 else if (h
->got
.refcount
> 0)
318 int tls_type
= elf_x86_hash_entry (h
)->tls_type
;
320 /* Make sure this symbol is output as a dynamic symbol.
321 Undefined weak syms won't yet be marked as dynamic. */
325 && h
->root
.type
== bfd_link_hash_undefweak
)
327 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
332 if (GOT_TLS_GDESC_P (tls_type
))
334 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
335 - elf_x86_compute_jump_table_size (htab
);
336 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
337 h
->got
.offset
= (bfd_vma
) -2;
339 if (! GOT_TLS_GDESC_P (tls_type
)
340 || GOT_TLS_GD_P (tls_type
))
342 h
->got
.offset
= s
->size
;
343 s
->size
+= htab
->got_entry_size
;
344 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
346 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
347 s
->size
+= htab
->got_entry_size
;
349 dyn
= htab
->elf
.dynamic_sections_created
;
350 /* R_386_TLS_IE_32 needs one dynamic relocation,
351 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
352 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
353 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
354 symbol and two if global. No dynamic relocation against
355 resolved undefined weak symbol in executable. */
356 if (tls_type
== GOT_TLS_IE_BOTH
)
357 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
358 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
359 || (tls_type
& GOT_TLS_IE
))
360 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
361 else if (GOT_TLS_GD_P (tls_type
))
362 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
363 else if (! GOT_TLS_GDESC_P (tls_type
)
364 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
365 && !resolved_to_zero
)
366 || h
->root
.type
!= bfd_link_hash_undefweak
)
367 && (bfd_link_pic (info
)
368 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
369 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
370 if (GOT_TLS_GDESC_P (tls_type
))
371 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
374 h
->got
.offset
= (bfd_vma
) -1;
376 if (eh
->dyn_relocs
== NULL
)
379 /* In the shared -Bsymbolic case, discard space allocated for
380 dynamic pc-relative relocs against symbols which turn out to be
381 defined in regular objects. For the normal shared case, discard
382 space for pc-relative relocs that have become local due to symbol
383 visibility changes. */
385 if (bfd_link_pic (info
))
387 /* Relocs that use pc_count are those that appear on a call
388 insn, or certain REL relocs that can generated via assembly.
389 We want calls to protected symbols to resolve directly to the
390 function rather than going via the plt. If people want
391 function pointer comparisons to work as expected then they
392 should avoid writing weird assembly. */
393 if (SYMBOL_CALLS_LOCAL (info
, h
))
395 struct elf_dyn_relocs
**pp
;
397 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
399 p
->count
-= p
->pc_count
;
408 if (htab
->is_vxworks
)
410 struct elf_dyn_relocs
**pp
;
411 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
413 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
420 /* Also discard relocs on undefined weak syms with non-default
421 visibility or in PIE. */
422 if (eh
->dyn_relocs
!= NULL
)
424 if (h
->root
.type
== bfd_link_hash_undefweak
)
426 /* Undefined weak symbol is never bound locally in shared
428 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
431 if (bed
->target_id
== I386_ELF_DATA
434 /* Keep dynamic non-GOT/non-PLT relocation so
435 that we can branch to 0 without PLT. */
436 struct elf_dyn_relocs
**pp
;
438 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
439 if (p
->pc_count
== 0)
443 /* Remove non-R_386_PC32 relocation. */
444 p
->count
= p
->pc_count
;
448 /* Make sure undefined weak symbols are output
449 as dynamic symbols in PIEs for dynamic non-GOT
450 non-PLT reloations. */
451 if (eh
->dyn_relocs
!= NULL
452 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
456 eh
->dyn_relocs
= NULL
;
458 else if (h
->dynindx
== -1
460 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
463 else if (bfd_link_executable (info
)
464 && (h
->needs_copy
|| eh
->needs_copy
)
468 /* NB: needs_copy is set only for x86-64. For PIE,
469 discard space for pc-relative relocs against symbols
470 which turn out to need copy relocs. */
471 struct elf_dyn_relocs
**pp
;
473 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
475 if (p
->pc_count
!= 0)
483 else if (ELIMINATE_COPY_RELOCS
)
485 /* For the non-shared case, discard space for relocs against
486 symbols which turn out to need copy relocs or are not
487 dynamic. Keep dynamic relocations for run-time function
488 pointer initialization. */
491 || eh
->func_pointer_refcount
> 0
492 || (h
->root
.type
== bfd_link_hash_undefweak
493 && !resolved_to_zero
))
496 || (htab
->elf
.dynamic_sections_created
497 && (h
->root
.type
== bfd_link_hash_undefweak
498 || h
->root
.type
== bfd_link_hash_undefined
))))
500 /* Make sure this symbol is output as a dynamic symbol.
501 Undefined weak syms won't yet be marked as dynamic. */
505 && h
->root
.type
== bfd_link_hash_undefweak
506 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
509 /* If that succeeded, we know we'll be keeping all the
511 if (h
->dynindx
!= -1)
515 eh
->dyn_relocs
= NULL
;
516 eh
->func_pointer_refcount
= 0;
521 /* Finally, allocate space. */
522 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
526 sreloc
= elf_section_data (p
->sec
)->sreloc
;
528 BFD_ASSERT (sreloc
!= NULL
);
529 sreloc
->size
+= p
->count
* htab
->sizeof_reloc
;
535 /* Find any dynamic relocs that apply to read-only sections. */
538 _bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
541 struct elf_x86_link_hash_entry
*eh
;
542 struct elf_dyn_relocs
*p
;
544 /* Skip local IFUNC symbols. */
545 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
548 eh
= (struct elf_x86_link_hash_entry
*) h
;
549 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
551 asection
*s
= p
->sec
->output_section
;
553 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
555 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
557 info
->flags
|= DF_TEXTREL
;
559 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
560 || info
->error_textrel
)
561 /* xgettext:c-format */
562 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
563 p
->sec
->owner
, h
->root
.root
.string
,
566 /* Not an error, just cut short the traversal. */
573 /* Allocate space in .plt, .got and associated reloc sections for
574 local dynamic relocs. */
577 _bfd_x86_elf_allocate_local_dynrelocs (void **slot
, void *inf
)
579 struct elf_link_hash_entry
*h
580 = (struct elf_link_hash_entry
*) *slot
;
582 if (h
->type
!= STT_GNU_IFUNC
586 || h
->root
.type
!= bfd_link_hash_defined
)
589 return _bfd_x86_elf_allocate_dynrelocs (h
, inf
);
592 /* Find and/or create a hash entry for local symbol. */
594 struct elf_link_hash_entry
*
595 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table
*htab
,
596 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
599 struct elf_x86_link_hash_entry e
, *ret
;
600 asection
*sec
= abfd
->sections
;
601 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
602 htab
->r_sym (rel
->r_info
));
605 e
.elf
.indx
= sec
->id
;
606 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
607 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
608 create
? INSERT
: NO_INSERT
);
615 ret
= (struct elf_x86_link_hash_entry
*) *slot
;
619 ret
= (struct elf_x86_link_hash_entry
*)
620 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
621 sizeof (struct elf_x86_link_hash_entry
));
624 memset (ret
, 0, sizeof (*ret
));
625 ret
->elf
.indx
= sec
->id
;
626 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
627 ret
->elf
.dynindx
= -1;
628 ret
->plt_got
.offset
= (bfd_vma
) -1;
634 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
635 SYNC WITH _bfd_elf_link_hash_newfunc. */
637 struct bfd_hash_entry
*
638 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
639 struct bfd_hash_table
*table
,
642 /* Allocate the structure if it has not already been allocated by a
646 entry
= (struct bfd_hash_entry
*)
647 bfd_hash_allocate (table
,
648 sizeof (struct elf_x86_link_hash_entry
));
653 /* Call the allocation method of the superclass. */
654 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
657 struct elf_x86_link_hash_entry
*eh
658 = (struct elf_x86_link_hash_entry
*) entry
;
659 struct elf_link_hash_table
*htab
660 = (struct elf_link_hash_table
*) table
;
662 memset (&eh
->elf
.size
, 0,
663 (sizeof (struct elf_x86_link_hash_entry
)
664 - offsetof (struct elf_link_hash_entry
, size
)));
665 /* Set local fields. */
667 eh
->elf
.dynindx
= -1;
668 eh
->elf
.got
= htab
->init_got_refcount
;
669 eh
->elf
.plt
= htab
->init_plt_refcount
;
670 /* Assume that we have been called by a non-ELF symbol reader.
671 This flag is then reset by the code which reads an ELF input
672 file. This ensures that a symbol created by a non-ELF symbol
673 reader will have the flag set correctly. */
675 eh
->plt_second
.offset
= (bfd_vma
) -1;
676 eh
->plt_got
.offset
= (bfd_vma
) -1;
677 eh
->tlsdesc_got
= (bfd_vma
) -1;
683 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
684 for local symbol so that we can handle local STT_GNU_IFUNC symbols
685 as global symbol. We reuse indx and dynstr_index for local symbol
686 hash since they aren't used by global symbols in this backend. */
689 _bfd_x86_elf_local_htab_hash (const void *ptr
)
691 struct elf_link_hash_entry
*h
692 = (struct elf_link_hash_entry
*) ptr
;
693 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
696 /* Compare local hash entries. */
699 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
701 struct elf_link_hash_entry
*h1
702 = (struct elf_link_hash_entry
*) ptr1
;
703 struct elf_link_hash_entry
*h2
704 = (struct elf_link_hash_entry
*) ptr2
;
706 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
709 /* Destroy an x86 ELF linker hash table. */
712 elf_x86_link_hash_table_free (bfd
*obfd
)
714 struct elf_x86_link_hash_table
*htab
715 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
717 if (htab
->loc_hash_table
)
718 htab_delete (htab
->loc_hash_table
);
719 if (htab
->loc_hash_memory
)
720 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
721 _bfd_elf_link_hash_table_free (obfd
);
724 /* Create an x86 ELF linker hash table. */
726 struct bfd_link_hash_table
*
727 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
729 struct elf_x86_link_hash_table
*ret
;
730 const struct elf_backend_data
*bed
;
731 bfd_size_type amt
= sizeof (struct elf_x86_link_hash_table
);
733 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
737 bed
= get_elf_backend_data (abfd
);
738 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
739 _bfd_x86_elf_link_hash_newfunc
,
740 sizeof (struct elf_x86_link_hash_entry
),
750 ret
->r_info
= elf64_r_info
;
751 ret
->r_sym
= elf64_r_sym
;
752 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
753 ret
->got_entry_size
= 8;
754 ret
->pointer_r_type
= R_X86_64_64
;
755 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
756 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
757 ret
->tls_get_addr
= "__tls_get_addr";
762 ret
->r_info
= elf32_r_info
;
763 ret
->r_sym
= elf32_r_sym
;
764 if (bed
->target_id
== X86_64_ELF_DATA
)
766 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
767 ret
->got_entry_size
= 8;
768 ret
->pointer_r_type
= R_X86_64_32
;
769 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
770 ret
->dynamic_interpreter_size
771 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
772 ret
->tls_get_addr
= "__tls_get_addr";
776 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
777 ret
->got_entry_size
= 4;
778 ret
->pointer_r_type
= R_386_32
;
779 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
780 ret
->dynamic_interpreter_size
781 = sizeof ELF32_DYNAMIC_INTERPRETER
;
782 ret
->tls_get_addr
= "___tls_get_addr";
785 ret
->target_id
= bed
->target_id
;
787 ret
->loc_hash_table
= htab_try_create (1024,
788 _bfd_x86_elf_local_htab_hash
,
789 _bfd_x86_elf_local_htab_eq
,
791 ret
->loc_hash_memory
= objalloc_create ();
792 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
794 elf_x86_link_hash_table_free (abfd
);
797 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
799 return &ret
->elf
.root
;
802 /* Sort relocs into address order. */
805 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
807 const arelent
*a
= * (const arelent
**) ap
;
808 const arelent
*b
= * (const arelent
**) bp
;
810 if (a
->address
> b
->address
)
812 else if (a
->address
< b
->address
)
819 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
821 if (!bfd_link_relocatable (info
))
823 /* Check for __tls_get_addr reference. */
824 struct elf_x86_link_hash_table
*htab
;
825 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
826 htab
= elf_x86_hash_table (info
, bed
->target_id
);
829 struct elf_link_hash_entry
*h
830 = elf_link_hash_lookup (elf_hash_table (info
),
832 FALSE
, FALSE
, FALSE
);
834 ((struct elf_x86_link_hash_entry
*) h
)->tls_get_addr
= 1;
838 /* Invoke the regular ELF backend linker to do all the work. */
839 return _bfd_elf_link_check_relocs (abfd
, info
);
843 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
844 struct bfd_link_info
*info
)
846 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
850 struct elf_link_hash_entry
*tlsbase
;
852 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
854 FALSE
, FALSE
, FALSE
);
856 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
858 struct elf_x86_link_hash_table
*htab
;
859 struct bfd_link_hash_entry
*bh
= NULL
;
860 const struct elf_backend_data
*bed
861 = get_elf_backend_data (output_bfd
);
863 htab
= elf_x86_hash_table (info
, bed
->target_id
);
867 if (!(_bfd_generic_link_add_one_symbol
868 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
869 tls_sec
, 0, NULL
, FALSE
,
873 htab
->tls_module_base
= bh
;
875 tlsbase
= (struct elf_link_hash_entry
*)bh
;
876 tlsbase
->def_regular
= 1;
877 tlsbase
->other
= STV_HIDDEN
;
878 tlsbase
->root
.linker_def
= 1;
879 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
887 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
888 const Elf_Internal_Sym
*isym
,
889 bfd_boolean definition
,
890 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
894 struct elf_x86_link_hash_entry
*eh
895 = (struct elf_x86_link_hash_entry
*) h
;
896 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
901 /* Copy the extra info we tack onto an elf_link_hash_entry. */
904 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
905 struct elf_link_hash_entry
*dir
,
906 struct elf_link_hash_entry
*ind
)
908 struct elf_x86_link_hash_entry
*edir
, *eind
;
910 edir
= (struct elf_x86_link_hash_entry
*) dir
;
911 eind
= (struct elf_x86_link_hash_entry
*) ind
;
913 if (eind
->dyn_relocs
!= NULL
)
915 if (edir
->dyn_relocs
!= NULL
)
917 struct elf_dyn_relocs
**pp
;
918 struct elf_dyn_relocs
*p
;
920 /* Add reloc counts against the indirect sym to the direct sym
921 list. Merge any entries against the same section. */
922 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
924 struct elf_dyn_relocs
*q
;
926 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
927 if (q
->sec
== p
->sec
)
929 q
->pc_count
+= p
->pc_count
;
930 q
->count
+= p
->count
;
937 *pp
= edir
->dyn_relocs
;
940 edir
->dyn_relocs
= eind
->dyn_relocs
;
941 eind
->dyn_relocs
= NULL
;
944 if (ind
->root
.type
== bfd_link_hash_indirect
945 && dir
->got
.refcount
<= 0)
947 edir
->tls_type
= eind
->tls_type
;
948 eind
->tls_type
= GOT_UNKNOWN
;
951 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
952 generate a R_386_COPY reloc. */
953 edir
->gotoff_ref
|= eind
->gotoff_ref
;
955 edir
->has_got_reloc
|= eind
->has_got_reloc
;
956 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
958 if (ELIMINATE_COPY_RELOCS
959 && ind
->root
.type
!= bfd_link_hash_indirect
960 && dir
->dynamic_adjusted
)
962 /* If called to transfer flags for a weakdef during processing
963 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
964 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
965 if (dir
->versioned
!= versioned_hidden
)
966 dir
->ref_dynamic
|= ind
->ref_dynamic
;
967 dir
->ref_regular
|= ind
->ref_regular
;
968 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
969 dir
->needs_plt
|= ind
->needs_plt
;
970 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
974 if (eind
->func_pointer_refcount
> 0)
976 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
977 eind
->func_pointer_refcount
= 0;
980 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
984 /* Remove undefined weak symbol from the dynamic symbol table if it
988 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
989 struct elf_link_hash_entry
*h
)
991 if (h
->dynindx
!= -1)
993 const struct elf_backend_data
*bed
994 = get_elf_backend_data (info
->output_bfd
);
995 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
997 elf_x86_hash_entry (h
)->has_got_reloc
,
998 elf_x86_hash_entry (h
)))
1001 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1008 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1011 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
1013 if (h
->plt
.offset
!= (bfd_vma
) -1
1015 && !h
->pointer_equality_needed
)
1018 return _bfd_elf_hash_symbol (h
);
1021 /* Adjust a symbol defined by a dynamic object and referenced by a
1022 regular object. The current definition is in some section of the
1023 dynamic object, but we're not including those sections. We have to
1024 change the definition to something the rest of the link can
1028 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1029 struct elf_link_hash_entry
*h
)
1031 struct elf_x86_link_hash_table
*htab
;
1033 struct elf_x86_link_hash_entry
*eh
;
1034 struct elf_dyn_relocs
*p
;
1035 const struct elf_backend_data
*bed
1036 = get_elf_backend_data (info
->output_bfd
);
1038 /* STT_GNU_IFUNC symbol must go through PLT. */
1039 if (h
->type
== STT_GNU_IFUNC
)
1041 /* All local STT_GNU_IFUNC references must be treate as local
1042 calls via local PLT. */
1044 && SYMBOL_CALLS_LOCAL (info
, h
))
1046 bfd_size_type pc_count
= 0, count
= 0;
1047 struct elf_dyn_relocs
**pp
;
1049 eh
= (struct elf_x86_link_hash_entry
*) h
;
1050 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1052 pc_count
+= p
->pc_count
;
1053 p
->count
-= p
->pc_count
;
1062 if (pc_count
|| count
)
1067 /* Increment PLT reference count only for PC-relative
1070 if (h
->plt
.refcount
<= 0)
1071 h
->plt
.refcount
= 1;
1073 h
->plt
.refcount
+= 1;
1078 if (h
->plt
.refcount
<= 0)
1080 h
->plt
.offset
= (bfd_vma
) -1;
1086 /* If this is a function, put it in the procedure linkage table. We
1087 will fill in the contents of the procedure linkage table later,
1088 when we know the address of the .got section. */
1089 if (h
->type
== STT_FUNC
1092 if (h
->plt
.refcount
<= 0
1093 || SYMBOL_CALLS_LOCAL (info
, h
)
1094 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1095 && h
->root
.type
== bfd_link_hash_undefweak
))
1097 /* This case can occur if we saw a PLT32 reloc in an input
1098 file, but the symbol was never referred to by a dynamic
1099 object, or if all references were garbage collected. In
1100 such a case, we don't actually need to build a procedure
1101 linkage table, and we can just do a PC32 reloc instead. */
1102 h
->plt
.offset
= (bfd_vma
) -1;
1109 /* It's possible that we incorrectly decided a .plt reloc was needed
1110 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1111 check_relocs. We can't decide accurately between function and
1112 non-function syms in check-relocs; Objects loaded later in
1113 the link may change h->type. So fix it now. */
1114 h
->plt
.offset
= (bfd_vma
) -1;
1116 eh
= (struct elf_x86_link_hash_entry
*) h
;
1118 /* If this is a weak symbol, and there is a real definition, the
1119 processor independent code will have arranged for us to see the
1120 real definition first, and we can just use the same value. */
1121 if (h
->u
.weakdef
!= NULL
)
1123 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1124 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1125 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1126 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1127 if (ELIMINATE_COPY_RELOCS
1128 || info
->nocopyreloc
1129 || SYMBOL_NO_COPYRELOC (info
, eh
))
1131 /* NB: needs_copy is always 0 for i386. */
1132 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1133 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
1138 /* This is a reference to a symbol defined by a dynamic object which
1139 is not a function. */
1141 /* If we are creating a shared library, we must presume that the
1142 only references to the symbol are via the global offset table.
1143 For such cases we need not do anything here; the relocations will
1144 be handled correctly by relocate_section. */
1145 if (!bfd_link_executable (info
))
1148 /* If there are no references to this symbol that do not use the
1149 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1150 reloc. NB: gotoff_ref is always 0 for x86-64. */
1151 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
1154 /* If -z nocopyreloc was given, we won't generate them either. */
1155 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
1161 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1165 /* If there aren't any dynamic relocs in read-only sections nor
1166 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1167 avoid the copy reloc. This doesn't work on VxWorks, where we can
1168 not have dynamic relocations (other than copy and jump slot
1169 relocations) in an executable. */
1170 if (ELIMINATE_COPY_RELOCS
1171 && (bed
->target_id
== X86_64_ELF_DATA
1173 && !htab
->is_vxworks
)))
1175 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1177 s
= p
->sec
->output_section
;
1178 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1182 /* If we didn't find any dynamic relocs in read-only sections,
1183 then we'll be keeping the dynamic relocs and avoiding the copy
1192 /* We must allocate the symbol in our .dynbss section, which will
1193 become part of the .bss section of the executable. There will be
1194 an entry for this symbol in the .dynsym section. The dynamic
1195 object will contain position independent code, so all references
1196 from the dynamic object to this symbol will go through the global
1197 offset table. The dynamic linker will use the .dynsym entry to
1198 determine the address it must put in the global offset table, so
1199 both the dynamic object and the regular object will refer to the
1200 same memory location for the variable. */
1202 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1203 dynamic linker to copy the initial value out of the dynamic object
1204 and into the runtime process image. */
1205 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1207 s
= htab
->elf
.sdynrelro
;
1208 srel
= htab
->elf
.sreldynrelro
;
1212 s
= htab
->elf
.sdynbss
;
1213 srel
= htab
->elf
.srelbss
;
1215 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1217 srel
->size
+= htab
->sizeof_reloc
;
1221 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1224 /* Return the section that should be marked against GC for a given
1228 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
1229 struct bfd_link_info
*info
,
1230 Elf_Internal_Rela
*rel
,
1231 struct elf_link_hash_entry
*h
,
1232 Elf_Internal_Sym
*sym
)
1234 /* Compiler should optimize this out. */
1235 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1236 != (unsigned int) R_386_GNU_VTINHERIT
)
1237 || ((unsigned int) R_X86_64_GNU_VTENTRY
1238 != (unsigned int) R_386_GNU_VTENTRY
))
1242 switch (ELF32_R_TYPE (rel
->r_info
))
1244 case R_X86_64_GNU_VTINHERIT
:
1245 case R_X86_64_GNU_VTENTRY
:
1249 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1253 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
1255 bfd_vma offset ATTRIBUTE_UNUSED
,
1258 return got_addr
+ off
;
1262 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
1265 bfd_vma got_addr ATTRIBUTE_UNUSED
)
1267 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
1271 elf_i386_valid_plt_reloc_p (unsigned int type
)
1273 return (type
== R_386_JUMP_SLOT
1274 || type
== R_386_GLOB_DAT
1275 || type
== R_386_IRELATIVE
);
1279 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
1281 return (type
== R_X86_64_JUMP_SLOT
1282 || type
== R_X86_64_GLOB_DAT
1283 || type
== R_X86_64_IRELATIVE
);
1287 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
1291 struct elf_x86_plt plts
[],
1295 long size
, i
, n
, len
;
1297 unsigned int plt_got_offset
, plt_entry_size
;
1299 bfd_byte
*plt_contents
;
1301 arelent
**dynrelbuf
, *p
;
1303 const struct elf_backend_data
*bed
;
1304 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
1306 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
1311 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
1312 if (dynrelbuf
== NULL
)
1315 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
1318 /* Sort the relocs by address. */
1319 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
1320 _bfd_x86_elf_compare_relocs
);
1322 size
= count
* sizeof (asymbol
);
1324 /* Allocate space for @plt suffixes. */
1326 for (i
= 0; i
< dynrelcount
; i
++)
1329 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
1331 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
1334 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
1338 bed
= get_elf_backend_data (abfd
);
1340 if (bed
->target_id
== X86_64_ELF_DATA
)
1342 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
1343 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
1347 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
1348 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
1351 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
1353 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
1355 got_addr
= sec
->vma
;
1358 sec
= bfd_get_section_by_name (abfd
, ".got");
1360 got_addr
= sec
->vma
;
1363 if (got_addr
== (bfd_vma
) -1)
1368 /* Check for each PLT section. */
1369 names
= (char *) (s
+ count
);
1372 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1373 if ((plt_contents
= plts
[j
].contents
) != NULL
)
1378 struct elf_x86_plt
*plt_p
= &plts
[j
];
1380 plt_got_offset
= plt_p
->plt_got_offset
;
1381 plt_entry_size
= plt_p
->plt_entry_size
;
1385 if ((plt_p
->type
& plt_lazy
))
1387 /* Skip PLT0 in lazy PLT. */
1389 offset
= plt_entry_size
;
1397 /* Check each PLT entry against dynamic relocations. */
1398 for (; k
< plt_p
->count
; k
++)
1404 /* Get the GOT offset for i386 or the PC-relative offset
1405 for x86-64, a signed 32-bit integer. */
1406 off
= H_GET_32 (abfd
, (plt_contents
+ offset
1408 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
1410 /* Binary search. */
1414 while ((min
+ 1) < max
)
1418 mid
= (min
+ max
) / 2;
1420 if (got_vma
> r
->address
)
1422 else if (got_vma
< r
->address
)
1431 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
1432 if (got_vma
== p
->address
1434 && valid_plt_reloc_p (p
->howto
->type
))
1436 *s
= **p
->sym_ptr_ptr
;
1437 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
1438 set. Since we are defining a symbol, ensure one
1440 if ((s
->flags
& BSF_LOCAL
) == 0)
1441 s
->flags
|= BSF_GLOBAL
;
1442 s
->flags
|= BSF_SYNTHETIC
;
1443 /* This is no longer a section symbol. */
1444 s
->flags
&= ~BSF_SECTION_SYM
;
1446 s
->the_bfd
= plt
->owner
;
1450 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
1451 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
1457 memcpy (names
, "+0x", sizeof ("+0x") - 1);
1458 names
+= sizeof ("+0x") - 1;
1459 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
1460 for (a
= buf
; *a
== '0'; ++a
)
1463 memcpy (names
, a
, size
);
1466 memcpy (names
, "@plt", sizeof ("@plt"));
1467 names
+= sizeof ("@plt");
1471 offset
+= plt_entry_size
;
1475 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
1484 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1485 if (plts
[j
].contents
!= NULL
)
1486 free (plts
[j
].contents
);
1493 /* Parse x86 GNU properties. */
1495 enum elf_property_kind
1496 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
1497 bfd_byte
*ptr
, unsigned int datasz
)
1503 case GNU_PROPERTY_X86_ISA_1_USED
:
1504 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
1505 case GNU_PROPERTY_X86_FEATURE_1_AND
:
1509 ((type
== GNU_PROPERTY_X86_ISA_1_USED
1510 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
1511 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
1512 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
1513 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
1515 return property_corrupt
;
1517 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
1518 /* Combine properties of the same type. */
1519 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
1520 prop
->pr_kind
= property_number
;
1524 return property_ignored
;
1527 return property_number
;
1530 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
1531 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
1532 should be merged with ABFD. */
1535 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
1536 bfd
*abfd ATTRIBUTE_UNUSED
,
1537 elf_property
*aprop
,
1538 elf_property
*bprop
)
1540 unsigned int number
, features
;
1541 bfd_boolean updated
= FALSE
;
1542 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
1546 case GNU_PROPERTY_X86_ISA_1_USED
:
1547 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
1548 if (aprop
!= NULL
&& bprop
!= NULL
)
1550 number
= aprop
->u
.number
;
1551 aprop
->u
.number
= number
| bprop
->u
.number
;
1552 updated
= number
!= (unsigned int) aprop
->u
.number
;
1556 /* Return TRUE if APROP is NULL to indicate that BPROP should
1557 be added to ABFD. */
1558 updated
= aprop
== NULL
;
1562 case GNU_PROPERTY_X86_FEATURE_1_AND
:
1563 /* Only one of APROP and BPROP can be NULL:
1564 1. APROP & BPROP when both APROP and BPROP aren't NULL.
1565 2. If APROP is NULL, remove x86 feature.
1566 3. Otherwise, do nothing.
1568 if (aprop
!= NULL
&& bprop
!= NULL
)
1572 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1574 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1575 number
= aprop
->u
.number
;
1576 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1577 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1578 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
1579 updated
= number
!= (unsigned int) aprop
->u
.number
;
1580 /* Remove the property if all feature bits are cleared. */
1581 if (aprop
->u
.number
== 0)
1582 aprop
->pr_kind
= property_remove
;
1588 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1590 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1593 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1594 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1597 number
= aprop
->u
.number
;
1598 aprop
->u
.number
= number
| features
;
1599 updated
= number
!= (unsigned int) aprop
->u
.number
;
1603 bprop
->u
.number
|= features
;
1607 else if (aprop
!= NULL
)
1609 aprop
->pr_kind
= property_remove
;
1616 /* Never should happen. */
1623 /* Set up x86 GNU properties. Return the first relocatable ELF input
1624 with GNU properties if found. Otherwise, return NULL. */
1627 _bfd_x86_elf_link_setup_gnu_properties
1628 (struct bfd_link_info
*info
,
1629 struct elf_x86_plt_layout_table
*plt_layout
)
1631 bfd_boolean normal_target
;
1632 bfd_boolean lazy_plt
;
1633 asection
*sec
, *pltsec
;
1635 bfd_boolean use_ibt_plt
;
1636 unsigned int plt_alignment
, features
;
1637 struct elf_x86_link_hash_table
*htab
;
1641 const struct elf_backend_data
*bed
;
1642 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
1643 unsigned int got_align
;
1647 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
1649 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
1651 /* Find a normal input file with GNU property note. */
1652 for (pbfd
= info
->input_bfds
;
1654 pbfd
= pbfd
->link
.next
)
1655 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
1656 && bfd_count_sections (pbfd
) != 0)
1660 if (elf_properties (pbfd
) != NULL
)
1664 if (ebfd
!= NULL
&& features
)
1666 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
1667 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
1668 prop
= _bfd_elf_get_property (ebfd
,
1669 GNU_PROPERTY_X86_FEATURE_1_AND
,
1671 prop
->u
.number
|= features
;
1672 prop
->pr_kind
= property_number
;
1674 /* Create the GNU property note section if needed. */
1677 sec
= bfd_make_section_with_flags (ebfd
,
1678 NOTE_GNU_PROPERTY_SECTION_NAME
,
1686 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
1688 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
1691 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
1695 elf_section_type (sec
) = SHT_NOTE
;
1699 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
1701 if (bfd_link_relocatable (info
))
1704 bed
= get_elf_backend_data (info
->output_bfd
);
1706 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1710 htab
->is_vxworks
= plt_layout
->is_vxworks
;
1712 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
1713 if (!use_ibt_plt
&& pbfd
!= NULL
)
1715 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
1716 elf_property_list
*p
;
1718 /* The property list is sorted in order of type. */
1719 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
1721 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
1723 use_ibt_plt
= !!(p
->property
.u
.number
1724 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
1727 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
1732 dynobj
= htab
->elf
.dynobj
;
1734 /* Set htab->elf.dynobj here so that there is no need to check and
1735 set it in check_relocs. */
1740 htab
->elf
.dynobj
= pbfd
;
1747 /* Find a normal input file to hold linker created
1749 for (abfd
= info
->input_bfds
;
1751 abfd
= abfd
->link
.next
)
1752 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1754 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
1756 htab
->elf
.dynobj
= abfd
;
1763 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
1764 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
1765 canonical function address. */
1766 htab
->plt
.has_plt0
= 1;
1767 normal_target
= plt_layout
->normal_target
;
1773 htab
->lazy_plt
= plt_layout
->lazy_ibt_plt
;
1774 htab
->non_lazy_plt
= plt_layout
->non_lazy_ibt_plt
;
1778 htab
->lazy_plt
= plt_layout
->lazy_plt
;
1779 htab
->non_lazy_plt
= plt_layout
->non_lazy_plt
;
1784 htab
->lazy_plt
= plt_layout
->lazy_plt
;
1785 htab
->non_lazy_plt
= NULL
;
1788 pltsec
= htab
->elf
.splt
;
1790 /* If the non-lazy PLT is available, use it for all PLT entries if
1791 there are no PLT0 or no .plt section. */
1792 if (htab
->non_lazy_plt
!= NULL
1793 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
1796 if (bfd_link_pic (info
))
1797 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
1799 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
1800 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
1801 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
1802 htab
->plt
.plt_got_insn_size
1803 = htab
->non_lazy_plt
->plt_got_insn_size
;
1804 htab
->plt
.eh_frame_plt_size
1805 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1806 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
1811 if (bfd_link_pic (info
))
1813 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
1814 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
1818 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
1819 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
1821 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
1822 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
1823 htab
->plt
.plt_got_insn_size
1824 = htab
->lazy_plt
->plt_got_insn_size
;
1825 htab
->plt
.eh_frame_plt_size
1826 = htab
->lazy_plt
->eh_frame_plt_size
;
1827 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
1830 /* Return if there are no normal input files. */
1834 if (htab
->is_vxworks
1835 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1838 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
1842 /* Since create_dynamic_sections isn't always called, but GOT
1843 relocations need GOT relocations, create them here so that we
1844 don't need to do it in check_relocs. */
1845 if (htab
->elf
.sgot
== NULL
1846 && !_bfd_elf_create_got_section (dynobj
, info
))
1847 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
1849 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
1851 /* Align .got and .got.plt sections to their entry size. Do it here
1852 instead of in create_dynamic_sections so that they are always
1853 properly aligned even if create_dynamic_sections isn't called. */
1854 sec
= htab
->elf
.sgot
;
1855 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
1856 goto error_alignment
;
1858 sec
= htab
->elf
.sgotplt
;
1859 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
1860 goto error_alignment
;
1862 /* Create the ifunc sections here so that check_relocs can be
1864 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
1865 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
1867 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
1871 /* Whe creating executable, set the contents of the .interp
1872 section to the interpreter. */
1873 if (bfd_link_executable (info
) && !info
->nointerp
)
1875 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1878 s
->size
= htab
->dynamic_interpreter_size
;
1879 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1883 /* Don't change PLT section alignment for NaCl since it uses
1884 64-byte PLT entry and sets PLT section alignment to 32
1885 bytes. Don't create additional PLT sections for NaCl. */
1888 flagword pltflags
= (bed
->dynamic_sec_flags
1893 unsigned int non_lazy_plt_alignment
1894 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
1897 if (!bfd_set_section_alignment (sec
->owner
, sec
,
1899 goto error_alignment
;
1901 /* Create the GOT procedure linkage table. */
1902 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1906 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
1908 if (!bfd_set_section_alignment (dynobj
, sec
,
1909 non_lazy_plt_alignment
))
1910 goto error_alignment
;
1912 htab
->plt_got
= sec
;
1920 /* Create the second PLT for Intel IBT support. IBT
1921 PLT is supported only for non-NaCl target and is
1922 is needed only for lazy binding. */
1923 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1927 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
1929 if (!bfd_set_section_alignment (dynobj
, sec
,
1931 goto error_alignment
;
1933 else if (info
->bndplt
&& ABI_64_P (dynobj
))
1935 /* Create the second PLT for Intel MPX support. MPX
1936 PLT is supported only for non-NaCl target in 64-bit
1937 mode and is needed only for lazy binding. */
1938 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1942 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
1944 if (!bfd_set_section_alignment (dynobj
, sec
,
1945 non_lazy_plt_alignment
))
1946 goto error_alignment
;
1949 htab
->plt_second
= sec
;
1953 if (!info
->no_ld_generated_unwind_info
)
1955 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1956 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1957 | SEC_LINKER_CREATED
);
1959 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1963 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
1965 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1966 goto error_alignment
;
1968 htab
->plt_eh_frame
= sec
;
1970 if (htab
->plt_got
!= NULL
)
1972 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1976 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
1978 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1979 goto error_alignment
;
1981 htab
->plt_got_eh_frame
= sec
;
1984 if (htab
->plt_second
!= NULL
)
1986 sec
= bfd_make_section_anyway_with_flags (dynobj
,
1990 info
->callbacks
->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
1992 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
1993 goto error_alignment
;
1995 htab
->plt_second_eh_frame
= sec
;
2002 /* The .iplt section is used for IFUNC symbols in static
2004 sec
= htab
->elf
.iplt
;
2006 && !bfd_set_section_alignment (sec
->owner
, sec
,
2008 goto error_alignment
;