1 /* x86 specific support for ELF
2 Copyright (C) 2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
21 #include "elfxx-x86.h"
22 #include "elf-vxworks.h"
25 #include "elf/x86-64.h"
27 /* The name of the dynamic interpreter. This is put in the .interp
30 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
31 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
32 #define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
35 _bfd_x86_elf_mkobject (bfd
*abfd
)
37 return bfd_elf_allocate_object (abfd
,
38 sizeof (struct elf_x86_obj_tdata
),
39 get_elf_backend_data (abfd
)->target_id
);
42 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
43 executables. Rather than setting it to the beginning of the TLS
44 section, we have to set it to the end. This function may be called
45 multiple times, it is idempotent. */
48 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info
*info
)
50 struct elf_x86_link_hash_table
*htab
;
51 struct bfd_link_hash_entry
*base
;
52 const struct elf_backend_data
*bed
;
54 if (!bfd_link_executable (info
))
57 bed
= get_elf_backend_data (info
->output_bfd
);
58 htab
= elf_x86_hash_table (info
, bed
->target_id
);
62 base
= htab
->tls_module_base
;
66 base
->u
.def
.value
= htab
->elf
.tls_size
;
69 /* Return the base VMA address which should be subtracted from real addresses
70 when resolving @dtpoff relocation.
71 This is PT_TLS segment p_vaddr. */
74 _bfd_x86_elf_dtpoff_base (struct bfd_link_info
*info
)
76 /* If tls_sec is NULL, we should have signalled an error already. */
77 if (elf_hash_table (info
)->tls_sec
== NULL
)
79 return elf_hash_table (info
)->tls_sec
->vma
;
82 /* Allocate space in .plt, .got and associated reloc sections for
86 elf_x86_allocate_dynrelocs (struct elf_link_hash_entry
*h
, 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 /* Clear the reference count of function pointer relocations if
112 symbol isn't a normal function. */
113 if (h
->type
!= STT_FUNC
)
114 eh
->func_pointer_refcount
= 0;
116 /* We can't use the GOT PLT if pointer equality is needed since
117 finish_dynamic_symbol won't clear symbol value and the dynamic
118 linker won't update the GOT slot. We will get into an infinite
120 if (htab
->plt_got
!= NULL
121 && h
->type
!= STT_GNU_IFUNC
122 && !h
->pointer_equality_needed
123 && h
->plt
.refcount
> 0
124 && h
->got
.refcount
> 0)
126 /* Don't use the regular PLT if there are both GOT and GOTPLT
128 h
->plt
.offset
= (bfd_vma
) -1;
130 /* Use the GOT PLT. */
131 eh
->plt_got
.refcount
= 1;
134 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
135 here if it is defined and referenced in a non-shared object. */
136 if (h
->type
== STT_GNU_IFUNC
139 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
140 &htab
->readonly_dynrelocs_against_ifunc
,
144 htab
->got_entry_size
,
147 asection
*s
= htab
->plt_second
;
148 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
150 /* Use the second PLT section if it is created. */
151 eh
->plt_second
.offset
= s
->size
;
153 /* Make room for this entry in the second PLT section. */
154 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
162 /* Don't create the PLT entry if there are only function pointer
163 relocations which can be resolved at run-time. */
164 else if (htab
->elf
.dynamic_sections_created
165 && (h
->plt
.refcount
> eh
->func_pointer_refcount
166 || eh
->plt_got
.refcount
> 0))
168 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
170 /* Clear the reference count of function pointer relocations
172 eh
->func_pointer_refcount
= 0;
174 /* Make sure this symbol is output as a dynamic symbol.
175 Undefined weak syms won't yet be marked as dynamic. */
179 && h
->root
.type
== bfd_link_hash_undefweak
)
181 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
185 if (bfd_link_pic (info
)
186 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
188 asection
*s
= htab
->elf
.splt
;
189 asection
*second_s
= htab
->plt_second
;
190 asection
*got_s
= htab
->plt_got
;
192 /* If this is the first .plt entry, make room for the special
193 first entry. The .plt section is used by prelink to undo
194 prelinking for dynamic relocations. */
196 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
199 eh
->plt_got
.offset
= got_s
->size
;
202 h
->plt
.offset
= s
->size
;
204 eh
->plt_second
.offset
= second_s
->size
;
207 /* If this symbol is not defined in a regular file, and we are
208 not generating a shared library, then set the symbol to this
209 location in the .plt. This is required to make function
210 pointers compare as equal between the normal executable and
211 the shared library. */
212 if (! bfd_link_pic (info
)
217 /* We need to make a call to the entry of the GOT PLT
218 instead of regular PLT entry. */
219 h
->root
.u
.def
.section
= got_s
;
220 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
226 /* We need to make a call to the entry of the
227 second PLT instead of regular PLT entry. */
228 h
->root
.u
.def
.section
= second_s
;
229 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
233 h
->root
.u
.def
.section
= s
;
234 h
->root
.u
.def
.value
= h
->plt
.offset
;
239 /* Make room for this entry. */
241 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
244 s
->size
+= plt_entry_size
;
246 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
248 /* We also need to make an entry in the .got.plt section,
249 which will be placed in the .got section by the linker
251 htab
->elf
.sgotplt
->size
+= htab
->got_entry_size
;
253 /* There should be no PLT relocation against resolved
254 undefined weak symbol in executable. */
255 if (!resolved_to_zero
)
257 /* We also need to make an entry in the .rel.plt
259 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
260 htab
->elf
.srelplt
->reloc_count
++;
264 if (htab
->target_os
== is_vxworks
&& !bfd_link_pic (info
))
266 /* VxWorks has a second set of relocations for each PLT entry
267 in executables. They go in a separate relocation section,
268 which is processed by the kernel loader. */
270 /* There are two relocations for the initial PLT entry: an
271 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
272 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
274 asection
*srelplt2
= htab
->srelplt2
;
275 if (h
->plt
.offset
== plt_entry_size
)
276 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
278 /* There are two extra relocations for each subsequent PLT entry:
279 an R_386_32 relocation for the GOT entry, and an R_386_32
280 relocation for the PLT entry. */
282 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
287 eh
->plt_got
.offset
= (bfd_vma
) -1;
288 h
->plt
.offset
= (bfd_vma
) -1;
294 eh
->plt_got
.offset
= (bfd_vma
) -1;
295 h
->plt
.offset
= (bfd_vma
) -1;
299 eh
->tlsdesc_got
= (bfd_vma
) -1;
301 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
302 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
303 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
304 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
305 if (h
->got
.refcount
> 0
306 && bfd_link_executable (info
)
308 && (elf_x86_hash_entry (h
)->tls_type
& GOT_TLS_IE
))
309 h
->got
.offset
= (bfd_vma
) -1;
310 else if (h
->got
.refcount
> 0)
314 int tls_type
= elf_x86_hash_entry (h
)->tls_type
;
316 /* Make sure this symbol is output as a dynamic symbol.
317 Undefined weak syms won't yet be marked as dynamic. */
321 && h
->root
.type
== bfd_link_hash_undefweak
)
323 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
328 if (GOT_TLS_GDESC_P (tls_type
))
330 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
331 - elf_x86_compute_jump_table_size (htab
);
332 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
333 h
->got
.offset
= (bfd_vma
) -2;
335 if (! GOT_TLS_GDESC_P (tls_type
)
336 || GOT_TLS_GD_P (tls_type
))
338 h
->got
.offset
= s
->size
;
339 s
->size
+= htab
->got_entry_size
;
340 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
342 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
343 s
->size
+= htab
->got_entry_size
;
345 dyn
= htab
->elf
.dynamic_sections_created
;
346 /* R_386_TLS_IE_32 needs one dynamic relocation,
347 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
348 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
349 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
350 symbol and two if global. No dynamic relocation against
351 resolved undefined weak symbol in executable. */
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 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
365 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
366 if (GOT_TLS_GDESC_P (tls_type
))
368 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
369 if (bed
->target_id
== X86_64_ELF_DATA
)
370 htab
->tlsdesc_plt
= (bfd_vma
) -1;
374 h
->got
.offset
= (bfd_vma
) -1;
376 if (eh
->dyn_relocs
== NULL
)
379 /* In the shared -Bsymbolic case, discard space allocated for
380 dynamic pc-relative relocs against symbols which turn out to be
381 defined in regular objects. For the normal shared case, discard
382 space for pc-relative relocs that have become local due to symbol
383 visibility changes. */
385 if (bfd_link_pic (info
))
387 /* Relocs that use pc_count are those that appear on a call
388 insn, or certain REL relocs that can generated via assembly.
389 We want calls to protected symbols to resolve directly to the
390 function rather than going via the plt. If people want
391 function pointer comparisons to work as expected then they
392 should avoid writing weird assembly. */
393 if (SYMBOL_CALLS_LOCAL (info
, h
))
395 struct elf_dyn_relocs
**pp
;
397 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
399 p
->count
-= p
->pc_count
;
408 if (htab
->target_os
== is_vxworks
)
410 struct elf_dyn_relocs
**pp
;
411 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
413 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
420 /* Also discard relocs on undefined weak syms with non-default
421 visibility or in PIE. */
422 if (eh
->dyn_relocs
!= NULL
)
424 if (h
->root
.type
== bfd_link_hash_undefweak
)
426 /* Undefined weak symbol is never bound locally in shared
428 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
431 if (bed
->target_id
== I386_ELF_DATA
434 /* Keep dynamic non-GOT/non-PLT relocation so
435 that we can branch to 0 without PLT. */
436 struct elf_dyn_relocs
**pp
;
438 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
439 if (p
->pc_count
== 0)
443 /* Remove non-R_386_PC32 relocation. */
444 p
->count
= p
->pc_count
;
448 /* Make sure undefined weak symbols are output
449 as dynamic symbols in PIEs for dynamic non-GOT
450 non-PLT reloations. */
451 if (eh
->dyn_relocs
!= NULL
452 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
456 eh
->dyn_relocs
= NULL
;
458 else if (h
->dynindx
== -1
460 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
463 else if (bfd_link_executable (info
)
464 && (h
->needs_copy
|| eh
->needs_copy
)
468 /* NB: needs_copy is set only for x86-64. For PIE,
469 discard space for pc-relative relocs against symbols
470 which turn out to need copy relocs. */
471 struct elf_dyn_relocs
**pp
;
473 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
475 if (p
->pc_count
!= 0)
483 else if (ELIMINATE_COPY_RELOCS
)
485 /* For the non-shared case, discard space for relocs against
486 symbols which turn out to need copy relocs or are not
487 dynamic. Keep dynamic relocations for run-time function
488 pointer initialization. */
491 || eh
->func_pointer_refcount
> 0
492 || (h
->root
.type
== bfd_link_hash_undefweak
493 && !resolved_to_zero
))
496 || (htab
->elf
.dynamic_sections_created
497 && (h
->root
.type
== bfd_link_hash_undefweak
498 || h
->root
.type
== bfd_link_hash_undefined
))))
500 /* Make sure this symbol is output as a dynamic symbol.
501 Undefined weak syms won't yet be marked as dynamic. */
505 && h
->root
.type
== bfd_link_hash_undefweak
506 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
509 /* If that succeeded, we know we'll be keeping all the
511 if (h
->dynindx
!= -1)
515 eh
->dyn_relocs
= NULL
;
516 eh
->func_pointer_refcount
= 0;
521 /* Finally, allocate space. */
522 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
526 sreloc
= elf_section_data (p
->sec
)->sreloc
;
528 BFD_ASSERT (sreloc
!= NULL
);
529 sreloc
->size
+= p
->count
* htab
->sizeof_reloc
;
535 /* Find any dynamic relocs that apply to read-only sections. */
538 _bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
541 struct elf_x86_link_hash_entry
*eh
;
542 struct elf_dyn_relocs
*p
;
544 /* Skip local IFUNC symbols. */
545 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
548 eh
= (struct elf_x86_link_hash_entry
*) h
;
549 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
551 asection
*s
= p
->sec
->output_section
;
553 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
555 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
557 info
->flags
|= DF_TEXTREL
;
559 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
560 || info
->error_textrel
)
561 /* xgettext:c-format */
562 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
563 p
->sec
->owner
, h
->root
.root
.string
,
566 /* Not an error, just cut short the traversal. */
573 /* Allocate space in .plt, .got and associated reloc sections for
574 local dynamic relocs. */
577 elf_x86_allocate_local_dynreloc (void **slot
, void *inf
)
579 struct elf_link_hash_entry
*h
580 = (struct elf_link_hash_entry
*) *slot
;
582 if (h
->type
!= STT_GNU_IFUNC
586 || h
->root
.type
!= bfd_link_hash_defined
)
589 return elf_x86_allocate_dynrelocs (h
, inf
);
592 /* Find and/or create a hash entry for local symbol. */
594 struct elf_link_hash_entry
*
595 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table
*htab
,
596 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
599 struct elf_x86_link_hash_entry e
, *ret
;
600 asection
*sec
= abfd
->sections
;
601 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
602 htab
->r_sym (rel
->r_info
));
605 e
.elf
.indx
= sec
->id
;
606 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
607 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
608 create
? INSERT
: NO_INSERT
);
615 ret
= (struct elf_x86_link_hash_entry
*) *slot
;
619 ret
= (struct elf_x86_link_hash_entry
*)
620 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
621 sizeof (struct elf_x86_link_hash_entry
));
624 memset (ret
, 0, sizeof (*ret
));
625 ret
->elf
.indx
= sec
->id
;
626 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
627 ret
->elf
.dynindx
= -1;
628 ret
->plt_got
.offset
= (bfd_vma
) -1;
634 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
635 SYNC WITH _bfd_elf_link_hash_newfunc. */
637 struct bfd_hash_entry
*
638 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
639 struct bfd_hash_table
*table
,
642 /* Allocate the structure if it has not already been allocated by a
646 entry
= (struct bfd_hash_entry
*)
647 bfd_hash_allocate (table
,
648 sizeof (struct elf_x86_link_hash_entry
));
653 /* Call the allocation method of the superclass. */
654 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
657 struct elf_x86_link_hash_entry
*eh
658 = (struct elf_x86_link_hash_entry
*) entry
;
659 struct elf_link_hash_table
*htab
660 = (struct elf_link_hash_table
*) table
;
662 memset (&eh
->elf
.size
, 0,
663 (sizeof (struct elf_x86_link_hash_entry
)
664 - offsetof (struct elf_link_hash_entry
, size
)));
665 /* Set local fields. */
667 eh
->elf
.dynindx
= -1;
668 eh
->elf
.got
= htab
->init_got_refcount
;
669 eh
->elf
.plt
= htab
->init_plt_refcount
;
670 /* Assume that we have been called by a non-ELF symbol reader.
671 This flag is then reset by the code which reads an ELF input
672 file. This ensures that a symbol created by a non-ELF symbol
673 reader will have the flag set correctly. */
675 eh
->plt_second
.offset
= (bfd_vma
) -1;
676 eh
->plt_got
.offset
= (bfd_vma
) -1;
677 eh
->tlsdesc_got
= (bfd_vma
) -1;
678 eh
->zero_undefweak
= 1;
684 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
685 for local symbol so that we can handle local STT_GNU_IFUNC symbols
686 as global symbol. We reuse indx and dynstr_index for local symbol
687 hash since they aren't used by global symbols in this backend. */
690 _bfd_x86_elf_local_htab_hash (const void *ptr
)
692 struct elf_link_hash_entry
*h
693 = (struct elf_link_hash_entry
*) ptr
;
694 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
697 /* Compare local hash entries. */
700 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
702 struct elf_link_hash_entry
*h1
703 = (struct elf_link_hash_entry
*) ptr1
;
704 struct elf_link_hash_entry
*h2
705 = (struct elf_link_hash_entry
*) ptr2
;
707 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
710 /* Destroy an x86 ELF linker hash table. */
713 elf_x86_link_hash_table_free (bfd
*obfd
)
715 struct elf_x86_link_hash_table
*htab
716 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
718 if (htab
->loc_hash_table
)
719 htab_delete (htab
->loc_hash_table
);
720 if (htab
->loc_hash_memory
)
721 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
722 _bfd_elf_link_hash_table_free (obfd
);
726 elf_i386_is_reloc_section (const char *secname
)
728 return CONST_STRNEQ (secname
, ".rel");
732 elf_x86_64_is_reloc_section (const char *secname
)
734 return CONST_STRNEQ (secname
, ".rela");
737 /* Create an x86 ELF linker hash table. */
739 struct bfd_link_hash_table
*
740 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
742 struct elf_x86_link_hash_table
*ret
;
743 const struct elf_backend_data
*bed
;
744 bfd_size_type amt
= sizeof (struct elf_x86_link_hash_table
);
746 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
750 bed
= get_elf_backend_data (abfd
);
751 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
752 _bfd_x86_elf_link_hash_newfunc
,
753 sizeof (struct elf_x86_link_hash_entry
),
760 if (bed
->target_id
== X86_64_ELF_DATA
)
762 ret
->is_reloc_section
= elf_x86_64_is_reloc_section
;
763 ret
->dt_reloc
= DT_RELA
;
764 ret
->dt_reloc_sz
= DT_RELASZ
;
765 ret
->dt_reloc_ent
= DT_RELAENT
;
766 ret
->got_entry_size
= 8;
767 ret
->tls_get_addr
= "__tls_get_addr";
771 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
772 ret
->pointer_r_type
= R_X86_64_64
;
773 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
774 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
778 if (bed
->target_id
== X86_64_ELF_DATA
)
780 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
781 ret
->pointer_r_type
= R_X86_64_32
;
782 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
783 ret
->dynamic_interpreter_size
784 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
788 ret
->is_reloc_section
= elf_i386_is_reloc_section
;
789 ret
->dt_reloc
= DT_REL
;
790 ret
->dt_reloc_sz
= DT_RELSZ
;
791 ret
->dt_reloc_ent
= DT_RELENT
;
792 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
793 ret
->got_entry_size
= 4;
794 ret
->pointer_r_type
= R_386_32
;
795 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
796 ret
->dynamic_interpreter_size
797 = sizeof ELF32_DYNAMIC_INTERPRETER
;
798 ret
->tls_get_addr
= "___tls_get_addr";
801 ret
->target_id
= bed
->target_id
;
802 ret
->target_os
= get_elf_x86_backend_data (abfd
)->target_os
;
804 ret
->loc_hash_table
= htab_try_create (1024,
805 _bfd_x86_elf_local_htab_hash
,
806 _bfd_x86_elf_local_htab_eq
,
808 ret
->loc_hash_memory
= objalloc_create ();
809 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
811 elf_x86_link_hash_table_free (abfd
);
814 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
816 return &ret
->elf
.root
;
819 /* Sort relocs into address order. */
822 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
824 const arelent
*a
= * (const arelent
**) ap
;
825 const arelent
*b
= * (const arelent
**) bp
;
827 if (a
->address
> b
->address
)
829 else if (a
->address
< b
->address
)
836 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
838 if (!bfd_link_relocatable (info
))
840 /* Check for __tls_get_addr reference. */
841 struct elf_x86_link_hash_table
*htab
;
842 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
843 htab
= elf_x86_hash_table (info
, bed
->target_id
);
846 struct elf_link_hash_entry
*h
;
848 h
= elf_link_hash_lookup (elf_hash_table (info
),
850 FALSE
, FALSE
, FALSE
);
852 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
854 /* "__ehdr_start" will be defined by linker as a hidden symbol
855 later if it is referenced and not defined. */
856 h
= elf_link_hash_lookup (elf_hash_table (info
),
858 FALSE
, FALSE
, FALSE
);
860 && (h
->root
.type
== bfd_link_hash_new
861 || h
->root
.type
== bfd_link_hash_undefined
862 || h
->root
.type
== bfd_link_hash_undefweak
863 || h
->root
.type
== bfd_link_hash_common
))
865 elf_x86_hash_entry (h
)->local_ref
= 2;
866 elf_x86_hash_entry (h
)->linker_def
= 1;
871 /* Invoke the regular ELF backend linker to do all the work. */
872 return _bfd_elf_link_check_relocs (abfd
, info
);
875 /* Set the sizes of the dynamic sections. */
878 _bfd_x86_elf_size_dynamic_sections (bfd
*output_bfd
,
879 struct bfd_link_info
*info
)
881 struct elf_x86_link_hash_table
*htab
;
886 const struct elf_backend_data
*bed
887 = get_elf_backend_data (output_bfd
);
889 htab
= elf_x86_hash_table (info
, bed
->target_id
);
892 dynobj
= htab
->elf
.dynobj
;
896 /* Set up .got offsets for local syms, and space for local dynamic
898 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
900 bfd_signed_vma
*local_got
;
901 bfd_signed_vma
*end_local_got
;
902 char *local_tls_type
;
903 bfd_vma
*local_tlsdesc_gotent
;
904 bfd_size_type locsymcount
;
905 Elf_Internal_Shdr
*symtab_hdr
;
908 if (! is_x86_elf (ibfd
, htab
))
911 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
913 struct elf_dyn_relocs
*p
;
915 for (p
= ((struct elf_dyn_relocs
*)
916 elf_section_data (s
)->local_dynrel
);
920 if (!bfd_is_abs_section (p
->sec
)
921 && bfd_is_abs_section (p
->sec
->output_section
))
923 /* Input section has been discarded, either because
924 it is a copy of a linkonce section or due to
925 linker script /DISCARD/, so we'll be discarding
928 else if (htab
->target_os
== is_vxworks
929 && strcmp (p
->sec
->output_section
->name
,
932 /* Relocations in vxworks .tls_vars sections are
933 handled specially by the loader. */
935 else if (p
->count
!= 0)
937 srel
= elf_section_data (p
->sec
)->sreloc
;
938 srel
->size
+= p
->count
* htab
->sizeof_reloc
;
939 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
940 && (info
->flags
& DF_TEXTREL
) == 0)
942 info
->flags
|= DF_TEXTREL
;
943 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
944 || info
->error_textrel
)
945 /* xgettext:c-format */
946 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
947 p
->sec
->owner
, p
->sec
);
953 local_got
= elf_local_got_refcounts (ibfd
);
957 symtab_hdr
= &elf_symtab_hdr (ibfd
);
958 locsymcount
= symtab_hdr
->sh_info
;
959 end_local_got
= local_got
+ locsymcount
;
960 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
961 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
963 srel
= htab
->elf
.srelgot
;
964 for (; local_got
< end_local_got
;
965 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
967 *local_tlsdesc_gotent
= (bfd_vma
) -1;
970 if (GOT_TLS_GDESC_P (*local_tls_type
))
972 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
973 - elf_x86_compute_jump_table_size (htab
);
974 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
975 *local_got
= (bfd_vma
) -2;
977 if (! GOT_TLS_GDESC_P (*local_tls_type
)
978 || GOT_TLS_GD_P (*local_tls_type
))
980 *local_got
= s
->size
;
981 s
->size
+= htab
->got_entry_size
;
982 if (GOT_TLS_GD_P (*local_tls_type
)
983 || *local_tls_type
== GOT_TLS_IE_BOTH
)
984 s
->size
+= htab
->got_entry_size
;
986 if (bfd_link_pic (info
)
987 || GOT_TLS_GD_ANY_P (*local_tls_type
)
988 || (*local_tls_type
& GOT_TLS_IE
))
990 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
991 srel
->size
+= 2 * htab
->sizeof_reloc
;
992 else if (GOT_TLS_GD_P (*local_tls_type
)
993 || ! GOT_TLS_GDESC_P (*local_tls_type
))
994 srel
->size
+= htab
->sizeof_reloc
;
995 if (GOT_TLS_GDESC_P (*local_tls_type
))
997 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
998 if (bed
->target_id
== X86_64_ELF_DATA
)
999 htab
->tlsdesc_plt
= (bfd_vma
) -1;
1004 *local_got
= (bfd_vma
) -1;
1008 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
1010 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1011 or R_X86_64_TLSLD relocs. */
1012 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
1013 htab
->elf
.sgot
->size
+= 2 * htab
->got_entry_size
;
1014 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
1017 htab
->tls_ld_or_ldm_got
.offset
= -1;
1019 /* Allocate global sym .plt and .got entries, and space for global
1020 sym dynamic relocs. */
1021 elf_link_hash_traverse (&htab
->elf
, elf_x86_allocate_dynrelocs
,
1024 /* Allocate .plt and .got entries, and space for local symbols. */
1025 htab_traverse (htab
->loc_hash_table
, elf_x86_allocate_local_dynreloc
,
1028 /* For every jump slot reserved in the sgotplt, reloc_count is
1029 incremented. However, when we reserve space for TLS descriptors,
1030 it's not incremented, so in order to compute the space reserved
1031 for them, it suffices to multiply the reloc count by the jump
1034 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1035 so that R_{386,X86_64}_IRELATIVE entries come last. */
1036 if (htab
->elf
.srelplt
)
1038 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
1039 htab
->sgotplt_jump_table_size
1040 = elf_x86_compute_jump_table_size (htab
);
1041 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
1043 else if (htab
->elf
.irelplt
)
1044 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1046 if (htab
->tlsdesc_plt
)
1048 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1049 lazy TLS relocations, don't generate the PLT and GOT entries
1051 if ((info
->flags
& DF_BIND_NOW
))
1052 htab
->tlsdesc_plt
= 0;
1055 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
1056 htab
->elf
.sgot
->size
+= htab
->got_entry_size
;
1057 /* Reserve room for the initial entry.
1058 FIXME: we could probably do away with it in this case. */
1059 if (htab
->elf
.splt
->size
== 0)
1060 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
1061 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
1062 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
1066 if (htab
->elf
.sgotplt
)
1068 /* Don't allocate .got.plt section if there are no GOT nor PLT
1069 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1070 if ((htab
->elf
.hgot
== NULL
1071 || !htab
->elf
.hgot
->ref_regular_nonweak
)
1072 && (htab
->elf
.sgotplt
->size
== bed
->got_header_size
)
1073 && (htab
->elf
.splt
== NULL
1074 || htab
->elf
.splt
->size
== 0)
1075 && (htab
->elf
.sgot
== NULL
1076 || htab
->elf
.sgot
->size
== 0)
1077 && (htab
->elf
.iplt
== NULL
1078 || htab
->elf
.iplt
->size
== 0)
1079 && (htab
->elf
.igotplt
== NULL
1080 || htab
->elf
.igotplt
->size
== 0))
1081 htab
->elf
.sgotplt
->size
= 0;
1084 if (_bfd_elf_eh_frame_present (info
))
1086 if (htab
->plt_eh_frame
!= NULL
1087 && htab
->elf
.splt
!= NULL
1088 && htab
->elf
.splt
->size
!= 0
1089 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
1090 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
1092 if (htab
->plt_got_eh_frame
!= NULL
1093 && htab
->plt_got
!= NULL
1094 && htab
->plt_got
->size
!= 0
1095 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
1096 htab
->plt_got_eh_frame
->size
1097 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1099 /* Unwind info for the second PLT and .plt.got sections are
1101 if (htab
->plt_second_eh_frame
!= NULL
1102 && htab
->plt_second
!= NULL
1103 && htab
->plt_second
->size
!= 0
1104 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
1105 htab
->plt_second_eh_frame
->size
1106 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1109 /* We now have determined the sizes of the various dynamic sections.
1110 Allocate memory for them. */
1112 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1114 bfd_boolean strip_section
= TRUE
;
1116 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1119 if (s
== htab
->elf
.splt
1120 || s
== htab
->elf
.sgot
)
1122 /* Strip this section if we don't need it; see the
1124 /* We'd like to strip these sections if they aren't needed, but if
1125 we've exported dynamic symbols from them we must leave them.
1126 It's too late to tell BFD to get rid of the symbols. */
1128 if (htab
->elf
.hplt
!= NULL
)
1129 strip_section
= FALSE
;
1131 else if (s
== htab
->elf
.sgotplt
1132 || s
== htab
->elf
.iplt
1133 || s
== htab
->elf
.igotplt
1134 || s
== htab
->plt_second
1135 || s
== htab
->plt_got
1136 || s
== htab
->plt_eh_frame
1137 || s
== htab
->plt_got_eh_frame
1138 || s
== htab
->plt_second_eh_frame
1139 || s
== htab
->elf
.sdynbss
1140 || s
== htab
->elf
.sdynrelro
)
1142 /* Strip these too. */
1144 else if (htab
->is_reloc_section (bfd_get_section_name (dynobj
, s
)))
1147 && s
!= htab
->elf
.srelplt
1148 && s
!= htab
->srelplt2
)
1151 /* We use the reloc_count field as a counter if we need
1152 to copy relocs into the output file. */
1153 if (s
!= htab
->elf
.srelplt
)
1158 /* It's not one of our sections, so don't allocate space. */
1164 /* If we don't need this section, strip it from the
1165 output file. This is mostly to handle .rel.bss and
1166 .rel.plt. We must create both sections in
1167 create_dynamic_sections, because they must be created
1168 before the linker maps input sections to output
1169 sections. The linker does that before
1170 adjust_dynamic_symbol is called, and it is that
1171 function which decides whether anything needs to go
1172 into these sections. */
1174 s
->flags
|= SEC_EXCLUDE
;
1178 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1181 /* Allocate memory for the section contents. We use bfd_zalloc
1182 here in case unused entries are not reclaimed before the
1183 section's contents are written out. This should not happen,
1184 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1185 reloc instead of garbage. */
1186 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
1187 if (s
->contents
== NULL
)
1191 if (htab
->plt_eh_frame
!= NULL
1192 && htab
->plt_eh_frame
->contents
!= NULL
)
1194 memcpy (htab
->plt_eh_frame
->contents
,
1195 htab
->plt
.eh_frame_plt
,
1196 htab
->plt_eh_frame
->size
);
1197 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
1198 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
1201 if (htab
->plt_got_eh_frame
!= NULL
1202 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1204 memcpy (htab
->plt_got_eh_frame
->contents
,
1205 htab
->non_lazy_plt
->eh_frame_plt
,
1206 htab
->plt_got_eh_frame
->size
);
1207 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
1208 (htab
->plt_got_eh_frame
->contents
1209 + PLT_FDE_LEN_OFFSET
));
1212 if (htab
->plt_second_eh_frame
!= NULL
1213 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1215 memcpy (htab
->plt_second_eh_frame
->contents
,
1216 htab
->non_lazy_plt
->eh_frame_plt
,
1217 htab
->plt_second_eh_frame
->size
);
1218 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
1219 (htab
->plt_second_eh_frame
->contents
1220 + PLT_FDE_LEN_OFFSET
));
1223 if (htab
->elf
.dynamic_sections_created
)
1225 /* Add some entries to the .dynamic section. We fill in the
1226 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1227 but we must add the entries now so that we get the correct
1228 size for the .dynamic section. The DT_DEBUG entry is filled
1229 in by the dynamic linker and used by the debugger. */
1230 #define add_dynamic_entry(TAG, VAL) \
1231 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1233 if (bfd_link_executable (info
))
1235 if (!add_dynamic_entry (DT_DEBUG
, 0))
1239 if (htab
->elf
.splt
->size
!= 0)
1241 /* DT_PLTGOT is used by prelink even if there is no PLT
1243 if (!add_dynamic_entry (DT_PLTGOT
, 0))
1247 if (htab
->elf
.srelplt
->size
!= 0)
1249 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1250 || !add_dynamic_entry (DT_PLTREL
, htab
->dt_reloc
)
1251 || !add_dynamic_entry (DT_JMPREL
, 0))
1255 if (htab
->tlsdesc_plt
1256 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
1257 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
1262 if (!add_dynamic_entry (htab
->dt_reloc
, 0)
1263 || !add_dynamic_entry (htab
->dt_reloc_sz
, 0)
1264 || !add_dynamic_entry (htab
->dt_reloc_ent
,
1265 htab
->sizeof_reloc
))
1268 /* If any dynamic relocs apply to a read-only section,
1269 then we need a DT_TEXTREL entry. */
1270 if ((info
->flags
& DF_TEXTREL
) == 0)
1271 elf_link_hash_traverse (&htab
->elf
,
1272 _bfd_x86_elf_readonly_dynrelocs
,
1275 if ((info
->flags
& DF_TEXTREL
) != 0)
1277 if (htab
->readonly_dynrelocs_against_ifunc
)
1279 info
->callbacks
->einfo
1280 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
1281 bfd_set_error (bfd_error_bad_value
);
1285 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1289 if (htab
->target_os
== is_vxworks
1290 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
1293 #undef add_dynamic_entry
1298 /* Finish up the x86 dynamic sections. */
1300 struct elf_x86_link_hash_table
*
1301 _bfd_x86_elf_finish_dynamic_sections (bfd
*output_bfd
,
1302 struct bfd_link_info
*info
)
1304 struct elf_x86_link_hash_table
*htab
;
1305 const struct elf_backend_data
*bed
;
1308 bfd_byte
*dyncon
, *dynconend
;
1309 bfd_size_type sizeof_dyn
;
1311 bed
= get_elf_backend_data (output_bfd
);
1312 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1316 dynobj
= htab
->elf
.dynobj
;
1317 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
1319 /* GOT is always created in setup_gnu_properties. But it may not be
1320 needed. .got.plt section may be needed for static IFUNC. */
1321 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
1323 bfd_vma dynamic_addr
;
1325 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
1328 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
1332 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
1333 = htab
->got_entry_size
;
1335 dynamic_addr
= (sdyn
== NULL
1337 : sdyn
->output_section
->vma
+ sdyn
->output_offset
);
1339 /* Set the first entry in the global offset table to the address
1340 of the dynamic section. Write GOT[1] and GOT[2], needed for
1341 the dynamic linker. */
1342 if (htab
->got_entry_size
== 8)
1344 bfd_put_64 (output_bfd
, dynamic_addr
,
1345 htab
->elf
.sgotplt
->contents
);
1346 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1347 htab
->elf
.sgotplt
->contents
+ 8);
1348 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1349 htab
->elf
.sgotplt
->contents
+ 8*2);
1353 bfd_put_32 (output_bfd
, dynamic_addr
,
1354 htab
->elf
.sgotplt
->contents
);
1355 bfd_put_32 (output_bfd
, 0,
1356 htab
->elf
.sgotplt
->contents
+ 4);
1357 bfd_put_32 (output_bfd
, 0,
1358 htab
->elf
.sgotplt
->contents
+ 4*2);
1362 if (!htab
->elf
.dynamic_sections_created
)
1365 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
1368 sizeof_dyn
= bed
->s
->sizeof_dyn
;
1369 dyncon
= sdyn
->contents
;
1370 dynconend
= sdyn
->contents
+ sdyn
->size
;
1371 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
1373 Elf_Internal_Dyn dyn
;
1376 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
1381 if (htab
->target_os
== is_vxworks
1382 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
1387 s
= htab
->elf
.sgotplt
;
1388 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
1392 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
1396 s
= htab
->elf
.srelplt
->output_section
;
1397 dyn
.d_un
.d_val
= s
->size
;
1400 case DT_TLSDESC_PLT
:
1402 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1403 + htab
->tlsdesc_plt
;
1406 case DT_TLSDESC_GOT
:
1408 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1409 + htab
->tlsdesc_got
;
1413 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
1416 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
1417 elf_section_data (htab
->plt_got
->output_section
)
1418 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1420 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
1421 elf_section_data (htab
->plt_second
->output_section
)
1422 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1424 /* Adjust .eh_frame for .plt section. */
1425 if (htab
->plt_eh_frame
!= NULL
1426 && htab
->plt_eh_frame
->contents
!= NULL
)
1428 if (htab
->elf
.splt
!= NULL
1429 && htab
->elf
.splt
->size
!= 0
1430 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
1431 && htab
->elf
.splt
->output_section
!= NULL
1432 && htab
->plt_eh_frame
->output_section
!= NULL
)
1434 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
1435 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
1436 + htab
->plt_eh_frame
->output_offset
1437 + PLT_FDE_START_OFFSET
;
1438 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1439 htab
->plt_eh_frame
->contents
1440 + PLT_FDE_START_OFFSET
);
1443 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1445 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1447 htab
->plt_eh_frame
->contents
))
1452 /* Adjust .eh_frame for .plt.got section. */
1453 if (htab
->plt_got_eh_frame
!= NULL
1454 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1456 if (htab
->plt_got
!= NULL
1457 && htab
->plt_got
->size
!= 0
1458 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
1459 && htab
->plt_got
->output_section
!= NULL
1460 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
1462 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
1463 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
1464 + htab
->plt_got_eh_frame
->output_offset
1465 + PLT_FDE_START_OFFSET
;
1466 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1467 htab
->plt_got_eh_frame
->contents
1468 + PLT_FDE_START_OFFSET
);
1470 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1472 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1473 htab
->plt_got_eh_frame
,
1474 htab
->plt_got_eh_frame
->contents
))
1479 /* Adjust .eh_frame for the second PLT section. */
1480 if (htab
->plt_second_eh_frame
!= NULL
1481 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1483 if (htab
->plt_second
!= NULL
1484 && htab
->plt_second
->size
!= 0
1485 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
1486 && htab
->plt_second
->output_section
!= NULL
1487 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
1489 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
1490 bfd_vma eh_frame_start
1491 = (htab
->plt_second_eh_frame
->output_section
->vma
1492 + htab
->plt_second_eh_frame
->output_offset
1493 + PLT_FDE_START_OFFSET
);
1494 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1495 htab
->plt_second_eh_frame
->contents
1496 + PLT_FDE_START_OFFSET
);
1498 if (htab
->plt_second_eh_frame
->sec_info_type
1499 == SEC_INFO_TYPE_EH_FRAME
)
1501 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1502 htab
->plt_second_eh_frame
,
1503 htab
->plt_second_eh_frame
->contents
))
1508 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
1509 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
1510 = htab
->got_entry_size
;
1517 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
1518 struct bfd_link_info
*info
)
1520 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
1524 struct elf_link_hash_entry
*tlsbase
;
1526 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
1527 "_TLS_MODULE_BASE_",
1528 FALSE
, FALSE
, FALSE
);
1530 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
1532 struct elf_x86_link_hash_table
*htab
;
1533 struct bfd_link_hash_entry
*bh
= NULL
;
1534 const struct elf_backend_data
*bed
1535 = get_elf_backend_data (output_bfd
);
1537 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1541 if (!(_bfd_generic_link_add_one_symbol
1542 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1543 tls_sec
, 0, NULL
, FALSE
,
1544 bed
->collect
, &bh
)))
1547 htab
->tls_module_base
= bh
;
1549 tlsbase
= (struct elf_link_hash_entry
*)bh
;
1550 tlsbase
->def_regular
= 1;
1551 tlsbase
->other
= STV_HIDDEN
;
1552 tlsbase
->root
.linker_def
= 1;
1553 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1561 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
1562 const Elf_Internal_Sym
*isym
,
1563 bfd_boolean definition
,
1564 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
1568 struct elf_x86_link_hash_entry
*eh
1569 = (struct elf_x86_link_hash_entry
*) h
;
1570 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
1575 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1578 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1579 struct elf_link_hash_entry
*dir
,
1580 struct elf_link_hash_entry
*ind
)
1582 struct elf_x86_link_hash_entry
*edir
, *eind
;
1584 edir
= (struct elf_x86_link_hash_entry
*) dir
;
1585 eind
= (struct elf_x86_link_hash_entry
*) ind
;
1587 if (eind
->dyn_relocs
!= NULL
)
1589 if (edir
->dyn_relocs
!= NULL
)
1591 struct elf_dyn_relocs
**pp
;
1592 struct elf_dyn_relocs
*p
;
1594 /* Add reloc counts against the indirect sym to the direct sym
1595 list. Merge any entries against the same section. */
1596 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1598 struct elf_dyn_relocs
*q
;
1600 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1601 if (q
->sec
== p
->sec
)
1603 q
->pc_count
+= p
->pc_count
;
1604 q
->count
+= p
->count
;
1611 *pp
= edir
->dyn_relocs
;
1614 edir
->dyn_relocs
= eind
->dyn_relocs
;
1615 eind
->dyn_relocs
= NULL
;
1618 if (ind
->root
.type
== bfd_link_hash_indirect
1619 && dir
->got
.refcount
<= 0)
1621 edir
->tls_type
= eind
->tls_type
;
1622 eind
->tls_type
= GOT_UNKNOWN
;
1625 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1626 generate a R_386_COPY reloc. */
1627 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1629 edir
->zero_undefweak
|= eind
->zero_undefweak
;
1631 if (ELIMINATE_COPY_RELOCS
1632 && ind
->root
.type
!= bfd_link_hash_indirect
1633 && dir
->dynamic_adjusted
)
1635 /* If called to transfer flags for a weakdef during processing
1636 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1637 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1638 if (dir
->versioned
!= versioned_hidden
)
1639 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1640 dir
->ref_regular
|= ind
->ref_regular
;
1641 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1642 dir
->needs_plt
|= ind
->needs_plt
;
1643 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1647 if (eind
->func_pointer_refcount
> 0)
1649 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1650 eind
->func_pointer_refcount
= 0;
1653 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1657 /* Remove undefined weak symbol from the dynamic symbol table if it
1658 is resolved to 0. */
1661 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
1662 struct elf_link_hash_entry
*h
)
1664 if (h
->dynindx
!= -1
1665 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, elf_x86_hash_entry (h
)))
1668 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1674 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1677 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
1679 if (h
->plt
.offset
!= (bfd_vma
) -1
1681 && !h
->pointer_equality_needed
)
1684 return _bfd_elf_hash_symbol (h
);
1687 /* Adjust a symbol defined by a dynamic object and referenced by a
1688 regular object. The current definition is in some section of the
1689 dynamic object, but we're not including those sections. We have to
1690 change the definition to something the rest of the link can
1694 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1695 struct elf_link_hash_entry
*h
)
1697 struct elf_x86_link_hash_table
*htab
;
1699 struct elf_x86_link_hash_entry
*eh
;
1700 struct elf_dyn_relocs
*p
;
1701 const struct elf_backend_data
*bed
1702 = get_elf_backend_data (info
->output_bfd
);
1704 /* STT_GNU_IFUNC symbol must go through PLT. */
1705 if (h
->type
== STT_GNU_IFUNC
)
1707 /* All local STT_GNU_IFUNC references must be treate as local
1708 calls via local PLT. */
1710 && SYMBOL_CALLS_LOCAL (info
, h
))
1712 bfd_size_type pc_count
= 0, count
= 0;
1713 struct elf_dyn_relocs
**pp
;
1715 eh
= (struct elf_x86_link_hash_entry
*) h
;
1716 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1718 pc_count
+= p
->pc_count
;
1719 p
->count
-= p
->pc_count
;
1728 if (pc_count
|| count
)
1733 /* Increment PLT reference count only for PC-relative
1736 if (h
->plt
.refcount
<= 0)
1737 h
->plt
.refcount
= 1;
1739 h
->plt
.refcount
+= 1;
1744 if (h
->plt
.refcount
<= 0)
1746 h
->plt
.offset
= (bfd_vma
) -1;
1752 /* If this is a function, put it in the procedure linkage table. We
1753 will fill in the contents of the procedure linkage table later,
1754 when we know the address of the .got section. */
1755 if (h
->type
== STT_FUNC
1758 if (h
->plt
.refcount
<= 0
1759 || SYMBOL_CALLS_LOCAL (info
, h
)
1760 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1761 && h
->root
.type
== bfd_link_hash_undefweak
))
1763 /* This case can occur if we saw a PLT32 reloc in an input
1764 file, but the symbol was never referred to by a dynamic
1765 object, or if all references were garbage collected. In
1766 such a case, we don't actually need to build a procedure
1767 linkage table, and we can just do a PC32 reloc instead. */
1768 h
->plt
.offset
= (bfd_vma
) -1;
1775 /* It's possible that we incorrectly decided a .plt reloc was needed
1776 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1777 check_relocs. We can't decide accurately between function and
1778 non-function syms in check-relocs; Objects loaded later in
1779 the link may change h->type. So fix it now. */
1780 h
->plt
.offset
= (bfd_vma
) -1;
1782 eh
= (struct elf_x86_link_hash_entry
*) h
;
1784 /* If this is a weak symbol, and there is a real definition, the
1785 processor independent code will have arranged for us to see the
1786 real definition first, and we can just use the same value. */
1787 if (h
->u
.weakdef
!= NULL
)
1789 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1790 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1791 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1792 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1793 if (ELIMINATE_COPY_RELOCS
1794 || info
->nocopyreloc
1795 || SYMBOL_NO_COPYRELOC (info
, eh
))
1797 /* NB: needs_copy is always 0 for i386. */
1798 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1799 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
1804 /* This is a reference to a symbol defined by a dynamic object which
1805 is not a function. */
1807 /* If we are creating a shared library, we must presume that the
1808 only references to the symbol are via the global offset table.
1809 For such cases we need not do anything here; the relocations will
1810 be handled correctly by relocate_section. */
1811 if (!bfd_link_executable (info
))
1814 /* If there are no references to this symbol that do not use the
1815 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1816 reloc. NB: gotoff_ref is always 0 for x86-64. */
1817 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
1820 /* If -z nocopyreloc was given, we won't generate them either. */
1821 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
1827 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1831 /* If there aren't any dynamic relocs in read-only sections nor
1832 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1833 avoid the copy reloc. This doesn't work on VxWorks, where we can
1834 not have dynamic relocations (other than copy and jump slot
1835 relocations) in an executable. */
1836 if (ELIMINATE_COPY_RELOCS
1837 && (bed
->target_id
== X86_64_ELF_DATA
1839 && htab
->target_os
!= is_vxworks
)))
1841 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1843 s
= p
->sec
->output_section
;
1844 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1848 /* If we didn't find any dynamic relocs in read-only sections,
1849 then we'll be keeping the dynamic relocs and avoiding the copy
1858 /* We must allocate the symbol in our .dynbss section, which will
1859 become part of the .bss section of the executable. There will be
1860 an entry for this symbol in the .dynsym section. The dynamic
1861 object will contain position independent code, so all references
1862 from the dynamic object to this symbol will go through the global
1863 offset table. The dynamic linker will use the .dynsym entry to
1864 determine the address it must put in the global offset table, so
1865 both the dynamic object and the regular object will refer to the
1866 same memory location for the variable. */
1868 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1869 dynamic linker to copy the initial value out of the dynamic object
1870 and into the runtime process image. */
1871 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1873 s
= htab
->elf
.sdynrelro
;
1874 srel
= htab
->elf
.sreldynrelro
;
1878 s
= htab
->elf
.sdynbss
;
1879 srel
= htab
->elf
.srelbss
;
1881 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1883 srel
->size
+= htab
->sizeof_reloc
;
1887 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1891 _bfd_x86_elf_hide_symbol (struct bfd_link_info
*info
,
1892 struct elf_link_hash_entry
*h
,
1893 bfd_boolean force_local
)
1895 if (h
->root
.type
== bfd_link_hash_undefweak
1897 && bfd_link_pie (info
))
1899 /* When there is no dynamic interpreter in PIE, make the undefined
1900 weak symbol dynamic so that PC relative branch to the undefined
1901 weak symbol will land to address 0. */
1902 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
1903 if (h
->plt
.refcount
> eh
->func_pointer_refcount
1904 || eh
->plt_got
.refcount
> 0)
1908 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1911 /* Return TRUE if a symbol is referenced locally. It is similar to
1912 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
1913 works in check_relocs. */
1916 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info
*info
,
1917 struct elf_link_hash_entry
*h
)
1919 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
1920 struct elf_x86_link_hash_table
*htab
1921 = (struct elf_x86_link_hash_table
*) info
->hash
;
1923 if (eh
->local_ref
> 1)
1926 if (eh
->local_ref
== 1)
1929 /* Unversioned symbols defined in regular objects can be forced local
1930 by linker version script. A weak undefined symbol is forced local
1932 1. It has non-default visibility. Or
1933 2. When building executable, there is no dynamic linker. Or
1934 3. or "-z nodynamic-undefined-weak" is used.
1936 if (SYMBOL_REFERENCES_LOCAL (info
, h
)
1937 || (h
->root
.type
== bfd_link_hash_undefweak
1938 && (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1939 || (bfd_link_executable (info
)
1940 && htab
->interp
== NULL
)
1941 || info
->dynamic_undefined_weak
== 0))
1942 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
1943 && h
->versioned
== unversioned
1944 && info
->version_info
!= NULL
1945 && bfd_hide_sym_by_version (info
->version_info
,
1946 h
->root
.root
.string
)))
1956 /* Return the section that should be marked against GC for a given
1960 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
1961 struct bfd_link_info
*info
,
1962 Elf_Internal_Rela
*rel
,
1963 struct elf_link_hash_entry
*h
,
1964 Elf_Internal_Sym
*sym
)
1966 /* Compiler should optimize this out. */
1967 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1968 != (unsigned int) R_386_GNU_VTINHERIT
)
1969 || ((unsigned int) R_X86_64_GNU_VTENTRY
1970 != (unsigned int) R_386_GNU_VTENTRY
))
1974 switch (ELF32_R_TYPE (rel
->r_info
))
1976 case R_X86_64_GNU_VTINHERIT
:
1977 case R_X86_64_GNU_VTENTRY
:
1981 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1985 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
1987 bfd_vma offset ATTRIBUTE_UNUSED
,
1990 return got_addr
+ off
;
1994 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
1997 bfd_vma got_addr ATTRIBUTE_UNUSED
)
1999 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
2003 elf_i386_valid_plt_reloc_p (unsigned int type
)
2005 return (type
== R_386_JUMP_SLOT
2006 || type
== R_386_GLOB_DAT
2007 || type
== R_386_IRELATIVE
);
2011 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
2013 return (type
== R_X86_64_JUMP_SLOT
2014 || type
== R_X86_64_GLOB_DAT
2015 || type
== R_X86_64_IRELATIVE
);
2019 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
2023 struct elf_x86_plt plts
[],
2027 long size
, i
, n
, len
;
2029 unsigned int plt_got_offset
, plt_entry_size
;
2031 bfd_byte
*plt_contents
;
2033 arelent
**dynrelbuf
, *p
;
2035 const struct elf_backend_data
*bed
;
2036 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
2038 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
2043 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
2044 if (dynrelbuf
== NULL
)
2047 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
2049 if (dynrelcount
<= 0)
2052 /* Sort the relocs by address. */
2053 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
2054 _bfd_x86_elf_compare_relocs
);
2056 size
= count
* sizeof (asymbol
);
2058 /* Allocate space for @plt suffixes. */
2060 for (i
= 0; i
< dynrelcount
; i
++)
2063 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2065 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
2068 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
2072 bed
= get_elf_backend_data (abfd
);
2074 if (bed
->target_id
== X86_64_ELF_DATA
)
2076 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
2077 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
2081 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
2082 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
2085 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2087 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
2089 got_addr
= sec
->vma
;
2092 sec
= bfd_get_section_by_name (abfd
, ".got");
2094 got_addr
= sec
->vma
;
2097 if (got_addr
== (bfd_vma
) -1)
2102 /* Check for each PLT section. */
2103 names
= (char *) (s
+ count
);
2106 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2107 if ((plt_contents
= plts
[j
].contents
) != NULL
)
2112 struct elf_x86_plt
*plt_p
= &plts
[j
];
2114 plt_got_offset
= plt_p
->plt_got_offset
;
2115 plt_entry_size
= plt_p
->plt_entry_size
;
2119 if ((plt_p
->type
& plt_lazy
))
2121 /* Skip PLT0 in lazy PLT. */
2123 offset
= plt_entry_size
;
2131 /* Check each PLT entry against dynamic relocations. */
2132 for (; k
< plt_p
->count
; k
++)
2138 /* Get the GOT offset for i386 or the PC-relative offset
2139 for x86-64, a signed 32-bit integer. */
2140 off
= H_GET_32 (abfd
, (plt_contents
+ offset
2142 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
2144 /* Binary search. */
2148 while ((min
+ 1) < max
)
2152 mid
= (min
+ max
) / 2;
2154 if (got_vma
> r
->address
)
2156 else if (got_vma
< r
->address
)
2165 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2166 if (got_vma
== p
->address
2168 && valid_plt_reloc_p (p
->howto
->type
))
2170 *s
= **p
->sym_ptr_ptr
;
2171 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2172 set. Since we are defining a symbol, ensure one
2174 if ((s
->flags
& BSF_LOCAL
) == 0)
2175 s
->flags
|= BSF_GLOBAL
;
2176 s
->flags
|= BSF_SYNTHETIC
;
2177 /* This is no longer a section symbol. */
2178 s
->flags
&= ~BSF_SECTION_SYM
;
2180 s
->the_bfd
= plt
->owner
;
2184 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2185 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2191 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2192 names
+= sizeof ("+0x") - 1;
2193 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
2194 for (a
= buf
; *a
== '0'; ++a
)
2197 memcpy (names
, a
, size
);
2200 memcpy (names
, "@plt", sizeof ("@plt"));
2201 names
+= sizeof ("@plt");
2204 /* There should be only one entry in PLT for a given
2205 symbol. Set howto to NULL after processing a PLT
2206 entry to guard against corrupted PLT. */
2209 offset
+= plt_entry_size
;
2213 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2222 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2223 if (plts
[j
].contents
!= NULL
)
2224 free (plts
[j
].contents
);
2231 /* Parse x86 GNU properties. */
2233 enum elf_property_kind
2234 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
2235 bfd_byte
*ptr
, unsigned int datasz
)
2241 case GNU_PROPERTY_X86_ISA_1_USED
:
2242 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2243 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2247 ((type
== GNU_PROPERTY_X86_ISA_1_USED
2248 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
2249 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
2250 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
2251 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
2253 return property_corrupt
;
2255 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
2256 /* Combine properties of the same type. */
2257 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
2258 prop
->pr_kind
= property_number
;
2262 return property_ignored
;
2265 return property_number
;
2268 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2269 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2270 should be merged with ABFD. */
2273 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
2274 bfd
*abfd ATTRIBUTE_UNUSED
,
2275 elf_property
*aprop
,
2276 elf_property
*bprop
)
2278 unsigned int number
, features
;
2279 bfd_boolean updated
= FALSE
;
2280 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
2284 case GNU_PROPERTY_X86_ISA_1_USED
:
2285 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2286 if (aprop
!= NULL
&& bprop
!= NULL
)
2288 number
= aprop
->u
.number
;
2289 aprop
->u
.number
= number
| bprop
->u
.number
;
2290 updated
= number
!= (unsigned int) aprop
->u
.number
;
2294 /* Return TRUE if APROP is NULL to indicate that BPROP should
2295 be added to ABFD. */
2296 updated
= aprop
== NULL
;
2300 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2301 /* Only one of APROP and BPROP can be NULL:
2302 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2303 2. If APROP is NULL, remove x86 feature.
2304 3. Otherwise, do nothing.
2306 if (aprop
!= NULL
&& bprop
!= NULL
)
2310 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2312 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2313 number
= aprop
->u
.number
;
2314 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2315 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2316 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
2317 updated
= number
!= (unsigned int) aprop
->u
.number
;
2318 /* Remove the property if all feature bits are cleared. */
2319 if (aprop
->u
.number
== 0)
2320 aprop
->pr_kind
= property_remove
;
2326 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2328 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2331 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2332 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2335 number
= aprop
->u
.number
;
2336 aprop
->u
.number
= number
| features
;
2337 updated
= number
!= (unsigned int) aprop
->u
.number
;
2341 bprop
->u
.number
|= features
;
2345 else if (aprop
!= NULL
)
2347 aprop
->pr_kind
= property_remove
;
2354 /* Never should happen. */
2361 /* Set up x86 GNU properties. Return the first relocatable ELF input
2362 with GNU properties if found. Otherwise, return NULL. */
2365 _bfd_x86_elf_link_setup_gnu_properties
2366 (struct bfd_link_info
*info
, struct elf_x86_init_table
*init_table
)
2368 bfd_boolean normal_target
;
2369 bfd_boolean lazy_plt
;
2370 asection
*sec
, *pltsec
;
2372 bfd_boolean use_ibt_plt
;
2373 unsigned int plt_alignment
, features
;
2374 struct elf_x86_link_hash_table
*htab
;
2378 const struct elf_backend_data
*bed
;
2379 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
2380 unsigned int got_align
;
2384 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2386 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2388 /* Find a normal input file with GNU property note. */
2389 for (pbfd
= info
->input_bfds
;
2391 pbfd
= pbfd
->link
.next
)
2392 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
2393 && bfd_count_sections (pbfd
) != 0)
2397 if (elf_properties (pbfd
) != NULL
)
2401 if (ebfd
!= NULL
&& features
)
2403 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2404 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2405 prop
= _bfd_elf_get_property (ebfd
,
2406 GNU_PROPERTY_X86_FEATURE_1_AND
,
2408 prop
->u
.number
|= features
;
2409 prop
->pr_kind
= property_number
;
2411 /* Create the GNU property note section if needed. */
2414 sec
= bfd_make_section_with_flags (ebfd
,
2415 NOTE_GNU_PROPERTY_SECTION_NAME
,
2423 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
2425 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
2428 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
2432 elf_section_type (sec
) = SHT_NOTE
;
2436 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
2438 bed
= get_elf_backend_data (info
->output_bfd
);
2440 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2444 htab
->r_info
= init_table
->r_info
;
2445 htab
->r_sym
= init_table
->r_sym
;
2447 if (bfd_link_relocatable (info
))
2450 htab
->plt0_pad_byte
= init_table
->plt0_pad_byte
;
2452 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
2453 if (!use_ibt_plt
&& pbfd
!= NULL
)
2455 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2456 elf_property_list
*p
;
2458 /* The property list is sorted in order of type. */
2459 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
2461 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
2463 use_ibt_plt
= !!(p
->property
.u
.number
2464 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2467 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
2472 dynobj
= htab
->elf
.dynobj
;
2474 /* Set htab->elf.dynobj here so that there is no need to check and
2475 set it in check_relocs. */
2480 htab
->elf
.dynobj
= pbfd
;
2487 /* Find a normal input file to hold linker created
2489 for (abfd
= info
->input_bfds
;
2491 abfd
= abfd
->link
.next
)
2492 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2494 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
2496 htab
->elf
.dynobj
= abfd
;
2503 /* Return if there are no normal input files. */
2507 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2508 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2509 canonical function address. */
2510 htab
->plt
.has_plt0
= 1;
2511 normal_target
= htab
->target_os
== is_normal
;
2517 htab
->lazy_plt
= init_table
->lazy_ibt_plt
;
2518 htab
->non_lazy_plt
= init_table
->non_lazy_ibt_plt
;
2522 htab
->lazy_plt
= init_table
->lazy_plt
;
2523 htab
->non_lazy_plt
= init_table
->non_lazy_plt
;
2528 htab
->lazy_plt
= init_table
->lazy_plt
;
2529 htab
->non_lazy_plt
= NULL
;
2532 pltsec
= htab
->elf
.splt
;
2534 /* If the non-lazy PLT is available, use it for all PLT entries if
2535 there are no PLT0 or no .plt section. */
2536 if (htab
->non_lazy_plt
!= NULL
2537 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
2540 if (bfd_link_pic (info
))
2541 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
2543 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
2544 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
2545 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
2546 htab
->plt
.plt_got_insn_size
2547 = htab
->non_lazy_plt
->plt_got_insn_size
;
2548 htab
->plt
.eh_frame_plt_size
2549 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2550 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
2555 if (bfd_link_pic (info
))
2557 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
2558 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
2562 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
2563 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
2565 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
2566 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
2567 htab
->plt
.plt_got_insn_size
2568 = htab
->lazy_plt
->plt_got_insn_size
;
2569 htab
->plt
.eh_frame_plt_size
2570 = htab
->lazy_plt
->eh_frame_plt_size
;
2571 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
2574 if (htab
->target_os
== is_vxworks
2575 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
2578 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
2582 /* Since create_dynamic_sections isn't always called, but GOT
2583 relocations need GOT relocations, create them here so that we
2584 don't need to do it in check_relocs. */
2585 if (htab
->elf
.sgot
== NULL
2586 && !_bfd_elf_create_got_section (dynobj
, info
))
2587 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
2589 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
2591 /* Align .got and .got.plt sections to their entry size. Do it here
2592 instead of in create_dynamic_sections so that they are always
2593 properly aligned even if create_dynamic_sections isn't called. */
2594 sec
= htab
->elf
.sgot
;
2595 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2596 goto error_alignment
;
2598 sec
= htab
->elf
.sgotplt
;
2599 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2600 goto error_alignment
;
2602 /* Create the ifunc sections here so that check_relocs can be
2604 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
2605 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
2607 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
2611 /* Whe creating executable, set the contents of the .interp
2612 section to the interpreter. */
2613 if (bfd_link_executable (info
) && !info
->nointerp
)
2615 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
2618 s
->size
= htab
->dynamic_interpreter_size
;
2619 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2623 /* Don't change PLT section alignment for NaCl since it uses
2624 64-byte PLT entry and sets PLT section alignment to 32
2625 bytes. Don't create additional PLT sections for NaCl. */
2628 flagword pltflags
= (bed
->dynamic_sec_flags
2633 unsigned int non_lazy_plt_alignment
2634 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
2637 if (!bfd_set_section_alignment (sec
->owner
, sec
,
2639 goto error_alignment
;
2641 /* Create the GOT procedure linkage table. */
2642 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2646 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
2648 if (!bfd_set_section_alignment (dynobj
, sec
,
2649 non_lazy_plt_alignment
))
2650 goto error_alignment
;
2652 htab
->plt_got
= sec
;
2660 /* Create the second PLT for Intel IBT support. IBT
2661 PLT is supported only for non-NaCl target and is
2662 is needed only for lazy binding. */
2663 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2667 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
2669 if (!bfd_set_section_alignment (dynobj
, sec
,
2671 goto error_alignment
;
2673 else if (info
->bndplt
&& ABI_64_P (dynobj
))
2675 /* Create the second PLT for Intel MPX support. MPX
2676 PLT is supported only for non-NaCl target in 64-bit
2677 mode and is needed only for lazy binding. */
2678 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2682 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
2684 if (!bfd_set_section_alignment (dynobj
, sec
,
2685 non_lazy_plt_alignment
))
2686 goto error_alignment
;
2689 htab
->plt_second
= sec
;
2693 if (!info
->no_ld_generated_unwind_info
)
2695 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
2696 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2697 | SEC_LINKER_CREATED
);
2699 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2703 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
2705 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2706 goto error_alignment
;
2708 htab
->plt_eh_frame
= sec
;
2710 if (htab
->plt_got
!= NULL
)
2712 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2716 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
2718 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2719 goto error_alignment
;
2721 htab
->plt_got_eh_frame
= sec
;
2724 if (htab
->plt_second
!= NULL
)
2726 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2730 info
->callbacks
->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
2732 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2733 goto error_alignment
;
2735 htab
->plt_second_eh_frame
= sec
;
2742 /* The .iplt section is used for IFUNC symbols in static
2744 sec
= htab
->elf
.iplt
;
2746 && !bfd_set_section_alignment (sec
->owner
, sec
,
2748 goto error_alignment
;