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
, eh
);
112 /* Clear the reference count of function pointer relocations if
113 symbol isn't a normal function. */
114 if (h
->type
!= STT_FUNC
)
115 eh
->func_pointer_refcount
= 0;
117 /* We can't use the GOT PLT if pointer equality is needed since
118 finish_dynamic_symbol won't clear symbol value and the dynamic
119 linker won't update the GOT slot. We will get into an infinite
121 if (htab
->plt_got
!= NULL
122 && h
->type
!= STT_GNU_IFUNC
123 && !h
->pointer_equality_needed
124 && h
->plt
.refcount
> 0
125 && h
->got
.refcount
> 0)
127 /* Don't use the regular PLT if there are both GOT and GOTPLT
129 h
->plt
.offset
= (bfd_vma
) -1;
131 /* Use the GOT PLT. */
132 eh
->plt_got
.refcount
= 1;
135 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
136 here if it is defined and referenced in a non-shared object. */
137 if (h
->type
== STT_GNU_IFUNC
140 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
141 &htab
->readonly_dynrelocs_against_ifunc
,
145 htab
->got_entry_size
,
148 asection
*s
= htab
->plt_second
;
149 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
151 /* Use the second PLT section if it is created. */
152 eh
->plt_second
.offset
= s
->size
;
154 /* Make room for this entry in the second PLT section. */
155 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
163 /* Don't create the PLT entry if there are only function pointer
164 relocations which can be resolved at run-time. */
165 else if (htab
->elf
.dynamic_sections_created
166 && (h
->plt
.refcount
> eh
->func_pointer_refcount
167 || eh
->plt_got
.refcount
> 0))
169 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
171 /* Clear the reference count of function pointer relocations
173 eh
->func_pointer_refcount
= 0;
175 /* Make sure this symbol is output as a dynamic symbol.
176 Undefined weak syms won't yet be marked as dynamic. */
180 && h
->root
.type
== bfd_link_hash_undefweak
)
182 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
186 if (bfd_link_pic (info
)
187 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
189 asection
*s
= htab
->elf
.splt
;
190 asection
*second_s
= htab
->plt_second
;
191 asection
*got_s
= htab
->plt_got
;
193 /* If this is the first .plt entry, make room for the special
194 first entry. The .plt section is used by prelink to undo
195 prelinking for dynamic relocations. */
197 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
200 eh
->plt_got
.offset
= got_s
->size
;
203 h
->plt
.offset
= s
->size
;
205 eh
->plt_second
.offset
= second_s
->size
;
208 /* If this symbol is not defined in a regular file, and we are
209 not generating a shared library, then set the symbol to this
210 location in the .plt. This is required to make function
211 pointers compare as equal between the normal executable and
212 the shared library. */
213 if (! bfd_link_pic (info
)
218 /* We need to make a call to the entry of the GOT PLT
219 instead of regular PLT entry. */
220 h
->root
.u
.def
.section
= got_s
;
221 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
227 /* We need to make a call to the entry of the
228 second PLT instead of regular PLT entry. */
229 h
->root
.u
.def
.section
= second_s
;
230 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
234 h
->root
.u
.def
.section
= s
;
235 h
->root
.u
.def
.value
= h
->plt
.offset
;
240 /* Make room for this entry. */
242 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
245 s
->size
+= plt_entry_size
;
247 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
249 /* We also need to make an entry in the .got.plt section,
250 which will be placed in the .got section by the linker
252 htab
->elf
.sgotplt
->size
+= htab
->got_entry_size
;
254 /* There should be no PLT relocation against resolved
255 undefined weak symbol in executable. */
256 if (!resolved_to_zero
)
258 /* We also need to make an entry in the .rel.plt
260 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
261 htab
->elf
.srelplt
->reloc_count
++;
265 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
267 /* VxWorks has a second set of relocations for each PLT entry
268 in executables. They go in a separate relocation section,
269 which is processed by the kernel loader. */
271 /* There are two relocations for the initial PLT entry: an
272 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
273 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
275 asection
*srelplt2
= htab
->srelplt2
;
276 if (h
->plt
.offset
== plt_entry_size
)
277 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
279 /* There are two extra relocations for each subsequent PLT entry:
280 an R_386_32 relocation for the GOT entry, and an R_386_32
281 relocation for the PLT entry. */
283 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
288 eh
->plt_got
.offset
= (bfd_vma
) -1;
289 h
->plt
.offset
= (bfd_vma
) -1;
295 eh
->plt_got
.offset
= (bfd_vma
) -1;
296 h
->plt
.offset
= (bfd_vma
) -1;
300 eh
->tlsdesc_got
= (bfd_vma
) -1;
302 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
303 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
304 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
305 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
306 if (h
->got
.refcount
> 0
307 && bfd_link_executable (info
)
309 && (elf_x86_hash_entry (h
)->tls_type
& GOT_TLS_IE
))
310 h
->got
.offset
= (bfd_vma
) -1;
311 else if (h
->got
.refcount
> 0)
315 int tls_type
= elf_x86_hash_entry (h
)->tls_type
;
317 /* Make sure this symbol is output as a dynamic symbol.
318 Undefined weak syms won't yet be marked as dynamic. */
322 && h
->root
.type
== bfd_link_hash_undefweak
)
324 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
329 if (GOT_TLS_GDESC_P (tls_type
))
331 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
332 - elf_x86_compute_jump_table_size (htab
);
333 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
334 h
->got
.offset
= (bfd_vma
) -2;
336 if (! GOT_TLS_GDESC_P (tls_type
)
337 || GOT_TLS_GD_P (tls_type
))
339 h
->got
.offset
= s
->size
;
340 s
->size
+= htab
->got_entry_size
;
341 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
343 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
344 s
->size
+= htab
->got_entry_size
;
346 dyn
= htab
->elf
.dynamic_sections_created
;
347 /* R_386_TLS_IE_32 needs one dynamic relocation,
348 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
349 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
350 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
351 symbol and two if global. No dynamic relocation against
352 resolved undefined weak symbol in executable. */
353 if (tls_type
== GOT_TLS_IE_BOTH
)
354 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
355 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
356 || (tls_type
& GOT_TLS_IE
))
357 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
358 else if (GOT_TLS_GD_P (tls_type
))
359 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
360 else if (! GOT_TLS_GDESC_P (tls_type
)
361 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
362 && !resolved_to_zero
)
363 || h
->root
.type
!= bfd_link_hash_undefweak
)
364 && (bfd_link_pic (info
)
365 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
366 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
367 if (GOT_TLS_GDESC_P (tls_type
))
369 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
370 if (bed
->target_id
== X86_64_ELF_DATA
)
371 htab
->tlsdesc_plt
= (bfd_vma
) -1;
375 h
->got
.offset
= (bfd_vma
) -1;
377 if (eh
->dyn_relocs
== NULL
)
380 /* In the shared -Bsymbolic case, discard space allocated for
381 dynamic pc-relative relocs against symbols which turn out to be
382 defined in regular objects. For the normal shared case, discard
383 space for pc-relative relocs that have become local due to symbol
384 visibility changes. */
386 if (bfd_link_pic (info
))
388 /* Relocs that use pc_count are those that appear on a call
389 insn, or certain REL relocs that can generated via assembly.
390 We want calls to protected symbols to resolve directly to the
391 function rather than going via the plt. If people want
392 function pointer comparisons to work as expected then they
393 should avoid writing weird assembly. */
394 if (SYMBOL_CALLS_LOCAL (info
, h
))
396 struct elf_dyn_relocs
**pp
;
398 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
400 p
->count
-= p
->pc_count
;
409 if (htab
->is_vxworks
)
411 struct elf_dyn_relocs
**pp
;
412 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
414 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
421 /* Also discard relocs on undefined weak syms with non-default
422 visibility or in PIE. */
423 if (eh
->dyn_relocs
!= NULL
)
425 if (h
->root
.type
== bfd_link_hash_undefweak
)
427 /* Undefined weak symbol is never bound locally in shared
429 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
432 if (bed
->target_id
== I386_ELF_DATA
435 /* Keep dynamic non-GOT/non-PLT relocation so
436 that we can branch to 0 without PLT. */
437 struct elf_dyn_relocs
**pp
;
439 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
440 if (p
->pc_count
== 0)
444 /* Remove non-R_386_PC32 relocation. */
445 p
->count
= p
->pc_count
;
449 /* Make sure undefined weak symbols are output
450 as dynamic symbols in PIEs for dynamic non-GOT
451 non-PLT reloations. */
452 if (eh
->dyn_relocs
!= NULL
453 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
457 eh
->dyn_relocs
= NULL
;
459 else if (h
->dynindx
== -1
461 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
464 else if (bfd_link_executable (info
)
465 && (h
->needs_copy
|| eh
->needs_copy
)
469 /* NB: needs_copy is set only for x86-64. For PIE,
470 discard space for pc-relative relocs against symbols
471 which turn out to need copy relocs. */
472 struct elf_dyn_relocs
**pp
;
474 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
476 if (p
->pc_count
!= 0)
484 else if (ELIMINATE_COPY_RELOCS
)
486 /* For the non-shared case, discard space for relocs against
487 symbols which turn out to need copy relocs or are not
488 dynamic. Keep dynamic relocations for run-time function
489 pointer initialization. */
492 || eh
->func_pointer_refcount
> 0
493 || (h
->root
.type
== bfd_link_hash_undefweak
494 && !resolved_to_zero
))
497 || (htab
->elf
.dynamic_sections_created
498 && (h
->root
.type
== bfd_link_hash_undefweak
499 || h
->root
.type
== bfd_link_hash_undefined
))))
501 /* Make sure this symbol is output as a dynamic symbol.
502 Undefined weak syms won't yet be marked as dynamic. */
506 && h
->root
.type
== bfd_link_hash_undefweak
507 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
510 /* If that succeeded, we know we'll be keeping all the
512 if (h
->dynindx
!= -1)
516 eh
->dyn_relocs
= NULL
;
517 eh
->func_pointer_refcount
= 0;
522 /* Finally, allocate space. */
523 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
527 sreloc
= elf_section_data (p
->sec
)->sreloc
;
529 BFD_ASSERT (sreloc
!= NULL
);
530 sreloc
->size
+= p
->count
* htab
->sizeof_reloc
;
536 /* Find any dynamic relocs that apply to read-only sections. */
539 _bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
542 struct elf_x86_link_hash_entry
*eh
;
543 struct elf_dyn_relocs
*p
;
545 /* Skip local IFUNC symbols. */
546 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
549 eh
= (struct elf_x86_link_hash_entry
*) h
;
550 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
552 asection
*s
= p
->sec
->output_section
;
554 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
556 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
558 info
->flags
|= DF_TEXTREL
;
560 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
561 || info
->error_textrel
)
562 /* xgettext:c-format */
563 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
564 p
->sec
->owner
, h
->root
.root
.string
,
567 /* Not an error, just cut short the traversal. */
574 /* Allocate space in .plt, .got and associated reloc sections for
575 local dynamic relocs. */
578 elf_x86_allocate_local_dynreloc (void **slot
, void *inf
)
580 struct elf_link_hash_entry
*h
581 = (struct elf_link_hash_entry
*) *slot
;
583 if (h
->type
!= STT_GNU_IFUNC
587 || h
->root
.type
!= bfd_link_hash_defined
)
590 return elf_x86_allocate_dynrelocs (h
, inf
);
593 /* Find and/or create a hash entry for local symbol. */
595 struct elf_link_hash_entry
*
596 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table
*htab
,
597 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
600 struct elf_x86_link_hash_entry e
, *ret
;
601 asection
*sec
= abfd
->sections
;
602 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
603 htab
->r_sym (rel
->r_info
));
606 e
.elf
.indx
= sec
->id
;
607 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
608 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
609 create
? INSERT
: NO_INSERT
);
616 ret
= (struct elf_x86_link_hash_entry
*) *slot
;
620 ret
= (struct elf_x86_link_hash_entry
*)
621 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
622 sizeof (struct elf_x86_link_hash_entry
));
625 memset (ret
, 0, sizeof (*ret
));
626 ret
->elf
.indx
= sec
->id
;
627 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
628 ret
->elf
.dynindx
= -1;
629 ret
->plt_got
.offset
= (bfd_vma
) -1;
635 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
636 SYNC WITH _bfd_elf_link_hash_newfunc. */
638 struct bfd_hash_entry
*
639 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
640 struct bfd_hash_table
*table
,
643 /* Allocate the structure if it has not already been allocated by a
647 entry
= (struct bfd_hash_entry
*)
648 bfd_hash_allocate (table
,
649 sizeof (struct elf_x86_link_hash_entry
));
654 /* Call the allocation method of the superclass. */
655 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
658 struct elf_x86_link_hash_entry
*eh
659 = (struct elf_x86_link_hash_entry
*) entry
;
660 struct elf_link_hash_table
*htab
661 = (struct elf_link_hash_table
*) table
;
663 memset (&eh
->elf
.size
, 0,
664 (sizeof (struct elf_x86_link_hash_entry
)
665 - offsetof (struct elf_link_hash_entry
, size
)));
666 /* Set local fields. */
668 eh
->elf
.dynindx
= -1;
669 eh
->elf
.got
= htab
->init_got_refcount
;
670 eh
->elf
.plt
= htab
->init_plt_refcount
;
671 /* Assume that we have been called by a non-ELF symbol reader.
672 This flag is then reset by the code which reads an ELF input
673 file. This ensures that a symbol created by a non-ELF symbol
674 reader will have the flag set correctly. */
676 eh
->plt_second
.offset
= (bfd_vma
) -1;
677 eh
->plt_got
.offset
= (bfd_vma
) -1;
678 eh
->tlsdesc_got
= (bfd_vma
) -1;
684 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
685 for local symbol so that we can handle local STT_GNU_IFUNC symbols
686 as global symbol. We reuse indx and dynstr_index for local symbol
687 hash since they aren't used by global symbols in this backend. */
690 _bfd_x86_elf_local_htab_hash (const void *ptr
)
692 struct elf_link_hash_entry
*h
693 = (struct elf_link_hash_entry
*) ptr
;
694 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
697 /* Compare local hash entries. */
700 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
702 struct elf_link_hash_entry
*h1
703 = (struct elf_link_hash_entry
*) ptr1
;
704 struct elf_link_hash_entry
*h2
705 = (struct elf_link_hash_entry
*) ptr2
;
707 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
710 /* Destroy an x86 ELF linker hash table. */
713 elf_x86_link_hash_table_free (bfd
*obfd
)
715 struct elf_x86_link_hash_table
*htab
716 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
718 if (htab
->loc_hash_table
)
719 htab_delete (htab
->loc_hash_table
);
720 if (htab
->loc_hash_memory
)
721 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
722 _bfd_elf_link_hash_table_free (obfd
);
726 elf_i386_is_reloc_section (const char *secname
)
728 return CONST_STRNEQ (secname
, ".rel");
732 elf_x86_64_is_reloc_section (const char *secname
)
734 return CONST_STRNEQ (secname
, ".rela");
737 /* Create an x86 ELF linker hash table. */
739 struct bfd_link_hash_table
*
740 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
742 struct elf_x86_link_hash_table
*ret
;
743 const struct elf_backend_data
*bed
;
744 bfd_size_type amt
= sizeof (struct elf_x86_link_hash_table
);
746 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
750 bed
= get_elf_backend_data (abfd
);
751 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
752 _bfd_x86_elf_link_hash_newfunc
,
753 sizeof (struct elf_x86_link_hash_entry
),
760 if (bed
->target_id
== X86_64_ELF_DATA
)
762 ret
->is_reloc_section
= elf_x86_64_is_reloc_section
;
763 ret
->dt_reloc
= DT_RELA
;
764 ret
->dt_reloc_sz
= DT_RELASZ
;
765 ret
->dt_reloc_ent
= DT_RELAENT
;
766 ret
->got_entry_size
= 8;
767 ret
->tls_get_addr
= "__tls_get_addr";
771 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
772 ret
->pointer_r_type
= R_X86_64_64
;
773 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
774 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
778 if (bed
->target_id
== X86_64_ELF_DATA
)
780 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
781 ret
->pointer_r_type
= R_X86_64_32
;
782 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
783 ret
->dynamic_interpreter_size
784 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
788 ret
->is_reloc_section
= elf_i386_is_reloc_section
;
789 ret
->dt_reloc
= DT_REL
;
790 ret
->dt_reloc_sz
= DT_RELSZ
;
791 ret
->dt_reloc_ent
= DT_RELENT
;
792 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
793 ret
->got_entry_size
= 4;
794 ret
->pointer_r_type
= R_386_32
;
795 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
796 ret
->dynamic_interpreter_size
797 = sizeof ELF32_DYNAMIC_INTERPRETER
;
798 ret
->tls_get_addr
= "___tls_get_addr";
801 ret
->target_id
= bed
->target_id
;
803 ret
->loc_hash_table
= htab_try_create (1024,
804 _bfd_x86_elf_local_htab_hash
,
805 _bfd_x86_elf_local_htab_eq
,
807 ret
->loc_hash_memory
= objalloc_create ();
808 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
810 elf_x86_link_hash_table_free (abfd
);
813 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
815 return &ret
->elf
.root
;
818 /* Sort relocs into address order. */
821 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
823 const arelent
*a
= * (const arelent
**) ap
;
824 const arelent
*b
= * (const arelent
**) bp
;
826 if (a
->address
> b
->address
)
828 else if (a
->address
< b
->address
)
835 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
837 if (!bfd_link_relocatable (info
))
839 /* Check for __tls_get_addr reference. */
840 struct elf_x86_link_hash_table
*htab
;
841 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
842 htab
= elf_x86_hash_table (info
, bed
->target_id
);
845 struct elf_link_hash_entry
*h
;
847 h
= elf_link_hash_lookup (elf_hash_table (info
),
849 FALSE
, FALSE
, FALSE
);
851 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
853 /* "__ehdr_start" will be defined by linker as a hidden symbol
854 later if it is referenced and not defined. */
855 h
= elf_link_hash_lookup (elf_hash_table (info
),
857 FALSE
, FALSE
, FALSE
);
859 && (h
->root
.type
== bfd_link_hash_new
860 || h
->root
.type
== bfd_link_hash_undefined
861 || h
->root
.type
== bfd_link_hash_undefweak
862 || h
->root
.type
== bfd_link_hash_common
))
864 elf_x86_hash_entry (h
)->local_ref
= 2;
865 elf_x86_hash_entry (h
)->linker_def
= 1;
870 /* Invoke the regular ELF backend linker to do all the work. */
871 return _bfd_elf_link_check_relocs (abfd
, info
);
874 /* Set the sizes of the dynamic sections. */
877 _bfd_x86_elf_size_dynamic_sections (bfd
*output_bfd
,
878 struct bfd_link_info
*info
)
880 struct elf_x86_link_hash_table
*htab
;
885 const struct elf_backend_data
*bed
886 = get_elf_backend_data (output_bfd
);
888 htab
= elf_x86_hash_table (info
, bed
->target_id
);
891 dynobj
= htab
->elf
.dynobj
;
895 /* Set up .got offsets for local syms, and space for local dynamic
897 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
899 bfd_signed_vma
*local_got
;
900 bfd_signed_vma
*end_local_got
;
901 char *local_tls_type
;
902 bfd_vma
*local_tlsdesc_gotent
;
903 bfd_size_type locsymcount
;
904 Elf_Internal_Shdr
*symtab_hdr
;
907 if (! is_x86_elf (ibfd
, htab
))
910 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
912 struct elf_dyn_relocs
*p
;
914 for (p
= ((struct elf_dyn_relocs
*)
915 elf_section_data (s
)->local_dynrel
);
919 if (!bfd_is_abs_section (p
->sec
)
920 && bfd_is_abs_section (p
->sec
->output_section
))
922 /* Input section has been discarded, either because
923 it is a copy of a linkonce section or due to
924 linker script /DISCARD/, so we'll be discarding
927 else if (htab
->is_vxworks
928 && strcmp (p
->sec
->output_section
->name
,
931 /* Relocations in vxworks .tls_vars sections are
932 handled specially by the loader. */
934 else if (p
->count
!= 0)
936 srel
= elf_section_data (p
->sec
)->sreloc
;
937 srel
->size
+= p
->count
* htab
->sizeof_reloc
;
938 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
939 && (info
->flags
& DF_TEXTREL
) == 0)
941 info
->flags
|= DF_TEXTREL
;
942 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
943 || info
->error_textrel
)
944 /* xgettext:c-format */
945 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
946 p
->sec
->owner
, p
->sec
);
952 local_got
= elf_local_got_refcounts (ibfd
);
956 symtab_hdr
= &elf_symtab_hdr (ibfd
);
957 locsymcount
= symtab_hdr
->sh_info
;
958 end_local_got
= local_got
+ locsymcount
;
959 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
960 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
962 srel
= htab
->elf
.srelgot
;
963 for (; local_got
< end_local_got
;
964 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
966 *local_tlsdesc_gotent
= (bfd_vma
) -1;
969 if (GOT_TLS_GDESC_P (*local_tls_type
))
971 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
972 - elf_x86_compute_jump_table_size (htab
);
973 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
974 *local_got
= (bfd_vma
) -2;
976 if (! GOT_TLS_GDESC_P (*local_tls_type
)
977 || GOT_TLS_GD_P (*local_tls_type
))
979 *local_got
= s
->size
;
980 s
->size
+= htab
->got_entry_size
;
981 if (GOT_TLS_GD_P (*local_tls_type
)
982 || *local_tls_type
== GOT_TLS_IE_BOTH
)
983 s
->size
+= htab
->got_entry_size
;
985 if (bfd_link_pic (info
)
986 || GOT_TLS_GD_ANY_P (*local_tls_type
)
987 || (*local_tls_type
& GOT_TLS_IE
))
989 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
990 srel
->size
+= 2 * htab
->sizeof_reloc
;
991 else if (GOT_TLS_GD_P (*local_tls_type
)
992 || ! GOT_TLS_GDESC_P (*local_tls_type
))
993 srel
->size
+= htab
->sizeof_reloc
;
994 if (GOT_TLS_GDESC_P (*local_tls_type
))
996 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
997 if (bed
->target_id
== X86_64_ELF_DATA
)
998 htab
->tlsdesc_plt
= (bfd_vma
) -1;
1003 *local_got
= (bfd_vma
) -1;
1007 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
1009 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1010 or R_X86_64_TLSLD relocs. */
1011 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
1012 htab
->elf
.sgot
->size
+= 2 * htab
->got_entry_size
;
1013 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
1016 htab
->tls_ld_or_ldm_got
.offset
= -1;
1018 /* Allocate global sym .plt and .got entries, and space for global
1019 sym dynamic relocs. */
1020 elf_link_hash_traverse (&htab
->elf
, elf_x86_allocate_dynrelocs
,
1023 /* Allocate .plt and .got entries, and space for local symbols. */
1024 htab_traverse (htab
->loc_hash_table
, elf_x86_allocate_local_dynreloc
,
1027 /* For every jump slot reserved in the sgotplt, reloc_count is
1028 incremented. However, when we reserve space for TLS descriptors,
1029 it's not incremented, so in order to compute the space reserved
1030 for them, it suffices to multiply the reloc count by the jump
1033 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1034 so that R_{386,X86_64}_IRELATIVE entries come last. */
1035 if (htab
->elf
.srelplt
)
1037 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
1038 htab
->sgotplt_jump_table_size
1039 = elf_x86_compute_jump_table_size (htab
);
1040 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
1042 else if (htab
->elf
.irelplt
)
1043 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1045 if (htab
->tlsdesc_plt
)
1047 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1048 lazy TLS relocations, don't generate the PLT and GOT entries
1050 if ((info
->flags
& DF_BIND_NOW
))
1051 htab
->tlsdesc_plt
= 0;
1054 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
1055 htab
->elf
.sgot
->size
+= htab
->got_entry_size
;
1056 /* Reserve room for the initial entry.
1057 FIXME: we could probably do away with it in this case. */
1058 if (htab
->elf
.splt
->size
== 0)
1059 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
1060 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
1061 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
1065 if (htab
->elf
.sgotplt
)
1067 /* Don't allocate .got.plt section if there are no GOT nor PLT
1068 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1069 if ((htab
->elf
.hgot
== NULL
1070 || !htab
->elf
.hgot
->ref_regular_nonweak
)
1071 && (htab
->elf
.sgotplt
->size
== bed
->got_header_size
)
1072 && (htab
->elf
.splt
== NULL
1073 || htab
->elf
.splt
->size
== 0)
1074 && (htab
->elf
.sgot
== NULL
1075 || htab
->elf
.sgot
->size
== 0)
1076 && (htab
->elf
.iplt
== NULL
1077 || htab
->elf
.iplt
->size
== 0)
1078 && (htab
->elf
.igotplt
== NULL
1079 || htab
->elf
.igotplt
->size
== 0))
1080 htab
->elf
.sgotplt
->size
= 0;
1083 if (_bfd_elf_eh_frame_present (info
))
1085 if (htab
->plt_eh_frame
!= NULL
1086 && htab
->elf
.splt
!= NULL
1087 && htab
->elf
.splt
->size
!= 0
1088 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
1089 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
1091 if (htab
->plt_got_eh_frame
!= NULL
1092 && htab
->plt_got
!= NULL
1093 && htab
->plt_got
->size
!= 0
1094 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
1095 htab
->plt_got_eh_frame
->size
1096 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1098 /* Unwind info for the second PLT and .plt.got sections are
1100 if (htab
->plt_second_eh_frame
!= NULL
1101 && htab
->plt_second
!= NULL
1102 && htab
->plt_second
->size
!= 0
1103 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
1104 htab
->plt_second_eh_frame
->size
1105 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1108 /* We now have determined the sizes of the various dynamic sections.
1109 Allocate memory for them. */
1111 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1113 bfd_boolean strip_section
= TRUE
;
1115 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1118 if (s
== htab
->elf
.splt
1119 || s
== htab
->elf
.sgot
)
1121 /* Strip this section if we don't need it; see the
1123 /* We'd like to strip these sections if they aren't needed, but if
1124 we've exported dynamic symbols from them we must leave them.
1125 It's too late to tell BFD to get rid of the symbols. */
1127 if (htab
->elf
.hplt
!= NULL
)
1128 strip_section
= FALSE
;
1130 else if (s
== htab
->elf
.sgotplt
1131 || s
== htab
->elf
.iplt
1132 || s
== htab
->elf
.igotplt
1133 || s
== htab
->plt_second
1134 || s
== htab
->plt_got
1135 || s
== htab
->plt_eh_frame
1136 || s
== htab
->plt_got_eh_frame
1137 || s
== htab
->plt_second_eh_frame
1138 || s
== htab
->elf
.sdynbss
1139 || s
== htab
->elf
.sdynrelro
)
1141 /* Strip these too. */
1143 else if (htab
->is_reloc_section (bfd_get_section_name (dynobj
, s
)))
1146 && s
!= htab
->elf
.srelplt
1147 && s
!= htab
->srelplt2
)
1150 /* We use the reloc_count field as a counter if we need
1151 to copy relocs into the output file. */
1152 if (s
!= htab
->elf
.srelplt
)
1157 /* It's not one of our sections, so don't allocate space. */
1163 /* If we don't need this section, strip it from the
1164 output file. This is mostly to handle .rel.bss and
1165 .rel.plt. We must create both sections in
1166 create_dynamic_sections, because they must be created
1167 before the linker maps input sections to output
1168 sections. The linker does that before
1169 adjust_dynamic_symbol is called, and it is that
1170 function which decides whether anything needs to go
1171 into these sections. */
1173 s
->flags
|= SEC_EXCLUDE
;
1177 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1180 /* Allocate memory for the section contents. We use bfd_zalloc
1181 here in case unused entries are not reclaimed before the
1182 section's contents are written out. This should not happen,
1183 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1184 reloc instead of garbage. */
1185 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
1186 if (s
->contents
== NULL
)
1190 if (htab
->plt_eh_frame
!= NULL
1191 && htab
->plt_eh_frame
->contents
!= NULL
)
1193 memcpy (htab
->plt_eh_frame
->contents
,
1194 htab
->plt
.eh_frame_plt
,
1195 htab
->plt_eh_frame
->size
);
1196 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
1197 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
1200 if (htab
->plt_got_eh_frame
!= NULL
1201 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1203 memcpy (htab
->plt_got_eh_frame
->contents
,
1204 htab
->non_lazy_plt
->eh_frame_plt
,
1205 htab
->plt_got_eh_frame
->size
);
1206 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
1207 (htab
->plt_got_eh_frame
->contents
1208 + PLT_FDE_LEN_OFFSET
));
1211 if (htab
->plt_second_eh_frame
!= NULL
1212 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1214 memcpy (htab
->plt_second_eh_frame
->contents
,
1215 htab
->non_lazy_plt
->eh_frame_plt
,
1216 htab
->plt_second_eh_frame
->size
);
1217 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
1218 (htab
->plt_second_eh_frame
->contents
1219 + PLT_FDE_LEN_OFFSET
));
1222 if (htab
->elf
.dynamic_sections_created
)
1224 /* Add some entries to the .dynamic section. We fill in the
1225 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1226 but we must add the entries now so that we get the correct
1227 size for the .dynamic section. The DT_DEBUG entry is filled
1228 in by the dynamic linker and used by the debugger. */
1229 #define add_dynamic_entry(TAG, VAL) \
1230 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1232 if (bfd_link_executable (info
))
1234 if (!add_dynamic_entry (DT_DEBUG
, 0))
1238 if (htab
->elf
.splt
->size
!= 0)
1240 /* DT_PLTGOT is used by prelink even if there is no PLT
1242 if (!add_dynamic_entry (DT_PLTGOT
, 0))
1246 if (htab
->elf
.srelplt
->size
!= 0)
1248 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1249 || !add_dynamic_entry (DT_PLTREL
, htab
->dt_reloc
)
1250 || !add_dynamic_entry (DT_JMPREL
, 0))
1254 if (htab
->tlsdesc_plt
1255 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
1256 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
1261 if (!add_dynamic_entry (htab
->dt_reloc
, 0)
1262 || !add_dynamic_entry (htab
->dt_reloc_sz
, 0)
1263 || !add_dynamic_entry (htab
->dt_reloc_ent
,
1264 htab
->sizeof_reloc
))
1267 /* If any dynamic relocs apply to a read-only section,
1268 then we need a DT_TEXTREL entry. */
1269 if ((info
->flags
& DF_TEXTREL
) == 0)
1270 elf_link_hash_traverse (&htab
->elf
,
1271 _bfd_x86_elf_readonly_dynrelocs
,
1274 if ((info
->flags
& DF_TEXTREL
) != 0)
1276 if (htab
->readonly_dynrelocs_against_ifunc
)
1278 info
->callbacks
->einfo
1279 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
1280 bfd_set_error (bfd_error_bad_value
);
1284 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1288 if (htab
->is_vxworks
1289 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
1292 #undef add_dynamic_entry
1298 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
1299 struct bfd_link_info
*info
)
1301 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
1305 struct elf_link_hash_entry
*tlsbase
;
1307 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
1308 "_TLS_MODULE_BASE_",
1309 FALSE
, FALSE
, FALSE
);
1311 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
1313 struct elf_x86_link_hash_table
*htab
;
1314 struct bfd_link_hash_entry
*bh
= NULL
;
1315 const struct elf_backend_data
*bed
1316 = get_elf_backend_data (output_bfd
);
1318 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1322 if (!(_bfd_generic_link_add_one_symbol
1323 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1324 tls_sec
, 0, NULL
, FALSE
,
1325 bed
->collect
, &bh
)))
1328 htab
->tls_module_base
= bh
;
1330 tlsbase
= (struct elf_link_hash_entry
*)bh
;
1331 tlsbase
->def_regular
= 1;
1332 tlsbase
->other
= STV_HIDDEN
;
1333 tlsbase
->root
.linker_def
= 1;
1334 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1342 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
1343 const Elf_Internal_Sym
*isym
,
1344 bfd_boolean definition
,
1345 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
1349 struct elf_x86_link_hash_entry
*eh
1350 = (struct elf_x86_link_hash_entry
*) h
;
1351 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
1356 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1359 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1360 struct elf_link_hash_entry
*dir
,
1361 struct elf_link_hash_entry
*ind
)
1363 struct elf_x86_link_hash_entry
*edir
, *eind
;
1365 edir
= (struct elf_x86_link_hash_entry
*) dir
;
1366 eind
= (struct elf_x86_link_hash_entry
*) ind
;
1368 if (eind
->dyn_relocs
!= NULL
)
1370 if (edir
->dyn_relocs
!= NULL
)
1372 struct elf_dyn_relocs
**pp
;
1373 struct elf_dyn_relocs
*p
;
1375 /* Add reloc counts against the indirect sym to the direct sym
1376 list. Merge any entries against the same section. */
1377 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1379 struct elf_dyn_relocs
*q
;
1381 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1382 if (q
->sec
== p
->sec
)
1384 q
->pc_count
+= p
->pc_count
;
1385 q
->count
+= p
->count
;
1392 *pp
= edir
->dyn_relocs
;
1395 edir
->dyn_relocs
= eind
->dyn_relocs
;
1396 eind
->dyn_relocs
= NULL
;
1399 if (ind
->root
.type
== bfd_link_hash_indirect
1400 && dir
->got
.refcount
<= 0)
1402 edir
->tls_type
= eind
->tls_type
;
1403 eind
->tls_type
= GOT_UNKNOWN
;
1406 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1407 generate a R_386_COPY reloc. */
1408 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1410 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1411 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1413 if (ELIMINATE_COPY_RELOCS
1414 && ind
->root
.type
!= bfd_link_hash_indirect
1415 && dir
->dynamic_adjusted
)
1417 /* If called to transfer flags for a weakdef during processing
1418 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1419 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1420 if (dir
->versioned
!= versioned_hidden
)
1421 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1422 dir
->ref_regular
|= ind
->ref_regular
;
1423 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1424 dir
->needs_plt
|= ind
->needs_plt
;
1425 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1429 if (eind
->func_pointer_refcount
> 0)
1431 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1432 eind
->func_pointer_refcount
= 0;
1435 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1439 /* Remove undefined weak symbol from the dynamic symbol table if it
1440 is resolved to 0. */
1443 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
1444 struct elf_link_hash_entry
*h
)
1446 if (h
->dynindx
!= -1
1447 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, elf_x86_hash_entry (h
)))
1450 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1456 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1459 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
1461 if (h
->plt
.offset
!= (bfd_vma
) -1
1463 && !h
->pointer_equality_needed
)
1466 return _bfd_elf_hash_symbol (h
);
1469 /* Adjust a symbol defined by a dynamic object and referenced by a
1470 regular object. The current definition is in some section of the
1471 dynamic object, but we're not including those sections. We have to
1472 change the definition to something the rest of the link can
1476 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1477 struct elf_link_hash_entry
*h
)
1479 struct elf_x86_link_hash_table
*htab
;
1481 struct elf_x86_link_hash_entry
*eh
;
1482 struct elf_dyn_relocs
*p
;
1483 const struct elf_backend_data
*bed
1484 = get_elf_backend_data (info
->output_bfd
);
1486 /* STT_GNU_IFUNC symbol must go through PLT. */
1487 if (h
->type
== STT_GNU_IFUNC
)
1489 /* All local STT_GNU_IFUNC references must be treate as local
1490 calls via local PLT. */
1492 && SYMBOL_CALLS_LOCAL (info
, h
))
1494 bfd_size_type pc_count
= 0, count
= 0;
1495 struct elf_dyn_relocs
**pp
;
1497 eh
= (struct elf_x86_link_hash_entry
*) h
;
1498 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1500 pc_count
+= p
->pc_count
;
1501 p
->count
-= p
->pc_count
;
1510 if (pc_count
|| count
)
1515 /* Increment PLT reference count only for PC-relative
1518 if (h
->plt
.refcount
<= 0)
1519 h
->plt
.refcount
= 1;
1521 h
->plt
.refcount
+= 1;
1526 if (h
->plt
.refcount
<= 0)
1528 h
->plt
.offset
= (bfd_vma
) -1;
1534 /* If this is a function, put it in the procedure linkage table. We
1535 will fill in the contents of the procedure linkage table later,
1536 when we know the address of the .got section. */
1537 if (h
->type
== STT_FUNC
1540 if (h
->plt
.refcount
<= 0
1541 || SYMBOL_CALLS_LOCAL (info
, h
)
1542 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1543 && h
->root
.type
== bfd_link_hash_undefweak
))
1545 /* This case can occur if we saw a PLT32 reloc in an input
1546 file, but the symbol was never referred to by a dynamic
1547 object, or if all references were garbage collected. In
1548 such a case, we don't actually need to build a procedure
1549 linkage table, and we can just do a PC32 reloc instead. */
1550 h
->plt
.offset
= (bfd_vma
) -1;
1557 /* It's possible that we incorrectly decided a .plt reloc was needed
1558 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1559 check_relocs. We can't decide accurately between function and
1560 non-function syms in check-relocs; Objects loaded later in
1561 the link may change h->type. So fix it now. */
1562 h
->plt
.offset
= (bfd_vma
) -1;
1564 eh
= (struct elf_x86_link_hash_entry
*) h
;
1566 /* If this is a weak symbol, and there is a real definition, the
1567 processor independent code will have arranged for us to see the
1568 real definition first, and we can just use the same value. */
1569 if (h
->u
.weakdef
!= NULL
)
1571 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1572 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1573 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1574 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1575 if (ELIMINATE_COPY_RELOCS
1576 || info
->nocopyreloc
1577 || SYMBOL_NO_COPYRELOC (info
, eh
))
1579 /* NB: needs_copy is always 0 for i386. */
1580 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1581 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
1586 /* This is a reference to a symbol defined by a dynamic object which
1587 is not a function. */
1589 /* If we are creating a shared library, we must presume that the
1590 only references to the symbol are via the global offset table.
1591 For such cases we need not do anything here; the relocations will
1592 be handled correctly by relocate_section. */
1593 if (!bfd_link_executable (info
))
1596 /* If there are no references to this symbol that do not use the
1597 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1598 reloc. NB: gotoff_ref is always 0 for x86-64. */
1599 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
1602 /* If -z nocopyreloc was given, we won't generate them either. */
1603 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
1609 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1613 /* If there aren't any dynamic relocs in read-only sections nor
1614 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1615 avoid the copy reloc. This doesn't work on VxWorks, where we can
1616 not have dynamic relocations (other than copy and jump slot
1617 relocations) in an executable. */
1618 if (ELIMINATE_COPY_RELOCS
1619 && (bed
->target_id
== X86_64_ELF_DATA
1621 && !htab
->is_vxworks
)))
1623 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1625 s
= p
->sec
->output_section
;
1626 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1630 /* If we didn't find any dynamic relocs in read-only sections,
1631 then we'll be keeping the dynamic relocs and avoiding the copy
1640 /* We must allocate the symbol in our .dynbss section, which will
1641 become part of the .bss section of the executable. There will be
1642 an entry for this symbol in the .dynsym section. The dynamic
1643 object will contain position independent code, so all references
1644 from the dynamic object to this symbol will go through the global
1645 offset table. The dynamic linker will use the .dynsym entry to
1646 determine the address it must put in the global offset table, so
1647 both the dynamic object and the regular object will refer to the
1648 same memory location for the variable. */
1650 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1651 dynamic linker to copy the initial value out of the dynamic object
1652 and into the runtime process image. */
1653 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1655 s
= htab
->elf
.sdynrelro
;
1656 srel
= htab
->elf
.sreldynrelro
;
1660 s
= htab
->elf
.sdynbss
;
1661 srel
= htab
->elf
.srelbss
;
1663 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1665 srel
->size
+= htab
->sizeof_reloc
;
1669 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1672 /* Return TRUE if a symbol is referenced locally. It is similar to
1673 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
1674 works in check_relocs. */
1677 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info
*info
,
1678 struct elf_link_hash_entry
*h
)
1680 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
1681 struct elf_x86_link_hash_table
*htab
1682 = (struct elf_x86_link_hash_table
*) info
->hash
;
1684 if (eh
->local_ref
> 1)
1687 if (eh
->local_ref
== 1)
1690 /* Unversioned symbols defined in regular objects can be forced local
1691 by linker version script. A weak undefined symbol is forced local
1693 1. It has non-default visibility. Or
1694 2. When building executable, there is no dynamic linker. Or
1695 3. or "-z nodynamic-undefined-weak" is used.
1697 if (SYMBOL_REFERENCES_LOCAL (info
, h
)
1698 || (h
->root
.type
== bfd_link_hash_undefweak
1699 && (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1700 || (bfd_link_executable (info
)
1701 && htab
->interp
== NULL
)
1702 || info
->dynamic_undefined_weak
== 0))
1703 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
1704 && h
->versioned
== unversioned
1705 && info
->version_info
!= NULL
1706 && bfd_hide_sym_by_version (info
->version_info
,
1707 h
->root
.root
.string
)))
1717 /* Return the section that should be marked against GC for a given
1721 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
1722 struct bfd_link_info
*info
,
1723 Elf_Internal_Rela
*rel
,
1724 struct elf_link_hash_entry
*h
,
1725 Elf_Internal_Sym
*sym
)
1727 /* Compiler should optimize this out. */
1728 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1729 != (unsigned int) R_386_GNU_VTINHERIT
)
1730 || ((unsigned int) R_X86_64_GNU_VTENTRY
1731 != (unsigned int) R_386_GNU_VTENTRY
))
1735 switch (ELF32_R_TYPE (rel
->r_info
))
1737 case R_X86_64_GNU_VTINHERIT
:
1738 case R_X86_64_GNU_VTENTRY
:
1742 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1746 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
1748 bfd_vma offset ATTRIBUTE_UNUSED
,
1751 return got_addr
+ off
;
1755 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
1758 bfd_vma got_addr ATTRIBUTE_UNUSED
)
1760 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
1764 elf_i386_valid_plt_reloc_p (unsigned int type
)
1766 return (type
== R_386_JUMP_SLOT
1767 || type
== R_386_GLOB_DAT
1768 || type
== R_386_IRELATIVE
);
1772 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
1774 return (type
== R_X86_64_JUMP_SLOT
1775 || type
== R_X86_64_GLOB_DAT
1776 || type
== R_X86_64_IRELATIVE
);
1780 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
1784 struct elf_x86_plt plts
[],
1788 long size
, i
, n
, len
;
1790 unsigned int plt_got_offset
, plt_entry_size
;
1792 bfd_byte
*plt_contents
;
1794 arelent
**dynrelbuf
, *p
;
1796 const struct elf_backend_data
*bed
;
1797 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
1799 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
1804 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
1805 if (dynrelbuf
== NULL
)
1808 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
1810 if (dynrelcount
<= 0)
1813 /* Sort the relocs by address. */
1814 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
1815 _bfd_x86_elf_compare_relocs
);
1817 size
= count
* sizeof (asymbol
);
1819 /* Allocate space for @plt suffixes. */
1821 for (i
= 0; i
< dynrelcount
; i
++)
1824 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
1826 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
1829 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
1833 bed
= get_elf_backend_data (abfd
);
1835 if (bed
->target_id
== X86_64_ELF_DATA
)
1837 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
1838 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
1842 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
1843 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
1846 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
1848 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
1850 got_addr
= sec
->vma
;
1853 sec
= bfd_get_section_by_name (abfd
, ".got");
1855 got_addr
= sec
->vma
;
1858 if (got_addr
== (bfd_vma
) -1)
1863 /* Check for each PLT section. */
1864 names
= (char *) (s
+ count
);
1867 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1868 if ((plt_contents
= plts
[j
].contents
) != NULL
)
1873 struct elf_x86_plt
*plt_p
= &plts
[j
];
1875 plt_got_offset
= plt_p
->plt_got_offset
;
1876 plt_entry_size
= plt_p
->plt_entry_size
;
1880 if ((plt_p
->type
& plt_lazy
))
1882 /* Skip PLT0 in lazy PLT. */
1884 offset
= plt_entry_size
;
1892 /* Check each PLT entry against dynamic relocations. */
1893 for (; k
< plt_p
->count
; k
++)
1899 /* Get the GOT offset for i386 or the PC-relative offset
1900 for x86-64, a signed 32-bit integer. */
1901 off
= H_GET_32 (abfd
, (plt_contents
+ offset
1903 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
1905 /* Binary search. */
1909 while ((min
+ 1) < max
)
1913 mid
= (min
+ max
) / 2;
1915 if (got_vma
> r
->address
)
1917 else if (got_vma
< r
->address
)
1926 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
1927 if (got_vma
== p
->address
1929 && valid_plt_reloc_p (p
->howto
->type
))
1931 *s
= **p
->sym_ptr_ptr
;
1932 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
1933 set. Since we are defining a symbol, ensure one
1935 if ((s
->flags
& BSF_LOCAL
) == 0)
1936 s
->flags
|= BSF_GLOBAL
;
1937 s
->flags
|= BSF_SYNTHETIC
;
1938 /* This is no longer a section symbol. */
1939 s
->flags
&= ~BSF_SECTION_SYM
;
1941 s
->the_bfd
= plt
->owner
;
1945 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
1946 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
1952 memcpy (names
, "+0x", sizeof ("+0x") - 1);
1953 names
+= sizeof ("+0x") - 1;
1954 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
1955 for (a
= buf
; *a
== '0'; ++a
)
1958 memcpy (names
, a
, size
);
1961 memcpy (names
, "@plt", sizeof ("@plt"));
1962 names
+= sizeof ("@plt");
1965 /* There should be only one entry in PLT for a given
1966 symbol. Set howto to NULL after processing a PLT
1967 entry to guard against corrupted PLT. */
1970 offset
+= plt_entry_size
;
1974 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
1983 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1984 if (plts
[j
].contents
!= NULL
)
1985 free (plts
[j
].contents
);
1992 /* Parse x86 GNU properties. */
1994 enum elf_property_kind
1995 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
1996 bfd_byte
*ptr
, unsigned int datasz
)
2002 case GNU_PROPERTY_X86_ISA_1_USED
:
2003 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2004 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2008 ((type
== GNU_PROPERTY_X86_ISA_1_USED
2009 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
2010 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
2011 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
2012 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
2014 return property_corrupt
;
2016 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
2017 /* Combine properties of the same type. */
2018 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
2019 prop
->pr_kind
= property_number
;
2023 return property_ignored
;
2026 return property_number
;
2029 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2030 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2031 should be merged with ABFD. */
2034 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
2035 bfd
*abfd ATTRIBUTE_UNUSED
,
2036 elf_property
*aprop
,
2037 elf_property
*bprop
)
2039 unsigned int number
, features
;
2040 bfd_boolean updated
= FALSE
;
2041 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
2045 case GNU_PROPERTY_X86_ISA_1_USED
:
2046 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2047 if (aprop
!= NULL
&& bprop
!= NULL
)
2049 number
= aprop
->u
.number
;
2050 aprop
->u
.number
= number
| bprop
->u
.number
;
2051 updated
= number
!= (unsigned int) aprop
->u
.number
;
2055 /* Return TRUE if APROP is NULL to indicate that BPROP should
2056 be added to ABFD. */
2057 updated
= aprop
== NULL
;
2061 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2062 /* Only one of APROP and BPROP can be NULL:
2063 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2064 2. If APROP is NULL, remove x86 feature.
2065 3. Otherwise, do nothing.
2067 if (aprop
!= NULL
&& bprop
!= NULL
)
2071 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2073 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2074 number
= aprop
->u
.number
;
2075 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2076 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2077 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
2078 updated
= number
!= (unsigned int) aprop
->u
.number
;
2079 /* Remove the property if all feature bits are cleared. */
2080 if (aprop
->u
.number
== 0)
2081 aprop
->pr_kind
= property_remove
;
2087 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2089 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2092 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2093 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2096 number
= aprop
->u
.number
;
2097 aprop
->u
.number
= number
| features
;
2098 updated
= number
!= (unsigned int) aprop
->u
.number
;
2102 bprop
->u
.number
|= features
;
2106 else if (aprop
!= NULL
)
2108 aprop
->pr_kind
= property_remove
;
2115 /* Never should happen. */
2122 /* Set up x86 GNU properties. Return the first relocatable ELF input
2123 with GNU properties if found. Otherwise, return NULL. */
2126 _bfd_x86_elf_link_setup_gnu_properties
2127 (struct bfd_link_info
*info
, struct elf_x86_init_table
*init_table
)
2129 bfd_boolean normal_target
;
2130 bfd_boolean lazy_plt
;
2131 asection
*sec
, *pltsec
;
2133 bfd_boolean use_ibt_plt
;
2134 unsigned int plt_alignment
, features
;
2135 struct elf_x86_link_hash_table
*htab
;
2139 const struct elf_backend_data
*bed
;
2140 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
2141 unsigned int got_align
;
2145 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2147 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2149 /* Find a normal input file with GNU property note. */
2150 for (pbfd
= info
->input_bfds
;
2152 pbfd
= pbfd
->link
.next
)
2153 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
2154 && bfd_count_sections (pbfd
) != 0)
2158 if (elf_properties (pbfd
) != NULL
)
2162 if (ebfd
!= NULL
&& features
)
2164 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2165 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2166 prop
= _bfd_elf_get_property (ebfd
,
2167 GNU_PROPERTY_X86_FEATURE_1_AND
,
2169 prop
->u
.number
|= features
;
2170 prop
->pr_kind
= property_number
;
2172 /* Create the GNU property note section if needed. */
2175 sec
= bfd_make_section_with_flags (ebfd
,
2176 NOTE_GNU_PROPERTY_SECTION_NAME
,
2184 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
2186 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
2189 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
2193 elf_section_type (sec
) = SHT_NOTE
;
2197 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
2199 bed
= get_elf_backend_data (info
->output_bfd
);
2201 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2205 htab
->is_vxworks
= init_table
->is_vxworks
;
2206 htab
->r_info
= init_table
->r_info
;
2207 htab
->r_sym
= init_table
->r_sym
;
2209 if (bfd_link_relocatable (info
))
2212 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
2213 if (!use_ibt_plt
&& pbfd
!= NULL
)
2215 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2216 elf_property_list
*p
;
2218 /* The property list is sorted in order of type. */
2219 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
2221 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
2223 use_ibt_plt
= !!(p
->property
.u
.number
2224 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2227 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
2232 dynobj
= htab
->elf
.dynobj
;
2234 /* Set htab->elf.dynobj here so that there is no need to check and
2235 set it in check_relocs. */
2240 htab
->elf
.dynobj
= pbfd
;
2247 /* Find a normal input file to hold linker created
2249 for (abfd
= info
->input_bfds
;
2251 abfd
= abfd
->link
.next
)
2252 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2254 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
2256 htab
->elf
.dynobj
= abfd
;
2263 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2264 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2265 canonical function address. */
2266 htab
->plt
.has_plt0
= 1;
2267 normal_target
= init_table
->normal_target
;
2273 htab
->lazy_plt
= init_table
->lazy_ibt_plt
;
2274 htab
->non_lazy_plt
= init_table
->non_lazy_ibt_plt
;
2278 htab
->lazy_plt
= init_table
->lazy_plt
;
2279 htab
->non_lazy_plt
= init_table
->non_lazy_plt
;
2284 htab
->lazy_plt
= init_table
->lazy_plt
;
2285 htab
->non_lazy_plt
= NULL
;
2288 pltsec
= htab
->elf
.splt
;
2290 /* If the non-lazy PLT is available, use it for all PLT entries if
2291 there are no PLT0 or no .plt section. */
2292 if (htab
->non_lazy_plt
!= NULL
2293 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
2296 if (bfd_link_pic (info
))
2297 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
2299 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
2300 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
2301 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
2302 htab
->plt
.plt_got_insn_size
2303 = htab
->non_lazy_plt
->plt_got_insn_size
;
2304 htab
->plt
.eh_frame_plt_size
2305 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2306 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
2311 if (bfd_link_pic (info
))
2313 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
2314 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
2318 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
2319 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
2321 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
2322 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
2323 htab
->plt
.plt_got_insn_size
2324 = htab
->lazy_plt
->plt_got_insn_size
;
2325 htab
->plt
.eh_frame_plt_size
2326 = htab
->lazy_plt
->eh_frame_plt_size
;
2327 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
2330 /* Return if there are no normal input files. */
2334 if (htab
->is_vxworks
2335 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
2338 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
2342 /* Since create_dynamic_sections isn't always called, but GOT
2343 relocations need GOT relocations, create them here so that we
2344 don't need to do it in check_relocs. */
2345 if (htab
->elf
.sgot
== NULL
2346 && !_bfd_elf_create_got_section (dynobj
, info
))
2347 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
2349 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
2351 /* Align .got and .got.plt sections to their entry size. Do it here
2352 instead of in create_dynamic_sections so that they are always
2353 properly aligned even if create_dynamic_sections isn't called. */
2354 sec
= htab
->elf
.sgot
;
2355 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2356 goto error_alignment
;
2358 sec
= htab
->elf
.sgotplt
;
2359 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2360 goto error_alignment
;
2362 /* Create the ifunc sections here so that check_relocs can be
2364 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
2365 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
2367 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
2371 /* Whe creating executable, set the contents of the .interp
2372 section to the interpreter. */
2373 if (bfd_link_executable (info
) && !info
->nointerp
)
2375 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
2378 s
->size
= htab
->dynamic_interpreter_size
;
2379 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2383 /* Don't change PLT section alignment for NaCl since it uses
2384 64-byte PLT entry and sets PLT section alignment to 32
2385 bytes. Don't create additional PLT sections for NaCl. */
2388 flagword pltflags
= (bed
->dynamic_sec_flags
2393 unsigned int non_lazy_plt_alignment
2394 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
2397 if (!bfd_set_section_alignment (sec
->owner
, sec
,
2399 goto error_alignment
;
2401 /* Create the GOT procedure linkage table. */
2402 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2406 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
2408 if (!bfd_set_section_alignment (dynobj
, sec
,
2409 non_lazy_plt_alignment
))
2410 goto error_alignment
;
2412 htab
->plt_got
= sec
;
2420 /* Create the second PLT for Intel IBT support. IBT
2421 PLT is supported only for non-NaCl target and is
2422 is needed only for lazy binding. */
2423 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2427 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
2429 if (!bfd_set_section_alignment (dynobj
, sec
,
2431 goto error_alignment
;
2433 else if (info
->bndplt
&& ABI_64_P (dynobj
))
2435 /* Create the second PLT for Intel MPX support. MPX
2436 PLT is supported only for non-NaCl target in 64-bit
2437 mode and is needed only for lazy binding. */
2438 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2442 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
2444 if (!bfd_set_section_alignment (dynobj
, sec
,
2445 non_lazy_plt_alignment
))
2446 goto error_alignment
;
2449 htab
->plt_second
= sec
;
2453 if (!info
->no_ld_generated_unwind_info
)
2455 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
2456 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2457 | SEC_LINKER_CREATED
);
2459 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2463 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
2465 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2466 goto error_alignment
;
2468 htab
->plt_eh_frame
= sec
;
2470 if (htab
->plt_got
!= NULL
)
2472 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2476 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
2478 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2479 goto error_alignment
;
2481 htab
->plt_got_eh_frame
= sec
;
2484 if (htab
->plt_second
!= NULL
)
2486 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2490 info
->callbacks
->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
2492 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2493 goto error_alignment
;
2495 htab
->plt_second_eh_frame
= sec
;
2502 /* The .iplt section is used for IFUNC symbols in static
2504 sec
= htab
->elf
.iplt
;
2506 && !bfd_set_section_alignment (sec
->owner
, sec
,
2508 goto error_alignment
;