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 elf_x86_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
))
372 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
373 if (bed
->target_id
== X86_64_ELF_DATA
)
374 htab
->tlsdesc_plt
= (bfd_vma
) -1;
378 h
->got
.offset
= (bfd_vma
) -1;
380 if (eh
->dyn_relocs
== NULL
)
383 /* In the shared -Bsymbolic case, discard space allocated for
384 dynamic pc-relative relocs against symbols which turn out to be
385 defined in regular objects. For the normal shared case, discard
386 space for pc-relative relocs that have become local due to symbol
387 visibility changes. */
389 if (bfd_link_pic (info
))
391 /* Relocs that use pc_count are those that appear on a call
392 insn, or certain REL relocs that can generated via assembly.
393 We want calls to protected symbols to resolve directly to the
394 function rather than going via the plt. If people want
395 function pointer comparisons to work as expected then they
396 should avoid writing weird assembly. */
397 if (SYMBOL_CALLS_LOCAL (info
, h
))
399 struct elf_dyn_relocs
**pp
;
401 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
403 p
->count
-= p
->pc_count
;
412 if (htab
->is_vxworks
)
414 struct elf_dyn_relocs
**pp
;
415 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
417 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
424 /* Also discard relocs on undefined weak syms with non-default
425 visibility or in PIE. */
426 if (eh
->dyn_relocs
!= NULL
)
428 if (h
->root
.type
== bfd_link_hash_undefweak
)
430 /* Undefined weak symbol is never bound locally in shared
432 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
435 if (bed
->target_id
== I386_ELF_DATA
438 /* Keep dynamic non-GOT/non-PLT relocation so
439 that we can branch to 0 without PLT. */
440 struct elf_dyn_relocs
**pp
;
442 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
443 if (p
->pc_count
== 0)
447 /* Remove non-R_386_PC32 relocation. */
448 p
->count
= p
->pc_count
;
452 /* Make sure undefined weak symbols are output
453 as dynamic symbols in PIEs for dynamic non-GOT
454 non-PLT reloations. */
455 if (eh
->dyn_relocs
!= NULL
456 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
460 eh
->dyn_relocs
= NULL
;
462 else if (h
->dynindx
== -1
464 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
467 else if (bfd_link_executable (info
)
468 && (h
->needs_copy
|| eh
->needs_copy
)
472 /* NB: needs_copy is set only for x86-64. For PIE,
473 discard space for pc-relative relocs against symbols
474 which turn out to need copy relocs. */
475 struct elf_dyn_relocs
**pp
;
477 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
479 if (p
->pc_count
!= 0)
487 else if (ELIMINATE_COPY_RELOCS
)
489 /* For the non-shared case, discard space for relocs against
490 symbols which turn out to need copy relocs or are not
491 dynamic. Keep dynamic relocations for run-time function
492 pointer initialization. */
495 || eh
->func_pointer_refcount
> 0
496 || (h
->root
.type
== bfd_link_hash_undefweak
497 && !resolved_to_zero
))
500 || (htab
->elf
.dynamic_sections_created
501 && (h
->root
.type
== bfd_link_hash_undefweak
502 || h
->root
.type
== bfd_link_hash_undefined
))))
504 /* Make sure this symbol is output as a dynamic symbol.
505 Undefined weak syms won't yet be marked as dynamic. */
509 && h
->root
.type
== bfd_link_hash_undefweak
510 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
513 /* If that succeeded, we know we'll be keeping all the
515 if (h
->dynindx
!= -1)
519 eh
->dyn_relocs
= NULL
;
520 eh
->func_pointer_refcount
= 0;
525 /* Finally, allocate space. */
526 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
530 sreloc
= elf_section_data (p
->sec
)->sreloc
;
532 BFD_ASSERT (sreloc
!= NULL
);
533 sreloc
->size
+= p
->count
* htab
->sizeof_reloc
;
539 /* Find any dynamic relocs that apply to read-only sections. */
542 _bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
545 struct elf_x86_link_hash_entry
*eh
;
546 struct elf_dyn_relocs
*p
;
548 /* Skip local IFUNC symbols. */
549 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
552 eh
= (struct elf_x86_link_hash_entry
*) h
;
553 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
555 asection
*s
= p
->sec
->output_section
;
557 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
559 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
561 info
->flags
|= DF_TEXTREL
;
563 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
564 || info
->error_textrel
)
565 /* xgettext:c-format */
566 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
567 p
->sec
->owner
, h
->root
.root
.string
,
570 /* Not an error, just cut short the traversal. */
577 /* Allocate space in .plt, .got and associated reloc sections for
578 local dynamic relocs. */
581 elf_x86_allocate_local_dynreloc (void **slot
, void *inf
)
583 struct elf_link_hash_entry
*h
584 = (struct elf_link_hash_entry
*) *slot
;
586 if (h
->type
!= STT_GNU_IFUNC
590 || h
->root
.type
!= bfd_link_hash_defined
)
593 return elf_x86_allocate_dynrelocs (h
, inf
);
596 /* Find and/or create a hash entry for local symbol. */
598 struct elf_link_hash_entry
*
599 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table
*htab
,
600 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
603 struct elf_x86_link_hash_entry e
, *ret
;
604 asection
*sec
= abfd
->sections
;
605 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
606 htab
->r_sym (rel
->r_info
));
609 e
.elf
.indx
= sec
->id
;
610 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
611 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
612 create
? INSERT
: NO_INSERT
);
619 ret
= (struct elf_x86_link_hash_entry
*) *slot
;
623 ret
= (struct elf_x86_link_hash_entry
*)
624 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
625 sizeof (struct elf_x86_link_hash_entry
));
628 memset (ret
, 0, sizeof (*ret
));
629 ret
->elf
.indx
= sec
->id
;
630 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
631 ret
->elf
.dynindx
= -1;
632 ret
->plt_got
.offset
= (bfd_vma
) -1;
638 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
639 SYNC WITH _bfd_elf_link_hash_newfunc. */
641 struct bfd_hash_entry
*
642 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
643 struct bfd_hash_table
*table
,
646 /* Allocate the structure if it has not already been allocated by a
650 entry
= (struct bfd_hash_entry
*)
651 bfd_hash_allocate (table
,
652 sizeof (struct elf_x86_link_hash_entry
));
657 /* Call the allocation method of the superclass. */
658 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
661 struct elf_x86_link_hash_entry
*eh
662 = (struct elf_x86_link_hash_entry
*) entry
;
663 struct elf_link_hash_table
*htab
664 = (struct elf_link_hash_table
*) table
;
666 memset (&eh
->elf
.size
, 0,
667 (sizeof (struct elf_x86_link_hash_entry
)
668 - offsetof (struct elf_link_hash_entry
, size
)));
669 /* Set local fields. */
671 eh
->elf
.dynindx
= -1;
672 eh
->elf
.got
= htab
->init_got_refcount
;
673 eh
->elf
.plt
= htab
->init_plt_refcount
;
674 /* Assume that we have been called by a non-ELF symbol reader.
675 This flag is then reset by the code which reads an ELF input
676 file. This ensures that a symbol created by a non-ELF symbol
677 reader will have the flag set correctly. */
679 eh
->plt_second
.offset
= (bfd_vma
) -1;
680 eh
->plt_got
.offset
= (bfd_vma
) -1;
681 eh
->tlsdesc_got
= (bfd_vma
) -1;
687 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
688 for local symbol so that we can handle local STT_GNU_IFUNC symbols
689 as global symbol. We reuse indx and dynstr_index for local symbol
690 hash since they aren't used by global symbols in this backend. */
693 _bfd_x86_elf_local_htab_hash (const void *ptr
)
695 struct elf_link_hash_entry
*h
696 = (struct elf_link_hash_entry
*) ptr
;
697 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
700 /* Compare local hash entries. */
703 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
705 struct elf_link_hash_entry
*h1
706 = (struct elf_link_hash_entry
*) ptr1
;
707 struct elf_link_hash_entry
*h2
708 = (struct elf_link_hash_entry
*) ptr2
;
710 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
713 /* Destroy an x86 ELF linker hash table. */
716 elf_x86_link_hash_table_free (bfd
*obfd
)
718 struct elf_x86_link_hash_table
*htab
719 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
721 if (htab
->loc_hash_table
)
722 htab_delete (htab
->loc_hash_table
);
723 if (htab
->loc_hash_memory
)
724 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
725 _bfd_elf_link_hash_table_free (obfd
);
729 elf_i386_is_reloc_section (const char *secname
)
731 return CONST_STRNEQ (secname
, ".rel");
735 elf_x86_64_is_reloc_section (const char *secname
)
737 return CONST_STRNEQ (secname
, ".rela");
740 /* Create an x86 ELF linker hash table. */
742 struct bfd_link_hash_table
*
743 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
745 struct elf_x86_link_hash_table
*ret
;
746 const struct elf_backend_data
*bed
;
747 bfd_size_type amt
= sizeof (struct elf_x86_link_hash_table
);
749 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
753 bed
= get_elf_backend_data (abfd
);
754 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
755 _bfd_x86_elf_link_hash_newfunc
,
756 sizeof (struct elf_x86_link_hash_entry
),
763 if (bed
->target_id
== X86_64_ELF_DATA
)
765 ret
->is_reloc_section
= elf_x86_64_is_reloc_section
;
766 ret
->dt_reloc
= DT_RELA
;
767 ret
->dt_reloc_sz
= DT_RELASZ
;
768 ret
->dt_reloc_ent
= DT_RELAENT
;
769 ret
->got_entry_size
= 8;
770 ret
->tls_get_addr
= "__tls_get_addr";
774 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
775 ret
->pointer_r_type
= R_X86_64_64
;
776 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
777 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
781 if (bed
->target_id
== X86_64_ELF_DATA
)
783 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
784 ret
->pointer_r_type
= R_X86_64_32
;
785 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
786 ret
->dynamic_interpreter_size
787 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
791 ret
->is_reloc_section
= elf_i386_is_reloc_section
;
792 ret
->dt_reloc
= DT_REL
;
793 ret
->dt_reloc_sz
= DT_RELSZ
;
794 ret
->dt_reloc_ent
= DT_RELENT
;
795 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
796 ret
->got_entry_size
= 4;
797 ret
->pointer_r_type
= R_386_32
;
798 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
799 ret
->dynamic_interpreter_size
800 = sizeof ELF32_DYNAMIC_INTERPRETER
;
801 ret
->tls_get_addr
= "___tls_get_addr";
804 ret
->target_id
= bed
->target_id
;
806 ret
->loc_hash_table
= htab_try_create (1024,
807 _bfd_x86_elf_local_htab_hash
,
808 _bfd_x86_elf_local_htab_eq
,
810 ret
->loc_hash_memory
= objalloc_create ();
811 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
813 elf_x86_link_hash_table_free (abfd
);
816 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
818 return &ret
->elf
.root
;
821 /* Sort relocs into address order. */
824 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
826 const arelent
*a
= * (const arelent
**) ap
;
827 const arelent
*b
= * (const arelent
**) bp
;
829 if (a
->address
> b
->address
)
831 else if (a
->address
< b
->address
)
838 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
840 if (!bfd_link_relocatable (info
))
842 /* Check for __tls_get_addr reference. */
843 struct elf_x86_link_hash_table
*htab
;
844 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
845 htab
= elf_x86_hash_table (info
, bed
->target_id
);
848 struct elf_link_hash_entry
*h
;
850 h
= elf_link_hash_lookup (elf_hash_table (info
),
852 FALSE
, FALSE
, FALSE
);
854 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
856 /* "__ehdr_start" will be defined by linker as a hidden symbol
857 later if it is referenced and not defined. */
858 h
= elf_link_hash_lookup (elf_hash_table (info
),
860 FALSE
, FALSE
, FALSE
);
862 && (h
->root
.type
== bfd_link_hash_new
863 || h
->root
.type
== bfd_link_hash_undefined
864 || h
->root
.type
== bfd_link_hash_undefweak
865 || h
->root
.type
== bfd_link_hash_common
))
867 elf_x86_hash_entry (h
)->local_ref
= 2;
868 elf_x86_hash_entry (h
)->linker_def
= 1;
873 /* Invoke the regular ELF backend linker to do all the work. */
874 return _bfd_elf_link_check_relocs (abfd
, info
);
877 /* Set the sizes of the dynamic sections. */
880 _bfd_x86_elf_size_dynamic_sections (bfd
*output_bfd
,
881 struct bfd_link_info
*info
)
883 struct elf_x86_link_hash_table
*htab
;
888 const struct elf_backend_data
*bed
889 = get_elf_backend_data (output_bfd
);
891 htab
= elf_x86_hash_table (info
, bed
->target_id
);
894 dynobj
= htab
->elf
.dynobj
;
898 /* Set up .got offsets for local syms, and space for local dynamic
900 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
902 bfd_signed_vma
*local_got
;
903 bfd_signed_vma
*end_local_got
;
904 char *local_tls_type
;
905 bfd_vma
*local_tlsdesc_gotent
;
906 bfd_size_type locsymcount
;
907 Elf_Internal_Shdr
*symtab_hdr
;
910 if (! is_x86_elf (ibfd
, htab
))
913 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
915 struct elf_dyn_relocs
*p
;
917 for (p
= ((struct elf_dyn_relocs
*)
918 elf_section_data (s
)->local_dynrel
);
922 if (!bfd_is_abs_section (p
->sec
)
923 && bfd_is_abs_section (p
->sec
->output_section
))
925 /* Input section has been discarded, either because
926 it is a copy of a linkonce section or due to
927 linker script /DISCARD/, so we'll be discarding
930 else if (htab
->is_vxworks
931 && strcmp (p
->sec
->output_section
->name
,
934 /* Relocations in vxworks .tls_vars sections are
935 handled specially by the loader. */
937 else if (p
->count
!= 0)
939 srel
= elf_section_data (p
->sec
)->sreloc
;
940 srel
->size
+= p
->count
* htab
->sizeof_reloc
;
941 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
942 && (info
->flags
& DF_TEXTREL
) == 0)
944 info
->flags
|= DF_TEXTREL
;
945 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
946 || info
->error_textrel
)
947 /* xgettext:c-format */
948 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
949 p
->sec
->owner
, p
->sec
);
955 local_got
= elf_local_got_refcounts (ibfd
);
959 symtab_hdr
= &elf_symtab_hdr (ibfd
);
960 locsymcount
= symtab_hdr
->sh_info
;
961 end_local_got
= local_got
+ locsymcount
;
962 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
963 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
965 srel
= htab
->elf
.srelgot
;
966 for (; local_got
< end_local_got
;
967 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
969 *local_tlsdesc_gotent
= (bfd_vma
) -1;
972 if (GOT_TLS_GDESC_P (*local_tls_type
))
974 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
975 - elf_x86_compute_jump_table_size (htab
);
976 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
977 *local_got
= (bfd_vma
) -2;
979 if (! GOT_TLS_GDESC_P (*local_tls_type
)
980 || GOT_TLS_GD_P (*local_tls_type
))
982 *local_got
= s
->size
;
983 s
->size
+= htab
->got_entry_size
;
984 if (GOT_TLS_GD_P (*local_tls_type
)
985 || *local_tls_type
== GOT_TLS_IE_BOTH
)
986 s
->size
+= htab
->got_entry_size
;
988 if (bfd_link_pic (info
)
989 || GOT_TLS_GD_ANY_P (*local_tls_type
)
990 || (*local_tls_type
& GOT_TLS_IE
))
992 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
993 srel
->size
+= 2 * htab
->sizeof_reloc
;
994 else if (GOT_TLS_GD_P (*local_tls_type
)
995 || ! GOT_TLS_GDESC_P (*local_tls_type
))
996 srel
->size
+= htab
->sizeof_reloc
;
997 if (GOT_TLS_GDESC_P (*local_tls_type
))
999 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
1000 if (bed
->target_id
== X86_64_ELF_DATA
)
1001 htab
->tlsdesc_plt
= (bfd_vma
) -1;
1006 *local_got
= (bfd_vma
) -1;
1010 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
1012 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1013 or R_X86_64_TLSLD relocs. */
1014 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
1015 htab
->elf
.sgot
->size
+= 2 * htab
->got_entry_size
;
1016 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
1019 htab
->tls_ld_or_ldm_got
.offset
= -1;
1021 /* Allocate global sym .plt and .got entries, and space for global
1022 sym dynamic relocs. */
1023 elf_link_hash_traverse (&htab
->elf
, elf_x86_allocate_dynrelocs
,
1026 /* Allocate .plt and .got entries, and space for local symbols. */
1027 htab_traverse (htab
->loc_hash_table
, elf_x86_allocate_local_dynreloc
,
1030 /* For every jump slot reserved in the sgotplt, reloc_count is
1031 incremented. However, when we reserve space for TLS descriptors,
1032 it's not incremented, so in order to compute the space reserved
1033 for them, it suffices to multiply the reloc count by the jump
1036 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1037 so that R_{386,X86_64}_IRELATIVE entries come last. */
1038 if (htab
->elf
.srelplt
)
1040 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
1041 htab
->sgotplt_jump_table_size
1042 = elf_x86_compute_jump_table_size (htab
);
1043 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
1045 else if (htab
->elf
.irelplt
)
1046 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1048 if (htab
->tlsdesc_plt
)
1050 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1051 lazy TLS relocations, don't generate the PLT and GOT entries
1053 if ((info
->flags
& DF_BIND_NOW
))
1054 htab
->tlsdesc_plt
= 0;
1057 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
1058 htab
->elf
.sgot
->size
+= htab
->got_entry_size
;
1059 /* Reserve room for the initial entry.
1060 FIXME: we could probably do away with it in this case. */
1061 if (htab
->elf
.splt
->size
== 0)
1062 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
1063 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
1064 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
1068 if (htab
->elf
.sgotplt
)
1070 /* Don't allocate .got.plt section if there are no GOT nor PLT
1071 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1072 if ((htab
->elf
.hgot
== NULL
1073 || !htab
->elf
.hgot
->ref_regular_nonweak
)
1074 && (htab
->elf
.sgotplt
->size
== bed
->got_header_size
)
1075 && (htab
->elf
.splt
== NULL
1076 || htab
->elf
.splt
->size
== 0)
1077 && (htab
->elf
.sgot
== NULL
1078 || htab
->elf
.sgot
->size
== 0)
1079 && (htab
->elf
.iplt
== NULL
1080 || htab
->elf
.iplt
->size
== 0)
1081 && (htab
->elf
.igotplt
== NULL
1082 || htab
->elf
.igotplt
->size
== 0))
1083 htab
->elf
.sgotplt
->size
= 0;
1086 if (_bfd_elf_eh_frame_present (info
))
1088 if (htab
->plt_eh_frame
!= NULL
1089 && htab
->elf
.splt
!= NULL
1090 && htab
->elf
.splt
->size
!= 0
1091 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
1092 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
1094 if (htab
->plt_got_eh_frame
!= NULL
1095 && htab
->plt_got
!= NULL
1096 && htab
->plt_got
->size
!= 0
1097 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
1098 htab
->plt_got_eh_frame
->size
1099 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1101 /* Unwind info for the second PLT and .plt.got sections are
1103 if (htab
->plt_second_eh_frame
!= NULL
1104 && htab
->plt_second
!= NULL
1105 && htab
->plt_second
->size
!= 0
1106 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
1107 htab
->plt_second_eh_frame
->size
1108 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1111 /* We now have determined the sizes of the various dynamic sections.
1112 Allocate memory for them. */
1114 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1116 bfd_boolean strip_section
= TRUE
;
1118 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1121 if (s
== htab
->elf
.splt
1122 || s
== htab
->elf
.sgot
)
1124 /* Strip this section if we don't need it; see the
1126 /* We'd like to strip these sections if they aren't needed, but if
1127 we've exported dynamic symbols from them we must leave them.
1128 It's too late to tell BFD to get rid of the symbols. */
1130 if (htab
->elf
.hplt
!= NULL
)
1131 strip_section
= FALSE
;
1133 else if (s
== htab
->elf
.sgotplt
1134 || s
== htab
->elf
.iplt
1135 || s
== htab
->elf
.igotplt
1136 || s
== htab
->plt_second
1137 || s
== htab
->plt_got
1138 || s
== htab
->plt_eh_frame
1139 || s
== htab
->plt_got_eh_frame
1140 || s
== htab
->plt_second_eh_frame
1141 || s
== htab
->elf
.sdynbss
1142 || s
== htab
->elf
.sdynrelro
)
1144 /* Strip these too. */
1146 else if (htab
->is_reloc_section (bfd_get_section_name (dynobj
, s
)))
1149 && s
!= htab
->elf
.srelplt
1150 && s
!= htab
->srelplt2
)
1153 /* We use the reloc_count field as a counter if we need
1154 to copy relocs into the output file. */
1155 if (s
!= htab
->elf
.srelplt
)
1160 /* It's not one of our sections, so don't allocate space. */
1166 /* If we don't need this section, strip it from the
1167 output file. This is mostly to handle .rel.bss and
1168 .rel.plt. We must create both sections in
1169 create_dynamic_sections, because they must be created
1170 before the linker maps input sections to output
1171 sections. The linker does that before
1172 adjust_dynamic_symbol is called, and it is that
1173 function which decides whether anything needs to go
1174 into these sections. */
1176 s
->flags
|= SEC_EXCLUDE
;
1180 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1183 /* Allocate memory for the section contents. We use bfd_zalloc
1184 here in case unused entries are not reclaimed before the
1185 section's contents are written out. This should not happen,
1186 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1187 reloc instead of garbage. */
1188 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
1189 if (s
->contents
== NULL
)
1193 if (htab
->plt_eh_frame
!= NULL
1194 && htab
->plt_eh_frame
->contents
!= NULL
)
1196 memcpy (htab
->plt_eh_frame
->contents
,
1197 htab
->plt
.eh_frame_plt
,
1198 htab
->plt_eh_frame
->size
);
1199 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
1200 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
1203 if (htab
->plt_got_eh_frame
!= NULL
1204 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1206 memcpy (htab
->plt_got_eh_frame
->contents
,
1207 htab
->non_lazy_plt
->eh_frame_plt
,
1208 htab
->plt_got_eh_frame
->size
);
1209 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
1210 (htab
->plt_got_eh_frame
->contents
1211 + PLT_FDE_LEN_OFFSET
));
1214 if (htab
->plt_second_eh_frame
!= NULL
1215 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1217 memcpy (htab
->plt_second_eh_frame
->contents
,
1218 htab
->non_lazy_plt
->eh_frame_plt
,
1219 htab
->plt_second_eh_frame
->size
);
1220 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
1221 (htab
->plt_second_eh_frame
->contents
1222 + PLT_FDE_LEN_OFFSET
));
1225 if (htab
->elf
.dynamic_sections_created
)
1227 /* Add some entries to the .dynamic section. We fill in the
1228 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1229 but we must add the entries now so that we get the correct
1230 size for the .dynamic section. The DT_DEBUG entry is filled
1231 in by the dynamic linker and used by the debugger. */
1232 #define add_dynamic_entry(TAG, VAL) \
1233 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1235 if (bfd_link_executable (info
))
1237 if (!add_dynamic_entry (DT_DEBUG
, 0))
1241 if (htab
->elf
.splt
->size
!= 0)
1243 /* DT_PLTGOT is used by prelink even if there is no PLT
1245 if (!add_dynamic_entry (DT_PLTGOT
, 0))
1249 if (htab
->elf
.srelplt
->size
!= 0)
1251 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1252 || !add_dynamic_entry (DT_PLTREL
, htab
->dt_reloc
)
1253 || !add_dynamic_entry (DT_JMPREL
, 0))
1257 if (htab
->tlsdesc_plt
1258 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
1259 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
1264 if (!add_dynamic_entry (htab
->dt_reloc
, 0)
1265 || !add_dynamic_entry (htab
->dt_reloc_sz
, 0)
1266 || !add_dynamic_entry (htab
->dt_reloc_ent
,
1267 htab
->sizeof_reloc
))
1270 /* If any dynamic relocs apply to a read-only section,
1271 then we need a DT_TEXTREL entry. */
1272 if ((info
->flags
& DF_TEXTREL
) == 0)
1273 elf_link_hash_traverse (&htab
->elf
,
1274 _bfd_x86_elf_readonly_dynrelocs
,
1277 if ((info
->flags
& DF_TEXTREL
) != 0)
1279 if (htab
->readonly_dynrelocs_against_ifunc
)
1281 info
->callbacks
->einfo
1282 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
1283 bfd_set_error (bfd_error_bad_value
);
1287 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1291 if (htab
->is_vxworks
1292 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
1295 #undef add_dynamic_entry
1301 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
1302 struct bfd_link_info
*info
)
1304 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
1308 struct elf_link_hash_entry
*tlsbase
;
1310 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
1311 "_TLS_MODULE_BASE_",
1312 FALSE
, FALSE
, FALSE
);
1314 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
1316 struct elf_x86_link_hash_table
*htab
;
1317 struct bfd_link_hash_entry
*bh
= NULL
;
1318 const struct elf_backend_data
*bed
1319 = get_elf_backend_data (output_bfd
);
1321 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1325 if (!(_bfd_generic_link_add_one_symbol
1326 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1327 tls_sec
, 0, NULL
, FALSE
,
1328 bed
->collect
, &bh
)))
1331 htab
->tls_module_base
= bh
;
1333 tlsbase
= (struct elf_link_hash_entry
*)bh
;
1334 tlsbase
->def_regular
= 1;
1335 tlsbase
->other
= STV_HIDDEN
;
1336 tlsbase
->root
.linker_def
= 1;
1337 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1345 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
1346 const Elf_Internal_Sym
*isym
,
1347 bfd_boolean definition
,
1348 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
1352 struct elf_x86_link_hash_entry
*eh
1353 = (struct elf_x86_link_hash_entry
*) h
;
1354 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
1359 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1362 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1363 struct elf_link_hash_entry
*dir
,
1364 struct elf_link_hash_entry
*ind
)
1366 struct elf_x86_link_hash_entry
*edir
, *eind
;
1368 edir
= (struct elf_x86_link_hash_entry
*) dir
;
1369 eind
= (struct elf_x86_link_hash_entry
*) ind
;
1371 if (eind
->dyn_relocs
!= NULL
)
1373 if (edir
->dyn_relocs
!= NULL
)
1375 struct elf_dyn_relocs
**pp
;
1376 struct elf_dyn_relocs
*p
;
1378 /* Add reloc counts against the indirect sym to the direct sym
1379 list. Merge any entries against the same section. */
1380 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1382 struct elf_dyn_relocs
*q
;
1384 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1385 if (q
->sec
== p
->sec
)
1387 q
->pc_count
+= p
->pc_count
;
1388 q
->count
+= p
->count
;
1395 *pp
= edir
->dyn_relocs
;
1398 edir
->dyn_relocs
= eind
->dyn_relocs
;
1399 eind
->dyn_relocs
= NULL
;
1402 if (ind
->root
.type
== bfd_link_hash_indirect
1403 && dir
->got
.refcount
<= 0)
1405 edir
->tls_type
= eind
->tls_type
;
1406 eind
->tls_type
= GOT_UNKNOWN
;
1409 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1410 generate a R_386_COPY reloc. */
1411 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1413 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1414 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1416 if (ELIMINATE_COPY_RELOCS
1417 && ind
->root
.type
!= bfd_link_hash_indirect
1418 && dir
->dynamic_adjusted
)
1420 /* If called to transfer flags for a weakdef during processing
1421 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1422 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1423 if (dir
->versioned
!= versioned_hidden
)
1424 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1425 dir
->ref_regular
|= ind
->ref_regular
;
1426 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1427 dir
->needs_plt
|= ind
->needs_plt
;
1428 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1432 if (eind
->func_pointer_refcount
> 0)
1434 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1435 eind
->func_pointer_refcount
= 0;
1438 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1442 /* Remove undefined weak symbol from the dynamic symbol table if it
1443 is resolved to 0. */
1446 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
1447 struct elf_link_hash_entry
*h
)
1449 if (h
->dynindx
!= -1)
1451 const struct elf_backend_data
*bed
1452 = get_elf_backend_data (info
->output_bfd
);
1453 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
1455 elf_x86_hash_entry (h
)->has_got_reloc
,
1456 elf_x86_hash_entry (h
)))
1459 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1466 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1469 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
1471 if (h
->plt
.offset
!= (bfd_vma
) -1
1473 && !h
->pointer_equality_needed
)
1476 return _bfd_elf_hash_symbol (h
);
1479 /* Adjust a symbol defined by a dynamic object and referenced by a
1480 regular object. The current definition is in some section of the
1481 dynamic object, but we're not including those sections. We have to
1482 change the definition to something the rest of the link can
1486 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1487 struct elf_link_hash_entry
*h
)
1489 struct elf_x86_link_hash_table
*htab
;
1491 struct elf_x86_link_hash_entry
*eh
;
1492 struct elf_dyn_relocs
*p
;
1493 const struct elf_backend_data
*bed
1494 = get_elf_backend_data (info
->output_bfd
);
1496 /* STT_GNU_IFUNC symbol must go through PLT. */
1497 if (h
->type
== STT_GNU_IFUNC
)
1499 /* All local STT_GNU_IFUNC references must be treate as local
1500 calls via local PLT. */
1502 && SYMBOL_CALLS_LOCAL (info
, h
))
1504 bfd_size_type pc_count
= 0, count
= 0;
1505 struct elf_dyn_relocs
**pp
;
1507 eh
= (struct elf_x86_link_hash_entry
*) h
;
1508 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1510 pc_count
+= p
->pc_count
;
1511 p
->count
-= p
->pc_count
;
1520 if (pc_count
|| count
)
1525 /* Increment PLT reference count only for PC-relative
1528 if (h
->plt
.refcount
<= 0)
1529 h
->plt
.refcount
= 1;
1531 h
->plt
.refcount
+= 1;
1536 if (h
->plt
.refcount
<= 0)
1538 h
->plt
.offset
= (bfd_vma
) -1;
1544 /* If this is a function, put it in the procedure linkage table. We
1545 will fill in the contents of the procedure linkage table later,
1546 when we know the address of the .got section. */
1547 if (h
->type
== STT_FUNC
1550 if (h
->plt
.refcount
<= 0
1551 || SYMBOL_CALLS_LOCAL (info
, h
)
1552 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1553 && h
->root
.type
== bfd_link_hash_undefweak
))
1555 /* This case can occur if we saw a PLT32 reloc in an input
1556 file, but the symbol was never referred to by a dynamic
1557 object, or if all references were garbage collected. In
1558 such a case, we don't actually need to build a procedure
1559 linkage table, and we can just do a PC32 reloc instead. */
1560 h
->plt
.offset
= (bfd_vma
) -1;
1567 /* It's possible that we incorrectly decided a .plt reloc was needed
1568 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1569 check_relocs. We can't decide accurately between function and
1570 non-function syms in check-relocs; Objects loaded later in
1571 the link may change h->type. So fix it now. */
1572 h
->plt
.offset
= (bfd_vma
) -1;
1574 eh
= (struct elf_x86_link_hash_entry
*) h
;
1576 /* If this is a weak symbol, and there is a real definition, the
1577 processor independent code will have arranged for us to see the
1578 real definition first, and we can just use the same value. */
1579 if (h
->u
.weakdef
!= NULL
)
1581 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1582 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1583 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1584 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1585 if (ELIMINATE_COPY_RELOCS
1586 || info
->nocopyreloc
1587 || SYMBOL_NO_COPYRELOC (info
, eh
))
1589 /* NB: needs_copy is always 0 for i386. */
1590 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1591 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
1596 /* This is a reference to a symbol defined by a dynamic object which
1597 is not a function. */
1599 /* If we are creating a shared library, we must presume that the
1600 only references to the symbol are via the global offset table.
1601 For such cases we need not do anything here; the relocations will
1602 be handled correctly by relocate_section. */
1603 if (!bfd_link_executable (info
))
1606 /* If there are no references to this symbol that do not use the
1607 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1608 reloc. NB: gotoff_ref is always 0 for x86-64. */
1609 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
1612 /* If -z nocopyreloc was given, we won't generate them either. */
1613 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
1619 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1623 /* If there aren't any dynamic relocs in read-only sections nor
1624 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1625 avoid the copy reloc. This doesn't work on VxWorks, where we can
1626 not have dynamic relocations (other than copy and jump slot
1627 relocations) in an executable. */
1628 if (ELIMINATE_COPY_RELOCS
1629 && (bed
->target_id
== X86_64_ELF_DATA
1631 && !htab
->is_vxworks
)))
1633 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1635 s
= p
->sec
->output_section
;
1636 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1640 /* If we didn't find any dynamic relocs in read-only sections,
1641 then we'll be keeping the dynamic relocs and avoiding the copy
1650 /* We must allocate the symbol in our .dynbss section, which will
1651 become part of the .bss section of the executable. There will be
1652 an entry for this symbol in the .dynsym section. The dynamic
1653 object will contain position independent code, so all references
1654 from the dynamic object to this symbol will go through the global
1655 offset table. The dynamic linker will use the .dynsym entry to
1656 determine the address it must put in the global offset table, so
1657 both the dynamic object and the regular object will refer to the
1658 same memory location for the variable. */
1660 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1661 dynamic linker to copy the initial value out of the dynamic object
1662 and into the runtime process image. */
1663 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1665 s
= htab
->elf
.sdynrelro
;
1666 srel
= htab
->elf
.sreldynrelro
;
1670 s
= htab
->elf
.sdynbss
;
1671 srel
= htab
->elf
.srelbss
;
1673 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1675 srel
->size
+= htab
->sizeof_reloc
;
1679 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1682 /* Return TRUE if a symbol is referenced locally. It is similar to
1683 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
1684 works in check_relocs. */
1687 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info
*info
,
1688 struct elf_link_hash_entry
*h
)
1690 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
1691 struct elf_x86_link_hash_table
*htab
1692 = (struct elf_x86_link_hash_table
*) info
->hash
;
1694 if (eh
->local_ref
> 1)
1697 if (eh
->local_ref
== 1)
1700 /* Unversioned symbols defined in regular objects can be forced local
1701 by linker version script. A weak undefined symbol is forced local
1703 1. It has non-default visibility. Or
1704 2. When building executable, it has non-GOT/non-PLT relocations
1705 in text section or there is no dynamic linker. Or
1706 3. or "-z nodynamic-undefined-weak" is used.
1708 if (SYMBOL_REFERENCES_LOCAL (info
, h
)
1709 || (h
->root
.type
== bfd_link_hash_undefweak
1710 && (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1711 || (bfd_link_executable (info
)
1712 && (htab
->interp
== NULL
|| eh
->has_non_got_reloc
))
1713 || info
->dynamic_undefined_weak
== 0))
1714 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
1715 && h
->versioned
== unversioned
1716 && info
->version_info
!= NULL
1717 && bfd_hide_sym_by_version (info
->version_info
,
1718 h
->root
.root
.string
)))
1728 /* Return the section that should be marked against GC for a given
1732 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
1733 struct bfd_link_info
*info
,
1734 Elf_Internal_Rela
*rel
,
1735 struct elf_link_hash_entry
*h
,
1736 Elf_Internal_Sym
*sym
)
1738 /* Compiler should optimize this out. */
1739 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1740 != (unsigned int) R_386_GNU_VTINHERIT
)
1741 || ((unsigned int) R_X86_64_GNU_VTENTRY
1742 != (unsigned int) R_386_GNU_VTENTRY
))
1746 switch (ELF32_R_TYPE (rel
->r_info
))
1748 case R_X86_64_GNU_VTINHERIT
:
1749 case R_X86_64_GNU_VTENTRY
:
1753 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1757 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
1759 bfd_vma offset ATTRIBUTE_UNUSED
,
1762 return got_addr
+ off
;
1766 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
1769 bfd_vma got_addr ATTRIBUTE_UNUSED
)
1771 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
1775 elf_i386_valid_plt_reloc_p (unsigned int type
)
1777 return (type
== R_386_JUMP_SLOT
1778 || type
== R_386_GLOB_DAT
1779 || type
== R_386_IRELATIVE
);
1783 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
1785 return (type
== R_X86_64_JUMP_SLOT
1786 || type
== R_X86_64_GLOB_DAT
1787 || type
== R_X86_64_IRELATIVE
);
1791 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
1795 struct elf_x86_plt plts
[],
1799 long size
, i
, n
, len
;
1801 unsigned int plt_got_offset
, plt_entry_size
;
1803 bfd_byte
*plt_contents
;
1805 arelent
**dynrelbuf
, *p
;
1807 const struct elf_backend_data
*bed
;
1808 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
1810 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
1815 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
1816 if (dynrelbuf
== NULL
)
1819 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
1822 /* Sort the relocs by address. */
1823 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
1824 _bfd_x86_elf_compare_relocs
);
1826 size
= count
* sizeof (asymbol
);
1828 /* Allocate space for @plt suffixes. */
1830 for (i
= 0; i
< dynrelcount
; i
++)
1833 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
1835 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
1838 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
1842 bed
= get_elf_backend_data (abfd
);
1844 if (bed
->target_id
== X86_64_ELF_DATA
)
1846 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
1847 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
1851 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
1852 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
1855 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
1857 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
1859 got_addr
= sec
->vma
;
1862 sec
= bfd_get_section_by_name (abfd
, ".got");
1864 got_addr
= sec
->vma
;
1867 if (got_addr
== (bfd_vma
) -1)
1872 /* Check for each PLT section. */
1873 names
= (char *) (s
+ count
);
1876 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1877 if ((plt_contents
= plts
[j
].contents
) != NULL
)
1882 struct elf_x86_plt
*plt_p
= &plts
[j
];
1884 plt_got_offset
= plt_p
->plt_got_offset
;
1885 plt_entry_size
= plt_p
->plt_entry_size
;
1889 if ((plt_p
->type
& plt_lazy
))
1891 /* Skip PLT0 in lazy PLT. */
1893 offset
= plt_entry_size
;
1901 /* Check each PLT entry against dynamic relocations. */
1902 for (; k
< plt_p
->count
; k
++)
1908 /* Get the GOT offset for i386 or the PC-relative offset
1909 for x86-64, a signed 32-bit integer. */
1910 off
= H_GET_32 (abfd
, (plt_contents
+ offset
1912 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
1914 /* Binary search. */
1918 while ((min
+ 1) < max
)
1922 mid
= (min
+ max
) / 2;
1924 if (got_vma
> r
->address
)
1926 else if (got_vma
< r
->address
)
1935 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
1936 if (got_vma
== p
->address
1938 && valid_plt_reloc_p (p
->howto
->type
))
1940 *s
= **p
->sym_ptr_ptr
;
1941 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
1942 set. Since we are defining a symbol, ensure one
1944 if ((s
->flags
& BSF_LOCAL
) == 0)
1945 s
->flags
|= BSF_GLOBAL
;
1946 s
->flags
|= BSF_SYNTHETIC
;
1947 /* This is no longer a section symbol. */
1948 s
->flags
&= ~BSF_SECTION_SYM
;
1950 s
->the_bfd
= plt
->owner
;
1954 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
1955 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
1961 memcpy (names
, "+0x", sizeof ("+0x") - 1);
1962 names
+= sizeof ("+0x") - 1;
1963 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
1964 for (a
= buf
; *a
== '0'; ++a
)
1967 memcpy (names
, a
, size
);
1970 memcpy (names
, "@plt", sizeof ("@plt"));
1971 names
+= sizeof ("@plt");
1975 offset
+= plt_entry_size
;
1979 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
1988 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1989 if (plts
[j
].contents
!= NULL
)
1990 free (plts
[j
].contents
);
1997 /* Parse x86 GNU properties. */
1999 enum elf_property_kind
2000 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
2001 bfd_byte
*ptr
, unsigned int datasz
)
2007 case GNU_PROPERTY_X86_ISA_1_USED
:
2008 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2009 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2013 ((type
== GNU_PROPERTY_X86_ISA_1_USED
2014 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
2015 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
2016 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
2017 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
2019 return property_corrupt
;
2021 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
2022 /* Combine properties of the same type. */
2023 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
2024 prop
->pr_kind
= property_number
;
2028 return property_ignored
;
2031 return property_number
;
2034 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2035 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2036 should be merged with ABFD. */
2039 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
2040 bfd
*abfd ATTRIBUTE_UNUSED
,
2041 elf_property
*aprop
,
2042 elf_property
*bprop
)
2044 unsigned int number
, features
;
2045 bfd_boolean updated
= FALSE
;
2046 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
2050 case GNU_PROPERTY_X86_ISA_1_USED
:
2051 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2052 if (aprop
!= NULL
&& bprop
!= NULL
)
2054 number
= aprop
->u
.number
;
2055 aprop
->u
.number
= number
| bprop
->u
.number
;
2056 updated
= number
!= (unsigned int) aprop
->u
.number
;
2060 /* Return TRUE if APROP is NULL to indicate that BPROP should
2061 be added to ABFD. */
2062 updated
= aprop
== NULL
;
2066 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2067 /* Only one of APROP and BPROP can be NULL:
2068 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2069 2. If APROP is NULL, remove x86 feature.
2070 3. Otherwise, do nothing.
2072 if (aprop
!= NULL
&& bprop
!= NULL
)
2076 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2078 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2079 number
= aprop
->u
.number
;
2080 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2081 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2082 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
2083 updated
= number
!= (unsigned int) aprop
->u
.number
;
2084 /* Remove the property if all feature bits are cleared. */
2085 if (aprop
->u
.number
== 0)
2086 aprop
->pr_kind
= property_remove
;
2092 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2094 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2097 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2098 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2101 number
= aprop
->u
.number
;
2102 aprop
->u
.number
= number
| features
;
2103 updated
= number
!= (unsigned int) aprop
->u
.number
;
2107 bprop
->u
.number
|= features
;
2111 else if (aprop
!= NULL
)
2113 aprop
->pr_kind
= property_remove
;
2120 /* Never should happen. */
2127 /* Set up x86 GNU properties. Return the first relocatable ELF input
2128 with GNU properties if found. Otherwise, return NULL. */
2131 _bfd_x86_elf_link_setup_gnu_properties
2132 (struct bfd_link_info
*info
, struct elf_x86_init_table
*init_table
)
2134 bfd_boolean normal_target
;
2135 bfd_boolean lazy_plt
;
2136 asection
*sec
, *pltsec
;
2138 bfd_boolean use_ibt_plt
;
2139 unsigned int plt_alignment
, features
;
2140 struct elf_x86_link_hash_table
*htab
;
2144 const struct elf_backend_data
*bed
;
2145 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
2146 unsigned int got_align
;
2150 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2152 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2154 /* Find a normal input file with GNU property note. */
2155 for (pbfd
= info
->input_bfds
;
2157 pbfd
= pbfd
->link
.next
)
2158 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
2159 && bfd_count_sections (pbfd
) != 0)
2163 if (elf_properties (pbfd
) != NULL
)
2167 if (ebfd
!= NULL
&& features
)
2169 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2170 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2171 prop
= _bfd_elf_get_property (ebfd
,
2172 GNU_PROPERTY_X86_FEATURE_1_AND
,
2174 prop
->u
.number
|= features
;
2175 prop
->pr_kind
= property_number
;
2177 /* Create the GNU property note section if needed. */
2180 sec
= bfd_make_section_with_flags (ebfd
,
2181 NOTE_GNU_PROPERTY_SECTION_NAME
,
2189 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
2191 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
2194 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
2198 elf_section_type (sec
) = SHT_NOTE
;
2202 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
2204 bed
= get_elf_backend_data (info
->output_bfd
);
2206 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2210 htab
->is_vxworks
= init_table
->is_vxworks
;
2211 htab
->r_info
= init_table
->r_info
;
2212 htab
->r_sym
= init_table
->r_sym
;
2214 if (bfd_link_relocatable (info
))
2217 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
2218 if (!use_ibt_plt
&& pbfd
!= NULL
)
2220 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2221 elf_property_list
*p
;
2223 /* The property list is sorted in order of type. */
2224 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
2226 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
2228 use_ibt_plt
= !!(p
->property
.u
.number
2229 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2232 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
2237 dynobj
= htab
->elf
.dynobj
;
2239 /* Set htab->elf.dynobj here so that there is no need to check and
2240 set it in check_relocs. */
2245 htab
->elf
.dynobj
= pbfd
;
2252 /* Find a normal input file to hold linker created
2254 for (abfd
= info
->input_bfds
;
2256 abfd
= abfd
->link
.next
)
2257 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2259 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
2261 htab
->elf
.dynobj
= abfd
;
2268 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2269 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2270 canonical function address. */
2271 htab
->plt
.has_plt0
= 1;
2272 normal_target
= init_table
->normal_target
;
2278 htab
->lazy_plt
= init_table
->lazy_ibt_plt
;
2279 htab
->non_lazy_plt
= init_table
->non_lazy_ibt_plt
;
2283 htab
->lazy_plt
= init_table
->lazy_plt
;
2284 htab
->non_lazy_plt
= init_table
->non_lazy_plt
;
2289 htab
->lazy_plt
= init_table
->lazy_plt
;
2290 htab
->non_lazy_plt
= NULL
;
2293 pltsec
= htab
->elf
.splt
;
2295 /* If the non-lazy PLT is available, use it for all PLT entries if
2296 there are no PLT0 or no .plt section. */
2297 if (htab
->non_lazy_plt
!= NULL
2298 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
2301 if (bfd_link_pic (info
))
2302 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
2304 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
2305 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
2306 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
2307 htab
->plt
.plt_got_insn_size
2308 = htab
->non_lazy_plt
->plt_got_insn_size
;
2309 htab
->plt
.eh_frame_plt_size
2310 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2311 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
2316 if (bfd_link_pic (info
))
2318 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
2319 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
2323 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
2324 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
2326 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
2327 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
2328 htab
->plt
.plt_got_insn_size
2329 = htab
->lazy_plt
->plt_got_insn_size
;
2330 htab
->plt
.eh_frame_plt_size
2331 = htab
->lazy_plt
->eh_frame_plt_size
;
2332 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
2335 /* Return if there are no normal input files. */
2339 if (htab
->is_vxworks
2340 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
2343 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
2347 /* Since create_dynamic_sections isn't always called, but GOT
2348 relocations need GOT relocations, create them here so that we
2349 don't need to do it in check_relocs. */
2350 if (htab
->elf
.sgot
== NULL
2351 && !_bfd_elf_create_got_section (dynobj
, info
))
2352 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
2354 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
2356 /* Align .got and .got.plt sections to their entry size. Do it here
2357 instead of in create_dynamic_sections so that they are always
2358 properly aligned even if create_dynamic_sections isn't called. */
2359 sec
= htab
->elf
.sgot
;
2360 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2361 goto error_alignment
;
2363 sec
= htab
->elf
.sgotplt
;
2364 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2365 goto error_alignment
;
2367 /* Create the ifunc sections here so that check_relocs can be
2369 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
2370 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
2372 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
2376 /* Whe creating executable, set the contents of the .interp
2377 section to the interpreter. */
2378 if (bfd_link_executable (info
) && !info
->nointerp
)
2380 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
2383 s
->size
= htab
->dynamic_interpreter_size
;
2384 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2388 /* Don't change PLT section alignment for NaCl since it uses
2389 64-byte PLT entry and sets PLT section alignment to 32
2390 bytes. Don't create additional PLT sections for NaCl. */
2393 flagword pltflags
= (bed
->dynamic_sec_flags
2398 unsigned int non_lazy_plt_alignment
2399 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
2402 if (!bfd_set_section_alignment (sec
->owner
, sec
,
2404 goto error_alignment
;
2406 /* Create the GOT procedure linkage table. */
2407 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2411 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
2413 if (!bfd_set_section_alignment (dynobj
, sec
,
2414 non_lazy_plt_alignment
))
2415 goto error_alignment
;
2417 htab
->plt_got
= sec
;
2425 /* Create the second PLT for Intel IBT support. IBT
2426 PLT is supported only for non-NaCl target and is
2427 is needed only for lazy binding. */
2428 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2432 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
2434 if (!bfd_set_section_alignment (dynobj
, sec
,
2436 goto error_alignment
;
2438 else if (info
->bndplt
&& ABI_64_P (dynobj
))
2440 /* Create the second PLT for Intel MPX support. MPX
2441 PLT is supported only for non-NaCl target in 64-bit
2442 mode and is needed only for lazy binding. */
2443 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2447 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
2449 if (!bfd_set_section_alignment (dynobj
, sec
,
2450 non_lazy_plt_alignment
))
2451 goto error_alignment
;
2454 htab
->plt_second
= sec
;
2458 if (!info
->no_ld_generated_unwind_info
)
2460 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
2461 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2462 | SEC_LINKER_CREATED
);
2464 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2468 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
2470 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2471 goto error_alignment
;
2473 htab
->plt_eh_frame
= sec
;
2475 if (htab
->plt_got
!= NULL
)
2477 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2481 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
2483 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2484 goto error_alignment
;
2486 htab
->plt_got_eh_frame
= sec
;
2489 if (htab
->plt_second
!= NULL
)
2491 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2495 info
->callbacks
->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
2497 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2498 goto error_alignment
;
2500 htab
->plt_second_eh_frame
= sec
;
2507 /* The .iplt section is used for IFUNC symbols in static
2509 sec
= htab
->elf
.iplt
;
2511 && !bfd_set_section_alignment (sec
->owner
, sec
,
2513 goto error_alignment
;