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
, &eh
->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 (eh
->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
= &eh
->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
= &eh
->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 (eh
->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
= &eh
->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 (eh
->dyn_relocs
!= NULL
454 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
458 eh
->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
= &eh
->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 eh
->dyn_relocs
= NULL
;
521 /* Finally, allocate space. */
522 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
526 sreloc
= elf_section_data (p
->sec
)->sreloc
;
528 BFD_ASSERT (sreloc
!= NULL
);
529 sreloc
->size
+= p
->count
* htab
->sizeof_reloc
;
535 /* Find 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
= elf_x86_hash_entry (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 ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
579 || info
->error_textrel
)
580 /* xgettext:c-format */
581 info
->callbacks
->einfo (_("%P: %pB: warning: relocation against `%s' "
582 "in read-only section `%pA'\n"),
583 sec
->owner
, h
->root
.root
.string
, sec
);
585 /* Not an error, just cut short the traversal. */
591 /* Allocate space in .plt, .got and associated reloc sections for
592 local dynamic relocs. */
595 elf_x86_allocate_local_dynreloc (void **slot
, void *inf
)
597 struct elf_link_hash_entry
*h
598 = (struct elf_link_hash_entry
*) *slot
;
600 if (h
->type
!= STT_GNU_IFUNC
604 || h
->root
.type
!= bfd_link_hash_defined
)
607 return elf_x86_allocate_dynrelocs (h
, inf
);
610 /* Find and/or create a hash entry for local symbol. */
612 struct elf_link_hash_entry
*
613 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table
*htab
,
614 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
617 struct elf_x86_link_hash_entry e
, *ret
;
618 asection
*sec
= abfd
->sections
;
619 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
620 htab
->r_sym (rel
->r_info
));
623 e
.elf
.indx
= sec
->id
;
624 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
625 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
626 create
? INSERT
: NO_INSERT
);
633 ret
= (struct elf_x86_link_hash_entry
*) *slot
;
637 ret
= (struct elf_x86_link_hash_entry
*)
638 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
639 sizeof (struct elf_x86_link_hash_entry
));
642 memset (ret
, 0, sizeof (*ret
));
643 ret
->elf
.indx
= sec
->id
;
644 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
645 ret
->elf
.dynindx
= -1;
646 ret
->plt_got
.offset
= (bfd_vma
) -1;
652 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
653 SYNC WITH _bfd_elf_link_hash_newfunc. */
655 struct bfd_hash_entry
*
656 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
657 struct bfd_hash_table
*table
,
660 /* Allocate the structure if it has not already been allocated by a
664 entry
= (struct bfd_hash_entry
*)
665 bfd_hash_allocate (table
,
666 sizeof (struct elf_x86_link_hash_entry
));
671 /* Call the allocation method of the superclass. */
672 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
675 struct elf_x86_link_hash_entry
*eh
676 = (struct elf_x86_link_hash_entry
*) entry
;
677 struct elf_link_hash_table
*htab
678 = (struct elf_link_hash_table
*) table
;
680 memset (&eh
->elf
.size
, 0,
681 (sizeof (struct elf_x86_link_hash_entry
)
682 - offsetof (struct elf_link_hash_entry
, size
)));
683 /* Set local fields. */
685 eh
->elf
.dynindx
= -1;
686 eh
->elf
.got
= htab
->init_got_refcount
;
687 eh
->elf
.plt
= htab
->init_plt_refcount
;
688 /* Assume that we have been called by a non-ELF symbol reader.
689 This flag is then reset by the code which reads an ELF input
690 file. This ensures that a symbol created by a non-ELF symbol
691 reader will have the flag set correctly. */
693 eh
->plt_second
.offset
= (bfd_vma
) -1;
694 eh
->plt_got
.offset
= (bfd_vma
) -1;
695 eh
->tlsdesc_got
= (bfd_vma
) -1;
696 eh
->zero_undefweak
= 1;
702 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
703 for local symbol so that we can handle local STT_GNU_IFUNC symbols
704 as global symbol. We reuse indx and dynstr_index for local symbol
705 hash since they aren't used by global symbols in this backend. */
708 _bfd_x86_elf_local_htab_hash (const void *ptr
)
710 struct elf_link_hash_entry
*h
711 = (struct elf_link_hash_entry
*) ptr
;
712 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
715 /* Compare local hash entries. */
718 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
720 struct elf_link_hash_entry
*h1
721 = (struct elf_link_hash_entry
*) ptr1
;
722 struct elf_link_hash_entry
*h2
723 = (struct elf_link_hash_entry
*) ptr2
;
725 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
728 /* Destroy an x86 ELF linker hash table. */
731 elf_x86_link_hash_table_free (bfd
*obfd
)
733 struct elf_x86_link_hash_table
*htab
734 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
736 if (htab
->loc_hash_table
)
737 htab_delete (htab
->loc_hash_table
);
738 if (htab
->loc_hash_memory
)
739 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
740 _bfd_elf_link_hash_table_free (obfd
);
744 elf_i386_is_reloc_section (const char *secname
)
746 return CONST_STRNEQ (secname
, ".rel");
750 elf_x86_64_is_reloc_section (const char *secname
)
752 return CONST_STRNEQ (secname
, ".rela");
755 /* Create an x86 ELF linker hash table. */
757 struct bfd_link_hash_table
*
758 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
760 struct elf_x86_link_hash_table
*ret
;
761 const struct elf_backend_data
*bed
;
762 size_t amt
= sizeof (struct elf_x86_link_hash_table
);
764 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
768 bed
= get_elf_backend_data (abfd
);
769 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
770 _bfd_x86_elf_link_hash_newfunc
,
771 sizeof (struct elf_x86_link_hash_entry
),
778 if (bed
->target_id
== X86_64_ELF_DATA
)
780 ret
->is_reloc_section
= elf_x86_64_is_reloc_section
;
781 ret
->dt_reloc
= DT_RELA
;
782 ret
->dt_reloc_sz
= DT_RELASZ
;
783 ret
->dt_reloc_ent
= DT_RELAENT
;
784 ret
->got_entry_size
= 8;
785 ret
->pcrel_plt
= TRUE
;
786 ret
->tls_get_addr
= "__tls_get_addr";
790 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
791 ret
->pointer_r_type
= R_X86_64_64
;
792 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
793 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
797 if (bed
->target_id
== X86_64_ELF_DATA
)
799 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
800 ret
->pointer_r_type
= R_X86_64_32
;
801 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
802 ret
->dynamic_interpreter_size
803 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
807 ret
->is_reloc_section
= elf_i386_is_reloc_section
;
808 ret
->dt_reloc
= DT_REL
;
809 ret
->dt_reloc_sz
= DT_RELSZ
;
810 ret
->dt_reloc_ent
= DT_RELENT
;
811 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
812 ret
->got_entry_size
= 4;
813 ret
->pcrel_plt
= FALSE
;
814 ret
->pointer_r_type
= R_386_32
;
815 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
816 ret
->dynamic_interpreter_size
817 = sizeof ELF32_DYNAMIC_INTERPRETER
;
818 ret
->tls_get_addr
= "___tls_get_addr";
821 ret
->target_id
= bed
->target_id
;
822 ret
->target_os
= get_elf_x86_backend_data (abfd
)->target_os
;
824 ret
->loc_hash_table
= htab_try_create (1024,
825 _bfd_x86_elf_local_htab_hash
,
826 _bfd_x86_elf_local_htab_eq
,
828 ret
->loc_hash_memory
= objalloc_create ();
829 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
831 elf_x86_link_hash_table_free (abfd
);
834 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
836 return &ret
->elf
.root
;
839 /* Sort relocs into address order. */
842 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
844 const arelent
*a
= * (const arelent
**) ap
;
845 const arelent
*b
= * (const arelent
**) bp
;
847 if (a
->address
> b
->address
)
849 else if (a
->address
< b
->address
)
855 /* Mark symbol, NAME, as locally defined by linker if it is referenced
856 and not defined in a relocatable object file. */
859 elf_x86_linker_defined (struct bfd_link_info
*info
, const char *name
)
861 struct elf_link_hash_entry
*h
;
863 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
864 FALSE
, FALSE
, FALSE
);
868 while (h
->root
.type
== bfd_link_hash_indirect
)
869 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
871 if (h
->root
.type
== bfd_link_hash_new
872 || h
->root
.type
== bfd_link_hash_undefined
873 || h
->root
.type
== bfd_link_hash_undefweak
874 || h
->root
.type
== bfd_link_hash_common
875 || (!h
->def_regular
&& h
->def_dynamic
))
877 elf_x86_hash_entry (h
)->local_ref
= 2;
878 elf_x86_hash_entry (h
)->linker_def
= 1;
882 /* Hide a linker-defined symbol, NAME, with hidden visibility. */
885 elf_x86_hide_linker_defined (struct bfd_link_info
*info
,
888 struct elf_link_hash_entry
*h
;
890 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
891 FALSE
, FALSE
, FALSE
);
895 while (h
->root
.type
== bfd_link_hash_indirect
)
896 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
898 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
899 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
900 _bfd_elf_link_hash_hide_symbol (info
, h
, TRUE
);
904 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
906 if (!bfd_link_relocatable (info
))
908 /* Check for __tls_get_addr reference. */
909 struct elf_x86_link_hash_table
*htab
;
910 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
911 htab
= elf_x86_hash_table (info
, bed
->target_id
);
914 struct elf_link_hash_entry
*h
;
916 h
= elf_link_hash_lookup (elf_hash_table (info
),
918 FALSE
, FALSE
, FALSE
);
921 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
923 /* Check the versioned __tls_get_addr symbol. */
924 while (h
->root
.type
== bfd_link_hash_indirect
)
926 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
927 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
931 /* "__ehdr_start" will be defined by linker as a hidden symbol
932 later if it is referenced and not defined. */
933 elf_x86_linker_defined (info
, "__ehdr_start");
935 if (bfd_link_executable (info
))
937 /* References to __bss_start, _end and _edata should be
938 locally resolved within executables. */
939 elf_x86_linker_defined (info
, "__bss_start");
940 elf_x86_linker_defined (info
, "_end");
941 elf_x86_linker_defined (info
, "_edata");
945 /* Hide hidden __bss_start, _end and _edata in shared
947 elf_x86_hide_linker_defined (info
, "__bss_start");
948 elf_x86_hide_linker_defined (info
, "_end");
949 elf_x86_hide_linker_defined (info
, "_edata");
954 /* Invoke the regular ELF backend linker to do all the work. */
955 return _bfd_elf_link_check_relocs (abfd
, info
);
959 _bfd_elf_x86_valid_reloc_p (asection
*input_section
,
960 struct bfd_link_info
*info
,
961 struct elf_x86_link_hash_table
*htab
,
962 const Elf_Internal_Rela
*rel
,
963 struct elf_link_hash_entry
*h
,
964 Elf_Internal_Sym
*sym
,
965 Elf_Internal_Shdr
*symtab_hdr
,
966 bfd_boolean
*no_dynreloc_p
)
968 bfd_boolean valid_p
= TRUE
;
970 *no_dynreloc_p
= FALSE
;
972 /* Check If relocation against non-preemptible absolute symbol is
973 valid in PIC. FIXME: Can't use SYMBOL_REFERENCES_LOCAL_P since
974 it may call _bfd_elf_link_hide_sym_by_version and result in
975 ld-elfvers/ vers21 test failure. */
976 if (bfd_link_pic (info
)
977 && (h
== NULL
|| SYMBOL_REFERENCES_LOCAL (info
, h
)))
979 const struct elf_backend_data
*bed
;
981 Elf_Internal_Rela irel
;
983 /* Skip non-absolute symbol. */
986 if (!ABS_SYMBOL_P (h
))
989 else if (sym
->st_shndx
!= SHN_ABS
)
992 bed
= get_elf_backend_data (input_section
->owner
);
993 r_type
= ELF32_R_TYPE (rel
->r_info
);
996 /* Only allow relocations against absolute symbol, which can be
997 resolved as absolute value + addend. GOTPCREL relocations
998 are allowed since absolute value + addend is stored in the
1000 if (bed
->target_id
== X86_64_ELF_DATA
)
1002 r_type
&= ~R_X86_64_converted_reloc_bit
;
1003 valid_p
= (r_type
== R_X86_64_64
1004 || r_type
== R_X86_64_32
1005 || r_type
== R_X86_64_32S
1006 || r_type
== R_X86_64_16
1007 || r_type
== R_X86_64_8
1008 || r_type
== R_X86_64_GOTPCREL
1009 || r_type
== R_X86_64_GOTPCRELX
1010 || r_type
== R_X86_64_REX_GOTPCRELX
);
1013 unsigned int r_symndx
= htab
->r_sym (rel
->r_info
);
1014 irel
.r_info
= htab
->r_info (r_symndx
, r_type
);
1018 valid_p
= (r_type
== R_386_32
1019 || r_type
== R_386_16
1020 || r_type
== R_386_8
);
1023 *no_dynreloc_p
= TRUE
;
1027 arelent internal_reloc
;
1029 if (!bed
->elf_info_to_howto (input_section
->owner
,
1030 &internal_reloc
, &irel
)
1031 || internal_reloc
.howto
== NULL
)
1035 name
= h
->root
.root
.string
;
1037 name
= bfd_elf_sym_name (input_section
->owner
, symtab_hdr
,
1039 info
->callbacks
->einfo
1040 /* xgettext:c-format */
1041 (_("%F%P: %pB: relocation %s against absolute symbol "
1042 "`%s' in section `%pA' is disallowed\n"),
1043 input_section
->owner
, internal_reloc
.howto
->name
, name
,
1045 bfd_set_error (bfd_error_bad_value
);
1052 /* Set the sizes of the dynamic sections. */
1055 _bfd_x86_elf_size_dynamic_sections (bfd
*output_bfd
,
1056 struct bfd_link_info
*info
)
1058 struct elf_x86_link_hash_table
*htab
;
1063 const struct elf_backend_data
*bed
1064 = get_elf_backend_data (output_bfd
);
1066 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1069 dynobj
= htab
->elf
.dynobj
;
1073 /* Set up .got offsets for local syms, and space for local dynamic
1075 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1077 bfd_signed_vma
*local_got
;
1078 bfd_signed_vma
*end_local_got
;
1079 char *local_tls_type
;
1080 bfd_vma
*local_tlsdesc_gotent
;
1081 bfd_size_type locsymcount
;
1082 Elf_Internal_Shdr
*symtab_hdr
;
1085 if (! is_x86_elf (ibfd
, htab
))
1088 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1090 struct elf_dyn_relocs
*p
;
1092 for (p
= ((struct elf_dyn_relocs
*)
1093 elf_section_data (s
)->local_dynrel
);
1097 if (!bfd_is_abs_section (p
->sec
)
1098 && bfd_is_abs_section (p
->sec
->output_section
))
1100 /* Input section has been discarded, either because
1101 it is a copy of a linkonce section or due to
1102 linker script /DISCARD/, so we'll be discarding
1105 else if (htab
->target_os
== is_vxworks
1106 && strcmp (p
->sec
->output_section
->name
,
1109 /* Relocations in vxworks .tls_vars sections are
1110 handled specially by the loader. */
1112 else if (p
->count
!= 0)
1114 srel
= elf_section_data (p
->sec
)->sreloc
;
1115 srel
->size
+= p
->count
* htab
->sizeof_reloc
;
1116 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
1117 && (info
->flags
& DF_TEXTREL
) == 0)
1119 info
->flags
|= DF_TEXTREL
;
1120 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
1121 || info
->error_textrel
)
1122 /* xgettext:c-format */
1123 info
->callbacks
->einfo
1124 (_("%P: %pB: warning: relocation "
1125 "in read-only section `%pA'\n"),
1126 p
->sec
->owner
, p
->sec
);
1132 local_got
= elf_local_got_refcounts (ibfd
);
1136 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1137 locsymcount
= symtab_hdr
->sh_info
;
1138 end_local_got
= local_got
+ locsymcount
;
1139 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
1140 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
1142 srel
= htab
->elf
.srelgot
;
1143 for (; local_got
< end_local_got
;
1144 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
1146 *local_tlsdesc_gotent
= (bfd_vma
) -1;
1149 if (GOT_TLS_GDESC_P (*local_tls_type
))
1151 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
1152 - elf_x86_compute_jump_table_size (htab
);
1153 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
1154 *local_got
= (bfd_vma
) -2;
1156 if (! GOT_TLS_GDESC_P (*local_tls_type
)
1157 || GOT_TLS_GD_P (*local_tls_type
))
1159 *local_got
= s
->size
;
1160 s
->size
+= htab
->got_entry_size
;
1161 if (GOT_TLS_GD_P (*local_tls_type
)
1162 || *local_tls_type
== GOT_TLS_IE_BOTH
)
1163 s
->size
+= htab
->got_entry_size
;
1165 if ((bfd_link_pic (info
) && *local_tls_type
!= GOT_ABS
)
1166 || GOT_TLS_GD_ANY_P (*local_tls_type
)
1167 || (*local_tls_type
& GOT_TLS_IE
))
1169 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
1170 srel
->size
+= 2 * htab
->sizeof_reloc
;
1171 else if (GOT_TLS_GD_P (*local_tls_type
)
1172 || ! GOT_TLS_GDESC_P (*local_tls_type
))
1173 srel
->size
+= htab
->sizeof_reloc
;
1174 if (GOT_TLS_GDESC_P (*local_tls_type
))
1176 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
1177 if (bed
->target_id
== X86_64_ELF_DATA
)
1178 htab
->tlsdesc_plt
= (bfd_vma
) -1;
1183 *local_got
= (bfd_vma
) -1;
1187 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
1189 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1190 or R_X86_64_TLSLD relocs. */
1191 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
1192 htab
->elf
.sgot
->size
+= 2 * htab
->got_entry_size
;
1193 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
1196 htab
->tls_ld_or_ldm_got
.offset
= -1;
1198 /* Allocate global sym .plt and .got entries, and space for global
1199 sym dynamic relocs. */
1200 elf_link_hash_traverse (&htab
->elf
, elf_x86_allocate_dynrelocs
,
1203 /* Allocate .plt and .got entries, and space for local symbols. */
1204 htab_traverse (htab
->loc_hash_table
, elf_x86_allocate_local_dynreloc
,
1207 /* For every jump slot reserved in the sgotplt, reloc_count is
1208 incremented. However, when we reserve space for TLS descriptors,
1209 it's not incremented, so in order to compute the space reserved
1210 for them, it suffices to multiply the reloc count by the jump
1213 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1214 so that R_{386,X86_64}_IRELATIVE entries come last. */
1215 if (htab
->elf
.srelplt
)
1217 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
1218 htab
->sgotplt_jump_table_size
1219 = elf_x86_compute_jump_table_size (htab
);
1220 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
1222 else if (htab
->elf
.irelplt
)
1223 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1225 if (htab
->tlsdesc_plt
)
1227 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1228 lazy TLS relocations, don't generate the PLT and GOT entries
1230 if ((info
->flags
& DF_BIND_NOW
))
1231 htab
->tlsdesc_plt
= 0;
1234 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
1235 htab
->elf
.sgot
->size
+= htab
->got_entry_size
;
1236 /* Reserve room for the initial entry.
1237 FIXME: we could probably do away with it in this case. */
1238 if (htab
->elf
.splt
->size
== 0)
1239 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
1240 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
1241 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
1245 if (htab
->elf
.sgotplt
)
1247 /* Don't allocate .got.plt section if there are no GOT nor PLT
1248 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1249 if ((htab
->elf
.hgot
== NULL
1250 || !htab
->got_referenced
)
1251 && (htab
->elf
.sgotplt
->size
== bed
->got_header_size
)
1252 && (htab
->elf
.splt
== NULL
1253 || htab
->elf
.splt
->size
== 0)
1254 && (htab
->elf
.sgot
== NULL
1255 || htab
->elf
.sgot
->size
== 0)
1256 && (htab
->elf
.iplt
== NULL
1257 || htab
->elf
.iplt
->size
== 0)
1258 && (htab
->elf
.igotplt
== NULL
1259 || htab
->elf
.igotplt
->size
== 0))
1261 htab
->elf
.sgotplt
->size
= 0;
1262 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
1264 if (htab
->elf
.hgot
!= NULL
&& htab
->target_os
!= is_solaris
)
1266 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
1268 htab
->elf
.hgot
->root
.type
= bfd_link_hash_undefined
;
1269 htab
->elf
.hgot
->root
.u
.undef
.abfd
1270 = htab
->elf
.hgot
->root
.u
.def
.section
->owner
;
1271 htab
->elf
.hgot
->root
.linker_def
= 0;
1272 htab
->elf
.hgot
->ref_regular
= 0;
1273 htab
->elf
.hgot
->def_regular
= 0;
1278 if (_bfd_elf_eh_frame_present (info
))
1280 if (htab
->plt_eh_frame
!= NULL
1281 && htab
->elf
.splt
!= NULL
1282 && htab
->elf
.splt
->size
!= 0
1283 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
1284 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
1286 if (htab
->plt_got_eh_frame
!= NULL
1287 && htab
->plt_got
!= NULL
1288 && htab
->plt_got
->size
!= 0
1289 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
1290 htab
->plt_got_eh_frame
->size
1291 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1293 /* Unwind info for the second PLT and .plt.got sections are
1295 if (htab
->plt_second_eh_frame
!= NULL
1296 && htab
->plt_second
!= NULL
1297 && htab
->plt_second
->size
!= 0
1298 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
1299 htab
->plt_second_eh_frame
->size
1300 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1303 /* We now have determined the sizes of the various dynamic sections.
1304 Allocate memory for them. */
1306 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1308 bfd_boolean strip_section
= TRUE
;
1310 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1313 if (s
== htab
->elf
.splt
1314 || s
== htab
->elf
.sgot
)
1316 /* Strip this section if we don't need it; see the
1318 /* We'd like to strip these sections if they aren't needed, but if
1319 we've exported dynamic symbols from them we must leave them.
1320 It's too late to tell BFD to get rid of the symbols. */
1322 if (htab
->elf
.hplt
!= NULL
)
1323 strip_section
= FALSE
;
1325 else if (s
== htab
->elf
.sgotplt
1326 || s
== htab
->elf
.iplt
1327 || s
== htab
->elf
.igotplt
1328 || s
== htab
->plt_second
1329 || s
== htab
->plt_got
1330 || s
== htab
->plt_eh_frame
1331 || s
== htab
->plt_got_eh_frame
1332 || s
== htab
->plt_second_eh_frame
1333 || s
== htab
->elf
.sdynbss
1334 || s
== htab
->elf
.sdynrelro
)
1336 /* Strip these too. */
1338 else if (htab
->is_reloc_section (bfd_section_name (s
)))
1341 && s
!= htab
->elf
.srelplt
1342 && s
!= htab
->srelplt2
)
1345 /* We use the reloc_count field as a counter if we need
1346 to copy relocs into the output file. */
1347 if (s
!= htab
->elf
.srelplt
)
1352 /* It's not one of our sections, so don't allocate space. */
1358 /* If we don't need this section, strip it from the
1359 output file. This is mostly to handle .rel.bss and
1360 .rel.plt. We must create both sections in
1361 create_dynamic_sections, because they must be created
1362 before the linker maps input sections to output
1363 sections. The linker does that before
1364 adjust_dynamic_symbol is called, and it is that
1365 function which decides whether anything needs to go
1366 into these sections. */
1368 s
->flags
|= SEC_EXCLUDE
;
1372 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1375 /* NB: Initially, the iplt section has minimal alignment to
1376 avoid moving dot of the following section backwards when
1377 it is empty. Update its section alignment now since it
1379 if (s
== htab
->elf
.iplt
)
1380 bfd_set_section_alignment (s
, htab
->plt
.iplt_alignment
);
1382 /* Allocate memory for the section contents. We use bfd_zalloc
1383 here in case unused entries are not reclaimed before the
1384 section's contents are written out. This should not happen,
1385 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1386 reloc instead of garbage. */
1387 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
1388 if (s
->contents
== NULL
)
1392 if (htab
->plt_eh_frame
!= NULL
1393 && htab
->plt_eh_frame
->contents
!= NULL
)
1395 memcpy (htab
->plt_eh_frame
->contents
,
1396 htab
->plt
.eh_frame_plt
,
1397 htab
->plt_eh_frame
->size
);
1398 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
1399 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
1402 if (htab
->plt_got_eh_frame
!= NULL
1403 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1405 memcpy (htab
->plt_got_eh_frame
->contents
,
1406 htab
->non_lazy_plt
->eh_frame_plt
,
1407 htab
->plt_got_eh_frame
->size
);
1408 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
1409 (htab
->plt_got_eh_frame
->contents
1410 + PLT_FDE_LEN_OFFSET
));
1413 if (htab
->plt_second_eh_frame
!= NULL
1414 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1416 memcpy (htab
->plt_second_eh_frame
->contents
,
1417 htab
->non_lazy_plt
->eh_frame_plt
,
1418 htab
->plt_second_eh_frame
->size
);
1419 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
1420 (htab
->plt_second_eh_frame
->contents
1421 + PLT_FDE_LEN_OFFSET
));
1424 if (htab
->elf
.dynamic_sections_created
)
1426 /* Add some entries to the .dynamic section. We fill in the
1427 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1428 but we must add the entries now so that we get the correct
1429 size for the .dynamic section. The DT_DEBUG entry is filled
1430 in by the dynamic linker and used by the debugger. */
1431 #define add_dynamic_entry(TAG, VAL) \
1432 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1434 if (bfd_link_executable (info
))
1436 if (!add_dynamic_entry (DT_DEBUG
, 0))
1440 if (htab
->elf
.splt
->size
!= 0)
1442 /* DT_PLTGOT is used by prelink even if there is no PLT
1444 if (!add_dynamic_entry (DT_PLTGOT
, 0))
1448 if (htab
->elf
.srelplt
->size
!= 0)
1450 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1451 || !add_dynamic_entry (DT_PLTREL
, htab
->dt_reloc
)
1452 || !add_dynamic_entry (DT_JMPREL
, 0))
1456 if (htab
->tlsdesc_plt
1457 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
1458 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
1463 if (!add_dynamic_entry (htab
->dt_reloc
, 0)
1464 || !add_dynamic_entry (htab
->dt_reloc_sz
, 0)
1465 || !add_dynamic_entry (htab
->dt_reloc_ent
,
1466 htab
->sizeof_reloc
))
1469 /* If any dynamic relocs apply to a read-only section,
1470 then we need a DT_TEXTREL entry. */
1471 if ((info
->flags
& DF_TEXTREL
) == 0)
1472 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
1474 if ((info
->flags
& DF_TEXTREL
) != 0)
1476 if (htab
->readonly_dynrelocs_against_ifunc
)
1478 info
->callbacks
->einfo
1479 (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1480 " recompile with %s\n"),
1481 bfd_link_dll (info
) ? "-fPIC" : "-fPIE");
1482 bfd_set_error (bfd_error_bad_value
);
1486 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1490 if (htab
->target_os
== is_vxworks
1491 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
1494 #undef add_dynamic_entry
1499 /* Finish up the x86 dynamic sections. */
1501 struct elf_x86_link_hash_table
*
1502 _bfd_x86_elf_finish_dynamic_sections (bfd
*output_bfd
,
1503 struct bfd_link_info
*info
)
1505 struct elf_x86_link_hash_table
*htab
;
1506 const struct elf_backend_data
*bed
;
1509 bfd_byte
*dyncon
, *dynconend
;
1510 bfd_size_type sizeof_dyn
;
1512 bed
= get_elf_backend_data (output_bfd
);
1513 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1517 dynobj
= htab
->elf
.dynobj
;
1518 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
1520 /* GOT is always created in setup_gnu_properties. But it may not be
1521 needed. .got.plt section may be needed for static IFUNC. */
1522 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
1524 bfd_vma dynamic_addr
;
1526 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
1529 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
1533 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
1534 = htab
->got_entry_size
;
1536 dynamic_addr
= (sdyn
== NULL
1538 : sdyn
->output_section
->vma
+ sdyn
->output_offset
);
1540 /* Set the first entry in the global offset table to the address
1541 of the dynamic section. Write GOT[1] and GOT[2], needed for
1542 the dynamic linker. */
1543 if (htab
->got_entry_size
== 8)
1545 bfd_put_64 (output_bfd
, dynamic_addr
,
1546 htab
->elf
.sgotplt
->contents
);
1547 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1548 htab
->elf
.sgotplt
->contents
+ 8);
1549 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1550 htab
->elf
.sgotplt
->contents
+ 8*2);
1554 bfd_put_32 (output_bfd
, dynamic_addr
,
1555 htab
->elf
.sgotplt
->contents
);
1556 bfd_put_32 (output_bfd
, 0,
1557 htab
->elf
.sgotplt
->contents
+ 4);
1558 bfd_put_32 (output_bfd
, 0,
1559 htab
->elf
.sgotplt
->contents
+ 4*2);
1563 if (!htab
->elf
.dynamic_sections_created
)
1566 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
1569 sizeof_dyn
= bed
->s
->sizeof_dyn
;
1570 dyncon
= sdyn
->contents
;
1571 dynconend
= sdyn
->contents
+ sdyn
->size
;
1572 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
1574 Elf_Internal_Dyn dyn
;
1577 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
1582 if (htab
->target_os
== is_vxworks
1583 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
1588 s
= htab
->elf
.sgotplt
;
1589 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
1593 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
1597 s
= htab
->elf
.srelplt
->output_section
;
1598 dyn
.d_un
.d_val
= s
->size
;
1601 case DT_TLSDESC_PLT
:
1603 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1604 + htab
->tlsdesc_plt
;
1607 case DT_TLSDESC_GOT
:
1609 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1610 + htab
->tlsdesc_got
;
1614 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
1617 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
1618 elf_section_data (htab
->plt_got
->output_section
)
1619 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1621 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
1622 elf_section_data (htab
->plt_second
->output_section
)
1623 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1625 /* Adjust .eh_frame for .plt section. */
1626 if (htab
->plt_eh_frame
!= NULL
1627 && htab
->plt_eh_frame
->contents
!= NULL
)
1629 if (htab
->elf
.splt
!= NULL
1630 && htab
->elf
.splt
->size
!= 0
1631 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
1632 && htab
->elf
.splt
->output_section
!= NULL
1633 && htab
->plt_eh_frame
->output_section
!= NULL
)
1635 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
1636 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
1637 + htab
->plt_eh_frame
->output_offset
1638 + PLT_FDE_START_OFFSET
;
1639 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1640 htab
->plt_eh_frame
->contents
1641 + PLT_FDE_START_OFFSET
);
1644 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1646 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1648 htab
->plt_eh_frame
->contents
))
1653 /* Adjust .eh_frame for .plt.got section. */
1654 if (htab
->plt_got_eh_frame
!= NULL
1655 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1657 if (htab
->plt_got
!= NULL
1658 && htab
->plt_got
->size
!= 0
1659 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
1660 && htab
->plt_got
->output_section
!= NULL
1661 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
1663 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
1664 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
1665 + htab
->plt_got_eh_frame
->output_offset
1666 + PLT_FDE_START_OFFSET
;
1667 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1668 htab
->plt_got_eh_frame
->contents
1669 + PLT_FDE_START_OFFSET
);
1671 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1673 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1674 htab
->plt_got_eh_frame
,
1675 htab
->plt_got_eh_frame
->contents
))
1680 /* Adjust .eh_frame for the second PLT section. */
1681 if (htab
->plt_second_eh_frame
!= NULL
1682 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1684 if (htab
->plt_second
!= NULL
1685 && htab
->plt_second
->size
!= 0
1686 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
1687 && htab
->plt_second
->output_section
!= NULL
1688 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
1690 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
1691 bfd_vma eh_frame_start
1692 = (htab
->plt_second_eh_frame
->output_section
->vma
1693 + htab
->plt_second_eh_frame
->output_offset
1694 + PLT_FDE_START_OFFSET
);
1695 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1696 htab
->plt_second_eh_frame
->contents
1697 + PLT_FDE_START_OFFSET
);
1699 if (htab
->plt_second_eh_frame
->sec_info_type
1700 == SEC_INFO_TYPE_EH_FRAME
)
1702 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1703 htab
->plt_second_eh_frame
,
1704 htab
->plt_second_eh_frame
->contents
))
1709 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
1710 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
1711 = htab
->got_entry_size
;
1718 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
1719 struct bfd_link_info
*info
)
1721 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
1725 struct elf_link_hash_entry
*tlsbase
;
1727 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
1728 "_TLS_MODULE_BASE_",
1729 FALSE
, FALSE
, FALSE
);
1731 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
1733 struct elf_x86_link_hash_table
*htab
;
1734 struct bfd_link_hash_entry
*bh
= NULL
;
1735 const struct elf_backend_data
*bed
1736 = get_elf_backend_data (output_bfd
);
1738 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1742 if (!(_bfd_generic_link_add_one_symbol
1743 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1744 tls_sec
, 0, NULL
, FALSE
,
1745 bed
->collect
, &bh
)))
1748 htab
->tls_module_base
= bh
;
1750 tlsbase
= (struct elf_link_hash_entry
*)bh
;
1751 tlsbase
->def_regular
= 1;
1752 tlsbase
->other
= STV_HIDDEN
;
1753 tlsbase
->root
.linker_def
= 1;
1754 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1762 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
1763 const Elf_Internal_Sym
*isym
,
1764 bfd_boolean definition
,
1765 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
1769 struct elf_x86_link_hash_entry
*eh
1770 = (struct elf_x86_link_hash_entry
*) h
;
1771 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
1776 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1779 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1780 struct elf_link_hash_entry
*dir
,
1781 struct elf_link_hash_entry
*ind
)
1783 struct elf_x86_link_hash_entry
*edir
, *eind
;
1785 edir
= (struct elf_x86_link_hash_entry
*) dir
;
1786 eind
= (struct elf_x86_link_hash_entry
*) ind
;
1788 if (eind
->dyn_relocs
!= NULL
)
1790 if (edir
->dyn_relocs
!= NULL
)
1792 struct elf_dyn_relocs
**pp
;
1793 struct elf_dyn_relocs
*p
;
1795 /* Add reloc counts against the indirect sym to the direct sym
1796 list. Merge any entries against the same section. */
1797 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1799 struct elf_dyn_relocs
*q
;
1801 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1802 if (q
->sec
== p
->sec
)
1804 q
->pc_count
+= p
->pc_count
;
1805 q
->count
+= p
->count
;
1812 *pp
= edir
->dyn_relocs
;
1815 edir
->dyn_relocs
= eind
->dyn_relocs
;
1816 eind
->dyn_relocs
= NULL
;
1819 if (ind
->root
.type
== bfd_link_hash_indirect
1820 && dir
->got
.refcount
<= 0)
1822 edir
->tls_type
= eind
->tls_type
;
1823 eind
->tls_type
= GOT_UNKNOWN
;
1826 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1827 generate a R_386_COPY reloc. */
1828 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1830 edir
->zero_undefweak
|= eind
->zero_undefweak
;
1832 if (ELIMINATE_COPY_RELOCS
1833 && ind
->root
.type
!= bfd_link_hash_indirect
1834 && dir
->dynamic_adjusted
)
1836 /* If called to transfer flags for a weakdef during processing
1837 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1838 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1839 if (dir
->versioned
!= versioned_hidden
)
1840 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1841 dir
->ref_regular
|= ind
->ref_regular
;
1842 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1843 dir
->needs_plt
|= ind
->needs_plt
;
1844 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1847 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1850 /* Remove undefined weak symbol from the dynamic symbol table if it
1851 is resolved to 0. */
1854 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
1855 struct elf_link_hash_entry
*h
)
1857 if (h
->dynindx
!= -1
1858 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, elf_x86_hash_entry (h
)))
1861 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1867 /* Change the STT_GNU_IFUNC symbol defined in position-dependent
1868 executable into the normal function symbol and set its address
1869 to its PLT entry, which should be resolved by R_*_IRELATIVE at
1873 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info
*info
,
1874 struct elf_x86_link_hash_table
*htab
,
1875 struct elf_link_hash_entry
*h
,
1876 Elf_Internal_Sym
*sym
)
1878 if (bfd_link_pde (info
)
1881 && h
->plt
.offset
!= (bfd_vma
) -1
1882 && h
->type
== STT_GNU_IFUNC
1883 && h
->pointer_equality_needed
)
1887 bfd
*output_bfd
= info
->output_bfd
;
1889 if (htab
->plt_second
)
1891 struct elf_x86_link_hash_entry
*eh
1892 = (struct elf_x86_link_hash_entry
*) h
;
1894 plt_s
= htab
->plt_second
;
1895 plt_offset
= eh
->plt_second
.offset
;
1899 plt_s
= htab
->elf
.splt
;
1900 plt_offset
= h
->plt
.offset
;
1904 sym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (sym
->st_info
), STT_FUNC
);
1906 = _bfd_elf_section_from_bfd_section (output_bfd
,
1907 plt_s
->output_section
);
1908 sym
->st_value
= (plt_s
->output_section
->vma
1909 + plt_s
->output_offset
+ plt_offset
);
1913 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1916 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
1918 if (h
->plt
.offset
!= (bfd_vma
) -1
1920 && !h
->pointer_equality_needed
)
1923 return _bfd_elf_hash_symbol (h
);
1926 /* Adjust a symbol defined by a dynamic object and referenced by a
1927 regular object. The current definition is in some section of the
1928 dynamic object, but we're not including those sections. We have to
1929 change the definition to something the rest of the link can
1933 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1934 struct elf_link_hash_entry
*h
)
1936 struct elf_x86_link_hash_table
*htab
;
1938 struct elf_x86_link_hash_entry
*eh
;
1939 struct elf_dyn_relocs
*p
;
1940 const struct elf_backend_data
*bed
1941 = get_elf_backend_data (info
->output_bfd
);
1943 /* STT_GNU_IFUNC symbol must go through PLT. */
1944 if (h
->type
== STT_GNU_IFUNC
)
1946 /* All local STT_GNU_IFUNC references must be treate as local
1947 calls via local PLT. */
1949 && SYMBOL_CALLS_LOCAL (info
, h
))
1951 bfd_size_type pc_count
= 0, count
= 0;
1952 struct elf_dyn_relocs
**pp
;
1954 eh
= (struct elf_x86_link_hash_entry
*) h
;
1955 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1957 pc_count
+= p
->pc_count
;
1958 p
->count
-= p
->pc_count
;
1967 if (pc_count
|| count
)
1972 /* Increment PLT reference count only for PC-relative
1975 if (h
->plt
.refcount
<= 0)
1976 h
->plt
.refcount
= 1;
1978 h
->plt
.refcount
+= 1;
1983 if (h
->plt
.refcount
<= 0)
1985 h
->plt
.offset
= (bfd_vma
) -1;
1991 /* If this is a function, put it in the procedure linkage table. We
1992 will fill in the contents of the procedure linkage table later,
1993 when we know the address of the .got section. */
1994 if (h
->type
== STT_FUNC
1997 if (h
->plt
.refcount
<= 0
1998 || SYMBOL_CALLS_LOCAL (info
, h
)
1999 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2000 && h
->root
.type
== bfd_link_hash_undefweak
))
2002 /* This case can occur if we saw a PLT32 reloc in an input
2003 file, but the symbol was never referred to by a dynamic
2004 object, or if all references were garbage collected. In
2005 such a case, we don't actually need to build a procedure
2006 linkage table, and we can just do a PC32 reloc instead. */
2007 h
->plt
.offset
= (bfd_vma
) -1;
2014 /* It's possible that we incorrectly decided a .plt reloc was needed
2015 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
2016 check_relocs. We can't decide accurately between function and
2017 non-function syms in check-relocs; Objects loaded later in
2018 the link may change h->type. So fix it now. */
2019 h
->plt
.offset
= (bfd_vma
) -1;
2021 eh
= (struct elf_x86_link_hash_entry
*) h
;
2023 /* If this is a weak symbol, and there is a real definition, the
2024 processor independent code will have arranged for us to see the
2025 real definition first, and we can just use the same value. */
2026 if (h
->is_weakalias
)
2028 struct elf_link_hash_entry
*def
= weakdef (h
);
2029 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2030 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2031 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2032 if (ELIMINATE_COPY_RELOCS
2033 || info
->nocopyreloc
2034 || SYMBOL_NO_COPYRELOC (info
, eh
))
2036 /* NB: needs_copy is always 0 for i386. */
2037 h
->non_got_ref
= def
->non_got_ref
;
2038 eh
->needs_copy
= def
->needs_copy
;
2043 /* This is a reference to a symbol defined by a dynamic object which
2044 is not a function. */
2046 /* If we are creating a shared library, we must presume that the
2047 only references to the symbol are via the global offset table.
2048 For such cases we need not do anything here; the relocations will
2049 be handled correctly by relocate_section. */
2050 if (!bfd_link_executable (info
))
2053 /* If there are no references to this symbol that do not use the
2054 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2055 reloc. NB: gotoff_ref is always 0 for x86-64. */
2056 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2059 /* If -z nocopyreloc was given, we won't generate them either. */
2060 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
2066 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2070 /* If there aren't any dynamic relocs in read-only sections nor
2071 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2072 avoid the copy reloc. This doesn't work on VxWorks, where we can
2073 not have dynamic relocations (other than copy and jump slot
2074 relocations) in an executable. */
2075 if (ELIMINATE_COPY_RELOCS
2076 && (bed
->target_id
== X86_64_ELF_DATA
2078 && htab
->target_os
!= is_vxworks
)))
2080 /* If we don't find any dynamic relocs in read-only sections,
2081 then we'll be keeping the dynamic relocs and avoiding the copy
2083 if (!readonly_dynrelocs (h
))
2090 /* We must allocate the symbol in our .dynbss section, which will
2091 become part of the .bss section of the executable. There will be
2092 an entry for this symbol in the .dynsym section. The dynamic
2093 object will contain position independent code, so all references
2094 from the dynamic object to this symbol will go through the global
2095 offset table. The dynamic linker will use the .dynsym entry to
2096 determine the address it must put in the global offset table, so
2097 both the dynamic object and the regular object will refer to the
2098 same memory location for the variable. */
2100 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
2101 dynamic linker to copy the initial value out of the dynamic object
2102 and into the runtime process image. */
2103 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
2105 s
= htab
->elf
.sdynrelro
;
2106 srel
= htab
->elf
.sreldynrelro
;
2110 s
= htab
->elf
.sdynbss
;
2111 srel
= htab
->elf
.srelbss
;
2113 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2115 srel
->size
+= htab
->sizeof_reloc
;
2119 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2123 _bfd_x86_elf_hide_symbol (struct bfd_link_info
*info
,
2124 struct elf_link_hash_entry
*h
,
2125 bfd_boolean force_local
)
2127 if (h
->root
.type
== bfd_link_hash_undefweak
2129 && bfd_link_pie (info
))
2131 /* When there is no dynamic interpreter in PIE, make the undefined
2132 weak symbol dynamic so that PC relative branch to the undefined
2133 weak symbol will land to address 0. */
2134 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
2135 if (h
->plt
.refcount
> 0
2136 || eh
->plt_got
.refcount
> 0)
2140 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
2143 /* Return TRUE if a symbol is referenced locally. It is similar to
2144 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
2145 works in check_relocs. */
2148 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info
*info
,
2149 struct elf_link_hash_entry
*h
)
2151 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
2152 struct elf_x86_link_hash_table
*htab
2153 = (struct elf_x86_link_hash_table
*) info
->hash
;
2155 if (eh
->local_ref
> 1)
2158 if (eh
->local_ref
== 1)
2161 /* Unversioned symbols defined in regular objects can be forced local
2162 by linker version script. A weak undefined symbol is forced local
2164 1. It has non-default visibility. Or
2165 2. When building executable, there is no dynamic linker. Or
2166 3. or "-z nodynamic-undefined-weak" is used.
2168 if (SYMBOL_REFERENCES_LOCAL (info
, h
)
2169 || (h
->root
.type
== bfd_link_hash_undefweak
2170 && (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2171 || (bfd_link_executable (info
)
2172 && htab
->interp
== NULL
)
2173 || info
->dynamic_undefined_weak
== 0))
2174 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
2175 && info
->version_info
!= NULL
2176 && _bfd_elf_link_hide_sym_by_version (info
, h
)))
2186 /* Return the section that should be marked against GC for a given
2190 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
2191 struct bfd_link_info
*info
,
2192 Elf_Internal_Rela
*rel
,
2193 struct elf_link_hash_entry
*h
,
2194 Elf_Internal_Sym
*sym
)
2196 /* Compiler should optimize this out. */
2197 if (((unsigned int) R_X86_64_GNU_VTINHERIT
2198 != (unsigned int) R_386_GNU_VTINHERIT
)
2199 || ((unsigned int) R_X86_64_GNU_VTENTRY
2200 != (unsigned int) R_386_GNU_VTENTRY
))
2204 switch (ELF32_R_TYPE (rel
->r_info
))
2206 case R_X86_64_GNU_VTINHERIT
:
2207 case R_X86_64_GNU_VTENTRY
:
2211 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2215 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
2217 bfd_vma offset ATTRIBUTE_UNUSED
,
2220 return got_addr
+ off
;
2224 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
2227 bfd_vma got_addr ATTRIBUTE_UNUSED
)
2229 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
2233 elf_i386_valid_plt_reloc_p (unsigned int type
)
2235 return (type
== R_386_JUMP_SLOT
2236 || type
== R_386_GLOB_DAT
2237 || type
== R_386_IRELATIVE
);
2241 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
2243 return (type
== R_X86_64_JUMP_SLOT
2244 || type
== R_X86_64_GLOB_DAT
2245 || type
== R_X86_64_IRELATIVE
);
2249 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
2253 struct elf_x86_plt plts
[],
2257 long size
, i
, n
, len
;
2259 unsigned int plt_got_offset
, plt_entry_size
;
2261 bfd_byte
*plt_contents
;
2263 arelent
**dynrelbuf
, *p
;
2265 const struct elf_backend_data
*bed
;
2266 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
2268 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
2274 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
2275 if (dynrelbuf
== NULL
)
2278 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
2280 if (dynrelcount
<= 0)
2283 /* Sort the relocs by address. */
2284 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
2285 _bfd_x86_elf_compare_relocs
);
2287 size
= count
* sizeof (asymbol
);
2289 /* Allocate space for @plt suffixes. */
2291 for (i
= 0; i
< dynrelcount
; i
++)
2294 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2296 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
2299 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
2303 bed
= get_elf_backend_data (abfd
);
2305 if (bed
->target_id
== X86_64_ELF_DATA
)
2307 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
2308 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
2312 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
2313 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
2316 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2318 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
2320 got_addr
= sec
->vma
;
2323 sec
= bfd_get_section_by_name (abfd
, ".got");
2325 got_addr
= sec
->vma
;
2328 if (got_addr
== (bfd_vma
) -1)
2333 /* Check for each PLT section. */
2334 names
= (char *) (s
+ count
);
2337 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2338 if ((plt_contents
= plts
[j
].contents
) != NULL
)
2343 struct elf_x86_plt
*plt_p
= &plts
[j
];
2345 plt_got_offset
= plt_p
->plt_got_offset
;
2346 plt_entry_size
= plt_p
->plt_entry_size
;
2350 if ((plt_p
->type
& plt_lazy
))
2352 /* Skip PLT0 in lazy PLT. */
2354 offset
= plt_entry_size
;
2362 /* Check each PLT entry against dynamic relocations. */
2363 for (; k
< plt_p
->count
; k
++)
2369 /* Get the GOT offset for i386 or the PC-relative offset
2370 for x86-64, a signed 32-bit integer. */
2371 off
= H_GET_32 (abfd
, (plt_contents
+ offset
2373 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
2375 /* Binary search. */
2379 while ((min
+ 1) < max
)
2383 mid
= (min
+ max
) / 2;
2385 if (got_vma
> r
->address
)
2387 else if (got_vma
< r
->address
)
2396 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2397 if (got_vma
== p
->address
2399 && valid_plt_reloc_p (p
->howto
->type
))
2401 *s
= **p
->sym_ptr_ptr
;
2402 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2403 set. Since we are defining a symbol, ensure one
2405 if ((s
->flags
& BSF_LOCAL
) == 0)
2406 s
->flags
|= BSF_GLOBAL
;
2407 s
->flags
|= BSF_SYNTHETIC
;
2408 /* This is no longer a section symbol. */
2409 s
->flags
&= ~BSF_SECTION_SYM
;
2411 s
->the_bfd
= plt
->owner
;
2415 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2416 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2422 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2423 names
+= sizeof ("+0x") - 1;
2424 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
2425 for (a
= buf
; *a
== '0'; ++a
)
2428 memcpy (names
, a
, size
);
2431 memcpy (names
, "@plt", sizeof ("@plt"));
2432 names
+= sizeof ("@plt");
2435 /* There should be only one entry in PLT for a given
2436 symbol. Set howto to NULL after processing a PLT
2437 entry to guard against corrupted PLT. */
2440 offset
+= plt_entry_size
;
2444 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2453 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2454 free (plts
[j
].contents
);
2461 /* Parse x86 GNU properties. */
2463 enum elf_property_kind
2464 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
2465 bfd_byte
*ptr
, unsigned int datasz
)
2469 if (type
== GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2470 || type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2471 || (type
>= GNU_PROPERTY_X86_UINT32_AND_LO
2472 && type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
2473 || (type
>= GNU_PROPERTY_X86_UINT32_OR_LO
2474 && type
<= GNU_PROPERTY_X86_UINT32_OR_HI
)
2475 || (type
>= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2476 && type
<= GNU_PROPERTY_X86_UINT32_OR_AND_HI
))
2481 (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"),
2482 abfd
, type
, datasz
);
2483 return property_corrupt
;
2485 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
2486 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
2487 prop
->pr_kind
= property_number
;
2488 return property_number
;
2491 return property_ignored
;
2494 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2495 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2496 should be merged with ABFD. */
2499 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
2500 bfd
*abfd ATTRIBUTE_UNUSED
,
2501 bfd
*bbfd ATTRIBUTE_UNUSED
,
2502 elf_property
*aprop
,
2503 elf_property
*bprop
)
2505 unsigned int number
, features
;
2506 bfd_boolean updated
= FALSE
;
2507 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
2509 if (pr_type
== GNU_PROPERTY_X86_COMPAT_ISA_1_USED
2510 || (pr_type
>= GNU_PROPERTY_X86_UINT32_OR_AND_LO
2511 && pr_type
<= GNU_PROPERTY_X86_UINT32_OR_AND_HI
))
2513 if (aprop
== NULL
|| bprop
== NULL
)
2515 /* Only one of APROP and BPROP can be NULL. */
2518 /* Remove this property since the other input file doesn't
2520 aprop
->pr_kind
= property_remove
;
2526 number
= aprop
->u
.number
;
2527 aprop
->u
.number
= number
| bprop
->u
.number
;
2528 updated
= number
!= (unsigned int) aprop
->u
.number
;
2532 else if (pr_type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
2533 || (pr_type
>= GNU_PROPERTY_X86_UINT32_OR_LO
2534 && pr_type
<= GNU_PROPERTY_X86_UINT32_OR_HI
))
2536 if (aprop
!= NULL
&& bprop
!= NULL
)
2538 number
= aprop
->u
.number
;
2539 aprop
->u
.number
= number
| bprop
->u
.number
;
2540 /* Remove the property if all bits are empty. */
2541 if (aprop
->u
.number
== 0)
2543 aprop
->pr_kind
= property_remove
;
2547 updated
= number
!= (unsigned int) aprop
->u
.number
;
2551 /* Only one of APROP and BPROP can be NULL. */
2554 if (aprop
->u
.number
== 0)
2556 /* Remove APROP if all bits are empty. */
2557 aprop
->pr_kind
= property_remove
;
2563 /* Return TRUE if APROP is NULL and all bits of BPROP
2564 aren't empty to indicate that BPROP should be added
2566 updated
= bprop
->u
.number
!= 0;
2571 else if (pr_type
>= GNU_PROPERTY_X86_UINT32_AND_LO
2572 && pr_type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
2574 /* Only one of APROP and BPROP can be NULL:
2575 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2576 2. If APROP is NULL, remove x86 feature.
2577 3. Otherwise, do nothing.
2579 const struct elf_backend_data
*bed
2580 = get_elf_backend_data (info
->output_bfd
);
2581 struct elf_x86_link_hash_table
*htab
2582 = elf_x86_hash_table (info
, bed
->target_id
);
2585 if (aprop
!= NULL
&& bprop
!= NULL
)
2588 if (htab
->params
->ibt
)
2589 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2590 if (htab
->params
->shstk
)
2591 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2592 number
= aprop
->u
.number
;
2593 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2594 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2595 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
2596 updated
= number
!= (unsigned int) aprop
->u
.number
;
2597 /* Remove the property if all feature bits are cleared. */
2598 if (aprop
->u
.number
== 0)
2599 aprop
->pr_kind
= property_remove
;
2603 /* There should be no AND properties since some input doesn't
2604 have them. Set IBT and SHSTK properties for -z ibt and -z
2607 if (htab
->params
->ibt
)
2608 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2609 if (htab
->params
->shstk
)
2610 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2615 updated
= features
!= (unsigned int) aprop
->u
.number
;
2616 aprop
->u
.number
= features
;
2621 bprop
->u
.number
= features
;
2624 else if (aprop
!= NULL
)
2626 aprop
->pr_kind
= property_remove
;
2634 /* Never should happen. */
2641 /* Set up x86 GNU properties. Return the first relocatable ELF input
2642 with GNU properties if found. Otherwise, return NULL. */
2645 _bfd_x86_elf_link_setup_gnu_properties
2646 (struct bfd_link_info
*info
, struct elf_x86_init_table
*init_table
)
2648 bfd_boolean normal_target
;
2649 bfd_boolean lazy_plt
;
2650 asection
*sec
, *pltsec
;
2652 bfd_boolean use_ibt_plt
;
2653 unsigned int plt_alignment
, features
;
2654 struct elf_x86_link_hash_table
*htab
;
2658 const struct elf_backend_data
*bed
;
2659 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
2660 unsigned int got_align
;
2662 /* Find a normal input file with GNU property note. */
2663 for (pbfd
= info
->input_bfds
;
2665 pbfd
= pbfd
->link
.next
)
2666 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
2667 && bfd_count_sections (pbfd
) != 0)
2671 if (elf_properties (pbfd
) != NULL
)
2675 bed
= get_elf_backend_data (info
->output_bfd
);
2677 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2682 if (htab
->params
->ibt
)
2684 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2685 htab
->params
->cet_report
&= ~cet_report_ibt
;
2687 if (htab
->params
->shstk
)
2689 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2690 htab
->params
->cet_report
&= ~cet_report_shstk
;
2692 if (!(htab
->params
->cet_report
& (cet_report_ibt
| cet_report_shstk
)))
2693 htab
->params
->cet_report
= cet_report_none
;
2700 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2701 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2702 prop
= _bfd_elf_get_property (ebfd
,
2703 GNU_PROPERTY_X86_FEATURE_1_AND
,
2705 prop
->u
.number
|= features
;
2706 prop
->pr_kind
= property_number
;
2709 /* Create the GNU property note section if needed. */
2710 if (prop
!= NULL
&& pbfd
== NULL
)
2712 sec
= bfd_make_section_with_flags (ebfd
,
2713 NOTE_GNU_PROPERTY_SECTION_NAME
,
2721 info
->callbacks
->einfo (_("%F%P: failed to create GNU property section\n"));
2723 if (!bfd_set_section_alignment (sec
, class_align
))
2726 info
->callbacks
->einfo (_("%F%pA: failed to align section\n"),
2730 elf_section_type (sec
) = SHT_NOTE
;
2734 if (htab
->params
->cet_report
)
2736 /* Report missing IBT and SHSTK properties. */
2739 elf_property_list
*p
;
2740 bfd_boolean missing_ibt
, missing_shstk
;
2741 bfd_boolean check_ibt
2742 = !!(htab
->params
->cet_report
& cet_report_ibt
);
2743 bfd_boolean check_shstk
2744 = !!(htab
->params
->cet_report
& cet_report_shstk
);
2746 if ((htab
->params
->cet_report
& cet_report_warning
))
2747 msg
= _("%P: %pB: warning: missing %s\n");
2749 msg
= _("%X%P: %pB: error: missing %s\n");
2751 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
2752 if (!(abfd
->flags
& (DYNAMIC
| BFD_PLUGIN
| BFD_LINKER_CREATED
))
2753 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2755 for (p
= elf_properties (abfd
); p
; p
= p
->next
)
2756 if (p
->property
.pr_type
== GNU_PROPERTY_X86_FEATURE_1_AND
)
2759 missing_ibt
= check_ibt
;
2760 missing_shstk
= check_shstk
;
2763 missing_ibt
&= !(p
->property
.u
.number
2764 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2765 missing_shstk
&= !(p
->property
.u
.number
2766 & GNU_PROPERTY_X86_FEATURE_1_SHSTK
);
2768 if (missing_ibt
|| missing_shstk
)
2770 const char *missing
;
2771 if (missing_ibt
&& missing_shstk
)
2772 missing
= _("IBT and SHSTK properties");
2773 else if (missing_ibt
)
2774 missing
= _("IBT property");
2776 missing
= _("SHSTK property");
2777 info
->callbacks
->einfo (msg
, abfd
, missing
);
2782 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
2784 htab
->r_info
= init_table
->r_info
;
2785 htab
->r_sym
= init_table
->r_sym
;
2787 if (bfd_link_relocatable (info
))
2790 htab
->plt0_pad_byte
= init_table
->plt0_pad_byte
;
2792 use_ibt_plt
= htab
->params
->ibtplt
|| htab
->params
->ibt
;
2793 if (!use_ibt_plt
&& pbfd
!= NULL
)
2795 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2796 elf_property_list
*p
;
2798 /* The property list is sorted in order of type. */
2799 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
2801 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
2803 use_ibt_plt
= !!(p
->property
.u
.number
2804 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2807 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
2812 dynobj
= htab
->elf
.dynobj
;
2814 /* Set htab->elf.dynobj here so that there is no need to check and
2815 set it in check_relocs. */
2820 htab
->elf
.dynobj
= pbfd
;
2827 /* Find a normal input file to hold linker created
2829 for (abfd
= info
->input_bfds
;
2831 abfd
= abfd
->link
.next
)
2832 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2834 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0
2835 && bed
->relocs_compatible (abfd
->xvec
,
2836 info
->output_bfd
->xvec
))
2838 htab
->elf
.dynobj
= abfd
;
2845 /* Return if there are no normal input files. */
2849 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2850 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2851 canonical function address. */
2852 htab
->plt
.has_plt0
= 1;
2853 normal_target
= htab
->target_os
== is_normal
;
2859 htab
->lazy_plt
= init_table
->lazy_ibt_plt
;
2860 htab
->non_lazy_plt
= init_table
->non_lazy_ibt_plt
;
2864 htab
->lazy_plt
= init_table
->lazy_plt
;
2865 htab
->non_lazy_plt
= init_table
->non_lazy_plt
;
2870 htab
->lazy_plt
= init_table
->lazy_plt
;
2871 htab
->non_lazy_plt
= NULL
;
2874 pltsec
= htab
->elf
.splt
;
2876 /* If the non-lazy PLT is available, use it for all PLT entries if
2877 there are no PLT0 or no .plt section. */
2878 if (htab
->non_lazy_plt
!= NULL
2879 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
2882 if (bfd_link_pic (info
))
2883 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
2885 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
2886 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
2887 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
2888 htab
->plt
.plt_got_insn_size
2889 = htab
->non_lazy_plt
->plt_got_insn_size
;
2890 htab
->plt
.eh_frame_plt_size
2891 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2892 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
2897 if (bfd_link_pic (info
))
2899 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
2900 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
2904 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
2905 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
2907 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
2908 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
2909 htab
->plt
.plt_got_insn_size
2910 = htab
->lazy_plt
->plt_got_insn_size
;
2911 htab
->plt
.eh_frame_plt_size
2912 = htab
->lazy_plt
->eh_frame_plt_size
;
2913 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
2916 if (htab
->target_os
== is_vxworks
2917 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
2920 info
->callbacks
->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2924 /* Since create_dynamic_sections isn't always called, but GOT
2925 relocations need GOT relocations, create them here so that we
2926 don't need to do it in check_relocs. */
2927 if (htab
->elf
.sgot
== NULL
2928 && !_bfd_elf_create_got_section (dynobj
, info
))
2929 info
->callbacks
->einfo (_("%F%P: failed to create GOT sections\n"));
2931 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
2933 /* Align .got and .got.plt sections to their entry size. Do it here
2934 instead of in create_dynamic_sections so that they are always
2935 properly aligned even if create_dynamic_sections isn't called. */
2936 sec
= htab
->elf
.sgot
;
2937 if (!bfd_set_section_alignment (sec
, got_align
))
2938 goto error_alignment
;
2940 sec
= htab
->elf
.sgotplt
;
2941 if (!bfd_set_section_alignment (sec
, got_align
))
2942 goto error_alignment
;
2944 /* Create the ifunc sections here so that check_relocs can be
2946 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
2947 info
->callbacks
->einfo (_("%F%P: failed to create ifunc sections\n"));
2949 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
2953 /* Whe creating executable, set the contents of the .interp
2954 section to the interpreter. */
2955 if (bfd_link_executable (info
) && !info
->nointerp
)
2957 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
2960 s
->size
= htab
->dynamic_interpreter_size
;
2961 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2965 /* Don't change PLT section alignment for NaCl since it uses
2966 64-byte PLT entry and sets PLT section alignment to 32
2967 bytes. Don't create additional PLT sections for NaCl. */
2970 flagword pltflags
= (bed
->dynamic_sec_flags
2975 unsigned int non_lazy_plt_alignment
2976 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
2979 if (!bfd_set_section_alignment (sec
, plt_alignment
))
2980 goto error_alignment
;
2982 /* Create the GOT procedure linkage table. */
2983 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2987 info
->callbacks
->einfo (_("%F%P: failed to create GOT PLT section\n"));
2989 if (!bfd_set_section_alignment (sec
, non_lazy_plt_alignment
))
2990 goto error_alignment
;
2992 htab
->plt_got
= sec
;
3000 /* Create the second PLT for Intel IBT support. IBT
3001 PLT is supported only for non-NaCl target and is
3002 is needed only for lazy binding. */
3003 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3007 info
->callbacks
->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
3009 if (!bfd_set_section_alignment (sec
, plt_alignment
))
3010 goto error_alignment
;
3012 else if (htab
->params
->bndplt
&& ABI_64_P (dynobj
))
3014 /* Create the second PLT for Intel MPX support. MPX
3015 PLT is supported only for non-NaCl target in 64-bit
3016 mode and is needed only for lazy binding. */
3017 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3021 info
->callbacks
->einfo (_("%F%P: failed to create BND PLT section\n"));
3023 if (!bfd_set_section_alignment (sec
, non_lazy_plt_alignment
))
3024 goto error_alignment
;
3027 htab
->plt_second
= sec
;
3031 if (!info
->no_ld_generated_unwind_info
)
3033 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3034 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3035 | SEC_LINKER_CREATED
);
3037 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3041 info
->callbacks
->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
3043 if (!bfd_set_section_alignment (sec
, class_align
))
3044 goto error_alignment
;
3046 htab
->plt_eh_frame
= sec
;
3048 if (htab
->plt_got
!= NULL
)
3050 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3054 info
->callbacks
->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
3056 if (!bfd_set_section_alignment (sec
, class_align
))
3057 goto error_alignment
;
3059 htab
->plt_got_eh_frame
= sec
;
3062 if (htab
->plt_second
!= NULL
)
3064 sec
= bfd_make_section_anyway_with_flags (dynobj
,
3068 info
->callbacks
->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
3070 if (!bfd_set_section_alignment (sec
, class_align
))
3071 goto error_alignment
;
3073 htab
->plt_second_eh_frame
= sec
;
3078 /* The .iplt section is used for IFUNC symbols in static
3080 sec
= htab
->elf
.iplt
;
3083 /* NB: Delay setting its alignment until we know it is non-empty.
3084 Otherwise an empty iplt section may change vma and lma of the
3085 following sections, which triggers moving dot of the following
3086 section backwards, resulting in a warning and section lma not
3087 being set properly. It later leads to a "File truncated"
3089 if (!bfd_set_section_alignment (sec
, 0))
3090 goto error_alignment
;
3092 htab
->plt
.iplt_alignment
= (normal_target
3094 : bed
->plt_alignment
);
3097 if (bfd_link_executable (info
)
3099 && !htab
->params
->has_dynamic_linker
3100 && htab
->params
->static_before_all_inputs
)
3102 /* Report error for dynamic input objects if -static is passed at
3103 command-line before all input files without --dynamic-linker
3104 unless --no-dynamic-linker is used. */
3107 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
3108 if ((abfd
->flags
& DYNAMIC
))
3109 info
->callbacks
->einfo
3110 (_("%X%P: attempted static link of dynamic object `%pB'\n"),
3117 /* Fix up x86 GNU properties. */
3120 _bfd_x86_elf_link_fixup_gnu_properties
3121 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3122 elf_property_list
**listp
)
3124 elf_property_list
*p
;
3126 for (p
= *listp
; p
; p
= p
->next
)
3128 unsigned int type
= p
->property
.pr_type
;
3129 if (type
== GNU_PROPERTY_X86_COMPAT_ISA_1_USED
3130 || type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3131 || (type
>= GNU_PROPERTY_X86_UINT32_AND_LO
3132 && type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
3133 || (type
>= GNU_PROPERTY_X86_UINT32_OR_LO
3134 && type
<= GNU_PROPERTY_X86_UINT32_OR_HI
)
3135 || (type
>= GNU_PROPERTY_X86_UINT32_OR_AND_LO
3136 && type
<= GNU_PROPERTY_X86_UINT32_OR_AND_HI
))
3138 if (p
->property
.u
.number
== 0
3139 && (type
== GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3140 || (type
>= GNU_PROPERTY_X86_UINT32_AND_LO
3141 && type
<= GNU_PROPERTY_X86_UINT32_AND_HI
)
3142 || (type
>= GNU_PROPERTY_X86_UINT32_OR_LO
3143 && type
<= GNU_PROPERTY_X86_UINT32_OR_HI
)))
3145 /* Remove empty property. */
3152 else if (type
> GNU_PROPERTY_HIPROC
)
3154 /* The property list is sorted in order of type. */
3161 _bfd_elf_linker_x86_set_options (struct bfd_link_info
* info
,
3162 struct elf_linker_x86_params
*params
)
3164 const struct elf_backend_data
*bed
3165 = get_elf_backend_data (info
->output_bfd
);
3166 struct elf_x86_link_hash_table
*htab
3167 = elf_x86_hash_table (info
, bed
->target_id
);
3169 htab
->params
= params
;