1 /* x86 specific support for ELF
2 Copyright (C) 2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
21 #include "elfxx-x86.h"
22 #include "elf-vxworks.h"
25 #include "elf/x86-64.h"
27 /* The name of the dynamic interpreter. This is put in the .interp
30 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
31 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
32 #define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
35 _bfd_x86_elf_mkobject (bfd
*abfd
)
37 return bfd_elf_allocate_object (abfd
,
38 sizeof (struct elf_x86_obj_tdata
),
39 get_elf_backend_data (abfd
)->target_id
);
42 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
43 executables. Rather than setting it to the beginning of the TLS
44 section, we have to set it to the end. This function may be called
45 multiple times, it is idempotent. */
48 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info
*info
)
50 struct elf_x86_link_hash_table
*htab
;
51 struct bfd_link_hash_entry
*base
;
52 const struct elf_backend_data
*bed
;
54 if (!bfd_link_executable (info
))
57 bed
= get_elf_backend_data (info
->output_bfd
);
58 htab
= elf_x86_hash_table (info
, bed
->target_id
);
62 base
= htab
->tls_module_base
;
66 base
->u
.def
.value
= htab
->elf
.tls_size
;
69 /* Return the base VMA address which should be subtracted from real addresses
70 when resolving @dtpoff relocation.
71 This is PT_TLS segment p_vaddr. */
74 _bfd_x86_elf_dtpoff_base (struct bfd_link_info
*info
)
76 /* If tls_sec is NULL, we should have signalled an error already. */
77 if (elf_hash_table (info
)->tls_sec
== NULL
)
79 return elf_hash_table (info
)->tls_sec
->vma
;
82 /* Allocate space in .plt, .got and associated reloc sections for
86 elf_x86_allocate_dynrelocs (struct elf_link_hash_entry
*h
,
89 struct bfd_link_info
*info
;
90 struct elf_x86_link_hash_table
*htab
;
91 struct elf_x86_link_hash_entry
*eh
;
92 struct elf_dyn_relocs
*p
;
93 unsigned int plt_entry_size
;
94 bfd_boolean resolved_to_zero
;
95 const struct elf_backend_data
*bed
;
97 if (h
->root
.type
== bfd_link_hash_indirect
)
100 eh
= (struct elf_x86_link_hash_entry
*) h
;
102 info
= (struct bfd_link_info
*) inf
;
103 bed
= get_elf_backend_data (info
->output_bfd
);
104 htab
= elf_x86_hash_table (info
, bed
->target_id
);
108 plt_entry_size
= htab
->plt
.plt_entry_size
;
110 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
115 /* Clear the reference count of function pointer relocations if
116 symbol isn't a normal function. */
117 if (h
->type
!= STT_FUNC
)
118 eh
->func_pointer_refcount
= 0;
120 /* We can't use the GOT PLT if pointer equality is needed since
121 finish_dynamic_symbol won't clear symbol value and the dynamic
122 linker won't update the GOT slot. We will get into an infinite
124 if (htab
->plt_got
!= NULL
125 && h
->type
!= STT_GNU_IFUNC
126 && !h
->pointer_equality_needed
127 && h
->plt
.refcount
> 0
128 && h
->got
.refcount
> 0)
130 /* Don't use the regular PLT if there are both GOT and GOTPLT
132 h
->plt
.offset
= (bfd_vma
) -1;
134 /* Use the GOT PLT. */
135 eh
->plt_got
.refcount
= 1;
138 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
139 here if it is defined and referenced in a non-shared object. */
140 if (h
->type
== STT_GNU_IFUNC
143 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
144 &htab
->readonly_dynrelocs_against_ifunc
,
148 htab
->got_entry_size
,
151 asection
*s
= htab
->plt_second
;
152 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
154 /* Use the second PLT section if it is created. */
155 eh
->plt_second
.offset
= s
->size
;
157 /* Make room for this entry in the second PLT section. */
158 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
166 /* Don't create the PLT entry if there are only function pointer
167 relocations which can be resolved at run-time. */
168 else if (htab
->elf
.dynamic_sections_created
169 && (h
->plt
.refcount
> eh
->func_pointer_refcount
170 || eh
->plt_got
.refcount
> 0))
172 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
174 /* Clear the reference count of function pointer relocations
176 eh
->func_pointer_refcount
= 0;
178 /* Make sure this symbol is output as a dynamic symbol.
179 Undefined weak syms won't yet be marked as dynamic. */
183 && h
->root
.type
== bfd_link_hash_undefweak
)
185 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
189 if (bfd_link_pic (info
)
190 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
192 asection
*s
= htab
->elf
.splt
;
193 asection
*second_s
= htab
->plt_second
;
194 asection
*got_s
= htab
->plt_got
;
196 /* If this is the first .plt entry, make room for the special
197 first entry. The .plt section is used by prelink to undo
198 prelinking for dynamic relocations. */
200 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
203 eh
->plt_got
.offset
= got_s
->size
;
206 h
->plt
.offset
= s
->size
;
208 eh
->plt_second
.offset
= second_s
->size
;
211 /* If this symbol is not defined in a regular file, and we are
212 not generating a shared library, then set the symbol to this
213 location in the .plt. This is required to make function
214 pointers compare as equal between the normal executable and
215 the shared library. */
216 if (! bfd_link_pic (info
)
221 /* We need to make a call to the entry of the GOT PLT
222 instead of regular PLT entry. */
223 h
->root
.u
.def
.section
= got_s
;
224 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
230 /* We need to make a call to the entry of the
231 second PLT instead of regular PLT entry. */
232 h
->root
.u
.def
.section
= second_s
;
233 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
237 h
->root
.u
.def
.section
= s
;
238 h
->root
.u
.def
.value
= h
->plt
.offset
;
243 /* Make room for this entry. */
245 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
248 s
->size
+= plt_entry_size
;
250 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
252 /* We also need to make an entry in the .got.plt section,
253 which will be placed in the .got section by the linker
255 htab
->elf
.sgotplt
->size
+= htab
->got_entry_size
;
257 /* There should be no PLT relocation against resolved
258 undefined weak symbol in executable. */
259 if (!resolved_to_zero
)
261 /* We also need to make an entry in the .rel.plt
263 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
264 htab
->elf
.srelplt
->reloc_count
++;
268 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
270 /* VxWorks has a second set of relocations for each PLT entry
271 in executables. They go in a separate relocation section,
272 which is processed by the kernel loader. */
274 /* There are two relocations for the initial PLT entry: an
275 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
276 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
278 asection
*srelplt2
= htab
->srelplt2
;
279 if (h
->plt
.offset
== plt_entry_size
)
280 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
282 /* There are two extra relocations for each subsequent PLT entry:
283 an R_386_32 relocation for the GOT entry, and an R_386_32
284 relocation for the PLT entry. */
286 srelplt2
->size
+= (htab
->sizeof_reloc
* 2);
291 eh
->plt_got
.offset
= (bfd_vma
) -1;
292 h
->plt
.offset
= (bfd_vma
) -1;
298 eh
->plt_got
.offset
= (bfd_vma
) -1;
299 h
->plt
.offset
= (bfd_vma
) -1;
303 eh
->tlsdesc_got
= (bfd_vma
) -1;
305 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
306 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For
307 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
308 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
309 if (h
->got
.refcount
> 0
310 && bfd_link_executable (info
)
312 && (elf_x86_hash_entry (h
)->tls_type
& GOT_TLS_IE
))
313 h
->got
.offset
= (bfd_vma
) -1;
314 else if (h
->got
.refcount
> 0)
318 int tls_type
= elf_x86_hash_entry (h
)->tls_type
;
320 /* Make sure this symbol is output as a dynamic symbol.
321 Undefined weak syms won't yet be marked as dynamic. */
325 && h
->root
.type
== bfd_link_hash_undefweak
)
327 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
332 if (GOT_TLS_GDESC_P (tls_type
))
334 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
335 - elf_x86_compute_jump_table_size (htab
);
336 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
337 h
->got
.offset
= (bfd_vma
) -2;
339 if (! GOT_TLS_GDESC_P (tls_type
)
340 || GOT_TLS_GD_P (tls_type
))
342 h
->got
.offset
= s
->size
;
343 s
->size
+= htab
->got_entry_size
;
344 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
346 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
347 s
->size
+= htab
->got_entry_size
;
349 dyn
= htab
->elf
.dynamic_sections_created
;
350 /* R_386_TLS_IE_32 needs one dynamic relocation,
351 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
352 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
353 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
354 symbol and two if global. No dynamic relocation against
355 resolved undefined weak symbol in executable. */
356 if (tls_type
== GOT_TLS_IE_BOTH
)
357 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
358 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
359 || (tls_type
& GOT_TLS_IE
))
360 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
361 else if (GOT_TLS_GD_P (tls_type
))
362 htab
->elf
.srelgot
->size
+= 2 * htab
->sizeof_reloc
;
363 else if (! GOT_TLS_GDESC_P (tls_type
)
364 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
365 && !resolved_to_zero
)
366 || h
->root
.type
!= bfd_link_hash_undefweak
)
367 && (bfd_link_pic (info
)
368 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
369 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
370 if (GOT_TLS_GDESC_P (tls_type
))
371 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
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
->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;
683 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
684 for local symbol so that we can handle local STT_GNU_IFUNC symbols
685 as global symbol. We reuse indx and dynstr_index for local symbol
686 hash since they aren't used by global symbols in this backend. */
689 _bfd_x86_elf_local_htab_hash (const void *ptr
)
691 struct elf_link_hash_entry
*h
692 = (struct elf_link_hash_entry
*) ptr
;
693 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
696 /* Compare local hash entries. */
699 _bfd_x86_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
701 struct elf_link_hash_entry
*h1
702 = (struct elf_link_hash_entry
*) ptr1
;
703 struct elf_link_hash_entry
*h2
704 = (struct elf_link_hash_entry
*) ptr2
;
706 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
709 /* Destroy an x86 ELF linker hash table. */
712 elf_x86_link_hash_table_free (bfd
*obfd
)
714 struct elf_x86_link_hash_table
*htab
715 = (struct elf_x86_link_hash_table
*) obfd
->link
.hash
;
717 if (htab
->loc_hash_table
)
718 htab_delete (htab
->loc_hash_table
);
719 if (htab
->loc_hash_memory
)
720 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
721 _bfd_elf_link_hash_table_free (obfd
);
725 elf_i386_is_reloc_section (const char *secname
)
727 return CONST_STRNEQ (secname
, ".rel");
732 elf_x86_64_is_reloc_section (const char *secname
)
734 return CONST_STRNEQ (secname
, ".rela");
738 /* Create an x86 ELF linker hash table. */
740 struct bfd_link_hash_table
*
741 _bfd_x86_elf_link_hash_table_create (bfd
*abfd
)
743 struct elf_x86_link_hash_table
*ret
;
744 const struct elf_backend_data
*bed
;
745 bfd_size_type amt
= sizeof (struct elf_x86_link_hash_table
);
747 ret
= (struct elf_x86_link_hash_table
*) bfd_zmalloc (amt
);
751 bed
= get_elf_backend_data (abfd
);
752 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
753 _bfd_x86_elf_link_hash_newfunc
,
754 sizeof (struct elf_x86_link_hash_entry
),
762 /* NB: If BFD64 isn't defined, only i386 will be supported. */
763 if (bed
->target_id
== X86_64_ELF_DATA
)
765 ret
->convert_load
= _bfd_x86_64_elf_convert_load
;
766 ret
->is_reloc_section
= elf_x86_64_is_reloc_section
;
767 ret
->dt_reloc
= DT_RELA
;
768 ret
->dt_reloc_sz
= DT_RELASZ
;
769 ret
->dt_reloc_ent
= DT_RELAENT
;
770 ret
->got_entry_size
= 8;
774 ret
->r_info
= elf64_r_info
;
775 ret
->r_sym
= elf64_r_sym
;
776 ret
->sizeof_reloc
= sizeof (Elf64_External_Rela
);
777 ret
->pointer_r_type
= R_X86_64_64
;
778 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
779 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
780 ret
->tls_get_addr
= "__tls_get_addr";
785 ret
->r_info
= elf32_r_info
;
786 ret
->r_sym
= elf32_r_sym
;
787 if (bed
->target_id
== X86_64_ELF_DATA
)
789 ret
->sizeof_reloc
= sizeof (Elf32_External_Rela
);
790 ret
->pointer_r_type
= R_X86_64_32
;
791 ret
->dynamic_interpreter
= ELFX32_DYNAMIC_INTERPRETER
;
792 ret
->dynamic_interpreter_size
793 = sizeof ELFX32_DYNAMIC_INTERPRETER
;
794 ret
->tls_get_addr
= "__tls_get_addr";
798 ret
->convert_load
= _bfd_i386_elf_convert_load
;
799 ret
->is_reloc_section
= elf_i386_is_reloc_section
;
800 ret
->dt_reloc
= DT_REL
;
801 ret
->dt_reloc_sz
= DT_RELSZ
;
802 ret
->dt_reloc_ent
= DT_RELENT
;
803 ret
->sizeof_reloc
= sizeof (Elf32_External_Rel
);
804 ret
->got_entry_size
= 4;
805 ret
->pointer_r_type
= R_386_32
;
806 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
807 ret
->dynamic_interpreter_size
808 = sizeof ELF32_DYNAMIC_INTERPRETER
;
809 ret
->tls_get_addr
= "___tls_get_addr";
812 ret
->target_id
= bed
->target_id
;
814 ret
->loc_hash_table
= htab_try_create (1024,
815 _bfd_x86_elf_local_htab_hash
,
816 _bfd_x86_elf_local_htab_eq
,
818 ret
->loc_hash_memory
= objalloc_create ();
819 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
821 elf_x86_link_hash_table_free (abfd
);
824 ret
->elf
.root
.hash_table_free
= elf_x86_link_hash_table_free
;
826 return &ret
->elf
.root
;
829 /* Sort relocs into address order. */
832 _bfd_x86_elf_compare_relocs (const void *ap
, const void *bp
)
834 const arelent
*a
= * (const arelent
**) ap
;
835 const arelent
*b
= * (const arelent
**) bp
;
837 if (a
->address
> b
->address
)
839 else if (a
->address
< b
->address
)
846 _bfd_x86_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
848 if (!bfd_link_relocatable (info
))
850 /* Check for __tls_get_addr reference. */
851 struct elf_x86_link_hash_table
*htab
;
852 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
853 htab
= elf_x86_hash_table (info
, bed
->target_id
);
856 struct elf_link_hash_entry
*h
857 = elf_link_hash_lookup (elf_hash_table (info
),
859 FALSE
, FALSE
, FALSE
);
861 ((struct elf_x86_link_hash_entry
*) h
)->tls_get_addr
= 1;
865 /* Invoke the regular ELF backend linker to do all the work. */
866 return _bfd_elf_link_check_relocs (abfd
, info
);
869 /* Set the sizes of the dynamic sections. */
872 _bfd_x86_elf_size_dynamic_sections (bfd
*output_bfd
,
873 struct bfd_link_info
*info
)
875 struct elf_x86_link_hash_table
*htab
;
880 const struct elf_backend_data
*bed
881 = get_elf_backend_data (output_bfd
);
883 htab
= elf_x86_hash_table (info
, bed
->target_id
);
886 dynobj
= htab
->elf
.dynobj
;
890 /* Set up .got offsets for local syms, and space for local dynamic
892 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
894 bfd_signed_vma
*local_got
;
895 bfd_signed_vma
*end_local_got
;
896 char *local_tls_type
;
897 bfd_vma
*local_tlsdesc_gotent
;
898 bfd_size_type locsymcount
;
899 Elf_Internal_Shdr
*symtab_hdr
;
902 if (! is_x86_elf (ibfd
, htab
))
905 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
907 struct elf_dyn_relocs
*p
;
909 if (!htab
->convert_load (ibfd
, s
, info
))
912 for (p
= ((struct elf_dyn_relocs
*)
913 elf_section_data (s
)->local_dynrel
);
917 if (!bfd_is_abs_section (p
->sec
)
918 && bfd_is_abs_section (p
->sec
->output_section
))
920 /* Input section has been discarded, either because
921 it is a copy of a linkonce section or due to
922 linker script /DISCARD/, so we'll be discarding
925 else if (htab
->is_vxworks
926 && strcmp (p
->sec
->output_section
->name
,
929 /* Relocations in vxworks .tls_vars sections are
930 handled specially by the loader. */
932 else if (p
->count
!= 0)
934 srel
= elf_section_data (p
->sec
)->sreloc
;
935 srel
->size
+= p
->count
* htab
->sizeof_reloc
;
936 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
937 && (info
->flags
& DF_TEXTREL
) == 0)
939 info
->flags
|= DF_TEXTREL
;
940 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
941 || info
->error_textrel
)
942 /* xgettext:c-format */
943 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
944 p
->sec
->owner
, p
->sec
);
950 local_got
= elf_local_got_refcounts (ibfd
);
954 symtab_hdr
= &elf_symtab_hdr (ibfd
);
955 locsymcount
= symtab_hdr
->sh_info
;
956 end_local_got
= local_got
+ locsymcount
;
957 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
958 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
960 srel
= htab
->elf
.srelgot
;
961 for (; local_got
< end_local_got
;
962 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
964 *local_tlsdesc_gotent
= (bfd_vma
) -1;
967 if (GOT_TLS_GDESC_P (*local_tls_type
))
969 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
970 - elf_x86_compute_jump_table_size (htab
);
971 htab
->elf
.sgotplt
->size
+= 2 * htab
->got_entry_size
;
972 *local_got
= (bfd_vma
) -2;
974 if (! GOT_TLS_GDESC_P (*local_tls_type
)
975 || GOT_TLS_GD_P (*local_tls_type
))
977 *local_got
= s
->size
;
978 s
->size
+= htab
->got_entry_size
;
979 if (GOT_TLS_GD_P (*local_tls_type
)
980 || *local_tls_type
== GOT_TLS_IE_BOTH
)
981 s
->size
+= htab
->got_entry_size
;
983 if (bfd_link_pic (info
)
984 || GOT_TLS_GD_ANY_P (*local_tls_type
)
985 || (*local_tls_type
& GOT_TLS_IE
))
987 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
988 srel
->size
+= 2 * htab
->sizeof_reloc
;
989 else if (GOT_TLS_GD_P (*local_tls_type
)
990 || ! GOT_TLS_GDESC_P (*local_tls_type
))
991 srel
->size
+= htab
->sizeof_reloc
;
992 if (GOT_TLS_GDESC_P (*local_tls_type
))
994 htab
->elf
.srelplt
->size
+= htab
->sizeof_reloc
;
995 if (bed
->target_id
== X86_64_ELF_DATA
)
996 htab
->tlsdesc_plt
= (bfd_vma
) -1;
1001 *local_got
= (bfd_vma
) -1;
1005 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
1007 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1008 or R_X86_64_TLSLD relocs. */
1009 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
1010 htab
->elf
.sgot
->size
+= 2 * htab
->got_entry_size
;
1011 htab
->elf
.srelgot
->size
+= htab
->sizeof_reloc
;
1014 htab
->tls_ld_or_ldm_got
.offset
= -1;
1016 /* Allocate global sym .plt and .got entries, and space for global
1017 sym dynamic relocs. */
1018 elf_link_hash_traverse (&htab
->elf
, elf_x86_allocate_dynrelocs
,
1021 /* Allocate .plt and .got entries, and space for local symbols. */
1022 htab_traverse (htab
->loc_hash_table
, elf_x86_allocate_local_dynreloc
,
1025 /* For every jump slot reserved in the sgotplt, reloc_count is
1026 incremented. However, when we reserve space for TLS descriptors,
1027 it's not incremented, so in order to compute the space reserved
1028 for them, it suffices to multiply the reloc count by the jump
1031 PR ld/13302: We start next_irelative_index at the end of .rela.plt
1032 so that R_{386,X86_64}_IRELATIVE entries come last. */
1033 if (htab
->elf
.srelplt
)
1035 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
1036 htab
->sgotplt_jump_table_size
1037 = elf_x86_compute_jump_table_size (htab
);
1038 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
1040 else if (htab
->elf
.irelplt
)
1041 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1043 if (htab
->tlsdesc_plt
)
1045 /* NB: tlsdesc_plt is set only for x86-64. If we're not using
1046 lazy TLS relocations, don't generate the PLT and GOT entries
1048 if ((info
->flags
& DF_BIND_NOW
))
1049 htab
->tlsdesc_plt
= 0;
1052 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
1053 htab
->elf
.sgot
->size
+= htab
->got_entry_size
;
1054 /* Reserve room for the initial entry.
1055 FIXME: we could probably do away with it in this case. */
1056 if (htab
->elf
.splt
->size
== 0)
1057 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
1058 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
1059 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
1063 if (htab
->elf
.sgotplt
)
1065 /* Don't allocate .got.plt section if there are no GOT nor PLT
1066 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
1067 if ((htab
->elf
.hgot
== NULL
1068 || !htab
->elf
.hgot
->ref_regular_nonweak
)
1069 && (htab
->elf
.sgotplt
->size
== bed
->got_header_size
)
1070 && (htab
->elf
.splt
== NULL
1071 || htab
->elf
.splt
->size
== 0)
1072 && (htab
->elf
.sgot
== NULL
1073 || htab
->elf
.sgot
->size
== 0)
1074 && (htab
->elf
.iplt
== NULL
1075 || htab
->elf
.iplt
->size
== 0)
1076 && (htab
->elf
.igotplt
== NULL
1077 || htab
->elf
.igotplt
->size
== 0))
1078 htab
->elf
.sgotplt
->size
= 0;
1081 if (_bfd_elf_eh_frame_present (info
))
1083 if (htab
->plt_eh_frame
!= NULL
1084 && htab
->elf
.splt
!= NULL
1085 && htab
->elf
.splt
->size
!= 0
1086 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
1087 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
1089 if (htab
->plt_got_eh_frame
!= NULL
1090 && htab
->plt_got
!= NULL
1091 && htab
->plt_got
->size
!= 0
1092 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
1093 htab
->plt_got_eh_frame
->size
1094 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1096 /* Unwind info for the second PLT and .plt.got sections are
1098 if (htab
->plt_second_eh_frame
!= NULL
1099 && htab
->plt_second
!= NULL
1100 && htab
->plt_second
->size
!= 0
1101 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
1102 htab
->plt_second_eh_frame
->size
1103 = htab
->non_lazy_plt
->eh_frame_plt_size
;
1106 /* We now have determined the sizes of the various dynamic sections.
1107 Allocate memory for them. */
1109 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1111 bfd_boolean strip_section
= TRUE
;
1113 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1116 if (s
== htab
->elf
.splt
1117 || s
== htab
->elf
.sgot
)
1119 /* Strip this section if we don't need it; see the
1121 /* We'd like to strip these sections if they aren't needed, but if
1122 we've exported dynamic symbols from them we must leave them.
1123 It's too late to tell BFD to get rid of the symbols. */
1125 if (htab
->elf
.hplt
!= NULL
)
1126 strip_section
= FALSE
;
1128 else if (s
== htab
->elf
.sgotplt
1129 || s
== htab
->elf
.iplt
1130 || s
== htab
->elf
.igotplt
1131 || s
== htab
->plt_second
1132 || s
== htab
->plt_got
1133 || s
== htab
->plt_eh_frame
1134 || s
== htab
->plt_got_eh_frame
1135 || s
== htab
->plt_second_eh_frame
1136 || s
== htab
->elf
.sdynbss
1137 || s
== htab
->elf
.sdynrelro
)
1139 /* Strip these too. */
1141 else if (htab
->is_reloc_section (bfd_get_section_name (dynobj
, s
)))
1144 && s
!= htab
->elf
.srelplt
1145 && s
!= htab
->srelplt2
)
1148 /* We use the reloc_count field as a counter if we need
1149 to copy relocs into the output file. */
1150 if (s
!= htab
->elf
.srelplt
)
1155 /* It's not one of our sections, so don't allocate space. */
1161 /* If we don't need this section, strip it from the
1162 output file. This is mostly to handle .rel.bss and
1163 .rel.plt. We must create both sections in
1164 create_dynamic_sections, because they must be created
1165 before the linker maps input sections to output
1166 sections. The linker does that before
1167 adjust_dynamic_symbol is called, and it is that
1168 function which decides whether anything needs to go
1169 into these sections. */
1171 s
->flags
|= SEC_EXCLUDE
;
1175 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1178 /* Allocate memory for the section contents. We use bfd_zalloc
1179 here in case unused entries are not reclaimed before the
1180 section's contents are written out. This should not happen,
1181 but this way if it does, we get a R_386_NONE or R_X86_64_NONE
1182 reloc instead of garbage. */
1183 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
1184 if (s
->contents
== NULL
)
1188 if (htab
->plt_eh_frame
!= NULL
1189 && htab
->plt_eh_frame
->contents
!= NULL
)
1191 memcpy (htab
->plt_eh_frame
->contents
,
1192 htab
->plt
.eh_frame_plt
,
1193 htab
->plt_eh_frame
->size
);
1194 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
1195 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
1198 if (htab
->plt_got_eh_frame
!= NULL
1199 && htab
->plt_got_eh_frame
->contents
!= NULL
)
1201 memcpy (htab
->plt_got_eh_frame
->contents
,
1202 htab
->non_lazy_plt
->eh_frame_plt
,
1203 htab
->plt_got_eh_frame
->size
);
1204 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
1205 (htab
->plt_got_eh_frame
->contents
1206 + PLT_FDE_LEN_OFFSET
));
1209 if (htab
->plt_second_eh_frame
!= NULL
1210 && htab
->plt_second_eh_frame
->contents
!= NULL
)
1212 memcpy (htab
->plt_second_eh_frame
->contents
,
1213 htab
->non_lazy_plt
->eh_frame_plt
,
1214 htab
->plt_second_eh_frame
->size
);
1215 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
1216 (htab
->plt_second_eh_frame
->contents
1217 + PLT_FDE_LEN_OFFSET
));
1220 if (htab
->elf
.dynamic_sections_created
)
1222 /* Add some entries to the .dynamic section. We fill in the
1223 values later, in elf_{i386,x86_64}_finish_dynamic_sections,
1224 but we must add the entries now so that we get the correct
1225 size for the .dynamic section. The DT_DEBUG entry is filled
1226 in by the dynamic linker and used by the debugger. */
1227 #define add_dynamic_entry(TAG, VAL) \
1228 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1230 if (bfd_link_executable (info
))
1232 if (!add_dynamic_entry (DT_DEBUG
, 0))
1236 if (htab
->elf
.splt
->size
!= 0)
1238 /* DT_PLTGOT is used by prelink even if there is no PLT
1240 if (!add_dynamic_entry (DT_PLTGOT
, 0))
1244 if (htab
->elf
.srelplt
->size
!= 0)
1246 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1247 || !add_dynamic_entry (DT_PLTREL
, htab
->dt_reloc
)
1248 || !add_dynamic_entry (DT_JMPREL
, 0))
1252 if (htab
->tlsdesc_plt
1253 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
1254 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
1259 if (!add_dynamic_entry (htab
->dt_reloc
, 0)
1260 || !add_dynamic_entry (htab
->dt_reloc_sz
, 0)
1261 || !add_dynamic_entry (htab
->dt_reloc_ent
,
1262 htab
->sizeof_reloc
))
1265 /* If any dynamic relocs apply to a read-only section,
1266 then we need a DT_TEXTREL entry. */
1267 if ((info
->flags
& DF_TEXTREL
) == 0)
1268 elf_link_hash_traverse (&htab
->elf
,
1269 _bfd_x86_elf_readonly_dynrelocs
,
1272 if ((info
->flags
& DF_TEXTREL
) != 0)
1274 if (htab
->readonly_dynrelocs_against_ifunc
)
1276 info
->callbacks
->einfo
1277 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
1278 bfd_set_error (bfd_error_bad_value
);
1282 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1286 if (htab
->is_vxworks
1287 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
1290 #undef add_dynamic_entry
1296 _bfd_x86_elf_always_size_sections (bfd
*output_bfd
,
1297 struct bfd_link_info
*info
)
1299 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
1303 struct elf_link_hash_entry
*tlsbase
;
1305 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
1306 "_TLS_MODULE_BASE_",
1307 FALSE
, FALSE
, FALSE
);
1309 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
1311 struct elf_x86_link_hash_table
*htab
;
1312 struct bfd_link_hash_entry
*bh
= NULL
;
1313 const struct elf_backend_data
*bed
1314 = get_elf_backend_data (output_bfd
);
1316 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1320 if (!(_bfd_generic_link_add_one_symbol
1321 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1322 tls_sec
, 0, NULL
, FALSE
,
1323 bed
->collect
, &bh
)))
1326 htab
->tls_module_base
= bh
;
1328 tlsbase
= (struct elf_link_hash_entry
*)bh
;
1329 tlsbase
->def_regular
= 1;
1330 tlsbase
->other
= STV_HIDDEN
;
1331 tlsbase
->root
.linker_def
= 1;
1332 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1340 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
1341 const Elf_Internal_Sym
*isym
,
1342 bfd_boolean definition
,
1343 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
1347 struct elf_x86_link_hash_entry
*eh
1348 = (struct elf_x86_link_hash_entry
*) h
;
1349 eh
->def_protected
= (ELF_ST_VISIBILITY (isym
->st_other
)
1354 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1357 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1358 struct elf_link_hash_entry
*dir
,
1359 struct elf_link_hash_entry
*ind
)
1361 struct elf_x86_link_hash_entry
*edir
, *eind
;
1363 edir
= (struct elf_x86_link_hash_entry
*) dir
;
1364 eind
= (struct elf_x86_link_hash_entry
*) ind
;
1366 if (eind
->dyn_relocs
!= NULL
)
1368 if (edir
->dyn_relocs
!= NULL
)
1370 struct elf_dyn_relocs
**pp
;
1371 struct elf_dyn_relocs
*p
;
1373 /* Add reloc counts against the indirect sym to the direct sym
1374 list. Merge any entries against the same section. */
1375 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1377 struct elf_dyn_relocs
*q
;
1379 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1380 if (q
->sec
== p
->sec
)
1382 q
->pc_count
+= p
->pc_count
;
1383 q
->count
+= p
->count
;
1390 *pp
= edir
->dyn_relocs
;
1393 edir
->dyn_relocs
= eind
->dyn_relocs
;
1394 eind
->dyn_relocs
= NULL
;
1397 if (ind
->root
.type
== bfd_link_hash_indirect
1398 && dir
->got
.refcount
<= 0)
1400 edir
->tls_type
= eind
->tls_type
;
1401 eind
->tls_type
= GOT_UNKNOWN
;
1404 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1405 generate a R_386_COPY reloc. */
1406 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1408 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1409 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1411 if (ELIMINATE_COPY_RELOCS
1412 && ind
->root
.type
!= bfd_link_hash_indirect
1413 && dir
->dynamic_adjusted
)
1415 /* If called to transfer flags for a weakdef during processing
1416 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1417 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1418 if (dir
->versioned
!= versioned_hidden
)
1419 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1420 dir
->ref_regular
|= ind
->ref_regular
;
1421 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1422 dir
->needs_plt
|= ind
->needs_plt
;
1423 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1427 if (eind
->func_pointer_refcount
> 0)
1429 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1430 eind
->func_pointer_refcount
= 0;
1433 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1437 /* Remove undefined weak symbol from the dynamic symbol table if it
1438 is resolved to 0. */
1441 _bfd_x86_elf_fixup_symbol (struct bfd_link_info
*info
,
1442 struct elf_link_hash_entry
*h
)
1444 if (h
->dynindx
!= -1)
1446 const struct elf_backend_data
*bed
1447 = get_elf_backend_data (info
->output_bfd
);
1448 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
1450 elf_x86_hash_entry (h
)->has_got_reloc
,
1451 elf_x86_hash_entry (h
)))
1454 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1461 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1464 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry
*h
)
1466 if (h
->plt
.offset
!= (bfd_vma
) -1
1468 && !h
->pointer_equality_needed
)
1471 return _bfd_elf_hash_symbol (h
);
1474 /* Adjust a symbol defined by a dynamic object and referenced by a
1475 regular object. The current definition is in some section of the
1476 dynamic object, but we're not including those sections. We have to
1477 change the definition to something the rest of the link can
1481 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1482 struct elf_link_hash_entry
*h
)
1484 struct elf_x86_link_hash_table
*htab
;
1486 struct elf_x86_link_hash_entry
*eh
;
1487 struct elf_dyn_relocs
*p
;
1488 const struct elf_backend_data
*bed
1489 = get_elf_backend_data (info
->output_bfd
);
1491 /* STT_GNU_IFUNC symbol must go through PLT. */
1492 if (h
->type
== STT_GNU_IFUNC
)
1494 /* All local STT_GNU_IFUNC references must be treate as local
1495 calls via local PLT. */
1497 && SYMBOL_CALLS_LOCAL (info
, h
))
1499 bfd_size_type pc_count
= 0, count
= 0;
1500 struct elf_dyn_relocs
**pp
;
1502 eh
= (struct elf_x86_link_hash_entry
*) h
;
1503 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1505 pc_count
+= p
->pc_count
;
1506 p
->count
-= p
->pc_count
;
1515 if (pc_count
|| count
)
1520 /* Increment PLT reference count only for PC-relative
1523 if (h
->plt
.refcount
<= 0)
1524 h
->plt
.refcount
= 1;
1526 h
->plt
.refcount
+= 1;
1531 if (h
->plt
.refcount
<= 0)
1533 h
->plt
.offset
= (bfd_vma
) -1;
1539 /* If this is a function, put it in the procedure linkage table. We
1540 will fill in the contents of the procedure linkage table later,
1541 when we know the address of the .got section. */
1542 if (h
->type
== STT_FUNC
1545 if (h
->plt
.refcount
<= 0
1546 || SYMBOL_CALLS_LOCAL (info
, h
)
1547 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1548 && h
->root
.type
== bfd_link_hash_undefweak
))
1550 /* This case can occur if we saw a PLT32 reloc in an input
1551 file, but the symbol was never referred to by a dynamic
1552 object, or if all references were garbage collected. In
1553 such a case, we don't actually need to build a procedure
1554 linkage table, and we can just do a PC32 reloc instead. */
1555 h
->plt
.offset
= (bfd_vma
) -1;
1562 /* It's possible that we incorrectly decided a .plt reloc was needed
1563 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
1564 check_relocs. We can't decide accurately between function and
1565 non-function syms in check-relocs; Objects loaded later in
1566 the link may change h->type. So fix it now. */
1567 h
->plt
.offset
= (bfd_vma
) -1;
1569 eh
= (struct elf_x86_link_hash_entry
*) h
;
1571 /* If this is a weak symbol, and there is a real definition, the
1572 processor independent code will have arranged for us to see the
1573 real definition first, and we can just use the same value. */
1574 if (h
->u
.weakdef
!= NULL
)
1576 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1577 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1578 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1579 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1580 if (ELIMINATE_COPY_RELOCS
1581 || info
->nocopyreloc
1582 || SYMBOL_NO_COPYRELOC (info
, eh
))
1584 /* NB: needs_copy is always 0 for i386. */
1585 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1586 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
1591 /* This is a reference to a symbol defined by a dynamic object which
1592 is not a function. */
1594 /* If we are creating a shared library, we must presume that the
1595 only references to the symbol are via the global offset table.
1596 For such cases we need not do anything here; the relocations will
1597 be handled correctly by relocate_section. */
1598 if (!bfd_link_executable (info
))
1601 /* If there are no references to this symbol that do not use the
1602 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
1603 reloc. NB: gotoff_ref is always 0 for x86-64. */
1604 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
1607 /* If -z nocopyreloc was given, we won't generate them either. */
1608 if (info
->nocopyreloc
|| SYMBOL_NO_COPYRELOC (info
, eh
))
1614 htab
= elf_x86_hash_table (info
, bed
->target_id
);
1618 /* If there aren't any dynamic relocs in read-only sections nor
1619 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
1620 avoid the copy reloc. This doesn't work on VxWorks, where we can
1621 not have dynamic relocations (other than copy and jump slot
1622 relocations) in an executable. */
1623 if (ELIMINATE_COPY_RELOCS
1624 && (bed
->target_id
== X86_64_ELF_DATA
1626 && !htab
->is_vxworks
)))
1628 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1630 s
= p
->sec
->output_section
;
1631 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1635 /* If we didn't find any dynamic relocs in read-only sections,
1636 then we'll be keeping the dynamic relocs and avoiding the copy
1645 /* We must allocate the symbol in our .dynbss section, which will
1646 become part of the .bss section of the executable. There will be
1647 an entry for this symbol in the .dynsym section. The dynamic
1648 object will contain position independent code, so all references
1649 from the dynamic object to this symbol will go through the global
1650 offset table. The dynamic linker will use the .dynsym entry to
1651 determine the address it must put in the global offset table, so
1652 both the dynamic object and the regular object will refer to the
1653 same memory location for the variable. */
1655 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
1656 dynamic linker to copy the initial value out of the dynamic object
1657 and into the runtime process image. */
1658 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1660 s
= htab
->elf
.sdynrelro
;
1661 srel
= htab
->elf
.sreldynrelro
;
1665 s
= htab
->elf
.sdynbss
;
1666 srel
= htab
->elf
.srelbss
;
1668 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1670 srel
->size
+= htab
->sizeof_reloc
;
1674 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1677 /* Return the section that should be marked against GC for a given
1681 _bfd_x86_elf_gc_mark_hook (asection
*sec
,
1682 struct bfd_link_info
*info
,
1683 Elf_Internal_Rela
*rel
,
1684 struct elf_link_hash_entry
*h
,
1685 Elf_Internal_Sym
*sym
)
1687 /* Compiler should optimize this out. */
1688 if (((unsigned int) R_X86_64_GNU_VTINHERIT
1689 != (unsigned int) R_386_GNU_VTINHERIT
)
1690 || ((unsigned int) R_X86_64_GNU_VTENTRY
1691 != (unsigned int) R_386_GNU_VTENTRY
))
1695 switch (ELF32_R_TYPE (rel
->r_info
))
1697 case R_X86_64_GNU_VTINHERIT
:
1698 case R_X86_64_GNU_VTENTRY
:
1702 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1706 elf_i386_get_plt_got_vma (struct elf_x86_plt
*plt_p ATTRIBUTE_UNUSED
,
1708 bfd_vma offset ATTRIBUTE_UNUSED
,
1711 return got_addr
+ off
;
1715 elf_x86_64_get_plt_got_vma (struct elf_x86_plt
*plt_p
,
1718 bfd_vma got_addr ATTRIBUTE_UNUSED
)
1720 return plt_p
->sec
->vma
+ offset
+ off
+ plt_p
->plt_got_insn_size
;
1724 elf_i386_valid_plt_reloc_p (unsigned int type
)
1726 return (type
== R_386_JUMP_SLOT
1727 || type
== R_386_GLOB_DAT
1728 || type
== R_386_IRELATIVE
);
1732 elf_x86_64_valid_plt_reloc_p (unsigned int type
)
1734 return (type
== R_X86_64_JUMP_SLOT
1735 || type
== R_X86_64_GLOB_DAT
1736 || type
== R_X86_64_IRELATIVE
);
1740 _bfd_x86_elf_get_synthetic_symtab (bfd
*abfd
,
1744 struct elf_x86_plt plts
[],
1748 long size
, i
, n
, len
;
1750 unsigned int plt_got_offset
, plt_entry_size
;
1752 bfd_byte
*plt_contents
;
1754 arelent
**dynrelbuf
, *p
;
1756 const struct elf_backend_data
*bed
;
1757 bfd_vma (*get_plt_got_vma
) (struct elf_x86_plt
*, bfd_vma
, bfd_vma
,
1759 bfd_boolean (*valid_plt_reloc_p
) (unsigned int);
1764 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
1765 if (dynrelbuf
== NULL
)
1768 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
1771 /* Sort the relocs by address. */
1772 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*),
1773 _bfd_x86_elf_compare_relocs
);
1775 size
= count
* sizeof (asymbol
);
1777 /* Allocate space for @plt suffixes. */
1779 for (i
= 0; i
< dynrelcount
; i
++)
1782 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
1784 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
1787 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
1791 bed
= get_elf_backend_data (abfd
);
1793 if (bed
->target_id
== X86_64_ELF_DATA
)
1795 get_plt_got_vma
= elf_x86_64_get_plt_got_vma
;
1796 valid_plt_reloc_p
= elf_x86_64_valid_plt_reloc_p
;
1800 get_plt_got_vma
= elf_i386_get_plt_got_vma
;
1801 valid_plt_reloc_p
= elf_i386_valid_plt_reloc_p
;
1804 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
1806 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
1808 got_addr
= sec
->vma
;
1811 sec
= bfd_get_section_by_name (abfd
, ".got");
1813 got_addr
= sec
->vma
;
1816 if (got_addr
== (bfd_vma
) -1)
1821 /* Check for each PLT section. */
1822 names
= (char *) (s
+ count
);
1825 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1826 if ((plt_contents
= plts
[j
].contents
) != NULL
)
1831 struct elf_x86_plt
*plt_p
= &plts
[j
];
1833 plt_got_offset
= plt_p
->plt_got_offset
;
1834 plt_entry_size
= plt_p
->plt_entry_size
;
1838 if ((plt_p
->type
& plt_lazy
))
1840 /* Skip PLT0 in lazy PLT. */
1842 offset
= plt_entry_size
;
1850 /* Check each PLT entry against dynamic relocations. */
1851 for (; k
< plt_p
->count
; k
++)
1857 /* Get the GOT offset for i386 or the PC-relative offset
1858 for x86-64, a signed 32-bit integer. */
1859 off
= H_GET_32 (abfd
, (plt_contents
+ offset
1861 got_vma
= get_plt_got_vma (plt_p
, off
, offset
, got_addr
);
1863 /* Binary search. */
1867 while ((min
+ 1) < max
)
1871 mid
= (min
+ max
) / 2;
1873 if (got_vma
> r
->address
)
1875 else if (got_vma
< r
->address
)
1884 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
1885 if (got_vma
== p
->address
1887 && valid_plt_reloc_p (p
->howto
->type
))
1889 *s
= **p
->sym_ptr_ptr
;
1890 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
1891 set. Since we are defining a symbol, ensure one
1893 if ((s
->flags
& BSF_LOCAL
) == 0)
1894 s
->flags
|= BSF_GLOBAL
;
1895 s
->flags
|= BSF_SYNTHETIC
;
1896 /* This is no longer a section symbol. */
1897 s
->flags
&= ~BSF_SECTION_SYM
;
1899 s
->the_bfd
= plt
->owner
;
1903 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
1904 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
1910 memcpy (names
, "+0x", sizeof ("+0x") - 1);
1911 names
+= sizeof ("+0x") - 1;
1912 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
1913 for (a
= buf
; *a
== '0'; ++a
)
1916 memcpy (names
, a
, size
);
1919 memcpy (names
, "@plt", sizeof ("@plt"));
1920 names
+= sizeof ("@plt");
1924 offset
+= plt_entry_size
;
1928 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
1937 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
1938 if (plts
[j
].contents
!= NULL
)
1939 free (plts
[j
].contents
);
1946 /* Parse x86 GNU properties. */
1948 enum elf_property_kind
1949 _bfd_x86_elf_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
1950 bfd_byte
*ptr
, unsigned int datasz
)
1956 case GNU_PROPERTY_X86_ISA_1_USED
:
1957 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
1958 case GNU_PROPERTY_X86_FEATURE_1_AND
:
1962 ((type
== GNU_PROPERTY_X86_ISA_1_USED
1963 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
1964 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
1965 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
1966 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
1968 return property_corrupt
;
1970 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
1971 /* Combine properties of the same type. */
1972 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
1973 prop
->pr_kind
= property_number
;
1977 return property_ignored
;
1980 return property_number
;
1983 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL,
1984 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
1985 should be merged with ABFD. */
1988 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info
*info
,
1989 bfd
*abfd ATTRIBUTE_UNUSED
,
1990 elf_property
*aprop
,
1991 elf_property
*bprop
)
1993 unsigned int number
, features
;
1994 bfd_boolean updated
= FALSE
;
1995 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
1999 case GNU_PROPERTY_X86_ISA_1_USED
:
2000 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
2001 if (aprop
!= NULL
&& bprop
!= NULL
)
2003 number
= aprop
->u
.number
;
2004 aprop
->u
.number
= number
| bprop
->u
.number
;
2005 updated
= number
!= (unsigned int) aprop
->u
.number
;
2009 /* Return TRUE if APROP is NULL to indicate that BPROP should
2010 be added to ABFD. */
2011 updated
= aprop
== NULL
;
2015 case GNU_PROPERTY_X86_FEATURE_1_AND
:
2016 /* Only one of APROP and BPROP can be NULL:
2017 1. APROP & BPROP when both APROP and BPROP aren't NULL.
2018 2. If APROP is NULL, remove x86 feature.
2019 3. Otherwise, do nothing.
2021 if (aprop
!= NULL
&& bprop
!= NULL
)
2025 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2027 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2028 number
= aprop
->u
.number
;
2029 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2030 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2031 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
2032 updated
= number
!= (unsigned int) aprop
->u
.number
;
2033 /* Remove the property if all feature bits are cleared. */
2034 if (aprop
->u
.number
== 0)
2035 aprop
->pr_kind
= property_remove
;
2041 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2043 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2046 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
2047 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2050 number
= aprop
->u
.number
;
2051 aprop
->u
.number
= number
| features
;
2052 updated
= number
!= (unsigned int) aprop
->u
.number
;
2056 bprop
->u
.number
|= features
;
2060 else if (aprop
!= NULL
)
2062 aprop
->pr_kind
= property_remove
;
2069 /* Never should happen. */
2076 /* Set up x86 GNU properties. Return the first relocatable ELF input
2077 with GNU properties if found. Otherwise, return NULL. */
2080 _bfd_x86_elf_link_setup_gnu_properties
2081 (struct bfd_link_info
*info
,
2082 struct elf_x86_plt_layout_table
*plt_layout
)
2084 bfd_boolean normal_target
;
2085 bfd_boolean lazy_plt
;
2086 asection
*sec
, *pltsec
;
2088 bfd_boolean use_ibt_plt
;
2089 unsigned int plt_alignment
, features
;
2090 struct elf_x86_link_hash_table
*htab
;
2094 const struct elf_backend_data
*bed
;
2095 unsigned int class_align
= ABI_64_P (info
->output_bfd
) ? 3 : 2;
2096 unsigned int got_align
;
2100 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
2102 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
2104 /* Find a normal input file with GNU property note. */
2105 for (pbfd
= info
->input_bfds
;
2107 pbfd
= pbfd
->link
.next
)
2108 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
2109 && bfd_count_sections (pbfd
) != 0)
2113 if (elf_properties (pbfd
) != NULL
)
2117 if (ebfd
!= NULL
&& features
)
2119 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
2120 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
2121 prop
= _bfd_elf_get_property (ebfd
,
2122 GNU_PROPERTY_X86_FEATURE_1_AND
,
2124 prop
->u
.number
|= features
;
2125 prop
->pr_kind
= property_number
;
2127 /* Create the GNU property note section if needed. */
2130 sec
= bfd_make_section_with_flags (ebfd
,
2131 NOTE_GNU_PROPERTY_SECTION_NAME
,
2139 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
2141 if (!bfd_set_section_alignment (ebfd
, sec
, class_align
))
2144 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
2148 elf_section_type (sec
) = SHT_NOTE
;
2152 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
2154 if (bfd_link_relocatable (info
))
2157 bed
= get_elf_backend_data (info
->output_bfd
);
2159 htab
= elf_x86_hash_table (info
, bed
->target_id
);
2163 htab
->is_vxworks
= plt_layout
->is_vxworks
;
2165 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
2166 if (!use_ibt_plt
&& pbfd
!= NULL
)
2168 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
2169 elf_property_list
*p
;
2171 /* The property list is sorted in order of type. */
2172 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
2174 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
2176 use_ibt_plt
= !!(p
->property
.u
.number
2177 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
2180 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
2185 dynobj
= htab
->elf
.dynobj
;
2187 /* Set htab->elf.dynobj here so that there is no need to check and
2188 set it in check_relocs. */
2193 htab
->elf
.dynobj
= pbfd
;
2200 /* Find a normal input file to hold linker created
2202 for (abfd
= info
->input_bfds
;
2204 abfd
= abfd
->link
.next
)
2205 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2207 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
2209 htab
->elf
.dynobj
= abfd
;
2216 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
2217 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
2218 canonical function address. */
2219 htab
->plt
.has_plt0
= 1;
2220 normal_target
= plt_layout
->normal_target
;
2226 htab
->lazy_plt
= plt_layout
->lazy_ibt_plt
;
2227 htab
->non_lazy_plt
= plt_layout
->non_lazy_ibt_plt
;
2231 htab
->lazy_plt
= plt_layout
->lazy_plt
;
2232 htab
->non_lazy_plt
= plt_layout
->non_lazy_plt
;
2237 htab
->lazy_plt
= plt_layout
->lazy_plt
;
2238 htab
->non_lazy_plt
= NULL
;
2241 pltsec
= htab
->elf
.splt
;
2243 /* If the non-lazy PLT is available, use it for all PLT entries if
2244 there are no PLT0 or no .plt section. */
2245 if (htab
->non_lazy_plt
!= NULL
2246 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
2249 if (bfd_link_pic (info
))
2250 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
2252 htab
->plt
.plt_entry
= htab
->non_lazy_plt
->plt_entry
;
2253 htab
->plt
.plt_entry_size
= htab
->non_lazy_plt
->plt_entry_size
;
2254 htab
->plt
.plt_got_offset
= htab
->non_lazy_plt
->plt_got_offset
;
2255 htab
->plt
.plt_got_insn_size
2256 = htab
->non_lazy_plt
->plt_got_insn_size
;
2257 htab
->plt
.eh_frame_plt_size
2258 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2259 htab
->plt
.eh_frame_plt
= htab
->non_lazy_plt
->eh_frame_plt
;
2264 if (bfd_link_pic (info
))
2266 htab
->plt
.plt0_entry
= htab
->lazy_plt
->pic_plt0_entry
;
2267 htab
->plt
.plt_entry
= htab
->lazy_plt
->pic_plt_entry
;
2271 htab
->plt
.plt0_entry
= htab
->lazy_plt
->plt0_entry
;
2272 htab
->plt
.plt_entry
= htab
->lazy_plt
->plt_entry
;
2274 htab
->plt
.plt_entry_size
= htab
->lazy_plt
->plt_entry_size
;
2275 htab
->plt
.plt_got_offset
= htab
->lazy_plt
->plt_got_offset
;
2276 htab
->plt
.plt_got_insn_size
2277 = htab
->lazy_plt
->plt_got_insn_size
;
2278 htab
->plt
.eh_frame_plt_size
2279 = htab
->lazy_plt
->eh_frame_plt_size
;
2280 htab
->plt
.eh_frame_plt
= htab
->lazy_plt
->eh_frame_plt
;
2283 /* Return if there are no normal input files. */
2287 if (htab
->is_vxworks
2288 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
2291 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
2295 /* Since create_dynamic_sections isn't always called, but GOT
2296 relocations need GOT relocations, create them here so that we
2297 don't need to do it in check_relocs. */
2298 if (htab
->elf
.sgot
== NULL
2299 && !_bfd_elf_create_got_section (dynobj
, info
))
2300 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
2302 got_align
= (bed
->target_id
== X86_64_ELF_DATA
) ? 3 : 2;
2304 /* Align .got and .got.plt sections to their entry size. Do it here
2305 instead of in create_dynamic_sections so that they are always
2306 properly aligned even if create_dynamic_sections isn't called. */
2307 sec
= htab
->elf
.sgot
;
2308 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2309 goto error_alignment
;
2311 sec
= htab
->elf
.sgotplt
;
2312 if (!bfd_set_section_alignment (dynobj
, sec
, got_align
))
2313 goto error_alignment
;
2315 /* Create the ifunc sections here so that check_relocs can be
2317 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
2318 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
2320 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
2324 /* Whe creating executable, set the contents of the .interp
2325 section to the interpreter. */
2326 if (bfd_link_executable (info
) && !info
->nointerp
)
2328 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
2331 s
->size
= htab
->dynamic_interpreter_size
;
2332 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2336 /* Don't change PLT section alignment for NaCl since it uses
2337 64-byte PLT entry and sets PLT section alignment to 32
2338 bytes. Don't create additional PLT sections for NaCl. */
2341 flagword pltflags
= (bed
->dynamic_sec_flags
2346 unsigned int non_lazy_plt_alignment
2347 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
2350 if (!bfd_set_section_alignment (sec
->owner
, sec
,
2352 goto error_alignment
;
2354 /* Create the GOT procedure linkage table. */
2355 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2359 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
2361 if (!bfd_set_section_alignment (dynobj
, sec
,
2362 non_lazy_plt_alignment
))
2363 goto error_alignment
;
2365 htab
->plt_got
= sec
;
2373 /* Create the second PLT for Intel IBT support. IBT
2374 PLT is supported only for non-NaCl target and is
2375 is needed only for lazy binding. */
2376 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2380 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
2382 if (!bfd_set_section_alignment (dynobj
, sec
,
2384 goto error_alignment
;
2386 else if (info
->bndplt
&& ABI_64_P (dynobj
))
2388 /* Create the second PLT for Intel MPX support. MPX
2389 PLT is supported only for non-NaCl target in 64-bit
2390 mode and is needed only for lazy binding. */
2391 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2395 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
2397 if (!bfd_set_section_alignment (dynobj
, sec
,
2398 non_lazy_plt_alignment
))
2399 goto error_alignment
;
2402 htab
->plt_second
= sec
;
2406 if (!info
->no_ld_generated_unwind_info
)
2408 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
2409 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2410 | SEC_LINKER_CREATED
);
2412 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2416 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
2418 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2419 goto error_alignment
;
2421 htab
->plt_eh_frame
= sec
;
2423 if (htab
->plt_got
!= NULL
)
2425 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2429 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
2431 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2432 goto error_alignment
;
2434 htab
->plt_got_eh_frame
= sec
;
2437 if (htab
->plt_second
!= NULL
)
2439 sec
= bfd_make_section_anyway_with_flags (dynobj
,
2443 info
->callbacks
->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
2445 if (!bfd_set_section_alignment (dynobj
, sec
, class_align
))
2446 goto error_alignment
;
2448 htab
->plt_second_eh_frame
= sec
;
2455 /* The .iplt section is used for IFUNC symbols in static
2457 sec
= htab
->elf
.iplt
;
2459 && !bfd_set_section_alignment (sec
->owner
, sec
,
2461 goto error_alignment
;