1 /* x86 specific support for ELF
2 Copyright (C) 2017-2020 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
, void *inf
)
88 struct bfd_link_info
*info
;
89 struct elf_x86_link_hash_table
*htab
;
90 struct elf_x86_link_hash_entry
*eh
;
91 struct elf_dyn_relocs
*p
;
92 unsigned int plt_entry_size
;
93 bfd_boolean resolved_to_zero
;
94 const struct elf_backend_data
*bed
;
96 if (h
->root
.type
== bfd_link_hash_indirect
)
99 eh
= (struct elf_x86_link_hash_entry
*) h
;
101 info
= (struct bfd_link_info
*) inf
;
102 bed
= get_elf_backend_data (info
->output_bfd
);
103 htab
= elf_x86_hash_table (info
, bed
->target_id
);
107 plt_entry_size
= htab
->plt
.plt_entry_size
;
109 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
111 /* We can't use the GOT PLT if pointer equality is needed since
112 finish_dynamic_symbol won't clear symbol value and the dynamic
113 linker won't update the GOT slot. We will get into an infinite
115 if (htab
->plt_got
!= NULL
116 && h
->type
!= STT_GNU_IFUNC
117 && !h
->pointer_equality_needed
118 && h
->plt
.refcount
> 0
119 && h
->got
.refcount
> 0)
121 /* Don't use the regular PLT if there are both GOT and GOTPLT
123 h
->plt
.offset
= (bfd_vma
) -1;
125 /* Use the GOT PLT. */
126 eh
->plt_got
.refcount
= 1;
129 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
130 here if it is defined and referenced in a non-shared object. */
131 if (h
->type
== STT_GNU_IFUNC
134 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &h
->dyn_relocs
,
135 &htab
->readonly_dynrelocs_against_ifunc
,
139 htab
->got_entry_size
,
142 asection
*s
= htab
->plt_second
;
143 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
145 /* Use the second PLT section if it is created. */
146 eh
->plt_second
.offset
= s
->size
;
148 /* Make room for this entry in the second PLT section. */
149 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
157 /* Don't create the PLT entry if there are only function pointer
158 relocations which can be resolved at run-time. */
159 else if (htab
->elf
.dynamic_sections_created
160 && (h
->plt
.refcount
> 0
161 || eh
->plt_got
.refcount
> 0))
163 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
165 /* Make sure this symbol is output as a dynamic symbol.
166 Undefined weak syms won't yet be marked as dynamic. */
170 && h
->root
.type
== bfd_link_hash_undefweak
)
172 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
176 if (bfd_link_pic (info
)
177 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
179 asection
*s
= htab
->elf
.splt
;
180 asection
*second_s
= htab
->plt_second
;
181 asection
*got_s
= htab
->plt_got
;
184 /* If this is the first .plt entry, make room for the special
185 first entry. The .plt section is used by prelink to undo
186 prelinking for dynamic relocations. */
188 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
191 eh
->plt_got
.offset
= got_s
->size
;
194 h
->plt
.offset
= s
->size
;
196 eh
->plt_second
.offset
= second_s
->size
;
199 /* If this symbol is not defined in a regular file, and we are
200 generating PDE, then set the symbol to this location in the
201 .plt. This is required to make function pointers compare
202 as equal between PDE and the shared library.
204 NB: If PLT is PC-relative, we can use the .plt in PIE for
208 else if (htab
->pcrel_plt
)
209 use_plt
= ! bfd_link_dll (info
);
211 use_plt
= bfd_link_pde (info
);
216 /* We need to make a call to the entry of the GOT PLT
217 instead of regular PLT entry. */
218 h
->root
.u
.def
.section
= got_s
;
219 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
225 /* We need to make a call to the entry of the
226 second PLT instead of regular PLT entry. */
227 h
->root
.u
.def
.section
= second_s
;
228 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
232 h
->root
.u
.def
.section
= s
;
233 h
->root
.u
.def
.value
= h
->plt
.offset
;
238 /* Make room for this entry. */
240 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
243 s
->size
+= plt_entry_size
;
245 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
247 /* We also need to make an entry in the .got.plt section,
248 which will be placed in the .got section by the linker
250 htab
->elf
.sgotplt
->size
+= htab
->got_entry_size
;
252 /* There should be no PLT relocation against resolved
253 undefined weak symbol in executable. */
254 if (!resolved_to_zero
)
256 /* We also need to make an entry in the .rel.plt
258 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
259 htab
->elf
.srelplt
->reloc_count
++;
263 if (htab
->target_os
== is_vxworks
&& !bfd_link_pic (info
))
265 /* VxWorks has a second set of relocations for each PLT entry
266 in executables. They go in a separate relocation section,
267 which is processed by the kernel loader. */
269 /* There are two relocations for the initial PLT entry: an
270 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
271 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
273 asection
*srelplt2
= htab
->srelplt2
;
274 if (h
->plt
.offset
== plt_entry_size
)
275 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
277 /* There are two extra relocations for each subsequent PLT entry:
278 an R_386_32 relocation for the GOT entry, and an R_386_32
279 relocation for the PLT entry. */
281 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
286 eh
->plt_got
.offset
= (bfd_vma
) -1;
287 h
->plt
.offset
= (bfd_vma
) -1;
293 eh
->plt_got
.offset
= (bfd_vma
) -1;
294 h
->plt
.offset
= (bfd_vma
) -1;
298 eh
->tlsdesc_got
= (bfd_vma
) -1;
300 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
301 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
302 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
303 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
304 if (h
->got
.refcount
> 0
305 && bfd_link_executable (info
)
307 && (elf_x86_hash_entry (h
)->tls_type
& GOT_TLS_IE
))
308 h
->got
.offset
= (bfd_vma
) -1;
309 else if (h
->got
.refcount
> 0)
313 int tls_type
= elf_x86_hash_entry (h
)->tls_type
;
315 /* Make sure this symbol is output as a dynamic symbol.
316 Undefined weak syms won't yet be marked as dynamic. */
320 && h
->root
.type
== bfd_link_hash_undefweak
)
322 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
327 if (GOT_TLS_GDESC_P (tls_type
))
329 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
330 - elf_x86_compute_jump_table_size (htab
);
331 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
332 h
->got
.offset
= (bfd_vma
) -2;
334 if (! GOT_TLS_GDESC_P (tls_type
)
335 || GOT_TLS_GD_P (tls_type
))
337 h
->got
.offset
= s
->size
;
338 s
->size
+= htab
->got_entry_size
;
339 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
341 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
342 s
->size
+= htab
->got_entry_size
;
344 dyn
= htab
->elf
.dynamic_sections_created
;
345 /* R_386_TLS_IE_32 needs one dynamic relocation,
346 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
347 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
348 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
349 symbol and two if global. No dynamic relocation against
350 resolved undefined weak symbol in executable. No dynamic
351 relocation against non-preemptible absolute symbol. */
352 if (tls_type
== GOT_TLS_IE_BOTH
)
353 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
354 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
355 || (tls_type
& GOT_TLS_IE
))
356 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
357 else if (GOT_TLS_GD_P (tls_type
))
358 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
359 else if (! GOT_TLS_GDESC_P (tls_type
)
360 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
361 && !resolved_to_zero
)
362 || h
->root
.type
!= bfd_link_hash_undefweak
)
363 && ((bfd_link_pic (info
)
364 && !(h
->dynindx
== -1
365 && ABS_SYMBOL_P (h
)))
366 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
367 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
368 if (GOT_TLS_GDESC_P (tls_type
))
370 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
371 if (bed
->target_id
== X86_64_ELF_DATA
)
372 htab
->tlsdesc_plt
= (bfd_vma
) -1;
376 h
->got
.offset
= (bfd_vma
) -1;
378 if (h
->dyn_relocs
== NULL
)
381 /* In the shared -Bsymbolic case, discard space allocated for
382 dynamic pc-relative relocs against symbols which turn out to be
383 defined in regular objects. For the normal shared case, discard
384 space for pc-relative relocs that have become local due to symbol
385 visibility changes. */
387 if (bfd_link_pic (info
))
389 /* Relocs that use pc_count are those that appear on a call
390 insn, or certain REL relocs that can generated via assembly.
391 We want calls to protected symbols to resolve directly to the
392 function rather than going via the plt. If people want
393 function pointer comparisons to work as expected then they
394 should avoid writing weird assembly. */
395 if (SYMBOL_CALLS_LOCAL (info
, h
))
397 struct elf_dyn_relocs
**pp
;
399 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
401 p
->count
-= p
->pc_count
;
410 if (htab
->target_os
== is_vxworks
)
412 struct elf_dyn_relocs
**pp
;
413 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
415 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
422 /* Also discard relocs on undefined weak syms with non-default
423 visibility or in PIE. */
424 if (h
->dyn_relocs
!= NULL
)
426 if (h
->root
.type
== bfd_link_hash_undefweak
)
428 /* Undefined weak symbol is never bound locally in shared
430 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
433 if (bed
->target_id
== I386_ELF_DATA
436 /* Keep dynamic non-GOT/non-PLT relocation so
437 that we can branch to 0 without PLT. */
438 struct elf_dyn_relocs
**pp
;
440 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
441 if (p
->pc_count
== 0)
445 /* Remove non-R_386_PC32 relocation. */
446 p
->count
= p
->pc_count
;
450 /* Make sure undefined weak symbols are output
451 as dynamic symbols in PIEs for dynamic non-GOT
452 non-PLT reloations. */
453 if (h
->dyn_relocs
!= NULL
454 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
458 h
->dyn_relocs
= NULL
;
460 else if (h
->dynindx
== -1
462 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
465 else if (bfd_link_executable (info
)
466 && (h
->needs_copy
|| eh
->needs_copy
)
470 /* NB: needs_copy is set only for x86-64. For PIE,
471 discard space for pc-relative relocs against symbols
472 which turn out to need copy relocs. */
473 struct elf_dyn_relocs
**pp
;
475 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
477 if (p
->pc_count
!= 0)
485 else if (ELIMINATE_COPY_RELOCS
)
487 /* For the non-shared case, discard space for relocs against
488 symbols which turn out to need copy relocs or are not
489 dynamic. Keep dynamic relocations for run-time function
490 pointer initialization. */
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 h
->dyn_relocs
= NULL
;
521 /* Finally, allocate space. */
522 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
526 sreloc
= elf_section_data (p
->sec
)->sreloc
;
528 BFD_ASSERT (sreloc
!= NULL
);
529 sreloc
->size
+= p
->count
* htab
->sizeof_reloc
;
535 /* Find dynamic relocs for H that apply to read-only sections. */
538 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
540 struct elf_dyn_relocs
*p
;
542 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
544 asection
*s
= p
->sec
->output_section
;
546 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
552 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
553 read-only sections. */
556 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
560 if (h
->root
.type
== bfd_link_hash_indirect
)
563 /* Skip local IFUNC symbols. */
564 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
567 sec
= readonly_dynrelocs (h
);
570 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
572 info
->flags
|= DF_TEXTREL
;
573 /* xgettext:c-format */
574 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT' "
575 "in read-only section `%pA'\n"),
576 sec
->owner
, h
->root
.root
.string
, sec
);
578 if (bfd_link_textrel_check (info
))
579 /* xgettext:c-format */
580 info
->callbacks
->einfo (_("%P: %pB: warning: relocation against `%s' "
581 "in read-only section `%pA'\n"),
582 sec
->owner
, h
->root
.root
.string
, sec
);
584 /* Not an error, just cut short the traversal. */
590 /* Allocate space in .plt, .got and associated reloc sections for
591 local dynamic relocs. */
594 elf_x86_allocate_local_dynreloc (void **slot
, void *inf
)
596 struct elf_link_hash_entry
*h
597 = (struct elf_link_hash_entry
*) *slot
;
599 if (h
->type
!= STT_GNU_IFUNC
603 || h
->root
.type
!= bfd_link_hash_defined
)
606 return elf_x86_allocate_dynrelocs (h
, inf
);
609 /* Find and/or create a hash entry for local symbol. */
611 struct elf_link_hash_entry
*
612 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table
*htab
,
613 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
616 struct elf_x86_link_hash_entry e
, *ret
;
617 asection
*sec
= abfd
->sections
;
618 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
619 htab
->r_sym (rel
->r_info
));
622 e
.elf
.indx
= sec
->id
;
623 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
624 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
625 create
? INSERT
: NO_INSERT
);
632 ret
= (struct elf_x86_link_hash_entry
*) *slot
;
636 ret
= (struct elf_x86_link_hash_entry
*)
637 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
638 sizeof (struct elf_x86_link_hash_entry
));
641 memset (ret
, 0, sizeof (*ret
));
642 ret
->elf
.indx
= sec
->id
;
643 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
644 ret
->elf
.dynindx
= -1;
645 ret
->plt_got
.offset
= (bfd_vma
) -1;
651 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
652 SYNC WITH _bfd_elf_link_hash_newfunc. */
654 struct bfd_hash_entry
*
655 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
656 struct bfd_hash_table
*table
,
659 /* Allocate the structure if it has not already been allocated by a
663 entry
= (struct bfd_hash_entry
*)
664 bfd_hash_allocate (table
,
665 sizeof (struct elf_x86_link_hash_entry
));
670 /* Call the allocation method of the superclass. */
671 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
674 struct elf_x86_link_hash_entry
*eh
675 = (struct elf_x86_link_hash_entry
*) entry
;
676 struct elf_link_hash_table
*htab
677 = (struct elf_link_hash_table
*) table
;
679 memset (&eh
->elf
.size
, 0,
680 (sizeof (struct elf_x86_link_hash_entry
)
681 - offsetof (struct elf_link_hash_entry
, size
)));
682 /* Set local fields. */
684 eh
->elf
.dynindx
= -1;
685 eh
->elf
.got
= htab
->init_got_refcount
;
686 eh
->elf
.plt
= htab
->init_plt_refcount
;
687 /* Assume that we have been called by a non-ELF symbol reader.
688 This flag is then reset by the code which reads an ELF input
689 file. This ensures that a symbol created by a non-ELF symbol
690 reader will have the flag set correctly. */
692 eh
->plt_second
.offset
= (bfd_vma
) -1;
693 eh
->plt_got
.offset
= (bfd_vma
) -1;
694 eh
->tlsdesc_got
= (bfd_vma
) -1;
695 eh
->zero_undefweak
= 1;
701 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
702 for local symbol so that we can handle local STT_GNU_IFUNC symbols
703 as global symbol. We reuse indx and dynstr_index for local symbol
704 hash since they aren't used by global symbols in this backend. */
707 _bfd_x86_elf_local_htab_hash (const void *ptr
)
709 struct elf_link_hash_entry
*h
710 = (struct elf_link_hash_entry
*) ptr
;
711 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
714 /* Compare local hash entries. */
717 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
719 struct elf_link_hash_entry
*h1
720 = (struct elf_link_hash_entry
*) ptr1
;
721 struct elf_link_hash_entry
*h2
722 = (struct elf_link_hash_entry
*) ptr2
;
724 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
727 /* Destroy an x86 ELF linker hash table. */
730 elf_x86_link_hash_table_free (bfd
*obfd
)
732 struct elf_x86_link_hash_table
*htab
733 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
735 if (htab
->loc_hash_table
)
736 htab_delete (htab
->loc_hash_table
);
737 if (htab
->loc_hash_memory
)
738 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
739 _bfd_elf_link_hash_table_free (obfd
);
743 elf_i386_is_reloc_section (const char *secname
)
745 return CONST_STRNEQ (secname
, ".rel");
749 elf_x86_64_is_reloc_section (const char *secname
)
751 return CONST_STRNEQ (secname
, ".rela");
754 /* Create an x86 ELF linker hash table. */
756 struct bfd_link_hash_table
*
757 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
759 struct elf_x86_link_hash_table
*ret
;
760 const struct elf_backend_data
*bed
;
761 size_t amt
= sizeof (struct elf_x86_link_hash_table
);
763 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
767 bed
= get_elf_backend_data (abfd
);
768 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
769 _bfd_x86_elf_link_hash_newfunc
,
770 sizeof (struct elf_x86_link_hash_entry
),
777 if (bed
->target_id
== X86_64_ELF_DATA
)
779 ret
->is_reloc_section
= elf_x86_64_is_reloc_section
;
780 ret
->dt_reloc
= DT_RELA
;
781 ret
->dt_reloc_sz
= DT_RELASZ
;
782 ret
->dt_reloc_ent
= DT_RELAENT
;
783 ret
->got_entry_size
= 8;
784 ret
->pcrel_plt
= TRUE
;
785 ret
->tls_get_addr
= "__tls_get_addr";
789 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
790 ret
->pointer_r_type
= R_X86_64_64
;
791 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
792 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
796 if (bed
->target_id
== X86_64_ELF_DATA
)
798 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
799 ret
->pointer_r_type
= R_X86_64_32
;
800 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
801 ret
->dynamic_interpreter_size
802 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
806 ret
->is_reloc_section
= elf_i386_is_reloc_section
;
807 ret
->dt_reloc
= DT_REL
;
808 ret
->dt_reloc_sz
= DT_RELSZ
;
809 ret
->dt_reloc_ent
= DT_RELENT
;
810 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
811 ret
->got_entry_size
= 4;
812 ret
->pcrel_plt
= FALSE
;
813 ret
->pointer_r_type
= R_386_32
;
814 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
815 ret
->dynamic_interpreter_size
816 = sizeof ELF32_DYNAMIC_INTERPRETER
;
817 ret
->tls_get_addr
= "___tls_get_addr";
820 ret
->target_id
= bed
->target_id
;
821 ret
->target_os
= get_elf_x86_backend_data (abfd
)->target_os
;
823 ret
->loc_hash_table
= htab_try_create (1024,
824 _bfd_x86_elf_local_htab_hash
,
825 _bfd_x86_elf_local_htab_eq
,
827 ret
->loc_hash_memory
= objalloc_create ();
828 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
830 elf_x86_link_hash_table_free (abfd
);
833 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
835 return &ret
->elf
.root
;
838 /* Sort relocs into address order. */
841 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
843 const arelent
*a
= * (const arelent
**) ap
;
844 const arelent
*b
= * (const arelent
**) bp
;
846 if (a
->address
> b
->address
)
848 else if (a
->address
< b
->address
)
854 /* Mark symbol, NAME, as locally defined by linker if it is referenced
855 and not defined in a relocatable object file. */
858 elf_x86_linker_defined (struct bfd_link_info
*info
, const char *name
)
860 struct elf_link_hash_entry
*h
;
862 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
863 FALSE
, FALSE
, FALSE
);
867 while (h
->root
.type
== bfd_link_hash_indirect
)
868 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
870 if (h
->root
.type
== bfd_link_hash_new
871 || h
->root
.type
== bfd_link_hash_undefined
872 || h
->root
.type
== bfd_link_hash_undefweak
873 || h
->root
.type
== bfd_link_hash_common
874 || (!h
->def_regular
&& h
->def_dynamic
))
876 elf_x86_hash_entry (h
)->local_ref
= 2;
877 elf_x86_hash_entry (h
)->linker_def
= 1;
881 /* Hide a linker-defined symbol, NAME, with hidden visibility. */
884 elf_x86_hide_linker_defined (struct bfd_link_info
*info
,
887 struct elf_link_hash_entry
*h
;
889 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
890 FALSE
, FALSE
, FALSE
);
894 while (h
->root
.type
== bfd_link_hash_indirect
)
895 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
897 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
898 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
899 _bfd_elf_link_hash_hide_symbol (info
, h
, TRUE
);
903 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
905 if (!bfd_link_relocatable (info
))
907 /* Check for __tls_get_addr reference. */
908 struct elf_x86_link_hash_table
*htab
;
909 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
910 htab
= elf_x86_hash_table (info
, bed
->target_id
);
913 struct elf_link_hash_entry
*h
;
915 h
= elf_link_hash_lookup (elf_hash_table (info
),
917 FALSE
, FALSE
, FALSE
);
920 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
922 /* Check the versioned __tls_get_addr symbol. */
923 while (h
->root
.type
== bfd_link_hash_indirect
)
925 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
926 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
930 /* "__ehdr_start" will be defined by linker as a hidden symbol
931 later if it is referenced and not defined. */
932 elf_x86_linker_defined (info
, "__ehdr_start");
934 if (bfd_link_executable (info
))
936 /* References to __bss_start, _end and _edata should be
937 locally resolved within executables. */
938 elf_x86_linker_defined (info
, "__bss_start");
939 elf_x86_linker_defined (info
, "_end");
940 elf_x86_linker_defined (info
, "_edata");
944 /* Hide hidden __bss_start, _end and _edata in shared
946 elf_x86_hide_linker_defined (info
, "__bss_start");
947 elf_x86_hide_linker_defined (info
, "_end");
948 elf_x86_hide_linker_defined (info
, "_edata");
953 /* Invoke the regular ELF backend linker to do all the work. */
954 return _bfd_elf_link_check_relocs (abfd
, info
);
958 _bfd_elf_x86_valid_reloc_p (asection
*input_section
,
959 struct bfd_link_info
*info
,
960 struct elf_x86_link_hash_table
*htab
,
961 const Elf_Internal_Rela
*rel
,
962 struct elf_link_hash_entry
*h
,
963 Elf_Internal_Sym
*sym
,
964 Elf_Internal_Shdr
*symtab_hdr
,
965 bfd_boolean
*no_dynreloc_p
)
967 bfd_boolean valid_p
= TRUE
;
969 *no_dynreloc_p
= FALSE
;
971 /* Check If relocation against non-preemptible absolute symbol is
972 valid in PIC. FIXME: Can't use SYMBOL_REFERENCES_LOCAL_P since
973 it may call _bfd_elf_link_hide_sym_by_version and result in
974 ld-elfvers/ vers21 test failure. */
975 if (bfd_link_pic (info
)
976 && (h
== NULL
|| SYMBOL_REFERENCES_LOCAL (info
, h
)))
978 const struct elf_backend_data
*bed
;
980 Elf_Internal_Rela irel
;
982 /* Skip non-absolute symbol. */
985 if (!ABS_SYMBOL_P (h
))
988 else if (sym
->st_shndx
!= SHN_ABS
)
991 bed
= get_elf_backend_data (input_section
->owner
);
992 r_type
= ELF32_R_TYPE (rel
->r_info
);
995 /* Only allow relocations against absolute symbol, which can be
996 resolved as absolute value + addend. GOTPCREL relocations
997 are allowed since absolute value + addend is stored in the
999 if (bed
->target_id
== X86_64_ELF_DATA
)
1001 r_type
&= ~R_X86_64_converted_reloc_bit
;
1002 valid_p
= (r_type
== R_X86_64_64
1003 || r_type
== R_X86_64_32
1004 || r_type
== R_X86_64_32S
1005 || r_type
== R_X86_64_16
1006 || r_type
== R_X86_64_8
1007 || r_type
== R_X86_64_GOTPCREL
1008 || r_type
== R_X86_64_GOTPCRELX
1009 || r_type
== R_X86_64_REX_GOTPCRELX
);
1012 unsigned int r_symndx
= htab
->r_sym (rel
->r_info
);
1013 irel
.r_info
= htab
->r_info (r_symndx
, r_type
);
1017 valid_p
= (r_type
== R_386_32
1018 || r_type
== R_386_16
1019 || r_type
== R_386_8
);
1022 *no_dynreloc_p
= TRUE
;
1026 arelent internal_reloc
;
1028 if (!bed
->elf_info_to_howto (input_section
->owner
,
1029 &internal_reloc
, &irel
)
1030 || internal_reloc
.howto
== NULL
)
1034 name
= h
->root
.root
.string
;
1036 name
= bfd_elf_sym_name (input_section
->owner
, symtab_hdr
,
1038 info
->callbacks
->einfo
1039 /* xgettext:c-format */
1040 (_("%F%P: %pB: relocation %s against absolute symbol "
1041 "`%s' in section `%pA' is disallowed\n"),
1042 input_section
->owner
, internal_reloc
.howto
->name
, name
,
1044 bfd_set_error (bfd_error_bad_value
);
1051 /* Set the sizes of the dynamic sections. */
1054 _bfd_x86_elf_size_dynamic_sections (bfd
*output_bfd
,
1055 struct bfd_link_info
*info
)
1057 struct elf_x86_link_hash_table
*htab
;
1062 const struct elf_backend_data
*bed
1063 = get_elf_backend_data (output_bfd
);
1065 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1068 dynobj
= htab
->elf
.dynobj
;
1072 /* Set up .got offsets for local syms, and space for local dynamic
1074 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1076 bfd_signed_vma
*local_got
;
1077 bfd_signed_vma
*end_local_got
;
1078 char *local_tls_type
;
1079 bfd_vma
*local_tlsdesc_gotent
;
1080 bfd_size_type locsymcount
;
1081 Elf_Internal_Shdr
*symtab_hdr
;
1084 if (! is_x86_elf (ibfd
, htab
))
1087 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1089 struct elf_dyn_relocs
*p
;
1091 for (p
= ((struct elf_dyn_relocs
*)
1092 elf_section_data (s
)->local_dynrel
);
1096 if (!bfd_is_abs_section (p
->sec
)
1097 && bfd_is_abs_section (p
->sec
->output_section
))
1099 /* Input section has been discarded, either because
1100 it is a copy of a linkonce section or due to
1101 linker script /DISCARD/, so we'll be discarding
1104 else if (htab
->target_os
== is_vxworks
1105 && strcmp (p
->sec
->output_section
->name
,
1108 /* Relocations in vxworks .tls_vars sections are
1109 handled specially by the loader. */
1111 else if (p
->count
!= 0)
1113 srel
= elf_section_data (p
->sec
)->sreloc
;
1114 srel
->size
+= p
->count
* htab
->sizeof_reloc
;
1115 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
1116 && (info
->flags
& DF_TEXTREL
) == 0)
1118 info
->flags
|= DF_TEXTREL
;
1119 if (bfd_link_textrel_check (info
))
1120 /* xgettext:c-format */
1121 info
->callbacks
->einfo
1122 (_("%P: %pB: warning: relocation "
1123 "in read-only section `%pA'\n"),
1124 p
->sec
->owner
, p
->sec
);
1130 local_got
= elf_local_got_refcounts (ibfd
);
1134 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1135 locsymcount
= symtab_hdr
->sh_info
;
1136 end_local_got
= local_got
+ locsymcount
;
1137 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
1138 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
1140 srel
= htab
->elf
.srelgot
;
1141 for (; local_got
< end_local_got
;
1142 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
1144 *local_tlsdesc_gotent
= (bfd_vma
) -1;
1147 if (GOT_TLS_GDESC_P (*local_tls_type
))
1149 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
1150 - elf_x86_compute_jump_table_size (htab
);
1151 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
1152 *local_got
= (bfd_vma
) -2;
1154 if (! GOT_TLS_GDESC_P (*local_tls_type
)
1155 || GOT_TLS_GD_P (*local_tls_type
))
1157 *local_got
= s
->size
;
1158 s
->size
+= htab
->got_entry_size
;
1159 if (GOT_TLS_GD_P (*local_tls_type
)
1160 || *local_tls_type
== GOT_TLS_IE_BOTH
)
1161 s
->size
+= htab
->got_entry_size
;
1163 if ((bfd_link_pic (info
) && *local_tls_type
!= GOT_ABS
)
1164 || GOT_TLS_GD_ANY_P (*local_tls_type
)
1165 || (*local_tls_type
& GOT_TLS_IE
))
1167 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
1168 srel
->size
+= 2 * htab
->sizeof_reloc
;
1169 else if (GOT_TLS_GD_P (*local_tls_type
)
1170 || ! GOT_TLS_GDESC_P (*local_tls_type
))
1171 srel
->size
+= htab
->sizeof_reloc
;
1172 if (GOT_TLS_GDESC_P (*local_tls_type
))
1174 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
1175 if (bed
->target_id
== X86_64_ELF_DATA
)
1176 htab
->tlsdesc_plt
= (bfd_vma
) -1;
1181 *local_got
= (bfd_vma
) -1;
1185 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
1187 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1188 or R_X86_64_TLSLD relocs. */
1189 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
1190 htab
->elf
.sgot
->size
+= 2 * htab
->got_entry_size
;
1191 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
1194 htab
->tls_ld_or_ldm_got
.offset
= -1;
1196 /* Allocate global sym .plt and .got entries, and space for global
1197 sym dynamic relocs. */
1198 elf_link_hash_traverse (&htab
->elf
, elf_x86_allocate_dynrelocs
,
1201 /* Allocate .plt and .got entries, and space for local symbols. */
1202 htab_traverse (htab
->loc_hash_table
, elf_x86_allocate_local_dynreloc
,
1205 /* For every jump slot reserved in the sgotplt, reloc_count is
1206 incremented. However, when we reserve space for TLS descriptors,
1207 it's not incremented, so in order to compute the space reserved
1208 for them, it suffices to multiply the reloc count by the jump
1211 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1212 so that R_{386,X86_64}_IRELATIVE entries come last. */
1213 if (htab
->elf
.srelplt
)
1215 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
1216 htab
->sgotplt_jump_table_size
1217 = elf_x86_compute_jump_table_size (htab
);
1218 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
1220 else if (htab
->elf
.irelplt
)
1221 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1223 if (htab
->tlsdesc_plt
)
1225 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1226 lazy TLS relocations, don't generate the PLT and GOT entries
1228 if ((info
->flags
& DF_BIND_NOW
))
1229 htab
->tlsdesc_plt
= 0;
1232 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
1233 htab
->elf
.sgot
->size
+= htab
->got_entry_size
;
1234 /* Reserve room for the initial entry.
1235 FIXME: we could probably do away with it in this case. */
1236 if (htab
->elf
.splt
->size
== 0)
1237 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
1238 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
1239 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
1243 if (htab
->elf
.sgotplt
)
1245 /* Don't allocate .got.plt section if there are no GOT nor PLT
1246 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1247 if ((htab
->elf
.hgot
== NULL
1248 || !htab
->got_referenced
)
1249 && (htab
->elf
.sgotplt
->size
== bed
->got_header_size
)
1250 && (htab
->elf
.splt
== NULL
1251 || htab
->elf
.splt
->size
== 0)
1252 && (htab
->elf
.sgot
== NULL
1253 || htab
->elf
.sgot
->size
== 0)
1254 && (htab
->elf
.iplt
== NULL
1255 || htab
->elf
.iplt
->size
== 0)
1256 && (htab
->elf
.igotplt
== NULL
1257 || htab
->elf
.igotplt
->size
== 0))
1259 htab
->elf
.sgotplt
->size
= 0;
1260 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
1262 if (htab
->elf
.hgot
!= NULL
&& htab
->target_os
!= is_solaris
)
1264 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
1266 htab
->elf
.hgot
->root
.type
= bfd_link_hash_undefined
;
1267 htab
->elf
.hgot
->root
.u
.undef
.abfd
1268 = htab
->elf
.hgot
->root
.u
.def
.section
->owner
;
1269 htab
->elf
.hgot
->root
.linker_def
= 0;
1270 htab
->elf
.hgot
->ref_regular
= 0;
1271 htab
->elf
.hgot
->def_regular
= 0;
1276 if (_bfd_elf_eh_frame_present (info
))
1278 if (htab
->plt_eh_frame
!= NULL
1279 && htab
->elf
.splt
!= NULL
1280 && htab
->elf
.splt
->size
!= 0
1281 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
1282 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
1284 if (htab
->plt_got_eh_frame
!= NULL
1285 && htab
->plt_got
!= NULL
1286 && htab
->plt_got
->size
!= 0
1287 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
1288 htab
->plt_got_eh_frame
->size
1289 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1291 /* Unwind info for the second PLT and .plt.got sections are
1293 if (htab
->plt_second_eh_frame
!= NULL
1294 && htab
->plt_second
!= NULL
1295 && htab
->plt_second
->size
!= 0
1296 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
1297 htab
->plt_second_eh_frame
->size
1298 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1301 /* We now have determined the sizes of the various dynamic sections.
1302 Allocate memory for them. */
1304 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1306 bfd_boolean strip_section
= TRUE
;
1308 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1311 if (s
== htab
->elf
.splt
1312 || s
== htab
->elf
.sgot
)
1314 /* Strip this section if we don't need it; see the
1316 /* We'd like to strip these sections if they aren't needed, but if
1317 we've exported dynamic symbols from them we must leave them.
1318 It's too late to tell BFD to get rid of the symbols. */
1320 if (htab
->elf
.hplt
!= NULL
)
1321 strip_section
= FALSE
;
1323 else if (s
== htab
->elf
.sgotplt
1324 || s
== htab
->elf
.iplt
1325 || s
== htab
->elf
.igotplt
1326 || s
== htab
->plt_second
1327 || s
== htab
->plt_got
1328 || s
== htab
->plt_eh_frame
1329 || s
== htab
->plt_got_eh_frame
1330 || s
== htab
->plt_second_eh_frame
1331 || s
== htab
->elf
.sdynbss
1332 || s
== htab
->elf
.sdynrelro
)
1334 /* Strip these too. */
1336 else if (htab
->is_reloc_section (bfd_section_name (s
)))
1339 && s
!= htab
->elf
.srelplt
1340 && s
!= htab
->srelplt2
)
1343 /* We use the reloc_count field as a counter if we need
1344 to copy relocs into the output file. */
1345 if (s
!= htab
->elf
.srelplt
)
1350 /* It's not one of our sections, so don't allocate space. */
1356 /* If we don't need this section, strip it from the
1357 output file. This is mostly to handle .rel.bss and
1358 .rel.plt. We must create both sections in
1359 create_dynamic_sections, because they must be created
1360 before the linker maps input sections to output
1361 sections. The linker does that before
1362 adjust_dynamic_symbol is called, and it is that
1363 function which decides whether anything needs to go
1364 into these sections. */
1366 s
->flags
|= SEC_EXCLUDE
;
1370 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1373 /* NB: Initially, the iplt section has minimal alignment to
1374 avoid moving dot of the following section backwards when
1375 it is empty. Update its section alignment now since it
1377 if (s
== htab
->elf
.iplt
)
1378 bfd_set_section_alignment (s
, htab
->plt
.iplt_alignment
);
1380 /* Allocate memory for the section contents. We use bfd_zalloc
1381 here in case unused entries are not reclaimed before the
1382 section's contents are written out. This should not happen,
1383 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1384 reloc instead of garbage. */
1385 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
1386 if (s
->contents
== NULL
)
1390 if (htab
->plt_eh_frame
!= NULL
1391 && htab
->plt_eh_frame
->contents
!= NULL
)
1393 memcpy (htab
->plt_eh_frame
->contents
,
1394 htab
->plt
.eh_frame_plt
,
1395 htab
->plt_eh_frame
->size
);
1396 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
1397 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
1400 if (htab
->plt_got_eh_frame
!= NULL
1401 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1403 memcpy (htab
->plt_got_eh_frame
->contents
,
1404 htab
->non_lazy_plt
->eh_frame_plt
,
1405 htab
->plt_got_eh_frame
->size
);
1406 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
1407 (htab
->plt_got_eh_frame
->contents
1408 + PLT_FDE_LEN_OFFSET
));
1411 if (htab
->plt_second_eh_frame
!= NULL
1412 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1414 memcpy (htab
->plt_second_eh_frame
->contents
,
1415 htab
->non_lazy_plt
->eh_frame_plt
,
1416 htab
->plt_second_eh_frame
->size
);
1417 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
1418 (htab
->plt_second_eh_frame
->contents
1419 + PLT_FDE_LEN_OFFSET
));
1422 if (htab
->elf
.dynamic_sections_created
)
1424 /* Add some entries to the .dynamic section. We fill in the
1425 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1426 but we must add the entries now so that we get the correct
1427 size for the .dynamic section. The DT_DEBUG entry is filled
1428 in by the dynamic linker and used by the debugger. */
1429 #define add_dynamic_entry(TAG, VAL) \
1430 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1432 if (bfd_link_executable (info
))
1434 if (!add_dynamic_entry (DT_DEBUG
, 0))
1438 if (htab
->elf
.splt
->size
!= 0)
1440 /* DT_PLTGOT is used by prelink even if there is no PLT
1442 if (!add_dynamic_entry (DT_PLTGOT
, 0))
1446 if (htab
->elf
.srelplt
->size
!= 0)
1448 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1449 || !add_dynamic_entry (DT_PLTREL
, htab
->dt_reloc
)
1450 || !add_dynamic_entry (DT_JMPREL
, 0))
1454 if (htab
->tlsdesc_plt
1455 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
1456 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
1461 if (!add_dynamic_entry (htab
->dt_reloc
, 0)
1462 || !add_dynamic_entry (htab
->dt_reloc_sz
, 0)
1463 || !add_dynamic_entry (htab
->dt_reloc_ent
,
1464 htab
->sizeof_reloc
))
1467 /* If any dynamic relocs apply to a read-only section,
1468 then we need a DT_TEXTREL entry. */
1469 if ((info
->flags
& DF_TEXTREL
) == 0)
1470 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
1472 if ((info
->flags
& DF_TEXTREL
) != 0)
1474 if (htab
->readonly_dynrelocs_against_ifunc
)
1476 info
->callbacks
->einfo
1477 (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1478 " recompile with %s\n"),
1479 bfd_link_dll (info
) ? "-fPIC" : "-fPIE");
1480 bfd_set_error (bfd_error_bad_value
);
1484 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1488 if (htab
->target_os
== is_vxworks
1489 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
1492 #undef add_dynamic_entry
1497 /* Finish up the x86 dynamic sections. */
1499 struct elf_x86_link_hash_table
*
1500 _bfd_x86_elf_finish_dynamic_sections (bfd
*output_bfd
,
1501 struct bfd_link_info
*info
)
1503 struct elf_x86_link_hash_table
*htab
;
1504 const struct elf_backend_data
*bed
;
1507 bfd_byte
*dyncon
, *dynconend
;
1508 bfd_size_type sizeof_dyn
;
1510 bed
= get_elf_backend_data (output_bfd
);
1511 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1515 dynobj
= htab
->elf
.dynobj
;
1516 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
1518 /* GOT is always created in setup_gnu_properties. But it may not be
1519 needed. .got.plt section may be needed for static IFUNC. */
1520 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
1522 bfd_vma dynamic_addr
;
1524 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
1527 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
1531 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
1532 = htab
->got_entry_size
;
1534 dynamic_addr
= (sdyn
== NULL
1536 : sdyn
->output_section
->vma
+ sdyn
->output_offset
);
1538 /* Set the first entry in the global offset table to the address
1539 of the dynamic section. Write GOT[1] and GOT[2], needed for
1540 the dynamic linker. */
1541 if (htab
->got_entry_size
== 8)
1543 bfd_put_64 (output_bfd
, dynamic_addr
,
1544 htab
->elf
.sgotplt
->contents
);
1545 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1546 htab
->elf
.sgotplt
->contents
+ 8);
1547 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1548 htab
->elf
.sgotplt
->contents
+ 8*2);
1552 bfd_put_32 (output_bfd
, dynamic_addr
,
1553 htab
->elf
.sgotplt
->contents
);
1554 bfd_put_32 (output_bfd
, 0,
1555 htab
->elf
.sgotplt
->contents
+ 4);
1556 bfd_put_32 (output_bfd
, 0,
1557 htab
->elf
.sgotplt
->contents
+ 4*2);
1561 if (!htab
->elf
.dynamic_sections_created
)
1564 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
1567 sizeof_dyn
= bed
->s
->sizeof_dyn
;
1568 dyncon
= sdyn
->contents
;
1569 dynconend
= sdyn
->contents
+ sdyn
->size
;
1570 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
1572 Elf_Internal_Dyn dyn
;
1575 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
1580 if (htab
->target_os
== is_vxworks
1581 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
1586 s
= htab
->elf
.sgotplt
;
1587 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
1591 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
1595 s
= htab
->elf
.srelplt
->output_section
;
1596 dyn
.d_un
.d_val
= s
->size
;
1599 case DT_TLSDESC_PLT
:
1601 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1602 + htab
->tlsdesc_plt
;
1605 case DT_TLSDESC_GOT
:
1607 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1608 + htab
->tlsdesc_got
;
1612 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
1615 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
1616 elf_section_data (htab
->plt_got
->output_section
)
1617 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1619 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
1620 elf_section_data (htab
->plt_second
->output_section
)
1621 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1623 /* Adjust .eh_frame for .plt section. */
1624 if (htab
->plt_eh_frame
!= NULL
1625 && htab
->plt_eh_frame
->contents
!= NULL
)
1627 if (htab
->elf
.splt
!= NULL
1628 && htab
->elf
.splt
->size
!= 0
1629 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
1630 && htab
->elf
.splt
->output_section
!= NULL
1631 && htab
->plt_eh_frame
->output_section
!= NULL
)
1633 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
1634 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
1635 + htab
->plt_eh_frame
->output_offset
1636 + PLT_FDE_START_OFFSET
;
1637 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1638 htab
->plt_eh_frame
->contents
1639 + PLT_FDE_START_OFFSET
);
1642 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1644 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1646 htab
->plt_eh_frame
->contents
))
1651 /* Adjust .eh_frame for .plt.got section. */
1652 if (htab
->plt_got_eh_frame
!= NULL
1653 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1655 if (htab
->plt_got
!= NULL
1656 && htab
->plt_got
->size
!= 0
1657 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
1658 && htab
->plt_got
->output_section
!= NULL
1659 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
1661 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
1662 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
1663 + htab
->plt_got_eh_frame
->output_offset
1664 + PLT_FDE_START_OFFSET
;
1665 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1666 htab
->plt_got_eh_frame
->contents
1667 + PLT_FDE_START_OFFSET
);
1669 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1671 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1672 htab
->plt_got_eh_frame
,
1673 htab
->plt_got_eh_frame
->contents
))
1678 /* Adjust .eh_frame for the second PLT section. */
1679 if (htab
->plt_second_eh_frame
!= NULL
1680 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1682 if (htab
->plt_second
!= NULL
1683 && htab
->plt_second
->size
!= 0
1684 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
1685 && htab
->plt_second
->output_section
!= NULL
1686 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
1688 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
1689 bfd_vma eh_frame_start
1690 = (htab
->plt_second_eh_frame
->output_section
->vma
1691 + htab
->plt_second_eh_frame
->output_offset
1692 + PLT_FDE_START_OFFSET
);
1693 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1694 htab
->plt_second_eh_frame
->contents
1695 + PLT_FDE_START_OFFSET
);
1697 if (htab
->plt_second_eh_frame
->sec_info_type
1698 == SEC_INFO_TYPE_EH_FRAME
)
1700 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1701 htab
->plt_second_eh_frame
,
1702 htab
->plt_second_eh_frame
->contents
))
1707 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
1708 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
1709 = htab
->got_entry_size
;
1716 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
1717 struct bfd_link_info
*info
)
1719 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
1723 struct elf_link_hash_entry
*tlsbase
;
1725 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
1726 "_TLS_MODULE_BASE_",
1727 FALSE
, FALSE
, FALSE
);
1729 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
1731 struct elf_x86_link_hash_table
*htab
;
1732 struct bfd_link_hash_entry
*bh
= NULL
;
1733 const struct elf_backend_data
*bed
1734 = get_elf_backend_data (output_bfd
);
1736 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1740 if (!(_bfd_generic_link_add_one_symbol
1741 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1742 tls_sec
, 0, NULL
, FALSE
,
1743 bed
->collect
, &bh
)))
1746 htab
->tls_module_base
= bh
;
1748 tlsbase
= (struct elf_link_hash_entry
*)bh
;
1749 tlsbase
->def_regular
= 1;
1750 tlsbase
->other
= STV_HIDDEN
;
1751 tlsbase
->root
.linker_def
= 1;
1752 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1760 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
1761 const Elf_Internal_Sym
*isym
,
1762 bfd_boolean definition
,
1763 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
1767 struct elf_x86_link_hash_entry
*eh
1768 = (struct elf_x86_link_hash_entry
*) h
;
1769 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
1774 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1777 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1778 struct elf_link_hash_entry
*dir
,
1779 struct elf_link_hash_entry
*ind
)
1781 struct elf_x86_link_hash_entry
*edir
, *eind
;
1783 edir
= (struct elf_x86_link_hash_entry
*) dir
;
1784 eind
= (struct elf_x86_link_hash_entry
*) ind
;
1786 if (ind
->dyn_relocs
!= NULL
)
1788 if (dir
->dyn_relocs
!= NULL
)
1790 struct elf_dyn_relocs
**pp
;
1791 struct elf_dyn_relocs
*p
;
1793 /* Add reloc counts against the indirect sym to the direct sym
1794 list. Merge any entries against the same section. */
1795 for (pp
= &ind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1797 struct elf_dyn_relocs
*q
;
1799 for (q
= dir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1800 if (q
->sec
== p
->sec
)
1802 q
->pc_count
+= p
->pc_count
;
1803 q
->count
+= p
->count
;
1810 *pp
= dir
->dyn_relocs
;
1813 dir
->dyn_relocs
= ind
->dyn_relocs
;
1814 ind
->dyn_relocs
= NULL
;
1817 if (ind
->root
.type
== bfd_link_hash_indirect
1818 && dir
->got
.refcount
<= 0)
1820 edir
->tls_type
= eind
->tls_type
;
1821 eind
->tls_type
= GOT_UNKNOWN
;
1824 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1825 generate a R_386_COPY reloc. */
1826 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1828 edir
->zero_undefweak
|= eind
->zero_undefweak
;
1830 if (ELIMINATE_COPY_RELOCS
1831 && ind
->root
.type
!= bfd_link_hash_indirect
1832 && dir
->dynamic_adjusted
)
1834 /* If called to transfer flags for a weakdef during processing
1835 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1836 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1837 if (dir
->versioned
!= versioned_hidden
)
1838 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1839 dir
->ref_regular
|= ind
->ref_regular
;
1840 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1841 dir
->needs_plt
|= ind
->needs_plt
;
1842 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1845 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1848 /* Remove undefined weak symbol from the dynamic symbol table if it
1849 is resolved to 0. */
1852 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
1853 struct elf_link_hash_entry
*h
)
1855 if (h
->dynindx
!= -1
1856 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, elf_x86_hash_entry (h
)))
1859 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1865 /* Change the STT_GNU_IFUNC symbol defined in position-dependent
1866 executable into the normal function symbol and set its address
1867 to its PLT entry, which should be resolved by R_*_IRELATIVE at
1871 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info
*info
,
1872 struct elf_x86_link_hash_table
*htab
,
1873 struct elf_link_hash_entry
*h
,
1874 Elf_Internal_Sym
*sym
)
1876 if (bfd_link_pde (info
)
1879 && h
->plt
.offset
!= (bfd_vma
) -1
1880 && h
->type
== STT_GNU_IFUNC
1881 && h
->pointer_equality_needed
)
1885 bfd
*output_bfd
= info
->output_bfd
;
1887 if (htab
->plt_second
)
1889 struct elf_x86_link_hash_entry
*eh
1890 = (struct elf_x86_link_hash_entry
*) h
;
1892 plt_s
= htab
->plt_second
;
1893 plt_offset
= eh
->plt_second
.offset
;
1897 plt_s
= htab
->elf
.splt
;
1898 plt_offset
= h
->plt
.offset
;
1902 sym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (sym
->st_info
), STT_FUNC
);
1904 = _bfd_elf_section_from_bfd_section (output_bfd
,
1905 plt_s
->output_section
);
1906 sym
->st_value
= (plt_s
->output_section
->vma
1907 + plt_s
->output_offset
+ plt_offset
);
1911 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1914 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
1916 if (h
->plt
.offset
!= (bfd_vma
) -1
1918 && !h
->pointer_equality_needed
)
1921 return _bfd_elf_hash_symbol (h
);
1924 /* Adjust a symbol defined by a dynamic object and referenced by a
1925 regular object. The current definition is in some section of the
1926 dynamic object, but we're not including those sections. We have to
1927 change the definition to something the rest of the link can
1931 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1932 struct elf_link_hash_entry
*h
)
1934 struct elf_x86_link_hash_table
*htab
;
1936 struct elf_x86_link_hash_entry
*eh
;
1937 struct elf_dyn_relocs
*p
;
1938 const struct elf_backend_data
*bed
1939 = get_elf_backend_data (info
->output_bfd
);
1941 /* STT_GNU_IFUNC symbol must go through PLT. */
1942 if (h
->type
== STT_GNU_IFUNC
)
1944 /* All local STT_GNU_IFUNC references must be treate as local
1945 calls via local PLT. */
1947 && SYMBOL_CALLS_LOCAL (info
, h
))
1949 bfd_size_type pc_count
= 0, count
= 0;
1950 struct elf_dyn_relocs
**pp
;
1952 eh
= (struct elf_x86_link_hash_entry
*) h
;
1953 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
1955 pc_count
+= p
->pc_count
;
1956 p
->count
-= p
->pc_count
;
1965 if (pc_count
|| count
)
1970 /* Increment PLT reference count only for PC-relative
1973 if (h
->plt
.refcount
<= 0)
1974 h
->plt
.refcount
= 1;
1976 h
->plt
.refcount
+= 1;
1981 if (h
->plt
.refcount
<= 0)
1983 h
->plt
.offset
= (bfd_vma
) -1;
1989 /* If this is a function, put it in the procedure linkage table. We
1990 will fill in the contents of the procedure linkage table later,
1991 when we know the address of the .got section. */
1992 if (h
->type
== STT_FUNC
1995 if (h
->plt
.refcount
<= 0
1996 || SYMBOL_CALLS_LOCAL (info
, h
)
1997 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1998 && h
->root
.type
== bfd_link_hash_undefweak
))
2000 /* This case can occur if we saw a PLT32 reloc in an input
2001 file, but the symbol was never referred to by a dynamic
2002 object, or if all references were garbage collected. In
2003 such a case, we don't actually need to build a procedure
2004 linkage table, and we can just do a PC32 reloc instead. */
2005 h
->plt
.offset
= (bfd_vma
) -1;
2012 /* It's possible that we incorrectly decided a .plt reloc was needed
2013 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
2014 check_relocs. We can't decide accurately between function and
2015 non-function syms in check-relocs; Objects loaded later in
2016 the link may change h->type. So fix it now. */
2017 h
->plt
.offset
= (bfd_vma
) -1;
2019 eh
= (struct elf_x86_link_hash_entry
*) h
;
2021 /* If this is a weak symbol, and there is a real definition, the
2022 processor independent code will have arranged for us to see the
2023 real definition first, and we can just use the same value. */
2024 if (h
->is_weakalias
)
2026 struct elf_link_hash_entry
*def
= weakdef (h
);
2027 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2028 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2029 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2030 if (ELIMINATE_COPY_RELOCS
2031 || info
->nocopyreloc
2032 || SYMBOL_NO_COPYRELOC (info
, eh
))
2034 /* NB: needs_copy is always 0 for i386. */
2035 h
->non_got_ref
= def
->non_got_ref
;
2036 eh
->needs_copy
= def
->needs_copy
;
2041 /* This is a reference to a symbol defined by a dynamic object which
2042 is not a function. */
2044 /* If we are creating a shared library, we must presume that the
2045 only references to the symbol are via the global offset table.
2046 For such cases we need not do anything here; the relocations will
2047 be handled correctly by relocate_section. */
2048 if (!bfd_link_executable (info
))
2051 /* If there are no references to this symbol that do not use the
2052 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2053 reloc. NB: gotoff_ref is always 0 for x86-64. */
2054 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2057 /* If -z nocopyreloc was given, we won't generate them either. */
2058 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
2064 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2068 /* If there aren't any dynamic relocs in read-only sections nor
2069 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2070 avoid the copy reloc. This doesn't work on VxWorks, where we can
2071 not have dynamic relocations (other than copy and jump slot
2072 relocations) in an executable. */
2073 if (ELIMINATE_COPY_RELOCS
2074 && (bed
->target_id
== X86_64_ELF_DATA
2076 && htab
->target_os
!= is_vxworks
)))
2078 /* If we don't find any dynamic relocs in read-only sections,
2079 then we'll be keeping the dynamic relocs and avoiding the copy
2081 if (!readonly_dynrelocs (h
))
2088 /* We must allocate the symbol in our .dynbss section, which will
2089 become part of the .bss section of the executable. There will be
2090 an entry for this symbol in the .dynsym section. The dynamic
2091 object will contain position independent code, so all references
2092 from the dynamic object to this symbol will go through the global
2093 offset table. The dynamic linker will use the .dynsym entry to
2094 determine the address it must put in the global offset table, so
2095 both the dynamic object and the regular object will refer to the
2096 same memory location for the variable. */
2098 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
2099 dynamic linker to copy the initial value out of the dynamic object
2100 and into the runtime process image. */
2101 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
2103 s
= htab
->elf
.sdynrelro
;
2104 srel
= htab
->elf
.sreldynrelro
;
2108 s
= htab
->elf
.sdynbss
;
2109 srel
= htab
->elf
.srelbss
;
2111 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2113 srel
->size
+= htab
->sizeof_reloc
;
2117 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2121 _bfd_x86_elf_hide_symbol (struct bfd_link_info
*info
,
2122 struct elf_link_hash_entry
*h
,
2123 bfd_boolean force_local
)
2125 if (h
->root
.type
== bfd_link_hash_undefweak
2127 && bfd_link_pie (info
))
2129 /* When there is no dynamic interpreter in PIE, make the undefined
2130 weak symbol dynamic so that PC relative branch to the undefined
2131 weak symbol will land to address 0. */
2132 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
2133 if (h
->plt
.refcount
> 0
2134 || eh
->plt_got
.refcount
> 0)
2138 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
2141 /* Return TRUE if a symbol is referenced locally. It is similar to
2142 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
2143 works in check_relocs. */
2146 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info
*info
,
2147 struct elf_link_hash_entry
*h
)
2149 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
2150 struct elf_x86_link_hash_table
*htab
2151 = (struct elf_x86_link_hash_table
*) info
->hash
;
2153 if (eh
->local_ref
> 1)
2156 if (eh
->local_ref
== 1)
2159 /* Unversioned symbols defined in regular objects can be forced local
2160 by linker version script. A weak undefined symbol is forced local
2162 1. It has non-default visibility. Or
2163 2. When building executable, there is no dynamic linker. Or
2164 3. or "-z nodynamic-undefined-weak" is used.
2166 if (SYMBOL_REFERENCES_LOCAL (info
, h
)
2167 || (h
->root
.type
== bfd_link_hash_undefweak
2168 && (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2169 || (bfd_link_executable (info
)
2170 && htab
->interp
== NULL
)
2171 || info
->dynamic_undefined_weak
== 0))
2172 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
2173 && info
->version_info
!= NULL
2174 && _bfd_elf_link_hide_sym_by_version (info
, h
)))
2184 /* Return the section that should be marked against GC for a given
2188 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
2189 struct bfd_link_info
*info
,
2190 Elf_Internal_Rela
*rel
,
2191 struct elf_link_hash_entry
*h
,
2192 Elf_Internal_Sym
*sym
)
2194 /* Compiler should optimize this out. */
2195 if (((unsigned int) R_X86_64_GNU_VTINHERIT
2196 != (unsigned int) R_386_GNU_VTINHERIT
)
2197 || ((unsigned int) R_X86_64_GNU_VTENTRY
2198 != (unsigned int) R_386_GNU_VTENTRY
))
2202 switch (ELF32_R_TYPE (rel
->r_info
))
2204 case R_X86_64_GNU_VTINHERIT
:
2205 case R_X86_64_GNU_VTENTRY
:
2209 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2213 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
2215 bfd_vma offset ATTRIBUTE_UNUSED
,
2218 return got_addr
+ off
;
2222 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
2225 bfd_vma got_addr ATTRIBUTE_UNUSED
)
2227 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
2231 elf_i386_valid_plt_reloc_p (unsigned int type
)
2233 return (type
== R_386_JUMP_SLOT
2234 || type
== R_386_GLOB_DAT
2235 || type
== R_386_IRELATIVE
);
2239 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
2241 return (type
== R_X86_64_JUMP_SLOT
2242 || type
== R_X86_64_GLOB_DAT
2243 || type
== R_X86_64_IRELATIVE
);
2247 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
2251 struct elf_x86_plt plts
[],
2255 long size
, i
, n
, len
;
2257 unsigned int plt_got_offset
, plt_entry_size
;
2259 bfd_byte
*plt_contents
;
2261 arelent
**dynrelbuf
, *p
;
2263 const struct elf_backend_data
*bed
;
2264 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
2266 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
2272 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
2273 if (dynrelbuf
== NULL
)
2276 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
2278 if (dynrelcount
<= 0)
2281 /* Sort the relocs by address. */
2282 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
2283 _bfd_x86_elf_compare_relocs
);
2285 size
= count
* sizeof (asymbol
);
2287 /* Allocate space for @plt suffixes. */
2289 for (i
= 0; i
< dynrelcount
; i
++)
2292 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2294 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
2297 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
2301 bed
= get_elf_backend_data (abfd
);
2303 if (bed
->target_id
== X86_64_ELF_DATA
)
2305 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
2306 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
2310 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
2311 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
2314 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2316 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
2318 got_addr
= sec
->vma
;
2321 sec
= bfd_get_section_by_name (abfd
, ".got");
2323 got_addr
= sec
->vma
;
2326 if (got_addr
== (bfd_vma
) -1)
2331 /* Check for each PLT section. */
2332 names
= (char *) (s
+ count
);
2335 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2336 if ((plt_contents
= plts
[j
].contents
) != NULL
)
2341 struct elf_x86_plt
*plt_p
= &plts
[j
];
2343 plt_got_offset
= plt_p
->plt_got_offset
;
2344 plt_entry_size
= plt_p
->plt_entry_size
;
2348 if ((plt_p
->type
& plt_lazy
))
2350 /* Skip PLT0 in lazy PLT. */
2352 offset
= plt_entry_size
;
2360 /* Check each PLT entry against dynamic relocations. */
2361 for (; k
< plt_p
->count
; k
++)
2367 /* Get the GOT offset for i386 or the PC-relative offset
2368 for x86-64, a signed 32-bit integer. */
2369 off
= H_GET_32 (abfd
, (plt_contents
+ offset
2371 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
2373 /* Binary search. */
2377 while ((min
+ 1) < max
)
2381 mid
= (min
+ max
) / 2;
2383 if (got_vma
> r
->address
)
2385 else if (got_vma
< r
->address
)
2394 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2395 if (got_vma
== p
->address
2397 && valid_plt_reloc_p (p
->howto
->type
))
2399 *s
= **p
->sym_ptr_ptr
;
2400 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2401 set. Since we are defining a symbol, ensure one
2403 if ((s
->flags
& BSF_LOCAL
) == 0)
2404 s
->flags
|= BSF_GLOBAL
;
2405 s
->flags
|= BSF_SYNTHETIC
;
2406 /* This is no longer a section symbol. */
2407 s
->flags
&= ~BSF_SECTION_SYM
;
2409 s
->the_bfd
= plt
->owner
;
2413 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2414 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2420 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2421 names
+= sizeof ("+0x") - 1;
2422 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
2423 for (a
= buf
; *a
== '0'; ++a
)
2426 memcpy (names
, a
, size
);
2429 memcpy (names
, "@plt", sizeof ("@plt"));
2430 names
+= sizeof ("@plt");
2433 /* There should be only one entry in PLT for a given
2434 symbol. Set howto to NULL after processing a PLT
2435 entry to guard against corrupted PLT. */
2438 offset
+= plt_entry_size
;
2442 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2451 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2452 free (plts
[j
].contents
);
2459 /* Parse x86 GNU properties. */
2461 enum elf_property_kind
2462 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
2463 bfd_byte
*ptr
, unsigned int datasz
)
2467 if (type
== GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2468 || type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2469 || (type
>= GNU_PROPERTY_X86_UINT32_AND_LO
2470 && type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
2471 || (type
>= GNU_PROPERTY_X86_UINT32_OR_LO
2472 && type
<= GNU_PROPERTY_X86_UINT32_OR_HI
)
2473 || (type
>= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2474 && type
<= GNU_PROPERTY_X86_UINT32_OR_AND_HI
))
2479 (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"),
2480 abfd
, type
, datasz
);
2481 return property_corrupt
;
2483 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
2484 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
2485 prop
->pr_kind
= property_number
;
2486 return property_number
;
2489 return property_ignored
;
2492 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2493 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2494 should be merged with ABFD. */
2497 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
2498 bfd
*abfd ATTRIBUTE_UNUSED
,
2499 bfd
*bbfd ATTRIBUTE_UNUSED
,
2500 elf_property
*aprop
,
2501 elf_property
*bprop
)
2503 unsigned int number
, features
;
2504 bfd_boolean updated
= FALSE
;
2505 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
2507 if (pr_type
== GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2508 || (pr_type
>= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2509 && pr_type
<= GNU_PROPERTY_X86_UINT32_OR_AND_HI
))
2511 if (aprop
== NULL
|| bprop
== NULL
)
2513 /* Only one of APROP and BPROP can be NULL. */
2516 /* Remove this property since the other input file doesn't
2518 aprop
->pr_kind
= property_remove
;
2524 number
= aprop
->u
.number
;
2525 aprop
->u
.number
= number
| bprop
->u
.number
;
2526 updated
= number
!= (unsigned int) aprop
->u
.number
;
2530 else if (pr_type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2531 || (pr_type
>= GNU_PROPERTY_X86_UINT32_OR_LO
2532 && pr_type
<= GNU_PROPERTY_X86_UINT32_OR_HI
))
2534 if (aprop
!= NULL
&& bprop
!= NULL
)
2536 number
= aprop
->u
.number
;
2537 aprop
->u
.number
= number
| bprop
->u
.number
;
2538 /* Remove the property if all bits are empty. */
2539 if (aprop
->u
.number
== 0)
2541 aprop
->pr_kind
= property_remove
;
2545 updated
= number
!= (unsigned int) aprop
->u
.number
;
2549 /* Only one of APROP and BPROP can be NULL. */
2552 if (aprop
->u
.number
== 0)
2554 /* Remove APROP if all bits are empty. */
2555 aprop
->pr_kind
= property_remove
;
2561 /* Return TRUE if APROP is NULL and all bits of BPROP
2562 aren't empty to indicate that BPROP should be added
2564 updated
= bprop
->u
.number
!= 0;
2569 else if (pr_type
>= GNU_PROPERTY_X86_UINT32_AND_LO
2570 && pr_type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
2572 /* Only one of APROP and BPROP can be NULL:
2573 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2574 2. If APROP is NULL, remove x86 feature.
2575 3. Otherwise, do nothing.
2577 const struct elf_backend_data
*bed
2578 = get_elf_backend_data (info
->output_bfd
);
2579 struct elf_x86_link_hash_table
*htab
2580 = elf_x86_hash_table (info
, bed
->target_id
);
2583 if (aprop
!= NULL
&& bprop
!= NULL
)
2586 if (htab
->params
->ibt
)
2587 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2588 if (htab
->params
->shstk
)
2589 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2590 number
= aprop
->u
.number
;
2591 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2592 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2593 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
2594 updated
= number
!= (unsigned int) aprop
->u
.number
;
2595 /* Remove the property if all feature bits are cleared. */
2596 if (aprop
->u
.number
== 0)
2597 aprop
->pr_kind
= property_remove
;
2601 /* There should be no AND properties since some input doesn't
2602 have them. Set IBT and SHSTK properties for -z ibt and -z
2605 if (htab
->params
->ibt
)
2606 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2607 if (htab
->params
->shstk
)
2608 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2613 updated
= features
!= (unsigned int) aprop
->u
.number
;
2614 aprop
->u
.number
= features
;
2619 bprop
->u
.number
= features
;
2622 else if (aprop
!= NULL
)
2624 aprop
->pr_kind
= property_remove
;
2632 /* Never should happen. */
2639 /* Set up x86 GNU properties. Return the first relocatable ELF input
2640 with GNU properties if found. Otherwise, return NULL. */
2643 _bfd_x86_elf_link_setup_gnu_properties
2644 (struct bfd_link_info
*info
, struct elf_x86_init_table
*init_table
)
2646 bfd_boolean normal_target
;
2647 bfd_boolean lazy_plt
;
2648 asection
*sec
, *pltsec
;
2650 bfd_boolean use_ibt_plt
;
2651 unsigned int plt_alignment
, features
;
2652 struct elf_x86_link_hash_table
*htab
;
2656 const struct elf_backend_data
*bed
;
2657 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
2658 unsigned int got_align
;
2660 /* Find a normal input file with GNU property note. */
2661 for (pbfd
= info
->input_bfds
;
2663 pbfd
= pbfd
->link
.next
)
2664 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
2665 && bfd_count_sections (pbfd
) != 0)
2669 if (elf_properties (pbfd
) != NULL
)
2673 bed
= get_elf_backend_data (info
->output_bfd
);
2675 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2680 if (htab
->params
->ibt
)
2682 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2683 htab
->params
->cet_report
&= ~cet_report_ibt
;
2685 if (htab
->params
->shstk
)
2687 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2688 htab
->params
->cet_report
&= ~cet_report_shstk
;
2690 if (!(htab
->params
->cet_report
& (cet_report_ibt
| cet_report_shstk
)))
2691 htab
->params
->cet_report
= cet_report_none
;
2698 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2699 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2700 prop
= _bfd_elf_get_property (ebfd
,
2701 GNU_PROPERTY_X86_FEATURE_1_AND
,
2703 prop
->u
.number
|= features
;
2704 prop
->pr_kind
= property_number
;
2707 /* Create the GNU property note section if needed. */
2708 if (prop
!= NULL
&& pbfd
== NULL
)
2710 sec
= bfd_make_section_with_flags (ebfd
,
2711 NOTE_GNU_PROPERTY_SECTION_NAME
,
2719 info
->callbacks
->einfo (_("%F%P: failed to create GNU property section\n"));
2721 if (!bfd_set_section_alignment (sec
, class_align
))
2724 info
->callbacks
->einfo (_("%F%pA: failed to align section\n"),
2728 elf_section_type (sec
) = SHT_NOTE
;
2732 if (htab
->params
->cet_report
)
2734 /* Report missing IBT and SHSTK properties. */
2737 elf_property_list
*p
;
2738 bfd_boolean missing_ibt
, missing_shstk
;
2739 bfd_boolean check_ibt
2740 = !!(htab
->params
->cet_report
& cet_report_ibt
);
2741 bfd_boolean check_shstk
2742 = !!(htab
->params
->cet_report
& cet_report_shstk
);
2744 if ((htab
->params
->cet_report
& cet_report_warning
))
2745 msg
= _("%P: %pB: warning: missing %s\n");
2747 msg
= _("%X%P: %pB: error: missing %s\n");
2749 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
2750 if (!(abfd
->flags
& (DYNAMIC
| BFD_PLUGIN
| BFD_LINKER_CREATED
))
2751 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2753 for (p
= elf_properties (abfd
); p
; p
= p
->next
)
2754 if (p
->property
.pr_type
== GNU_PROPERTY_X86_FEATURE_1_AND
)
2757 missing_ibt
= check_ibt
;
2758 missing_shstk
= check_shstk
;
2761 missing_ibt
&= !(p
->property
.u
.number
2762 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2763 missing_shstk
&= !(p
->property
.u
.number
2764 & GNU_PROPERTY_X86_FEATURE_1_SHSTK
);
2766 if (missing_ibt
|| missing_shstk
)
2768 const char *missing
;
2769 if (missing_ibt
&& missing_shstk
)
2770 missing
= _("IBT and SHSTK properties");
2771 else if (missing_ibt
)
2772 missing
= _("IBT property");
2774 missing
= _("SHSTK property");
2775 info
->callbacks
->einfo (msg
, abfd
, missing
);
2780 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
2782 htab
->r_info
= init_table
->r_info
;
2783 htab
->r_sym
= init_table
->r_sym
;
2785 if (bfd_link_relocatable (info
))
2788 htab
->plt0_pad_byte
= init_table
->plt0_pad_byte
;
2790 use_ibt_plt
= htab
->params
->ibtplt
|| htab
->params
->ibt
;
2791 if (!use_ibt_plt
&& pbfd
!= NULL
)
2793 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2794 elf_property_list
*p
;
2796 /* The property list is sorted in order of type. */
2797 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
2799 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
2801 use_ibt_plt
= !!(p
->property
.u
.number
2802 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2805 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
2810 dynobj
= htab
->elf
.dynobj
;
2812 /* Set htab->elf.dynobj here so that there is no need to check and
2813 set it in check_relocs. */
2818 htab
->elf
.dynobj
= pbfd
;
2825 /* Find a normal input file to hold linker created
2827 for (abfd
= info
->input_bfds
;
2829 abfd
= abfd
->link
.next
)
2830 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2832 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0
2833 && bed
->relocs_compatible (abfd
->xvec
,
2834 info
->output_bfd
->xvec
))
2836 htab
->elf
.dynobj
= abfd
;
2843 /* Return if there are no normal input files. */
2847 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2848 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2849 canonical function address. */
2850 htab
->plt
.has_plt0
= 1;
2851 normal_target
= htab
->target_os
== is_normal
;
2857 htab
->lazy_plt
= init_table
->lazy_ibt_plt
;
2858 htab
->non_lazy_plt
= init_table
->non_lazy_ibt_plt
;
2862 htab
->lazy_plt
= init_table
->lazy_plt
;
2863 htab
->non_lazy_plt
= init_table
->non_lazy_plt
;
2868 htab
->lazy_plt
= init_table
->lazy_plt
;
2869 htab
->non_lazy_plt
= NULL
;
2872 pltsec
= htab
->elf
.splt
;
2874 /* If the non-lazy PLT is available, use it for all PLT entries if
2875 there are no PLT0 or no .plt section. */
2876 if (htab
->non_lazy_plt
!= NULL
2877 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
2880 if (bfd_link_pic (info
))
2881 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
2883 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
2884 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
2885 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
2886 htab
->plt
.plt_got_insn_size
2887 = htab
->non_lazy_plt
->plt_got_insn_size
;
2888 htab
->plt
.eh_frame_plt_size
2889 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2890 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
2895 if (bfd_link_pic (info
))
2897 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
2898 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
2902 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
2903 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
2905 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
2906 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
2907 htab
->plt
.plt_got_insn_size
2908 = htab
->lazy_plt
->plt_got_insn_size
;
2909 htab
->plt
.eh_frame_plt_size
2910 = htab
->lazy_plt
->eh_frame_plt_size
;
2911 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
2914 if (htab
->target_os
== is_vxworks
2915 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
2918 info
->callbacks
->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2922 /* Since create_dynamic_sections isn't always called, but GOT
2923 relocations need GOT relocations, create them here so that we
2924 don't need to do it in check_relocs. */
2925 if (htab
->elf
.sgot
== NULL
2926 && !_bfd_elf_create_got_section (dynobj
, info
))
2927 info
->callbacks
->einfo (_("%F%P: failed to create GOT sections\n"));
2929 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
2931 /* Align .got and .got.plt sections to their entry size. Do it here
2932 instead of in create_dynamic_sections so that they are always
2933 properly aligned even if create_dynamic_sections isn't called. */
2934 sec
= htab
->elf
.sgot
;
2935 if (!bfd_set_section_alignment (sec
, got_align
))
2936 goto error_alignment
;
2938 sec
= htab
->elf
.sgotplt
;
2939 if (!bfd_set_section_alignment (sec
, got_align
))
2940 goto error_alignment
;
2942 /* Create the ifunc sections here so that check_relocs can be
2944 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
2945 info
->callbacks
->einfo (_("%F%P: failed to create ifunc sections\n"));
2947 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
2951 /* Whe creating executable, set the contents of the .interp
2952 section to the interpreter. */
2953 if (bfd_link_executable (info
) && !info
->nointerp
)
2955 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
2958 s
->size
= htab
->dynamic_interpreter_size
;
2959 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2963 /* Don't change PLT section alignment for NaCl since it uses
2964 64-byte PLT entry and sets PLT section alignment to 32
2965 bytes. Don't create additional PLT sections for NaCl. */
2968 flagword pltflags
= (bed
->dynamic_sec_flags
2973 unsigned int non_lazy_plt_alignment
2974 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
2977 if (!bfd_set_section_alignment (sec
, plt_alignment
))
2978 goto error_alignment
;
2980 /* Create the GOT procedure linkage table. */
2981 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2985 info
->callbacks
->einfo (_("%F%P: failed to create GOT PLT section\n"));
2987 if (!bfd_set_section_alignment (sec
, non_lazy_plt_alignment
))
2988 goto error_alignment
;
2990 htab
->plt_got
= sec
;
2998 /* Create the second PLT for Intel IBT support. IBT
2999 PLT is supported only for non-NaCl target and is
3000 is needed only for lazy binding. */
3001 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3005 info
->callbacks
->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
3007 if (!bfd_set_section_alignment (sec
, plt_alignment
))
3008 goto error_alignment
;
3010 else if (htab
->params
->bndplt
&& ABI_64_P (dynobj
))
3012 /* Create the second PLT for Intel MPX support. MPX
3013 PLT is supported only for non-NaCl target in 64-bit
3014 mode and is needed only for lazy binding. */
3015 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3019 info
->callbacks
->einfo (_("%F%P: failed to create BND PLT section\n"));
3021 if (!bfd_set_section_alignment (sec
, non_lazy_plt_alignment
))
3022 goto error_alignment
;
3025 htab
->plt_second
= sec
;
3029 if (!info
->no_ld_generated_unwind_info
)
3031 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3032 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3033 | SEC_LINKER_CREATED
);
3035 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3039 info
->callbacks
->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
3041 if (!bfd_set_section_alignment (sec
, class_align
))
3042 goto error_alignment
;
3044 htab
->plt_eh_frame
= sec
;
3046 if (htab
->plt_got
!= NULL
)
3048 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3052 info
->callbacks
->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
3054 if (!bfd_set_section_alignment (sec
, class_align
))
3055 goto error_alignment
;
3057 htab
->plt_got_eh_frame
= sec
;
3060 if (htab
->plt_second
!= NULL
)
3062 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3066 info
->callbacks
->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
3068 if (!bfd_set_section_alignment (sec
, class_align
))
3069 goto error_alignment
;
3071 htab
->plt_second_eh_frame
= sec
;
3076 /* The .iplt section is used for IFUNC symbols in static
3078 sec
= htab
->elf
.iplt
;
3081 /* NB: Delay setting its alignment until we know it is non-empty.
3082 Otherwise an empty iplt section may change vma and lma of the
3083 following sections, which triggers moving dot of the following
3084 section backwards, resulting in a warning and section lma not
3085 being set properly. It later leads to a "File truncated"
3087 if (!bfd_set_section_alignment (sec
, 0))
3088 goto error_alignment
;
3090 htab
->plt
.iplt_alignment
= (normal_target
3092 : bed
->plt_alignment
);
3095 if (bfd_link_executable (info
)
3097 && !htab
->params
->has_dynamic_linker
3098 && htab
->params
->static_before_all_inputs
)
3100 /* Report error for dynamic input objects if -static is passed at
3101 command-line before all input files without --dynamic-linker
3102 unless --no-dynamic-linker is used. */
3105 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
3106 if ((abfd
->flags
& DYNAMIC
))
3107 info
->callbacks
->einfo
3108 (_("%X%P: attempted static link of dynamic object `%pB'\n"),
3115 /* Fix up x86 GNU properties. */
3118 _bfd_x86_elf_link_fixup_gnu_properties
3119 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3120 elf_property_list
**listp
)
3122 elf_property_list
*p
;
3124 for (p
= *listp
; p
; p
= p
->next
)
3126 unsigned int type
= p
->property
.pr_type
;
3127 if (type
== GNU_PROPERTY_X86_COMPAT_ISA_1_USED
3128 || type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3129 || (type
>= GNU_PROPERTY_X86_UINT32_AND_LO
3130 && type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
3131 || (type
>= GNU_PROPERTY_X86_UINT32_OR_LO
3132 && type
<= GNU_PROPERTY_X86_UINT32_OR_HI
)
3133 || (type
>= GNU_PROPERTY_X86_UINT32_OR_AND_LO
3134 && type
<= GNU_PROPERTY_X86_UINT32_OR_AND_HI
))
3136 if (p
->property
.u
.number
== 0
3137 && (type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3138 || (type
>= GNU_PROPERTY_X86_UINT32_AND_LO
3139 && type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
3140 || (type
>= GNU_PROPERTY_X86_UINT32_OR_LO
3141 && type
<= GNU_PROPERTY_X86_UINT32_OR_HI
)))
3143 /* Remove empty property. */
3150 else if (type
> GNU_PROPERTY_HIPROC
)
3152 /* The property list is sorted in order of type. */
3159 _bfd_elf_linker_x86_set_options (struct bfd_link_info
* info
,
3160 struct elf_linker_x86_params
*params
)
3162 const struct elf_backend_data
*bed
3163 = get_elf_backend_data (info
->output_bfd
);
3164 struct elf_x86_link_hash_table
*htab
3165 = elf_x86_hash_table (info
, bed
->target_id
);
3167 htab
->params
= params
;