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 /* 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
;
183 /* If this is the first .plt entry, make room for the special
184 first entry. The .plt section is used by prelink to undo
185 prelinking for dynamic relocations. */
187 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
190 eh
->plt_got
.offset
= got_s
->size
;
193 h
->plt
.offset
= s
->size
;
195 eh
->plt_second
.offset
= second_s
->size
;
198 /* If this symbol is not defined in a regular file, and we are
199 not generating a shared library, then set the symbol to this
200 location in the .plt. This is required to make function
201 pointers compare as equal between the normal executable and
202 the shared library. */
203 if (! bfd_link_pic (info
)
208 /* We need to make a call to the entry of the GOT PLT
209 instead of regular PLT entry. */
210 h
->root
.u
.def
.section
= got_s
;
211 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
217 /* We need to make a call to the entry of the
218 second PLT instead of regular PLT entry. */
219 h
->root
.u
.def
.section
= second_s
;
220 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
224 h
->root
.u
.def
.section
= s
;
225 h
->root
.u
.def
.value
= h
->plt
.offset
;
230 /* Make room for this entry. */
232 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
235 s
->size
+= plt_entry_size
;
237 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
239 /* We also need to make an entry in the .got.plt section,
240 which will be placed in the .got section by the linker
242 htab
->elf
.sgotplt
->size
+= htab
->got_entry_size
;
244 /* There should be no PLT relocation against resolved
245 undefined weak symbol in executable. */
246 if (!resolved_to_zero
)
248 /* We also need to make an entry in the .rel.plt
250 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
251 htab
->elf
.srelplt
->reloc_count
++;
255 if (htab
->target_os
== is_vxworks
&& !bfd_link_pic (info
))
257 /* VxWorks has a second set of relocations for each PLT entry
258 in executables. They go in a separate relocation section,
259 which is processed by the kernel loader. */
261 /* There are two relocations for the initial PLT entry: an
262 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
263 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
265 asection
*srelplt2
= htab
->srelplt2
;
266 if (h
->plt
.offset
== plt_entry_size
)
267 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
269 /* There are two extra relocations for each subsequent PLT entry:
270 an R_386_32 relocation for the GOT entry, and an R_386_32
271 relocation for the PLT entry. */
273 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
278 eh
->plt_got
.offset
= (bfd_vma
) -1;
279 h
->plt
.offset
= (bfd_vma
) -1;
285 eh
->plt_got
.offset
= (bfd_vma
) -1;
286 h
->plt
.offset
= (bfd_vma
) -1;
290 eh
->tlsdesc_got
= (bfd_vma
) -1;
292 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
293 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
294 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
295 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
296 if (h
->got
.refcount
> 0
297 && bfd_link_executable (info
)
299 && (elf_x86_hash_entry (h
)->tls_type
& GOT_TLS_IE
))
300 h
->got
.offset
= (bfd_vma
) -1;
301 else if (h
->got
.refcount
> 0)
305 int tls_type
= elf_x86_hash_entry (h
)->tls_type
;
307 /* Make sure this symbol is output as a dynamic symbol.
308 Undefined weak syms won't yet be marked as dynamic. */
312 && h
->root
.type
== bfd_link_hash_undefweak
)
314 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
319 if (GOT_TLS_GDESC_P (tls_type
))
321 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
322 - elf_x86_compute_jump_table_size (htab
);
323 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
324 h
->got
.offset
= (bfd_vma
) -2;
326 if (! GOT_TLS_GDESC_P (tls_type
)
327 || GOT_TLS_GD_P (tls_type
))
329 h
->got
.offset
= s
->size
;
330 s
->size
+= htab
->got_entry_size
;
331 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
333 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
334 s
->size
+= htab
->got_entry_size
;
336 dyn
= htab
->elf
.dynamic_sections_created
;
337 /* R_386_TLS_IE_32 needs one dynamic relocation,
338 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
339 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
340 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
341 symbol and two if global. No dynamic relocation against
342 resolved undefined weak symbol in executable. */
343 if (tls_type
== GOT_TLS_IE_BOTH
)
344 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
345 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
346 || (tls_type
& GOT_TLS_IE
))
347 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
348 else if (GOT_TLS_GD_P (tls_type
))
349 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
350 else if (! GOT_TLS_GDESC_P (tls_type
)
351 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
352 && !resolved_to_zero
)
353 || h
->root
.type
!= bfd_link_hash_undefweak
)
354 && (bfd_link_pic (info
)
355 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
356 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
357 if (GOT_TLS_GDESC_P (tls_type
))
359 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
360 if (bed
->target_id
== X86_64_ELF_DATA
)
361 htab
->tlsdesc_plt
= (bfd_vma
) -1;
365 h
->got
.offset
= (bfd_vma
) -1;
367 if (eh
->dyn_relocs
== NULL
)
370 /* In the shared -Bsymbolic case, discard space allocated for
371 dynamic pc-relative relocs against symbols which turn out to be
372 defined in regular objects. For the normal shared case, discard
373 space for pc-relative relocs that have become local due to symbol
374 visibility changes. */
376 if (bfd_link_pic (info
))
378 /* Relocs that use pc_count are those that appear on a call
379 insn, or certain REL relocs that can generated via assembly.
380 We want calls to protected symbols to resolve directly to the
381 function rather than going via the plt. If people want
382 function pointer comparisons to work as expected then they
383 should avoid writing weird assembly. */
384 if (SYMBOL_CALLS_LOCAL (info
, h
))
386 struct elf_dyn_relocs
**pp
;
388 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
390 p
->count
-= p
->pc_count
;
399 if (htab
->target_os
== is_vxworks
)
401 struct elf_dyn_relocs
**pp
;
402 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
404 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
411 /* Also discard relocs on undefined weak syms with non-default
412 visibility or in PIE. */
413 if (eh
->dyn_relocs
!= NULL
)
415 if (h
->root
.type
== bfd_link_hash_undefweak
)
417 /* Undefined weak symbol is never bound locally in shared
419 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
422 if (bed
->target_id
== I386_ELF_DATA
425 /* Keep dynamic non-GOT/non-PLT relocation so
426 that we can branch to 0 without PLT. */
427 struct elf_dyn_relocs
**pp
;
429 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
430 if (p
->pc_count
== 0)
434 /* Remove non-R_386_PC32 relocation. */
435 p
->count
= p
->pc_count
;
439 /* Make sure undefined weak symbols are output
440 as dynamic symbols in PIEs for dynamic non-GOT
441 non-PLT reloations. */
442 if (eh
->dyn_relocs
!= NULL
443 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
447 eh
->dyn_relocs
= NULL
;
449 else if (h
->dynindx
== -1
451 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
454 else if (bfd_link_executable (info
)
455 && (h
->needs_copy
|| eh
->needs_copy
)
459 /* NB: needs_copy is set only for x86-64. For PIE,
460 discard space for pc-relative relocs against symbols
461 which turn out to need copy relocs. */
462 struct elf_dyn_relocs
**pp
;
464 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
466 if (p
->pc_count
!= 0)
474 else if (ELIMINATE_COPY_RELOCS
)
476 /* For the non-shared case, discard space for relocs against
477 symbols which turn out to need copy relocs or are not
478 dynamic. Keep dynamic relocations for run-time function
479 pointer initialization. */
482 || (h
->root
.type
== bfd_link_hash_undefweak
483 && !resolved_to_zero
))
486 || (htab
->elf
.dynamic_sections_created
487 && (h
->root
.type
== bfd_link_hash_undefweak
488 || h
->root
.type
== bfd_link_hash_undefined
))))
490 /* Make sure this symbol is output as a dynamic symbol.
491 Undefined weak syms won't yet be marked as dynamic. */
495 && h
->root
.type
== bfd_link_hash_undefweak
496 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
499 /* If that succeeded, we know we'll be keeping all the
501 if (h
->dynindx
!= -1)
505 eh
->dyn_relocs
= NULL
;
510 /* Finally, allocate space. */
511 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
515 sreloc
= elf_section_data (p
->sec
)->sreloc
;
517 BFD_ASSERT (sreloc
!= NULL
);
518 sreloc
->size
+= p
->count
* htab
->sizeof_reloc
;
524 /* Find dynamic relocs for H that apply to read-only sections. */
527 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
529 struct elf_dyn_relocs
*p
;
531 for (p
= elf_x86_hash_entry (h
)->dyn_relocs
; p
!= NULL
; p
= p
->next
)
533 asection
*s
= p
->sec
->output_section
;
535 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
541 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
542 read-only sections. */
545 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
549 if (h
->root
.type
== bfd_link_hash_indirect
)
552 /* Skip local IFUNC symbols. */
553 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
556 sec
= readonly_dynrelocs (h
);
559 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
561 info
->flags
|= DF_TEXTREL
;
562 /* xgettext:c-format */
563 info
->callbacks
->minfo (_("%B: dynamic relocation against `%T' "
564 "in read-only section `%A'\n"),
565 sec
->owner
, h
->root
.root
.string
, sec
);
567 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
568 || info
->error_textrel
)
569 /* xgettext:c-format */
570 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' "
571 "in read-only section `%A'\n"),
572 sec
->owner
, h
->root
.root
.string
, sec
);
574 /* Not an error, just cut short the traversal. */
580 /* Allocate space in .plt, .got and associated reloc sections for
581 local dynamic relocs. */
584 elf_x86_allocate_local_dynreloc (void **slot
, void *inf
)
586 struct elf_link_hash_entry
*h
587 = (struct elf_link_hash_entry
*) *slot
;
589 if (h
->type
!= STT_GNU_IFUNC
593 || h
->root
.type
!= bfd_link_hash_defined
)
596 return elf_x86_allocate_dynrelocs (h
, inf
);
599 /* Find and/or create a hash entry for local symbol. */
601 struct elf_link_hash_entry
*
602 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table
*htab
,
603 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
606 struct elf_x86_link_hash_entry e
, *ret
;
607 asection
*sec
= abfd
->sections
;
608 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
609 htab
->r_sym (rel
->r_info
));
612 e
.elf
.indx
= sec
->id
;
613 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
614 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
615 create
? INSERT
: NO_INSERT
);
622 ret
= (struct elf_x86_link_hash_entry
*) *slot
;
626 ret
= (struct elf_x86_link_hash_entry
*)
627 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
628 sizeof (struct elf_x86_link_hash_entry
));
631 memset (ret
, 0, sizeof (*ret
));
632 ret
->elf
.indx
= sec
->id
;
633 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
634 ret
->elf
.dynindx
= -1;
635 ret
->plt_got
.offset
= (bfd_vma
) -1;
641 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN
642 SYNC WITH _bfd_elf_link_hash_newfunc. */
644 struct bfd_hash_entry
*
645 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
646 struct bfd_hash_table
*table
,
649 /* Allocate the structure if it has not already been allocated by a
653 entry
= (struct bfd_hash_entry
*)
654 bfd_hash_allocate (table
,
655 sizeof (struct elf_x86_link_hash_entry
));
660 /* Call the allocation method of the superclass. */
661 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
664 struct elf_x86_link_hash_entry
*eh
665 = (struct elf_x86_link_hash_entry
*) entry
;
666 struct elf_link_hash_table
*htab
667 = (struct elf_link_hash_table
*) table
;
669 memset (&eh
->elf
.size
, 0,
670 (sizeof (struct elf_x86_link_hash_entry
)
671 - offsetof (struct elf_link_hash_entry
, size
)));
672 /* Set local fields. */
674 eh
->elf
.dynindx
= -1;
675 eh
->elf
.got
= htab
->init_got_refcount
;
676 eh
->elf
.plt
= htab
->init_plt_refcount
;
677 /* Assume that we have been called by a non-ELF symbol reader.
678 This flag is then reset by the code which reads an ELF input
679 file. This ensures that a symbol created by a non-ELF symbol
680 reader will have the flag set correctly. */
682 eh
->plt_second
.offset
= (bfd_vma
) -1;
683 eh
->plt_got
.offset
= (bfd_vma
) -1;
684 eh
->tlsdesc_got
= (bfd_vma
) -1;
685 eh
->zero_undefweak
= 1;
691 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
692 for local symbol so that we can handle local STT_GNU_IFUNC symbols
693 as global symbol. We reuse indx and dynstr_index for local symbol
694 hash since they aren't used by global symbols in this backend. */
697 _bfd_x86_elf_local_htab_hash (const void *ptr
)
699 struct elf_link_hash_entry
*h
700 = (struct elf_link_hash_entry
*) ptr
;
701 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
704 /* Compare local hash entries. */
707 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
709 struct elf_link_hash_entry
*h1
710 = (struct elf_link_hash_entry
*) ptr1
;
711 struct elf_link_hash_entry
*h2
712 = (struct elf_link_hash_entry
*) ptr2
;
714 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
717 /* Destroy an x86 ELF linker hash table. */
720 elf_x86_link_hash_table_free (bfd
*obfd
)
722 struct elf_x86_link_hash_table
*htab
723 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
725 if (htab
->loc_hash_table
)
726 htab_delete (htab
->loc_hash_table
);
727 if (htab
->loc_hash_memory
)
728 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
729 _bfd_elf_link_hash_table_free (obfd
);
733 elf_i386_is_reloc_section (const char *secname
)
735 return CONST_STRNEQ (secname
, ".rel");
739 elf_x86_64_is_reloc_section (const char *secname
)
741 return CONST_STRNEQ (secname
, ".rela");
744 /* Create an x86 ELF linker hash table. */
746 struct bfd_link_hash_table
*
747 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
749 struct elf_x86_link_hash_table
*ret
;
750 const struct elf_backend_data
*bed
;
751 bfd_size_type amt
= sizeof (struct elf_x86_link_hash_table
);
753 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
757 bed
= get_elf_backend_data (abfd
);
758 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
759 _bfd_x86_elf_link_hash_newfunc
,
760 sizeof (struct elf_x86_link_hash_entry
),
767 if (bed
->target_id
== X86_64_ELF_DATA
)
769 ret
->is_reloc_section
= elf_x86_64_is_reloc_section
;
770 ret
->dt_reloc
= DT_RELA
;
771 ret
->dt_reloc_sz
= DT_RELASZ
;
772 ret
->dt_reloc_ent
= DT_RELAENT
;
773 ret
->got_entry_size
= 8;
774 ret
->tls_get_addr
= "__tls_get_addr";
778 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
779 ret
->pointer_r_type
= R_X86_64_64
;
780 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
781 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
785 if (bed
->target_id
== X86_64_ELF_DATA
)
787 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
788 ret
->pointer_r_type
= R_X86_64_32
;
789 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
790 ret
->dynamic_interpreter_size
791 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
795 ret
->is_reloc_section
= elf_i386_is_reloc_section
;
796 ret
->dt_reloc
= DT_REL
;
797 ret
->dt_reloc_sz
= DT_RELSZ
;
798 ret
->dt_reloc_ent
= DT_RELENT
;
799 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
800 ret
->got_entry_size
= 4;
801 ret
->pointer_r_type
= R_386_32
;
802 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
803 ret
->dynamic_interpreter_size
804 = sizeof ELF32_DYNAMIC_INTERPRETER
;
805 ret
->tls_get_addr
= "___tls_get_addr";
808 ret
->target_id
= bed
->target_id
;
809 ret
->target_os
= get_elf_x86_backend_data (abfd
)->target_os
;
811 ret
->loc_hash_table
= htab_try_create (1024,
812 _bfd_x86_elf_local_htab_hash
,
813 _bfd_x86_elf_local_htab_eq
,
815 ret
->loc_hash_memory
= objalloc_create ();
816 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
818 elf_x86_link_hash_table_free (abfd
);
821 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
823 return &ret
->elf
.root
;
826 /* Sort relocs into address order. */
829 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
831 const arelent
*a
= * (const arelent
**) ap
;
832 const arelent
*b
= * (const arelent
**) bp
;
834 if (a
->address
> b
->address
)
836 else if (a
->address
< b
->address
)
843 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
845 if (!bfd_link_relocatable (info
))
847 /* Check for __tls_get_addr reference. */
848 struct elf_x86_link_hash_table
*htab
;
849 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
850 htab
= elf_x86_hash_table (info
, bed
->target_id
);
853 struct elf_link_hash_entry
*h
;
855 h
= elf_link_hash_lookup (elf_hash_table (info
),
857 FALSE
, FALSE
, FALSE
);
859 elf_x86_hash_entry (h
)->tls_get_addr
= 1;
861 /* "__ehdr_start" will be defined by linker as a hidden symbol
862 later if it is referenced and not defined. */
863 h
= elf_link_hash_lookup (elf_hash_table (info
),
865 FALSE
, FALSE
, FALSE
);
867 && (h
->root
.type
== bfd_link_hash_new
868 || h
->root
.type
== bfd_link_hash_undefined
869 || h
->root
.type
== bfd_link_hash_undefweak
870 || h
->root
.type
== bfd_link_hash_common
))
872 elf_x86_hash_entry (h
)->local_ref
= 2;
873 elf_x86_hash_entry (h
)->linker_def
= 1;
878 /* Invoke the regular ELF backend linker to do all the work. */
879 return _bfd_elf_link_check_relocs (abfd
, info
);
882 /* Set the sizes of the dynamic sections. */
885 _bfd_x86_elf_size_dynamic_sections (bfd
*output_bfd
,
886 struct bfd_link_info
*info
)
888 struct elf_x86_link_hash_table
*htab
;
893 const struct elf_backend_data
*bed
894 = get_elf_backend_data (output_bfd
);
896 htab
= elf_x86_hash_table (info
, bed
->target_id
);
899 dynobj
= htab
->elf
.dynobj
;
903 /* Set up .got offsets for local syms, and space for local dynamic
905 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
907 bfd_signed_vma
*local_got
;
908 bfd_signed_vma
*end_local_got
;
909 char *local_tls_type
;
910 bfd_vma
*local_tlsdesc_gotent
;
911 bfd_size_type locsymcount
;
912 Elf_Internal_Shdr
*symtab_hdr
;
915 if (! is_x86_elf (ibfd
, htab
))
918 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
920 struct elf_dyn_relocs
*p
;
922 for (p
= ((struct elf_dyn_relocs
*)
923 elf_section_data (s
)->local_dynrel
);
927 if (!bfd_is_abs_section (p
->sec
)
928 && bfd_is_abs_section (p
->sec
->output_section
))
930 /* Input section has been discarded, either because
931 it is a copy of a linkonce section or due to
932 linker script /DISCARD/, so we'll be discarding
935 else if (htab
->target_os
== is_vxworks
936 && strcmp (p
->sec
->output_section
->name
,
939 /* Relocations in vxworks .tls_vars sections are
940 handled specially by the loader. */
942 else if (p
->count
!= 0)
944 srel
= elf_section_data (p
->sec
)->sreloc
;
945 srel
->size
+= p
->count
* htab
->sizeof_reloc
;
946 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
947 && (info
->flags
& DF_TEXTREL
) == 0)
949 info
->flags
|= DF_TEXTREL
;
950 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
951 || info
->error_textrel
)
952 /* xgettext:c-format */
953 info
->callbacks
->einfo
954 (_("%P: %B: warning: relocation "
955 "in read-only section `%A'\n"),
956 p
->sec
->owner
, p
->sec
);
962 local_got
= elf_local_got_refcounts (ibfd
);
966 symtab_hdr
= &elf_symtab_hdr (ibfd
);
967 locsymcount
= symtab_hdr
->sh_info
;
968 end_local_got
= local_got
+ locsymcount
;
969 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
970 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
972 srel
= htab
->elf
.srelgot
;
973 for (; local_got
< end_local_got
;
974 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
976 *local_tlsdesc_gotent
= (bfd_vma
) -1;
979 if (GOT_TLS_GDESC_P (*local_tls_type
))
981 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
982 - elf_x86_compute_jump_table_size (htab
);
983 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
984 *local_got
= (bfd_vma
) -2;
986 if (! GOT_TLS_GDESC_P (*local_tls_type
)
987 || GOT_TLS_GD_P (*local_tls_type
))
989 *local_got
= s
->size
;
990 s
->size
+= htab
->got_entry_size
;
991 if (GOT_TLS_GD_P (*local_tls_type
)
992 || *local_tls_type
== GOT_TLS_IE_BOTH
)
993 s
->size
+= htab
->got_entry_size
;
995 if (bfd_link_pic (info
)
996 || GOT_TLS_GD_ANY_P (*local_tls_type
)
997 || (*local_tls_type
& GOT_TLS_IE
))
999 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
1000 srel
->size
+= 2 * htab
->sizeof_reloc
;
1001 else if (GOT_TLS_GD_P (*local_tls_type
)
1002 || ! GOT_TLS_GDESC_P (*local_tls_type
))
1003 srel
->size
+= htab
->sizeof_reloc
;
1004 if (GOT_TLS_GDESC_P (*local_tls_type
))
1006 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
1007 if (bed
->target_id
== X86_64_ELF_DATA
)
1008 htab
->tlsdesc_plt
= (bfd_vma
) -1;
1013 *local_got
= (bfd_vma
) -1;
1017 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
1019 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1020 or R_X86_64_TLSLD relocs. */
1021 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
1022 htab
->elf
.sgot
->size
+= 2 * htab
->got_entry_size
;
1023 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
1026 htab
->tls_ld_or_ldm_got
.offset
= -1;
1028 /* Allocate global sym .plt and .got entries, and space for global
1029 sym dynamic relocs. */
1030 elf_link_hash_traverse (&htab
->elf
, elf_x86_allocate_dynrelocs
,
1033 /* Allocate .plt and .got entries, and space for local symbols. */
1034 htab_traverse (htab
->loc_hash_table
, elf_x86_allocate_local_dynreloc
,
1037 /* For every jump slot reserved in the sgotplt, reloc_count is
1038 incremented. However, when we reserve space for TLS descriptors,
1039 it's not incremented, so in order to compute the space reserved
1040 for them, it suffices to multiply the reloc count by the jump
1043 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1044 so that R_{386,X86_64}_IRELATIVE entries come last. */
1045 if (htab
->elf
.srelplt
)
1047 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
1048 htab
->sgotplt_jump_table_size
1049 = elf_x86_compute_jump_table_size (htab
);
1050 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
1052 else if (htab
->elf
.irelplt
)
1053 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1055 if (htab
->tlsdesc_plt
)
1057 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1058 lazy TLS relocations, don't generate the PLT and GOT entries
1060 if ((info
->flags
& DF_BIND_NOW
))
1061 htab
->tlsdesc_plt
= 0;
1064 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
1065 htab
->elf
.sgot
->size
+= htab
->got_entry_size
;
1066 /* Reserve room for the initial entry.
1067 FIXME: we could probably do away with it in this case. */
1068 if (htab
->elf
.splt
->size
== 0)
1069 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
1070 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
1071 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
1075 if (htab
->elf
.sgotplt
)
1077 /* Don't allocate .got.plt section if there are no GOT nor PLT
1078 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1079 if ((htab
->elf
.hgot
== NULL
1080 || !htab
->elf
.hgot
->ref_regular_nonweak
)
1081 && (htab
->elf
.sgotplt
->size
== bed
->got_header_size
)
1082 && (htab
->elf
.splt
== NULL
1083 || htab
->elf
.splt
->size
== 0)
1084 && (htab
->elf
.sgot
== NULL
1085 || htab
->elf
.sgot
->size
== 0)
1086 && (htab
->elf
.iplt
== NULL
1087 || htab
->elf
.iplt
->size
== 0)
1088 && (htab
->elf
.igotplt
== NULL
1089 || htab
->elf
.igotplt
->size
== 0))
1090 htab
->elf
.sgotplt
->size
= 0;
1093 if (_bfd_elf_eh_frame_present (info
))
1095 if (htab
->plt_eh_frame
!= NULL
1096 && htab
->elf
.splt
!= NULL
1097 && htab
->elf
.splt
->size
!= 0
1098 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
1099 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
1101 if (htab
->plt_got_eh_frame
!= NULL
1102 && htab
->plt_got
!= NULL
1103 && htab
->plt_got
->size
!= 0
1104 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
1105 htab
->plt_got_eh_frame
->size
1106 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1108 /* Unwind info for the second PLT and .plt.got sections are
1110 if (htab
->plt_second_eh_frame
!= NULL
1111 && htab
->plt_second
!= NULL
1112 && htab
->plt_second
->size
!= 0
1113 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
1114 htab
->plt_second_eh_frame
->size
1115 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1118 /* We now have determined the sizes of the various dynamic sections.
1119 Allocate memory for them. */
1121 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1123 bfd_boolean strip_section
= TRUE
;
1125 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1128 if (s
== htab
->elf
.splt
1129 || s
== htab
->elf
.sgot
)
1131 /* Strip this section if we don't need it; see the
1133 /* We'd like to strip these sections if they aren't needed, but if
1134 we've exported dynamic symbols from them we must leave them.
1135 It's too late to tell BFD to get rid of the symbols. */
1137 if (htab
->elf
.hplt
!= NULL
)
1138 strip_section
= FALSE
;
1140 else if (s
== htab
->elf
.sgotplt
1141 || s
== htab
->elf
.iplt
1142 || s
== htab
->elf
.igotplt
1143 || s
== htab
->plt_second
1144 || s
== htab
->plt_got
1145 || s
== htab
->plt_eh_frame
1146 || s
== htab
->plt_got_eh_frame
1147 || s
== htab
->plt_second_eh_frame
1148 || s
== htab
->elf
.sdynbss
1149 || s
== htab
->elf
.sdynrelro
)
1151 /* Strip these too. */
1153 else if (htab
->is_reloc_section (bfd_get_section_name (dynobj
, s
)))
1156 && s
!= htab
->elf
.srelplt
1157 && s
!= htab
->srelplt2
)
1160 /* We use the reloc_count field as a counter if we need
1161 to copy relocs into the output file. */
1162 if (s
!= htab
->elf
.srelplt
)
1167 /* It's not one of our sections, so don't allocate space. */
1173 /* If we don't need this section, strip it from the
1174 output file. This is mostly to handle .rel.bss and
1175 .rel.plt. We must create both sections in
1176 create_dynamic_sections, because they must be created
1177 before the linker maps input sections to output
1178 sections. The linker does that before
1179 adjust_dynamic_symbol is called, and it is that
1180 function which decides whether anything needs to go
1181 into these sections. */
1183 s
->flags
|= SEC_EXCLUDE
;
1187 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1190 /* Allocate memory for the section contents. We use bfd_zalloc
1191 here in case unused entries are not reclaimed before the
1192 section's contents are written out. This should not happen,
1193 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1194 reloc instead of garbage. */
1195 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
1196 if (s
->contents
== NULL
)
1200 if (htab
->plt_eh_frame
!= NULL
1201 && htab
->plt_eh_frame
->contents
!= NULL
)
1203 memcpy (htab
->plt_eh_frame
->contents
,
1204 htab
->plt
.eh_frame_plt
,
1205 htab
->plt_eh_frame
->size
);
1206 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
1207 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
1210 if (htab
->plt_got_eh_frame
!= NULL
1211 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1213 memcpy (htab
->plt_got_eh_frame
->contents
,
1214 htab
->non_lazy_plt
->eh_frame_plt
,
1215 htab
->plt_got_eh_frame
->size
);
1216 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
1217 (htab
->plt_got_eh_frame
->contents
1218 + PLT_FDE_LEN_OFFSET
));
1221 if (htab
->plt_second_eh_frame
!= NULL
1222 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1224 memcpy (htab
->plt_second_eh_frame
->contents
,
1225 htab
->non_lazy_plt
->eh_frame_plt
,
1226 htab
->plt_second_eh_frame
->size
);
1227 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
1228 (htab
->plt_second_eh_frame
->contents
1229 + PLT_FDE_LEN_OFFSET
));
1232 if (htab
->elf
.dynamic_sections_created
)
1234 /* Add some entries to the .dynamic section. We fill in the
1235 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1236 but we must add the entries now so that we get the correct
1237 size for the .dynamic section. The DT_DEBUG entry is filled
1238 in by the dynamic linker and used by the debugger. */
1239 #define add_dynamic_entry(TAG, VAL) \
1240 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1242 if (bfd_link_executable (info
))
1244 if (!add_dynamic_entry (DT_DEBUG
, 0))
1248 if (htab
->elf
.splt
->size
!= 0)
1250 /* DT_PLTGOT is used by prelink even if there is no PLT
1252 if (!add_dynamic_entry (DT_PLTGOT
, 0))
1256 if (htab
->elf
.srelplt
->size
!= 0)
1258 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1259 || !add_dynamic_entry (DT_PLTREL
, htab
->dt_reloc
)
1260 || !add_dynamic_entry (DT_JMPREL
, 0))
1264 if (htab
->tlsdesc_plt
1265 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
1266 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
1271 if (!add_dynamic_entry (htab
->dt_reloc
, 0)
1272 || !add_dynamic_entry (htab
->dt_reloc_sz
, 0)
1273 || !add_dynamic_entry (htab
->dt_reloc_ent
,
1274 htab
->sizeof_reloc
))
1277 /* If any dynamic relocs apply to a read-only section,
1278 then we need a DT_TEXTREL entry. */
1279 if ((info
->flags
& DF_TEXTREL
) == 0)
1280 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
1282 if ((info
->flags
& DF_TEXTREL
) != 0)
1284 if (htab
->readonly_dynrelocs_against_ifunc
)
1286 info
->callbacks
->einfo
1287 (_("%P%X: read-only segment has dynamic IFUNC relocations;"
1288 " recompile with -fPIC\n"));
1289 bfd_set_error (bfd_error_bad_value
);
1293 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1297 if (htab
->target_os
== is_vxworks
1298 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
1301 #undef add_dynamic_entry
1306 /* Finish up the x86 dynamic sections. */
1308 struct elf_x86_link_hash_table
*
1309 _bfd_x86_elf_finish_dynamic_sections (bfd
*output_bfd
,
1310 struct bfd_link_info
*info
)
1312 struct elf_x86_link_hash_table
*htab
;
1313 const struct elf_backend_data
*bed
;
1316 bfd_byte
*dyncon
, *dynconend
;
1317 bfd_size_type sizeof_dyn
;
1319 bed
= get_elf_backend_data (output_bfd
);
1320 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1324 dynobj
= htab
->elf
.dynobj
;
1325 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
1327 /* GOT is always created in setup_gnu_properties. But it may not be
1328 needed. .got.plt section may be needed for static IFUNC. */
1329 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
1331 bfd_vma dynamic_addr
;
1333 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
1336 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
1340 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
1341 = htab
->got_entry_size
;
1343 dynamic_addr
= (sdyn
== NULL
1345 : sdyn
->output_section
->vma
+ sdyn
->output_offset
);
1347 /* Set the first entry in the global offset table to the address
1348 of the dynamic section. Write GOT[1] and GOT[2], needed for
1349 the dynamic linker. */
1350 if (htab
->got_entry_size
== 8)
1352 bfd_put_64 (output_bfd
, dynamic_addr
,
1353 htab
->elf
.sgotplt
->contents
);
1354 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1355 htab
->elf
.sgotplt
->contents
+ 8);
1356 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
1357 htab
->elf
.sgotplt
->contents
+ 8*2);
1361 bfd_put_32 (output_bfd
, dynamic_addr
,
1362 htab
->elf
.sgotplt
->contents
);
1363 bfd_put_32 (output_bfd
, 0,
1364 htab
->elf
.sgotplt
->contents
+ 4);
1365 bfd_put_32 (output_bfd
, 0,
1366 htab
->elf
.sgotplt
->contents
+ 4*2);
1370 if (!htab
->elf
.dynamic_sections_created
)
1373 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
1376 sizeof_dyn
= bed
->s
->sizeof_dyn
;
1377 dyncon
= sdyn
->contents
;
1378 dynconend
= sdyn
->contents
+ sdyn
->size
;
1379 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
1381 Elf_Internal_Dyn dyn
;
1384 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
1389 if (htab
->target_os
== is_vxworks
1390 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
1395 s
= htab
->elf
.sgotplt
;
1396 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
1400 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
1404 s
= htab
->elf
.srelplt
->output_section
;
1405 dyn
.d_un
.d_val
= s
->size
;
1408 case DT_TLSDESC_PLT
:
1410 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1411 + htab
->tlsdesc_plt
;
1414 case DT_TLSDESC_GOT
:
1416 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
1417 + htab
->tlsdesc_got
;
1421 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
1424 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
1425 elf_section_data (htab
->plt_got
->output_section
)
1426 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1428 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
1429 elf_section_data (htab
->plt_second
->output_section
)
1430 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
1432 /* Adjust .eh_frame for .plt section. */
1433 if (htab
->plt_eh_frame
!= NULL
1434 && htab
->plt_eh_frame
->contents
!= NULL
)
1436 if (htab
->elf
.splt
!= NULL
1437 && htab
->elf
.splt
->size
!= 0
1438 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
1439 && htab
->elf
.splt
->output_section
!= NULL
1440 && htab
->plt_eh_frame
->output_section
!= NULL
)
1442 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
1443 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
1444 + htab
->plt_eh_frame
->output_offset
1445 + PLT_FDE_START_OFFSET
;
1446 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1447 htab
->plt_eh_frame
->contents
1448 + PLT_FDE_START_OFFSET
);
1451 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1453 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1455 htab
->plt_eh_frame
->contents
))
1460 /* Adjust .eh_frame for .plt.got section. */
1461 if (htab
->plt_got_eh_frame
!= NULL
1462 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1464 if (htab
->plt_got
!= NULL
1465 && htab
->plt_got
->size
!= 0
1466 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
1467 && htab
->plt_got
->output_section
!= NULL
1468 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
1470 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
1471 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
1472 + htab
->plt_got_eh_frame
->output_offset
1473 + PLT_FDE_START_OFFSET
;
1474 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1475 htab
->plt_got_eh_frame
->contents
1476 + PLT_FDE_START_OFFSET
);
1478 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
1480 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1481 htab
->plt_got_eh_frame
,
1482 htab
->plt_got_eh_frame
->contents
))
1487 /* Adjust .eh_frame for the second PLT section. */
1488 if (htab
->plt_second_eh_frame
!= NULL
1489 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1491 if (htab
->plt_second
!= NULL
1492 && htab
->plt_second
->size
!= 0
1493 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
1494 && htab
->plt_second
->output_section
!= NULL
1495 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
1497 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
1498 bfd_vma eh_frame_start
1499 = (htab
->plt_second_eh_frame
->output_section
->vma
1500 + htab
->plt_second_eh_frame
->output_offset
1501 + PLT_FDE_START_OFFSET
);
1502 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
1503 htab
->plt_second_eh_frame
->contents
1504 + PLT_FDE_START_OFFSET
);
1506 if (htab
->plt_second_eh_frame
->sec_info_type
1507 == SEC_INFO_TYPE_EH_FRAME
)
1509 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
1510 htab
->plt_second_eh_frame
,
1511 htab
->plt_second_eh_frame
->contents
))
1516 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
1517 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
1518 = htab
->got_entry_size
;
1525 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
1526 struct bfd_link_info
*info
)
1528 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
1532 struct elf_link_hash_entry
*tlsbase
;
1534 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
1535 "_TLS_MODULE_BASE_",
1536 FALSE
, FALSE
, FALSE
);
1538 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
1540 struct elf_x86_link_hash_table
*htab
;
1541 struct bfd_link_hash_entry
*bh
= NULL
;
1542 const struct elf_backend_data
*bed
1543 = get_elf_backend_data (output_bfd
);
1545 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1549 if (!(_bfd_generic_link_add_one_symbol
1550 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1551 tls_sec
, 0, NULL
, FALSE
,
1552 bed
->collect
, &bh
)))
1555 htab
->tls_module_base
= bh
;
1557 tlsbase
= (struct elf_link_hash_entry
*)bh
;
1558 tlsbase
->def_regular
= 1;
1559 tlsbase
->other
= STV_HIDDEN
;
1560 tlsbase
->root
.linker_def
= 1;
1561 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1569 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
1570 const Elf_Internal_Sym
*isym
,
1571 bfd_boolean definition
,
1572 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
1576 struct elf_x86_link_hash_entry
*eh
1577 = (struct elf_x86_link_hash_entry
*) h
;
1578 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
1583 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1586 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1587 struct elf_link_hash_entry
*dir
,
1588 struct elf_link_hash_entry
*ind
)
1590 struct elf_x86_link_hash_entry
*edir
, *eind
;
1592 edir
= (struct elf_x86_link_hash_entry
*) dir
;
1593 eind
= (struct elf_x86_link_hash_entry
*) ind
;
1595 if (eind
->dyn_relocs
!= NULL
)
1597 if (edir
->dyn_relocs
!= NULL
)
1599 struct elf_dyn_relocs
**pp
;
1600 struct elf_dyn_relocs
*p
;
1602 /* Add reloc counts against the indirect sym to the direct sym
1603 list. Merge any entries against the same section. */
1604 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1606 struct elf_dyn_relocs
*q
;
1608 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1609 if (q
->sec
== p
->sec
)
1611 q
->pc_count
+= p
->pc_count
;
1612 q
->count
+= p
->count
;
1619 *pp
= edir
->dyn_relocs
;
1622 edir
->dyn_relocs
= eind
->dyn_relocs
;
1623 eind
->dyn_relocs
= NULL
;
1626 if (ind
->root
.type
== bfd_link_hash_indirect
1627 && dir
->got
.refcount
<= 0)
1629 edir
->tls_type
= eind
->tls_type
;
1630 eind
->tls_type
= GOT_UNKNOWN
;
1633 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1634 generate a R_386_COPY reloc. */
1635 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1637 edir
->zero_undefweak
|= eind
->zero_undefweak
;
1639 if (ELIMINATE_COPY_RELOCS
1640 && ind
->root
.type
!= bfd_link_hash_indirect
1641 && dir
->dynamic_adjusted
)
1643 /* If called to transfer flags for a weakdef during processing
1644 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1645 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1646 if (dir
->versioned
!= versioned_hidden
)
1647 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1648 dir
->ref_regular
|= ind
->ref_regular
;
1649 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1650 dir
->needs_plt
|= ind
->needs_plt
;
1651 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1654 _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
->is_weakalias
)
1789 struct elf_link_hash_entry
*def
= weakdef (h
);
1790 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1791 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1792 h
->root
.u
.def
.value
= def
->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
= def
->non_got_ref
;
1799 eh
->needs_copy
= def
->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 /* If we don't find any dynamic relocs in read-only sections,
1842 then we'll be keeping the dynamic relocs and avoiding the copy
1844 if (!readonly_dynrelocs (h
))
1851 /* We must allocate the symbol in our .dynbss section, which will
1852 become part of the .bss section of the executable. There will be
1853 an entry for this symbol in the .dynsym section. The dynamic
1854 object will contain position independent code, so all references
1855 from the dynamic object to this symbol will go through the global
1856 offset table. The dynamic linker will use the .dynsym entry to
1857 determine the address it must put in the global offset table, so
1858 both the dynamic object and the regular object will refer to the
1859 same memory location for the variable. */
1861 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1862 dynamic linker to copy the initial value out of the dynamic object
1863 and into the runtime process image. */
1864 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1866 s
= htab
->elf
.sdynrelro
;
1867 srel
= htab
->elf
.sreldynrelro
;
1871 s
= htab
->elf
.sdynbss
;
1872 srel
= htab
->elf
.srelbss
;
1874 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1876 srel
->size
+= htab
->sizeof_reloc
;
1880 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1884 _bfd_x86_elf_hide_symbol (struct bfd_link_info
*info
,
1885 struct elf_link_hash_entry
*h
,
1886 bfd_boolean force_local
)
1888 if (h
->root
.type
== bfd_link_hash_undefweak
1890 && bfd_link_pie (info
))
1892 /* When there is no dynamic interpreter in PIE, make the undefined
1893 weak symbol dynamic so that PC relative branch to the undefined
1894 weak symbol will land to address 0. */
1895 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
1896 if (h
->plt
.refcount
> 0
1897 || eh
->plt_got
.refcount
> 0)
1901 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1904 /* Return TRUE if a symbol is referenced locally. It is similar to
1905 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It
1906 works in check_relocs. */
1909 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info
*info
,
1910 struct elf_link_hash_entry
*h
)
1912 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
1913 struct elf_x86_link_hash_table
*htab
1914 = (struct elf_x86_link_hash_table
*) info
->hash
;
1916 if (eh
->local_ref
> 1)
1919 if (eh
->local_ref
== 1)
1922 /* Unversioned symbols defined in regular objects can be forced local
1923 by linker version script. A weak undefined symbol is forced local
1925 1. It has non-default visibility. Or
1926 2. When building executable, there is no dynamic linker. Or
1927 3. or "-z nodynamic-undefined-weak" is used.
1929 if (SYMBOL_REFERENCES_LOCAL (info
, h
)
1930 || (h
->root
.type
== bfd_link_hash_undefweak
1931 && (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1932 || (bfd_link_executable (info
)
1933 && htab
->interp
== NULL
)
1934 || info
->dynamic_undefined_weak
== 0))
1935 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
1936 && h
->versioned
== unversioned
1937 && info
->version_info
!= NULL
1938 && bfd_hide_sym_by_version (info
->version_info
,
1939 h
->root
.root
.string
)))
1949 /* Return the section that should be marked against GC for a given
1953 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
1954 struct bfd_link_info
*info
,
1955 Elf_Internal_Rela
*rel
,
1956 struct elf_link_hash_entry
*h
,
1957 Elf_Internal_Sym
*sym
)
1959 /* Compiler should optimize this out. */
1960 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1961 != (unsigned int) R_386_GNU_VTINHERIT
)
1962 || ((unsigned int) R_X86_64_GNU_VTENTRY
1963 != (unsigned int) R_386_GNU_VTENTRY
))
1967 switch (ELF32_R_TYPE (rel
->r_info
))
1969 case R_X86_64_GNU_VTINHERIT
:
1970 case R_X86_64_GNU_VTENTRY
:
1974 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1978 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
1980 bfd_vma offset ATTRIBUTE_UNUSED
,
1983 return got_addr
+ off
;
1987 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
1990 bfd_vma got_addr ATTRIBUTE_UNUSED
)
1992 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
1996 elf_i386_valid_plt_reloc_p (unsigned int type
)
1998 return (type
== R_386_JUMP_SLOT
1999 || type
== R_386_GLOB_DAT
2000 || type
== R_386_IRELATIVE
);
2004 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
2006 return (type
== R_X86_64_JUMP_SLOT
2007 || type
== R_X86_64_GLOB_DAT
2008 || type
== R_X86_64_IRELATIVE
);
2012 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
2016 struct elf_x86_plt plts
[],
2020 long size
, i
, n
, len
;
2022 unsigned int plt_got_offset
, plt_entry_size
;
2024 bfd_byte
*plt_contents
;
2026 arelent
**dynrelbuf
, *p
;
2028 const struct elf_backend_data
*bed
;
2029 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
2031 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
2036 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
2037 if (dynrelbuf
== NULL
)
2040 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
2042 if (dynrelcount
<= 0)
2045 /* Sort the relocs by address. */
2046 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
2047 _bfd_x86_elf_compare_relocs
);
2049 size
= count
* sizeof (asymbol
);
2051 /* Allocate space for @plt suffixes. */
2053 for (i
= 0; i
< dynrelcount
; i
++)
2056 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2058 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
2061 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
2065 bed
= get_elf_backend_data (abfd
);
2067 if (bed
->target_id
== X86_64_ELF_DATA
)
2069 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
2070 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
2074 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
2075 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
2078 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
2080 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
2082 got_addr
= sec
->vma
;
2085 sec
= bfd_get_section_by_name (abfd
, ".got");
2087 got_addr
= sec
->vma
;
2090 if (got_addr
== (bfd_vma
) -1)
2095 /* Check for each PLT section. */
2096 names
= (char *) (s
+ count
);
2099 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2100 if ((plt_contents
= plts
[j
].contents
) != NULL
)
2105 struct elf_x86_plt
*plt_p
= &plts
[j
];
2107 plt_got_offset
= plt_p
->plt_got_offset
;
2108 plt_entry_size
= plt_p
->plt_entry_size
;
2112 if ((plt_p
->type
& plt_lazy
))
2114 /* Skip PLT0 in lazy PLT. */
2116 offset
= plt_entry_size
;
2124 /* Check each PLT entry against dynamic relocations. */
2125 for (; k
< plt_p
->count
; k
++)
2131 /* Get the GOT offset for i386 or the PC-relative offset
2132 for x86-64, a signed 32-bit integer. */
2133 off
= H_GET_32 (abfd
, (plt_contents
+ offset
2135 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
2137 /* Binary search. */
2141 while ((min
+ 1) < max
)
2145 mid
= (min
+ max
) / 2;
2147 if (got_vma
> r
->address
)
2149 else if (got_vma
< r
->address
)
2158 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
2159 if (got_vma
== p
->address
2161 && valid_plt_reloc_p (p
->howto
->type
))
2163 *s
= **p
->sym_ptr_ptr
;
2164 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
2165 set. Since we are defining a symbol, ensure one
2167 if ((s
->flags
& BSF_LOCAL
) == 0)
2168 s
->flags
|= BSF_GLOBAL
;
2169 s
->flags
|= BSF_SYNTHETIC
;
2170 /* This is no longer a section symbol. */
2171 s
->flags
&= ~BSF_SECTION_SYM
;
2173 s
->the_bfd
= plt
->owner
;
2177 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2178 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2184 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2185 names
+= sizeof ("+0x") - 1;
2186 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
2187 for (a
= buf
; *a
== '0'; ++a
)
2190 memcpy (names
, a
, size
);
2193 memcpy (names
, "@plt", sizeof ("@plt"));
2194 names
+= sizeof ("@plt");
2197 /* There should be only one entry in PLT for a given
2198 symbol. Set howto to NULL after processing a PLT
2199 entry to guard against corrupted PLT. */
2202 offset
+= plt_entry_size
;
2206 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
2215 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
2216 if (plts
[j
].contents
!= NULL
)
2217 free (plts
[j
].contents
);
2224 /* Parse x86 GNU properties. */
2226 enum elf_property_kind
2227 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
2228 bfd_byte
*ptr
, unsigned int datasz
)
2234 case GNU_PROPERTY_X86_ISA_1_USED
:
2235 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2236 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2240 ((type
== GNU_PROPERTY_X86_ISA_1_USED
2241 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
2242 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
2243 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
2244 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
2246 return property_corrupt
;
2248 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
2249 /* Combine properties of the same type. */
2250 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
2251 prop
->pr_kind
= property_number
;
2255 return property_ignored
;
2258 return property_number
;
2261 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
2262 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
2263 should be merged with ABFD. */
2266 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
2267 bfd
*abfd ATTRIBUTE_UNUSED
,
2268 elf_property
*aprop
,
2269 elf_property
*bprop
)
2271 unsigned int number
, features
;
2272 bfd_boolean updated
= FALSE
;
2273 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
2277 case GNU_PROPERTY_X86_ISA_1_USED
:
2278 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2279 if (aprop
!= NULL
&& bprop
!= NULL
)
2281 number
= aprop
->u
.number
;
2282 aprop
->u
.number
= number
| bprop
->u
.number
;
2283 updated
= number
!= (unsigned int) aprop
->u
.number
;
2287 /* Return TRUE if APROP is NULL to indicate that BPROP should
2288 be added to ABFD. */
2289 updated
= aprop
== NULL
;
2293 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2294 /* Only one of APROP and BPROP can be NULL:
2295 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2296 2. If APROP is NULL, remove x86 feature.
2297 3. Otherwise, do nothing.
2299 if (aprop
!= NULL
&& bprop
!= NULL
)
2303 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2305 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2306 number
= aprop
->u
.number
;
2307 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2308 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2309 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
2310 updated
= number
!= (unsigned int) aprop
->u
.number
;
2311 /* Remove the property if all feature bits are cleared. */
2312 if (aprop
->u
.number
== 0)
2313 aprop
->pr_kind
= property_remove
;
2319 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2321 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2324 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2325 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2328 number
= aprop
->u
.number
;
2329 aprop
->u
.number
= number
| features
;
2330 updated
= number
!= (unsigned int) aprop
->u
.number
;
2334 bprop
->u
.number
|= features
;
2338 else if (aprop
!= NULL
)
2340 aprop
->pr_kind
= property_remove
;
2347 /* Never should happen. */
2354 /* Set up x86 GNU properties. Return the first relocatable ELF input
2355 with GNU properties if found. Otherwise, return NULL. */
2358 _bfd_x86_elf_link_setup_gnu_properties
2359 (struct bfd_link_info
*info
, struct elf_x86_init_table
*init_table
)
2361 bfd_boolean normal_target
;
2362 bfd_boolean lazy_plt
;
2363 asection
*sec
, *pltsec
;
2365 bfd_boolean use_ibt_plt
;
2366 unsigned int plt_alignment
, features
;
2367 struct elf_x86_link_hash_table
*htab
;
2371 const struct elf_backend_data
*bed
;
2372 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
2373 unsigned int got_align
;
2377 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2379 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2381 /* Find a normal input file with GNU property note. */
2382 for (pbfd
= info
->input_bfds
;
2384 pbfd
= pbfd
->link
.next
)
2385 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
2386 && bfd_count_sections (pbfd
) != 0)
2390 if (elf_properties (pbfd
) != NULL
)
2394 if (ebfd
!= NULL
&& features
)
2396 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2397 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2398 prop
= _bfd_elf_get_property (ebfd
,
2399 GNU_PROPERTY_X86_FEATURE_1_AND
,
2401 prop
->u
.number
|= features
;
2402 prop
->pr_kind
= property_number
;
2404 /* Create the GNU property note section if needed. */
2407 sec
= bfd_make_section_with_flags (ebfd
,
2408 NOTE_GNU_PROPERTY_SECTION_NAME
,
2416 info
->callbacks
->einfo (_("%F%P: failed to create GNU property section\n"));
2418 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
2421 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
2425 elf_section_type (sec
) = SHT_NOTE
;
2429 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
2431 bed
= get_elf_backend_data (info
->output_bfd
);
2433 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2437 htab
->r_info
= init_table
->r_info
;
2438 htab
->r_sym
= init_table
->r_sym
;
2440 if (bfd_link_relocatable (info
))
2443 htab
->plt0_pad_byte
= init_table
->plt0_pad_byte
;
2445 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
2446 if (!use_ibt_plt
&& pbfd
!= NULL
)
2448 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2449 elf_property_list
*p
;
2451 /* The property list is sorted in order of type. */
2452 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
2454 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
2456 use_ibt_plt
= !!(p
->property
.u
.number
2457 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2460 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
2465 dynobj
= htab
->elf
.dynobj
;
2467 /* Set htab->elf.dynobj here so that there is no need to check and
2468 set it in check_relocs. */
2473 htab
->elf
.dynobj
= pbfd
;
2480 /* Find a normal input file to hold linker created
2482 for (abfd
= info
->input_bfds
;
2484 abfd
= abfd
->link
.next
)
2485 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2487 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
2489 htab
->elf
.dynobj
= abfd
;
2496 /* Return if there are no normal input files. */
2500 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2501 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2502 canonical function address. */
2503 htab
->plt
.has_plt0
= 1;
2504 normal_target
= htab
->target_os
== is_normal
;
2510 htab
->lazy_plt
= init_table
->lazy_ibt_plt
;
2511 htab
->non_lazy_plt
= init_table
->non_lazy_ibt_plt
;
2515 htab
->lazy_plt
= init_table
->lazy_plt
;
2516 htab
->non_lazy_plt
= init_table
->non_lazy_plt
;
2521 htab
->lazy_plt
= init_table
->lazy_plt
;
2522 htab
->non_lazy_plt
= NULL
;
2525 pltsec
= htab
->elf
.splt
;
2527 /* If the non-lazy PLT is available, use it for all PLT entries if
2528 there are no PLT0 or no .plt section. */
2529 if (htab
->non_lazy_plt
!= NULL
2530 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
2533 if (bfd_link_pic (info
))
2534 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
2536 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
2537 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
2538 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
2539 htab
->plt
.plt_got_insn_size
2540 = htab
->non_lazy_plt
->plt_got_insn_size
;
2541 htab
->plt
.eh_frame_plt_size
2542 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2543 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
2548 if (bfd_link_pic (info
))
2550 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
2551 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
2555 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
2556 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
2558 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
2559 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
2560 htab
->plt
.plt_got_insn_size
2561 = htab
->lazy_plt
->plt_got_insn_size
;
2562 htab
->plt
.eh_frame_plt_size
2563 = htab
->lazy_plt
->eh_frame_plt_size
;
2564 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
2567 if (htab
->target_os
== is_vxworks
2568 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
2571 info
->callbacks
->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
2575 /* Since create_dynamic_sections isn't always called, but GOT
2576 relocations need GOT relocations, create them here so that we
2577 don't need to do it in check_relocs. */
2578 if (htab
->elf
.sgot
== NULL
2579 && !_bfd_elf_create_got_section (dynobj
, info
))
2580 info
->callbacks
->einfo (_("%F%P: failed to create GOT sections\n"));
2582 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
2584 /* Align .got and .got.plt sections to their entry size. Do it here
2585 instead of in create_dynamic_sections so that they are always
2586 properly aligned even if create_dynamic_sections isn't called. */
2587 sec
= htab
->elf
.sgot
;
2588 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2589 goto error_alignment
;
2591 sec
= htab
->elf
.sgotplt
;
2592 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2593 goto error_alignment
;
2595 /* Create the ifunc sections here so that check_relocs can be
2597 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
2598 info
->callbacks
->einfo (_("%F%P: failed to create ifunc sections\n"));
2600 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
2604 /* Whe creating executable, set the contents of the .interp
2605 section to the interpreter. */
2606 if (bfd_link_executable (info
) && !info
->nointerp
)
2608 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
2611 s
->size
= htab
->dynamic_interpreter_size
;
2612 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2616 /* Don't change PLT section alignment for NaCl since it uses
2617 64-byte PLT entry and sets PLT section alignment to 32
2618 bytes. Don't create additional PLT sections for NaCl. */
2621 flagword pltflags
= (bed
->dynamic_sec_flags
2626 unsigned int non_lazy_plt_alignment
2627 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
2630 if (!bfd_set_section_alignment (sec
->owner
, sec
,
2632 goto error_alignment
;
2634 /* Create the GOT procedure linkage table. */
2635 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2639 info
->callbacks
->einfo (_("%F%P: failed to create GOT PLT section\n"));
2641 if (!bfd_set_section_alignment (dynobj
, sec
,
2642 non_lazy_plt_alignment
))
2643 goto error_alignment
;
2645 htab
->plt_got
= sec
;
2653 /* Create the second PLT for Intel IBT support. IBT
2654 PLT is supported only for non-NaCl target and is
2655 is needed only for lazy binding. */
2656 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2660 info
->callbacks
->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
2662 if (!bfd_set_section_alignment (dynobj
, sec
,
2664 goto error_alignment
;
2666 else if (info
->bndplt
&& ABI_64_P (dynobj
))
2668 /* Create the second PLT for Intel MPX support. MPX
2669 PLT is supported only for non-NaCl target in 64-bit
2670 mode and is needed only for lazy binding. */
2671 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2675 info
->callbacks
->einfo (_("%F%P: failed to create BND PLT section\n"));
2677 if (!bfd_set_section_alignment (dynobj
, sec
,
2678 non_lazy_plt_alignment
))
2679 goto error_alignment
;
2682 htab
->plt_second
= sec
;
2686 if (!info
->no_ld_generated_unwind_info
)
2688 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
2689 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2690 | SEC_LINKER_CREATED
);
2692 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2696 info
->callbacks
->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
2698 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2699 goto error_alignment
;
2701 htab
->plt_eh_frame
= sec
;
2703 if (htab
->plt_got
!= NULL
)
2705 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2709 info
->callbacks
->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
2711 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2712 goto error_alignment
;
2714 htab
->plt_got_eh_frame
= sec
;
2717 if (htab
->plt_second
!= NULL
)
2719 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2723 info
->callbacks
->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
2725 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2726 goto error_alignment
;
2728 htab
->plt_second_eh_frame
= sec
;
2735 /* The .iplt section is used for IFUNC symbols in static
2737 sec
= htab
->elf
.iplt
;
2739 && !bfd_set_section_alignment (sec
->owner
, sec
,
2741 goto error_alignment
;