1 /* ELF linking support for BFD.
2 Copyright (C) 1995-2021 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. */
27 #include "safe-ctype.h"
28 #include "libiberty.h"
30 #if BFD_SUPPORTS_PLUGINS
31 #include "plugin-api.h"
40 /* This struct is used to pass information to routines called via
41 elf_link_hash_traverse which must return failure. */
43 struct elf_info_failed
45 struct bfd_link_info
*info
;
49 /* This structure is used to pass information to
50 _bfd_elf_link_find_version_dependencies. */
52 struct elf_find_verdep_info
54 /* General link information. */
55 struct bfd_link_info
*info
;
56 /* The number of dependencies. */
58 /* Whether we had a failure. */
62 static bool _bfd_elf_fix_symbol_flags
63 (struct elf_link_hash_entry
*, struct elf_info_failed
*);
66 _bfd_elf_section_for_symbol (struct elf_reloc_cookie
*cookie
,
67 unsigned long r_symndx
,
70 if (r_symndx
>= cookie
->locsymcount
71 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
73 struct elf_link_hash_entry
*h
;
75 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
77 while (h
->root
.type
== bfd_link_hash_indirect
78 || h
->root
.type
== bfd_link_hash_warning
)
79 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
81 if ((h
->root
.type
== bfd_link_hash_defined
82 || h
->root
.type
== bfd_link_hash_defweak
)
83 && discarded_section (h
->root
.u
.def
.section
))
84 return h
->root
.u
.def
.section
;
90 /* It's not a relocation against a global symbol,
91 but it could be a relocation against a local
92 symbol for a discarded section. */
94 Elf_Internal_Sym
*isym
;
96 /* Need to: get the symbol; get the section. */
97 isym
= &cookie
->locsyms
[r_symndx
];
98 isec
= bfd_section_from_elf_index (cookie
->abfd
, isym
->st_shndx
);
100 && discard
? discarded_section (isec
) : 1)
106 /* Define a symbol in a dynamic linkage section. */
108 struct elf_link_hash_entry
*
109 _bfd_elf_define_linkage_sym (bfd
*abfd
,
110 struct bfd_link_info
*info
,
114 struct elf_link_hash_entry
*h
;
115 struct bfd_link_hash_entry
*bh
;
116 const struct elf_backend_data
*bed
;
118 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, false, false, false);
121 /* Zap symbol defined in an as-needed lib that wasn't linked.
122 This is a symptom of a larger problem: Absolute symbols
123 defined in shared libraries can't be overridden, because we
124 lose the link to the bfd which is via the symbol section. */
125 h
->root
.type
= bfd_link_hash_new
;
131 bed
= get_elf_backend_data (abfd
);
132 if (!_bfd_generic_link_add_one_symbol (info
, abfd
, name
, BSF_GLOBAL
,
133 sec
, 0, NULL
, false, bed
->collect
,
136 h
= (struct elf_link_hash_entry
*) bh
;
137 BFD_ASSERT (h
!= NULL
);
140 h
->root
.linker_def
= 1;
141 h
->type
= STT_OBJECT
;
142 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
143 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
145 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
150 _bfd_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
154 struct elf_link_hash_entry
*h
;
155 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
156 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
158 /* This function may be called more than once. */
159 if (htab
->sgot
!= NULL
)
162 flags
= bed
->dynamic_sec_flags
;
164 s
= bfd_make_section_anyway_with_flags (abfd
,
165 (bed
->rela_plts_and_copies_p
166 ? ".rela.got" : ".rel.got"),
167 (bed
->dynamic_sec_flags
170 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
174 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
176 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
180 if (bed
->want_got_plt
)
182 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
184 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
189 /* The first bit of the global offset table is the header. */
190 s
->size
+= bed
->got_header_size
;
192 if (bed
->want_got_sym
)
194 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
195 (or .got.plt) section. We don't do this in the linker script
196 because we don't want to define the symbol if we are not creating
197 a global offset table. */
198 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
199 "_GLOBAL_OFFSET_TABLE_");
200 elf_hash_table (info
)->hgot
= h
;
208 /* Create a strtab to hold the dynamic symbol names. */
210 _bfd_elf_link_create_dynstrtab (bfd
*abfd
, struct bfd_link_info
*info
)
212 struct elf_link_hash_table
*hash_table
;
214 hash_table
= elf_hash_table (info
);
215 if (hash_table
->dynobj
== NULL
)
217 /* We may not set dynobj, an input file holding linker created
218 dynamic sections to abfd, which may be a dynamic object with
219 its own dynamic sections. We need to find a normal input file
220 to hold linker created sections if possible. */
221 if ((abfd
->flags
& (DYNAMIC
| BFD_PLUGIN
)) != 0)
225 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
227 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0
228 && bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
229 && elf_object_id (ibfd
) == elf_hash_table_id (hash_table
)
230 && !((s
= ibfd
->sections
) != NULL
231 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
))
237 hash_table
->dynobj
= abfd
;
240 if (hash_table
->dynstr
== NULL
)
242 hash_table
->dynstr
= _bfd_elf_strtab_init ();
243 if (hash_table
->dynstr
== NULL
)
249 /* Create some sections which will be filled in with dynamic linking
250 information. ABFD is an input file which requires dynamic sections
251 to be created. The dynamic sections take up virtual memory space
252 when the final executable is run, so we need to create them before
253 addresses are assigned to the output sections. We work out the
254 actual contents and size of these sections later. */
257 _bfd_elf_link_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
261 const struct elf_backend_data
*bed
;
262 struct elf_link_hash_entry
*h
;
264 if (! is_elf_hash_table (info
->hash
))
267 if (elf_hash_table (info
)->dynamic_sections_created
)
270 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
273 abfd
= elf_hash_table (info
)->dynobj
;
274 bed
= get_elf_backend_data (abfd
);
276 flags
= bed
->dynamic_sec_flags
;
278 /* A dynamically linked executable has a .interp section, but a
279 shared library does not. */
280 if (bfd_link_executable (info
) && !info
->nointerp
)
282 s
= bfd_make_section_anyway_with_flags (abfd
, ".interp",
283 flags
| SEC_READONLY
);
288 /* Create sections to hold version informations. These are removed
289 if they are not needed. */
290 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_d",
291 flags
| SEC_READONLY
);
293 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
296 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version",
297 flags
| SEC_READONLY
);
299 || !bfd_set_section_alignment (s
, 1))
302 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_r",
303 flags
| SEC_READONLY
);
305 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
308 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynsym",
309 flags
| SEC_READONLY
);
311 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
313 elf_hash_table (info
)->dynsym
= s
;
315 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynstr",
316 flags
| SEC_READONLY
);
320 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic", flags
);
322 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
325 /* The special symbol _DYNAMIC is always set to the start of the
326 .dynamic section. We could set _DYNAMIC in a linker script, but we
327 only want to define it if we are, in fact, creating a .dynamic
328 section. We don't want to define it if there is no .dynamic
329 section, since on some ELF platforms the start up code examines it
330 to decide how to initialize the process. */
331 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_DYNAMIC");
332 elf_hash_table (info
)->hdynamic
= h
;
338 s
= bfd_make_section_anyway_with_flags (abfd
, ".hash",
339 flags
| SEC_READONLY
);
341 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
343 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
346 if (info
->emit_gnu_hash
&& bed
->record_xhash_symbol
== NULL
)
348 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.hash",
349 flags
| SEC_READONLY
);
351 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
353 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
354 4 32-bit words followed by variable count of 64-bit words, then
355 variable count of 32-bit words. */
356 if (bed
->s
->arch_size
== 64)
357 elf_section_data (s
)->this_hdr
.sh_entsize
= 0;
359 elf_section_data (s
)->this_hdr
.sh_entsize
= 4;
362 /* Let the backend create the rest of the sections. This lets the
363 backend set the right flags. The backend will normally create
364 the .got and .plt sections. */
365 if (bed
->elf_backend_create_dynamic_sections
== NULL
366 || ! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
369 elf_hash_table (info
)->dynamic_sections_created
= true;
374 /* Create dynamic sections when linking against a dynamic object. */
377 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
379 flagword flags
, pltflags
;
380 struct elf_link_hash_entry
*h
;
382 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
383 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
385 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
386 .rel[a].bss sections. */
387 flags
= bed
->dynamic_sec_flags
;
390 if (bed
->plt_not_loaded
)
391 /* We do not clear SEC_ALLOC here because we still want the OS to
392 allocate space for the section; it's just that there's nothing
393 to read in from the object file. */
394 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
396 pltflags
|= SEC_ALLOC
| SEC_CODE
| SEC_LOAD
;
397 if (bed
->plt_readonly
)
398 pltflags
|= SEC_READONLY
;
400 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
402 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
406 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
408 if (bed
->want_plt_sym
)
410 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
411 "_PROCEDURE_LINKAGE_TABLE_");
412 elf_hash_table (info
)->hplt
= h
;
417 s
= bfd_make_section_anyway_with_flags (abfd
,
418 (bed
->rela_plts_and_copies_p
419 ? ".rela.plt" : ".rel.plt"),
420 flags
| SEC_READONLY
);
422 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
426 if (! _bfd_elf_create_got_section (abfd
, info
))
429 if (bed
->want_dynbss
)
431 /* The .dynbss section is a place to put symbols which are defined
432 by dynamic objects, are referenced by regular objects, and are
433 not functions. We must allocate space for them in the process
434 image and use a R_*_COPY reloc to tell the dynamic linker to
435 initialize them at run time. The linker script puts the .dynbss
436 section into the .bss section of the final image. */
437 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
438 SEC_ALLOC
| SEC_LINKER_CREATED
);
443 if (bed
->want_dynrelro
)
445 /* Similarly, but for symbols that were originally in read-only
446 sections. This section doesn't really need to have contents,
447 but make it like other .data.rel.ro sections. */
448 s
= bfd_make_section_anyway_with_flags (abfd
, ".data.rel.ro",
455 /* The .rel[a].bss section holds copy relocs. This section is not
456 normally needed. We need to create it here, though, so that the
457 linker will map it to an output section. We can't just create it
458 only if we need it, because we will not know whether we need it
459 until we have seen all the input files, and the first time the
460 main linker code calls BFD after examining all the input files
461 (size_dynamic_sections) the input sections have already been
462 mapped to the output sections. If the section turns out not to
463 be needed, we can discard it later. We will never need this
464 section when generating a shared object, since they do not use
466 if (bfd_link_executable (info
))
468 s
= bfd_make_section_anyway_with_flags (abfd
,
469 (bed
->rela_plts_and_copies_p
470 ? ".rela.bss" : ".rel.bss"),
471 flags
| SEC_READONLY
);
473 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
477 if (bed
->want_dynrelro
)
479 s
= (bfd_make_section_anyway_with_flags
480 (abfd
, (bed
->rela_plts_and_copies_p
481 ? ".rela.data.rel.ro" : ".rel.data.rel.ro"),
482 flags
| SEC_READONLY
));
484 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
486 htab
->sreldynrelro
= s
;
494 /* Record a new dynamic symbol. We record the dynamic symbols as we
495 read the input files, since we need to have a list of all of them
496 before we can determine the final sizes of the output sections.
497 Note that we may actually call this function even though we are not
498 going to output any dynamic symbols; in some cases we know that a
499 symbol should be in the dynamic symbol table, but only if there is
503 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
504 struct elf_link_hash_entry
*h
)
506 if (h
->dynindx
== -1)
508 struct elf_strtab_hash
*dynstr
;
513 if (h
->root
.type
== bfd_link_hash_defined
514 || h
->root
.type
== bfd_link_hash_defweak
)
516 /* An IR symbol should not be made dynamic. */
517 if (h
->root
.u
.def
.section
!= NULL
518 && h
->root
.u
.def
.section
->owner
!= NULL
519 && (h
->root
.u
.def
.section
->owner
->flags
& BFD_PLUGIN
) != 0)
523 /* XXX: The ABI draft says the linker must turn hidden and
524 internal symbols into STB_LOCAL symbols when producing the
525 DSO. However, if ld.so honors st_other in the dynamic table,
526 this would not be necessary. */
527 switch (ELF_ST_VISIBILITY (h
->other
))
531 if (h
->root
.type
!= bfd_link_hash_undefined
532 && h
->root
.type
!= bfd_link_hash_undefweak
)
535 if (!elf_hash_table (info
)->is_relocatable_executable
536 || ((h
->root
.type
== bfd_link_hash_defined
537 || h
->root
.type
== bfd_link_hash_defweak
)
538 && h
->root
.u
.def
.section
->owner
!= NULL
539 && h
->root
.u
.def
.section
->owner
->no_export
)
540 || (h
->root
.type
== bfd_link_hash_common
541 && h
->root
.u
.c
.p
->section
->owner
!= NULL
542 && h
->root
.u
.c
.p
->section
->owner
->no_export
))
550 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
551 ++elf_hash_table (info
)->dynsymcount
;
553 dynstr
= elf_hash_table (info
)->dynstr
;
556 /* Create a strtab to hold the dynamic symbol names. */
557 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
562 /* We don't put any version information in the dynamic string
564 name
= h
->root
.root
.string
;
565 p
= strchr (name
, ELF_VER_CHR
);
567 /* We know that the p points into writable memory. In fact,
568 there are only a few symbols that have read-only names, being
569 those like _GLOBAL_OFFSET_TABLE_ that are created specially
570 by the backends. Most symbols will have names pointing into
571 an ELF string table read from a file, or to objalloc memory. */
574 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
579 if (indx
== (size_t) -1)
581 h
->dynstr_index
= indx
;
587 /* Mark a symbol dynamic. */
590 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info
*info
,
591 struct elf_link_hash_entry
*h
,
592 Elf_Internal_Sym
*sym
)
594 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
596 /* It may be called more than once on the same H. */
597 if(h
->dynamic
|| bfd_link_relocatable (info
))
600 if ((info
->dynamic_data
601 && (h
->type
== STT_OBJECT
602 || h
->type
== STT_COMMON
604 && (ELF_ST_TYPE (sym
->st_info
) == STT_OBJECT
605 || ELF_ST_TYPE (sym
->st_info
) == STT_COMMON
))))
608 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
611 /* NB: If a symbol is made dynamic by --dynamic-list, it has
613 h
->root
.non_ir_ref_dynamic
= 1;
617 /* Record an assignment to a symbol made by a linker script. We need
618 this in case some dynamic object refers to this symbol. */
621 bfd_elf_record_link_assignment (bfd
*output_bfd
,
622 struct bfd_link_info
*info
,
627 struct elf_link_hash_entry
*h
, *hv
;
628 struct elf_link_hash_table
*htab
;
629 const struct elf_backend_data
*bed
;
631 if (!is_elf_hash_table (info
->hash
))
634 htab
= elf_hash_table (info
);
635 h
= elf_link_hash_lookup (htab
, name
, !provide
, true, false);
639 if (h
->root
.type
== bfd_link_hash_warning
)
640 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
642 if (h
->versioned
== unknown
)
644 /* Set versioned if symbol version is unknown. */
645 char *version
= strrchr (name
, ELF_VER_CHR
);
648 if (version
> name
&& version
[-1] != ELF_VER_CHR
)
649 h
->versioned
= versioned_hidden
;
651 h
->versioned
= versioned
;
655 /* Symbols defined in a linker script but not referenced anywhere
656 else will have non_elf set. */
659 bfd_elf_link_mark_dynamic_symbol (info
, h
, NULL
);
663 switch (h
->root
.type
)
665 case bfd_link_hash_defined
:
666 case bfd_link_hash_defweak
:
667 case bfd_link_hash_common
:
669 case bfd_link_hash_undefweak
:
670 case bfd_link_hash_undefined
:
671 /* Since we're defining the symbol, don't let it seem to have not
672 been defined. record_dynamic_symbol and size_dynamic_sections
673 may depend on this. */
674 h
->root
.type
= bfd_link_hash_new
;
675 if (h
->root
.u
.undef
.next
!= NULL
|| htab
->root
.undefs_tail
== &h
->root
)
676 bfd_link_repair_undef_list (&htab
->root
);
678 case bfd_link_hash_new
:
680 case bfd_link_hash_indirect
:
681 /* We had a versioned symbol in a dynamic library. We make the
682 the versioned symbol point to this one. */
683 bed
= get_elf_backend_data (output_bfd
);
685 while (hv
->root
.type
== bfd_link_hash_indirect
686 || hv
->root
.type
== bfd_link_hash_warning
)
687 hv
= (struct elf_link_hash_entry
*) hv
->root
.u
.i
.link
;
688 /* We don't need to update h->root.u since linker will set them
690 h
->root
.type
= bfd_link_hash_undefined
;
691 hv
->root
.type
= bfd_link_hash_indirect
;
692 hv
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
693 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hv
);
700 /* If this symbol is being provided by the linker script, and it is
701 currently defined by a dynamic object, but not by a regular
702 object, then mark it as undefined so that the generic linker will
703 force the correct value. */
707 h
->root
.type
= bfd_link_hash_undefined
;
709 /* If this symbol is currently defined by a dynamic object, but not
710 by a regular object, then clear out any version information because
711 the symbol will not be associated with the dynamic object any
713 if (h
->def_dynamic
&& !h
->def_regular
)
714 h
->verinfo
.verdef
= NULL
;
716 /* Make sure this symbol is not garbage collected. */
723 bed
= get_elf_backend_data (output_bfd
);
724 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
725 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
726 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
729 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
731 if (!bfd_link_relocatable (info
)
733 && (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
734 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
))
739 || bfd_link_dll (info
)
740 || elf_hash_table (info
)->is_relocatable_executable
)
744 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
747 /* If this is a weak defined symbol, and we know a corresponding
748 real symbol from the same dynamic object, make sure the real
749 symbol is also made into a dynamic symbol. */
752 struct elf_link_hash_entry
*def
= weakdef (h
);
754 if (def
->dynindx
== -1
755 && !bfd_elf_link_record_dynamic_symbol (info
, def
))
763 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
764 success, and 2 on a failure caused by attempting to record a symbol
765 in a discarded section, eg. a discarded link-once section symbol. */
768 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
773 struct elf_link_local_dynamic_entry
*entry
;
774 struct elf_link_hash_table
*eht
;
775 struct elf_strtab_hash
*dynstr
;
778 Elf_External_Sym_Shndx eshndx
;
779 char esym
[sizeof (Elf64_External_Sym
)];
781 if (! is_elf_hash_table (info
->hash
))
784 /* See if the entry exists already. */
785 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
786 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
789 amt
= sizeof (*entry
);
790 entry
= (struct elf_link_local_dynamic_entry
*) bfd_alloc (input_bfd
, amt
);
794 /* Go find the symbol, so that we can find it's name. */
795 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
796 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
798 bfd_release (input_bfd
, entry
);
802 if (entry
->isym
.st_shndx
!= SHN_UNDEF
803 && entry
->isym
.st_shndx
< SHN_LORESERVE
)
807 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
808 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
810 /* We can still bfd_release here as nothing has done another
811 bfd_alloc. We can't do this later in this function. */
812 bfd_release (input_bfd
, entry
);
817 name
= (bfd_elf_string_from_elf_section
818 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
819 entry
->isym
.st_name
));
821 dynstr
= elf_hash_table (info
)->dynstr
;
824 /* Create a strtab to hold the dynamic symbol names. */
825 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
830 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, false);
831 if (dynstr_index
== (size_t) -1)
833 entry
->isym
.st_name
= dynstr_index
;
835 eht
= elf_hash_table (info
);
837 entry
->next
= eht
->dynlocal
;
838 eht
->dynlocal
= entry
;
839 entry
->input_bfd
= input_bfd
;
840 entry
->input_indx
= input_indx
;
843 /* Whatever binding the symbol had before, it's now local. */
845 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
847 /* The dynindx will be set at the end of size_dynamic_sections. */
852 /* Return the dynindex of a local dynamic symbol. */
855 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
859 struct elf_link_local_dynamic_entry
*e
;
861 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
862 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
867 /* This function is used to renumber the dynamic symbols, if some of
868 them are removed because they are marked as local. This is called
869 via elf_link_hash_traverse. */
872 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
875 size_t *count
= (size_t *) data
;
880 if (h
->dynindx
!= -1)
881 h
->dynindx
= ++(*count
);
887 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
888 STB_LOCAL binding. */
891 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
894 size_t *count
= (size_t *) data
;
896 if (!h
->forced_local
)
899 if (h
->dynindx
!= -1)
900 h
->dynindx
= ++(*count
);
905 /* Return true if the dynamic symbol for a given section should be
906 omitted when creating a shared library. */
908 _bfd_elf_omit_section_dynsym_default (bfd
*output_bfd ATTRIBUTE_UNUSED
,
909 struct bfd_link_info
*info
,
912 struct elf_link_hash_table
*htab
;
915 switch (elf_section_data (p
)->this_hdr
.sh_type
)
919 /* If sh_type is yet undecided, assume it could be
920 SHT_PROGBITS/SHT_NOBITS. */
922 htab
= elf_hash_table (info
);
923 if (htab
->text_index_section
!= NULL
)
924 return p
!= htab
->text_index_section
&& p
!= htab
->data_index_section
;
926 return (htab
->dynobj
!= NULL
927 && (ip
= bfd_get_linker_section (htab
->dynobj
, p
->name
)) != NULL
928 && ip
->output_section
== p
);
930 /* There shouldn't be section relative relocations
931 against any other section. */
938 _bfd_elf_omit_section_dynsym_all
939 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
940 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
941 asection
*p ATTRIBUTE_UNUSED
)
946 /* Assign dynsym indices. In a shared library we generate a section
947 symbol for each output section, which come first. Next come symbols
948 which have been forced to local binding. Then all of the back-end
949 allocated local dynamic syms, followed by the rest of the global
950 symbols. If SECTION_SYM_COUNT is NULL, section dynindx is not set.
951 (This prevents the early call before elf_backend_init_index_section
952 and strip_excluded_output_sections setting dynindx for sections
953 that are stripped.) */
956 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
,
957 struct bfd_link_info
*info
,
958 unsigned long *section_sym_count
)
960 unsigned long dynsymcount
= 0;
961 bool do_sec
= section_sym_count
!= NULL
;
963 if (bfd_link_pic (info
)
964 || elf_hash_table (info
)->is_relocatable_executable
)
966 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
968 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
969 if ((p
->flags
& SEC_EXCLUDE
) == 0
970 && (p
->flags
& SEC_ALLOC
) != 0
971 && elf_hash_table (info
)->dynamic_relocs
972 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
976 elf_section_data (p
)->dynindx
= dynsymcount
;
979 elf_section_data (p
)->dynindx
= 0;
982 *section_sym_count
= dynsymcount
;
984 elf_link_hash_traverse (elf_hash_table (info
),
985 elf_link_renumber_local_hash_table_dynsyms
,
988 if (elf_hash_table (info
)->dynlocal
)
990 struct elf_link_local_dynamic_entry
*p
;
991 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
992 p
->dynindx
= ++dynsymcount
;
994 elf_hash_table (info
)->local_dynsymcount
= dynsymcount
;
996 elf_link_hash_traverse (elf_hash_table (info
),
997 elf_link_renumber_hash_table_dynsyms
,
1000 /* There is an unused NULL entry at the head of the table which we
1001 must account for in our count even if the table is empty since it
1002 is intended for the mandatory DT_SYMTAB tag (.dynsym section) in
1003 .dynamic section. */
1006 elf_hash_table (info
)->dynsymcount
= dynsymcount
;
1010 /* Merge st_other field. */
1013 elf_merge_st_other (bfd
*abfd
, struct elf_link_hash_entry
*h
,
1014 unsigned int st_other
, asection
*sec
,
1015 bool definition
, bool dynamic
)
1017 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1019 /* If st_other has a processor-specific meaning, specific
1020 code might be needed here. */
1021 if (bed
->elf_backend_merge_symbol_attribute
)
1022 (*bed
->elf_backend_merge_symbol_attribute
) (h
, st_other
, definition
,
1027 unsigned symvis
= ELF_ST_VISIBILITY (st_other
);
1028 unsigned hvis
= ELF_ST_VISIBILITY (h
->other
);
1030 /* Keep the most constraining visibility. Leave the remainder
1031 of the st_other field to elf_backend_merge_symbol_attribute. */
1032 if (symvis
- 1 < hvis
- 1)
1033 h
->other
= symvis
| (h
->other
& ~ELF_ST_VISIBILITY (-1));
1036 && ELF_ST_VISIBILITY (st_other
) != STV_DEFAULT
1037 && (sec
->flags
& SEC_READONLY
) == 0)
1038 h
->protected_def
= 1;
1041 /* This function is called when we want to merge a new symbol with an
1042 existing symbol. It handles the various cases which arise when we
1043 find a definition in a dynamic object, or when there is already a
1044 definition in a dynamic object. The new symbol is described by
1045 NAME, SYM, PSEC, and PVALUE. We set SYM_HASH to the hash table
1046 entry. We set POLDBFD to the old symbol's BFD. We set POLD_WEAK
1047 if the old symbol was weak. We set POLD_ALIGNMENT to the alignment
1048 of an old common symbol. We set OVERRIDE if the old symbol is
1049 overriding a new definition. We set TYPE_CHANGE_OK if it is OK for
1050 the type to change. We set SIZE_CHANGE_OK if it is OK for the size
1051 to change. By OK to change, we mean that we shouldn't warn if the
1052 type or size does change. */
1055 _bfd_elf_merge_symbol (bfd
*abfd
,
1056 struct bfd_link_info
*info
,
1058 Elf_Internal_Sym
*sym
,
1061 struct elf_link_hash_entry
**sym_hash
,
1064 unsigned int *pold_alignment
,
1067 bool *type_change_ok
,
1068 bool *size_change_ok
,
1071 asection
*sec
, *oldsec
;
1072 struct elf_link_hash_entry
*h
;
1073 struct elf_link_hash_entry
*hi
;
1074 struct elf_link_hash_entry
*flip
;
1077 bool newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
1078 bool newweak
, oldweak
, newfunc
, oldfunc
;
1079 const struct elf_backend_data
*bed
;
1081 bool default_sym
= *matched
;
1087 bind
= ELF_ST_BIND (sym
->st_info
);
1089 if (! bfd_is_und_section (sec
))
1090 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, false, false);
1092 h
= ((struct elf_link_hash_entry
*)
1093 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true, false, false));
1098 bed
= get_elf_backend_data (abfd
);
1100 /* NEW_VERSION is the symbol version of the new symbol. */
1101 if (h
->versioned
!= unversioned
)
1103 /* Symbol version is unknown or versioned. */
1104 new_version
= strrchr (name
, ELF_VER_CHR
);
1107 if (h
->versioned
== unknown
)
1109 if (new_version
> name
&& new_version
[-1] != ELF_VER_CHR
)
1110 h
->versioned
= versioned_hidden
;
1112 h
->versioned
= versioned
;
1115 if (new_version
[0] == '\0')
1119 h
->versioned
= unversioned
;
1124 /* For merging, we only care about real symbols. But we need to make
1125 sure that indirect symbol dynamic flags are updated. */
1127 while (h
->root
.type
== bfd_link_hash_indirect
1128 || h
->root
.type
== bfd_link_hash_warning
)
1129 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1133 if (hi
== h
|| h
->root
.type
== bfd_link_hash_new
)
1137 /* OLD_HIDDEN is true if the existing symbol is only visible
1138 to the symbol with the same symbol version. NEW_HIDDEN is
1139 true if the new symbol is only visible to the symbol with
1140 the same symbol version. */
1141 bool old_hidden
= h
->versioned
== versioned_hidden
;
1142 bool new_hidden
= hi
->versioned
== versioned_hidden
;
1143 if (!old_hidden
&& !new_hidden
)
1144 /* The new symbol matches the existing symbol if both
1149 /* OLD_VERSION is the symbol version of the existing
1153 if (h
->versioned
>= versioned
)
1154 old_version
= strrchr (h
->root
.root
.string
,
1159 /* The new symbol matches the existing symbol if they
1160 have the same symbol version. */
1161 *matched
= (old_version
== new_version
1162 || (old_version
!= NULL
1163 && new_version
!= NULL
1164 && strcmp (old_version
, new_version
) == 0));
1169 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
1174 switch (h
->root
.type
)
1179 case bfd_link_hash_undefined
:
1180 case bfd_link_hash_undefweak
:
1181 oldbfd
= h
->root
.u
.undef
.abfd
;
1184 case bfd_link_hash_defined
:
1185 case bfd_link_hash_defweak
:
1186 oldbfd
= h
->root
.u
.def
.section
->owner
;
1187 oldsec
= h
->root
.u
.def
.section
;
1190 case bfd_link_hash_common
:
1191 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
1192 oldsec
= h
->root
.u
.c
.p
->section
;
1194 *pold_alignment
= h
->root
.u
.c
.p
->alignment_power
;
1197 if (poldbfd
&& *poldbfd
== NULL
)
1200 /* Differentiate strong and weak symbols. */
1201 newweak
= bind
== STB_WEAK
;
1202 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
1203 || h
->root
.type
== bfd_link_hash_undefweak
);
1205 *pold_weak
= oldweak
;
1207 /* We have to check it for every instance since the first few may be
1208 references and not all compilers emit symbol type for undefined
1210 bfd_elf_link_mark_dynamic_symbol (info
, h
, sym
);
1212 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1213 respectively, is from a dynamic object. */
1215 newdyn
= (abfd
->flags
& DYNAMIC
) != 0;
1217 /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
1218 syms and defined syms in dynamic libraries respectively.
1219 ref_dynamic on the other hand can be set for a symbol defined in
1220 a dynamic library, and def_dynamic may not be set; When the
1221 definition in a dynamic lib is overridden by a definition in the
1222 executable use of the symbol in the dynamic lib becomes a
1223 reference to the executable symbol. */
1226 if (bfd_is_und_section (sec
))
1228 if (bind
!= STB_WEAK
)
1230 h
->ref_dynamic_nonweak
= 1;
1231 hi
->ref_dynamic_nonweak
= 1;
1236 /* Update the existing symbol only if they match. */
1239 hi
->dynamic_def
= 1;
1243 /* If we just created the symbol, mark it as being an ELF symbol.
1244 Other than that, there is nothing to do--there is no merge issue
1245 with a newly defined symbol--so we just return. */
1247 if (h
->root
.type
== bfd_link_hash_new
)
1253 /* In cases involving weak versioned symbols, we may wind up trying
1254 to merge a symbol with itself. Catch that here, to avoid the
1255 confusion that results if we try to override a symbol with
1256 itself. The additional tests catch cases like
1257 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1258 dynamic object, which we do want to handle here. */
1260 && (newweak
|| oldweak
)
1261 && ((abfd
->flags
& DYNAMIC
) == 0
1262 || !h
->def_regular
))
1267 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
1268 else if (oldsec
!= NULL
)
1270 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1271 indices used by MIPS ELF. */
1272 olddyn
= (oldsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
1276 && (oldbfd
->flags
& BFD_PLUGIN
) != (abfd
->flags
& BFD_PLUGIN
))
1278 if (newdyn
!= olddyn
)
1280 /* Handle a case where plugin_notice won't be called and thus
1281 won't set the non_ir_ref flags on the first pass over
1283 h
->root
.non_ir_ref_dynamic
= true;
1284 hi
->root
.non_ir_ref_dynamic
= true;
1287 if ((oldbfd
->flags
& BFD_PLUGIN
) != 0
1288 && hi
->root
.type
== bfd_link_hash_indirect
)
1290 /* Change indirect symbol from IR to undefined. */
1291 hi
->root
.type
= bfd_link_hash_undefined
;
1292 hi
->root
.u
.undef
.abfd
= oldbfd
;
1296 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1297 respectively, appear to be a definition rather than reference. */
1299 newdef
= !bfd_is_und_section (sec
) && !bfd_is_com_section (sec
);
1301 olddef
= (h
->root
.type
!= bfd_link_hash_undefined
1302 && h
->root
.type
!= bfd_link_hash_undefweak
1303 && h
->root
.type
!= bfd_link_hash_common
);
1305 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1306 respectively, appear to be a function. */
1308 newfunc
= (ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1309 && bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)));
1311 oldfunc
= (h
->type
!= STT_NOTYPE
1312 && bed
->is_function_type (h
->type
));
1314 if (!(newfunc
&& oldfunc
)
1315 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1316 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1317 && h
->type
!= STT_NOTYPE
1318 && (newdef
|| bfd_is_com_section (sec
))
1319 && (olddef
|| h
->root
.type
== bfd_link_hash_common
))
1321 /* If creating a default indirect symbol ("foo" or "foo@") from
1322 a dynamic versioned definition ("foo@@") skip doing so if
1323 there is an existing regular definition with a different
1324 type. We don't want, for example, a "time" variable in the
1325 executable overriding a "time" function in a shared library. */
1333 /* When adding a symbol from a regular object file after we have
1334 created indirect symbols, undo the indirection and any
1341 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
1342 h
->forced_local
= 0;
1346 if (h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1348 h
->root
.type
= bfd_link_hash_undefined
;
1349 h
->root
.u
.undef
.abfd
= abfd
;
1353 h
->root
.type
= bfd_link_hash_new
;
1354 h
->root
.u
.undef
.abfd
= NULL
;
1360 /* Check TLS symbols. We don't check undefined symbols introduced
1361 by "ld -u" which have no type (and oldbfd NULL), and we don't
1362 check symbols from plugins because they also have no type. */
1364 && (oldbfd
->flags
& BFD_PLUGIN
) == 0
1365 && (abfd
->flags
& BFD_PLUGIN
) == 0
1366 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1367 && (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
|| h
->type
== STT_TLS
))
1371 asection
*ntsec
, *tsec
;
1373 if (h
->type
== STT_TLS
)
1394 /* xgettext:c-format */
1395 (_("%s: TLS definition in %pB section %pA "
1396 "mismatches non-TLS definition in %pB section %pA"),
1397 h
->root
.root
.string
, tbfd
, tsec
, ntbfd
, ntsec
);
1398 else if (!tdef
&& !ntdef
)
1400 /* xgettext:c-format */
1401 (_("%s: TLS reference in %pB "
1402 "mismatches non-TLS reference in %pB"),
1403 h
->root
.root
.string
, tbfd
, ntbfd
);
1406 /* xgettext:c-format */
1407 (_("%s: TLS definition in %pB section %pA "
1408 "mismatches non-TLS reference in %pB"),
1409 h
->root
.root
.string
, tbfd
, tsec
, ntbfd
);
1412 /* xgettext:c-format */
1413 (_("%s: TLS reference in %pB "
1414 "mismatches non-TLS definition in %pB section %pA"),
1415 h
->root
.root
.string
, tbfd
, ntbfd
, ntsec
);
1417 bfd_set_error (bfd_error_bad_value
);
1421 /* If the old symbol has non-default visibility, we ignore the new
1422 definition from a dynamic object. */
1424 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1425 && !bfd_is_und_section (sec
))
1428 /* Make sure this symbol is dynamic. */
1430 hi
->ref_dynamic
= 1;
1431 /* A protected symbol has external availability. Make sure it is
1432 recorded as dynamic.
1434 FIXME: Should we check type and size for protected symbol? */
1435 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1436 return bfd_elf_link_record_dynamic_symbol (info
, h
);
1441 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
1444 /* If the new symbol with non-default visibility comes from a
1445 relocatable file and the old definition comes from a dynamic
1446 object, we remove the old definition. */
1447 if (hi
->root
.type
== bfd_link_hash_indirect
)
1449 /* Handle the case where the old dynamic definition is
1450 default versioned. We need to copy the symbol info from
1451 the symbol with default version to the normal one if it
1452 was referenced before. */
1455 hi
->root
.type
= h
->root
.type
;
1456 h
->root
.type
= bfd_link_hash_indirect
;
1457 (*bed
->elf_backend_copy_indirect_symbol
) (info
, hi
, h
);
1459 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1460 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1462 /* If the new symbol is hidden or internal, completely undo
1463 any dynamic link state. */
1464 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
1465 h
->forced_local
= 0;
1472 /* FIXME: Should we check type and size for protected symbol? */
1482 /* If the old symbol was undefined before, then it will still be
1483 on the undefs list. If the new symbol is undefined or
1484 common, we can't make it bfd_link_hash_new here, because new
1485 undefined or common symbols will be added to the undefs list
1486 by _bfd_generic_link_add_one_symbol. Symbols may not be
1487 added twice to the undefs list. Also, if the new symbol is
1488 undefweak then we don't want to lose the strong undef. */
1489 if (h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1491 h
->root
.type
= bfd_link_hash_undefined
;
1492 h
->root
.u
.undef
.abfd
= abfd
;
1496 h
->root
.type
= bfd_link_hash_new
;
1497 h
->root
.u
.undef
.abfd
= NULL
;
1500 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1502 /* If the new symbol is hidden or internal, completely undo
1503 any dynamic link state. */
1504 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
1505 h
->forced_local
= 0;
1511 /* FIXME: Should we check type and size for protected symbol? */
1517 /* If a new weak symbol definition comes from a regular file and the
1518 old symbol comes from a dynamic library, we treat the new one as
1519 strong. Similarly, an old weak symbol definition from a regular
1520 file is treated as strong when the new symbol comes from a dynamic
1521 library. Further, an old weak symbol from a dynamic library is
1522 treated as strong if the new symbol is from a dynamic library.
1523 This reflects the way glibc's ld.so works.
1525 Also allow a weak symbol to override a linker script symbol
1526 defined by an early pass over the script. This is done so the
1527 linker knows the symbol is defined in an object file, for the
1528 DEFINED script function.
1530 Do this before setting *type_change_ok or *size_change_ok so that
1531 we warn properly when dynamic library symbols are overridden. */
1533 if (newdef
&& !newdyn
&& (olddyn
|| h
->root
.ldscript_def
))
1535 if (olddef
&& newdyn
)
1538 /* Allow changes between different types of function symbol. */
1539 if (newfunc
&& oldfunc
)
1540 *type_change_ok
= true;
1542 /* It's OK to change the type if either the existing symbol or the
1543 new symbol is weak. A type change is also OK if the old symbol
1544 is undefined and the new symbol is defined. */
1549 && h
->root
.type
== bfd_link_hash_undefined
))
1550 *type_change_ok
= true;
1552 /* It's OK to change the size if either the existing symbol or the
1553 new symbol is weak, or if the old symbol is undefined. */
1556 || h
->root
.type
== bfd_link_hash_undefined
)
1557 *size_change_ok
= true;
1559 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1560 symbol, respectively, appears to be a common symbol in a dynamic
1561 object. If a symbol appears in an uninitialized section, and is
1562 not weak, and is not a function, then it may be a common symbol
1563 which was resolved when the dynamic object was created. We want
1564 to treat such symbols specially, because they raise special
1565 considerations when setting the symbol size: if the symbol
1566 appears as a common symbol in a regular object, and the size in
1567 the regular object is larger, we must make sure that we use the
1568 larger size. This problematic case can always be avoided in C,
1569 but it must be handled correctly when using Fortran shared
1572 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1573 likewise for OLDDYNCOMMON and OLDDEF.
1575 Note that this test is just a heuristic, and that it is quite
1576 possible to have an uninitialized symbol in a shared object which
1577 is really a definition, rather than a common symbol. This could
1578 lead to some minor confusion when the symbol really is a common
1579 symbol in some regular object. However, I think it will be
1585 && (sec
->flags
& SEC_ALLOC
) != 0
1586 && (sec
->flags
& SEC_LOAD
) == 0
1589 newdyncommon
= true;
1591 newdyncommon
= false;
1595 && h
->root
.type
== bfd_link_hash_defined
1597 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1598 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
1601 olddyncommon
= true;
1603 olddyncommon
= false;
1605 /* We now know everything about the old and new symbols. We ask the
1606 backend to check if we can merge them. */
1607 if (bed
->merge_symbol
!= NULL
)
1609 if (!bed
->merge_symbol (h
, sym
, psec
, newdef
, olddef
, oldbfd
, oldsec
))
1614 /* There are multiple definitions of a normal symbol. Skip the
1615 default symbol as well as definition from an IR object. */
1616 if (olddef
&& !olddyn
&& !oldweak
&& newdef
&& !newdyn
&& !newweak
1617 && !default_sym
&& h
->def_regular
1619 && (oldbfd
->flags
& BFD_PLUGIN
) != 0
1620 && (abfd
->flags
& BFD_PLUGIN
) == 0))
1622 /* Handle a multiple definition. */
1623 (*info
->callbacks
->multiple_definition
) (info
, &h
->root
,
1624 abfd
, sec
, *pvalue
);
1629 /* If both the old and the new symbols look like common symbols in a
1630 dynamic object, set the size of the symbol to the larger of the
1635 && sym
->st_size
!= h
->size
)
1637 /* Since we think we have two common symbols, issue a multiple
1638 common warning if desired. Note that we only warn if the
1639 size is different. If the size is the same, we simply let
1640 the old symbol override the new one as normally happens with
1641 symbols defined in dynamic objects. */
1643 (*info
->callbacks
->multiple_common
) (info
, &h
->root
, abfd
,
1644 bfd_link_hash_common
, sym
->st_size
);
1645 if (sym
->st_size
> h
->size
)
1646 h
->size
= sym
->st_size
;
1648 *size_change_ok
= true;
1651 /* If we are looking at a dynamic object, and we have found a
1652 definition, we need to see if the symbol was already defined by
1653 some other object. If so, we want to use the existing
1654 definition, and we do not want to report a multiple symbol
1655 definition error; we do this by clobbering *PSEC to be
1656 bfd_und_section_ptr.
1658 We treat a common symbol as a definition if the symbol in the
1659 shared library is a function, since common symbols always
1660 represent variables; this can cause confusion in principle, but
1661 any such confusion would seem to indicate an erroneous program or
1662 shared library. We also permit a common symbol in a regular
1663 object to override a weak symbol in a shared object. */
1668 || (h
->root
.type
== bfd_link_hash_common
1669 && (newweak
|| newfunc
))))
1673 newdyncommon
= false;
1675 *psec
= sec
= bfd_und_section_ptr
;
1676 *size_change_ok
= true;
1678 /* If we get here when the old symbol is a common symbol, then
1679 we are explicitly letting it override a weak symbol or
1680 function in a dynamic object, and we don't want to warn about
1681 a type change. If the old symbol is a defined symbol, a type
1682 change warning may still be appropriate. */
1684 if (h
->root
.type
== bfd_link_hash_common
)
1685 *type_change_ok
= true;
1688 /* Handle the special case of an old common symbol merging with a
1689 new symbol which looks like a common symbol in a shared object.
1690 We change *PSEC and *PVALUE to make the new symbol look like a
1691 common symbol, and let _bfd_generic_link_add_one_symbol do the
1695 && h
->root
.type
== bfd_link_hash_common
)
1699 newdyncommon
= false;
1700 *pvalue
= sym
->st_size
;
1701 *psec
= sec
= bed
->common_section (oldsec
);
1702 *size_change_ok
= true;
1705 /* Skip weak definitions of symbols that are already defined. */
1706 if (newdef
&& olddef
&& newweak
)
1708 /* Don't skip new non-IR weak syms. */
1709 if (!(oldbfd
!= NULL
1710 && (oldbfd
->flags
& BFD_PLUGIN
) != 0
1711 && (abfd
->flags
& BFD_PLUGIN
) == 0))
1717 /* Merge st_other. If the symbol already has a dynamic index,
1718 but visibility says it should not be visible, turn it into a
1720 elf_merge_st_other (abfd
, h
, sym
->st_other
, sec
, newdef
, newdyn
);
1721 if (h
->dynindx
!= -1)
1722 switch (ELF_ST_VISIBILITY (h
->other
))
1726 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
1731 /* If the old symbol is from a dynamic object, and the new symbol is
1732 a definition which is not from a dynamic object, then the new
1733 symbol overrides the old symbol. Symbols from regular files
1734 always take precedence over symbols from dynamic objects, even if
1735 they are defined after the dynamic object in the link.
1737 As above, we again permit a common symbol in a regular object to
1738 override a definition in a shared object if the shared object
1739 symbol is a function or is weak. */
1744 || (bfd_is_com_section (sec
)
1745 && (oldweak
|| oldfunc
)))
1750 /* Change the hash table entry to undefined, and let
1751 _bfd_generic_link_add_one_symbol do the right thing with the
1754 h
->root
.type
= bfd_link_hash_undefined
;
1755 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1756 *size_change_ok
= true;
1759 olddyncommon
= false;
1761 /* We again permit a type change when a common symbol may be
1762 overriding a function. */
1764 if (bfd_is_com_section (sec
))
1768 /* If a common symbol overrides a function, make sure
1769 that it isn't defined dynamically nor has type
1772 h
->type
= STT_NOTYPE
;
1774 *type_change_ok
= true;
1777 if (hi
->root
.type
== bfd_link_hash_indirect
)
1780 /* This union may have been set to be non-NULL when this symbol
1781 was seen in a dynamic object. We must force the union to be
1782 NULL, so that it is correct for a regular symbol. */
1783 h
->verinfo
.vertree
= NULL
;
1786 /* Handle the special case of a new common symbol merging with an
1787 old symbol that looks like it might be a common symbol defined in
1788 a shared object. Note that we have already handled the case in
1789 which a new common symbol should simply override the definition
1790 in the shared library. */
1793 && bfd_is_com_section (sec
)
1796 /* It would be best if we could set the hash table entry to a
1797 common symbol, but we don't know what to use for the section
1798 or the alignment. */
1799 (*info
->callbacks
->multiple_common
) (info
, &h
->root
, abfd
,
1800 bfd_link_hash_common
, sym
->st_size
);
1802 /* If the presumed common symbol in the dynamic object is
1803 larger, pretend that the new symbol has its size. */
1805 if (h
->size
> *pvalue
)
1808 /* We need to remember the alignment required by the symbol
1809 in the dynamic object. */
1810 BFD_ASSERT (pold_alignment
);
1811 *pold_alignment
= h
->root
.u
.def
.section
->alignment_power
;
1814 olddyncommon
= false;
1816 h
->root
.type
= bfd_link_hash_undefined
;
1817 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1819 *size_change_ok
= true;
1820 *type_change_ok
= true;
1822 if (hi
->root
.type
== bfd_link_hash_indirect
)
1825 h
->verinfo
.vertree
= NULL
;
1830 /* Handle the case where we had a versioned symbol in a dynamic
1831 library and now find a definition in a normal object. In this
1832 case, we make the versioned symbol point to the normal one. */
1833 flip
->root
.type
= h
->root
.type
;
1834 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1835 h
->root
.type
= bfd_link_hash_indirect
;
1836 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1837 (*bed
->elf_backend_copy_indirect_symbol
) (info
, flip
, h
);
1841 flip
->ref_dynamic
= 1;
1848 /* This function is called to create an indirect symbol from the
1849 default for the symbol with the default version if needed. The
1850 symbol is described by H, NAME, SYM, SEC, and VALUE. We
1851 set DYNSYM if the new indirect symbol is dynamic. */
1854 _bfd_elf_add_default_symbol (bfd
*abfd
,
1855 struct bfd_link_info
*info
,
1856 struct elf_link_hash_entry
*h
,
1858 Elf_Internal_Sym
*sym
,
1864 bool type_change_ok
;
1865 bool size_change_ok
;
1868 struct elf_link_hash_entry
*hi
;
1869 struct bfd_link_hash_entry
*bh
;
1870 const struct elf_backend_data
*bed
;
1875 size_t len
, shortlen
;
1879 if (h
->versioned
== unversioned
|| h
->versioned
== versioned_hidden
)
1882 /* If this symbol has a version, and it is the default version, we
1883 create an indirect symbol from the default name to the fully
1884 decorated name. This will cause external references which do not
1885 specify a version to be bound to this version of the symbol. */
1886 p
= strchr (name
, ELF_VER_CHR
);
1887 if (h
->versioned
== unknown
)
1891 h
->versioned
= unversioned
;
1896 if (p
[1] != ELF_VER_CHR
)
1898 h
->versioned
= versioned_hidden
;
1902 h
->versioned
= versioned
;
1907 /* PR ld/19073: We may see an unversioned definition after the
1913 bed
= get_elf_backend_data (abfd
);
1914 collect
= bed
->collect
;
1915 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1917 shortlen
= p
- name
;
1918 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1919 if (shortname
== NULL
)
1921 memcpy (shortname
, name
, shortlen
);
1922 shortname
[shortlen
] = '\0';
1924 /* We are going to create a new symbol. Merge it with any existing
1925 symbol with this name. For the purposes of the merge, act as
1926 though we were defining the symbol we just defined, although we
1927 actually going to define an indirect symbol. */
1928 type_change_ok
= false;
1929 size_change_ok
= false;
1932 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &tmp_sec
, &value
,
1933 &hi
, poldbfd
, NULL
, NULL
, &skip
, &override
,
1934 &type_change_ok
, &size_change_ok
, &matched
))
1940 if (hi
->def_regular
|| ELF_COMMON_DEF_P (hi
))
1942 /* If the undecorated symbol will have a version added by a
1943 script different to H, then don't indirect to/from the
1944 undecorated symbol. This isn't ideal because we may not yet
1945 have seen symbol versions, if given by a script on the
1946 command line rather than via --version-script. */
1947 if (hi
->verinfo
.vertree
== NULL
&& info
->version_info
!= NULL
)
1952 = bfd_find_version_for_sym (info
->version_info
,
1953 hi
->root
.root
.string
, &hide
);
1954 if (hi
->verinfo
.vertree
!= NULL
&& hide
)
1956 (*bed
->elf_backend_hide_symbol
) (info
, hi
, true);
1960 if (hi
->verinfo
.vertree
!= NULL
1961 && strcmp (p
+ 1 + (p
[1] == '@'), hi
->verinfo
.vertree
->name
) != 0)
1967 /* Add the default symbol if not performing a relocatable link. */
1968 if (! bfd_link_relocatable (info
))
1971 if (bh
->type
== bfd_link_hash_defined
1972 && bh
->u
.def
.section
->owner
!= NULL
1973 && (bh
->u
.def
.section
->owner
->flags
& BFD_PLUGIN
) != 0)
1975 /* Mark the previous definition from IR object as
1976 undefined so that the generic linker will override
1978 bh
->type
= bfd_link_hash_undefined
;
1979 bh
->u
.undef
.abfd
= bh
->u
.def
.section
->owner
;
1981 if (! (_bfd_generic_link_add_one_symbol
1982 (info
, abfd
, shortname
, BSF_INDIRECT
,
1983 bfd_ind_section_ptr
,
1984 0, name
, false, collect
, &bh
)))
1986 hi
= (struct elf_link_hash_entry
*) bh
;
1991 /* In this case the symbol named SHORTNAME is overriding the
1992 indirect symbol we want to add. We were planning on making
1993 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1994 is the name without a version. NAME is the fully versioned
1995 name, and it is the default version.
1997 Overriding means that we already saw a definition for the
1998 symbol SHORTNAME in a regular object, and it is overriding
1999 the symbol defined in the dynamic object.
2001 When this happens, we actually want to change NAME, the
2002 symbol we just added, to refer to SHORTNAME. This will cause
2003 references to NAME in the shared object to become references
2004 to SHORTNAME in the regular object. This is what we expect
2005 when we override a function in a shared object: that the
2006 references in the shared object will be mapped to the
2007 definition in the regular object. */
2009 while (hi
->root
.type
== bfd_link_hash_indirect
2010 || hi
->root
.type
== bfd_link_hash_warning
)
2011 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
2013 h
->root
.type
= bfd_link_hash_indirect
;
2014 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
2018 hi
->ref_dynamic
= 1;
2022 if (! bfd_elf_link_record_dynamic_symbol (info
, hi
))
2027 /* Now set HI to H, so that the following code will set the
2028 other fields correctly. */
2032 /* Check if HI is a warning symbol. */
2033 if (hi
->root
.type
== bfd_link_hash_warning
)
2034 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
2036 /* If there is a duplicate definition somewhere, then HI may not
2037 point to an indirect symbol. We will have reported an error to
2038 the user in that case. */
2040 if (hi
->root
.type
== bfd_link_hash_indirect
)
2042 struct elf_link_hash_entry
*ht
;
2044 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
2045 (*bed
->elf_backend_copy_indirect_symbol
) (info
, ht
, hi
);
2047 /* If we first saw a reference to SHORTNAME with non-default
2048 visibility, merge that visibility to the @@VER symbol. */
2049 elf_merge_st_other (abfd
, ht
, hi
->other
, sec
, true, dynamic
);
2051 /* A reference to the SHORTNAME symbol from a dynamic library
2052 will be satisfied by the versioned symbol at runtime. In
2053 effect, we have a reference to the versioned symbol. */
2054 ht
->ref_dynamic_nonweak
|= hi
->ref_dynamic_nonweak
;
2055 hi
->dynamic_def
|= ht
->dynamic_def
;
2057 /* See if the new flags lead us to realize that the symbol must
2063 if (! bfd_link_executable (info
)
2070 if (hi
->ref_regular
)
2076 /* We also need to define an indirection from the nondefault version
2080 len
= strlen (name
);
2081 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, len
);
2082 if (shortname
== NULL
)
2084 memcpy (shortname
, name
, shortlen
);
2085 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
2087 /* Once again, merge with any existing symbol. */
2088 type_change_ok
= false;
2089 size_change_ok
= false;
2091 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &tmp_sec
, &value
,
2092 &hi
, poldbfd
, NULL
, NULL
, &skip
, &override
,
2093 &type_change_ok
, &size_change_ok
, &matched
))
2099 && h
->root
.type
== bfd_link_hash_defweak
2100 && hi
->root
.type
== bfd_link_hash_defined
)
2102 /* We are handling a weak sym@@ver and attempting to define
2103 a weak sym@ver, but _bfd_elf_merge_symbol said to skip the
2104 new weak sym@ver because there is already a strong sym@ver.
2105 However, sym@ver and sym@@ver are really the same symbol.
2106 The existing strong sym@ver ought to override sym@@ver. */
2107 h
->root
.type
= bfd_link_hash_defined
;
2108 h
->root
.u
.def
.section
= hi
->root
.u
.def
.section
;
2109 h
->root
.u
.def
.value
= hi
->root
.u
.def
.value
;
2110 hi
->root
.type
= bfd_link_hash_indirect
;
2111 hi
->root
.u
.i
.link
= &h
->root
;
2118 /* Here SHORTNAME is a versioned name, so we don't expect to see
2119 the type of override we do in the case above unless it is
2120 overridden by a versioned definition. */
2121 if (hi
->root
.type
!= bfd_link_hash_defined
2122 && hi
->root
.type
!= bfd_link_hash_defweak
)
2124 /* xgettext:c-format */
2125 (_("%pB: unexpected redefinition of indirect versioned symbol `%s'"),
2132 if (! (_bfd_generic_link_add_one_symbol
2133 (info
, abfd
, shortname
, BSF_INDIRECT
,
2134 bfd_ind_section_ptr
, 0, name
, false, collect
, &bh
)))
2136 hi
= (struct elf_link_hash_entry
*) bh
;
2139 /* If there is a duplicate definition somewhere, then HI may not
2140 point to an indirect symbol. We will have reported an error
2141 to the user in that case. */
2142 if (hi
->root
.type
== bfd_link_hash_indirect
)
2144 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
2145 h
->ref_dynamic_nonweak
|= hi
->ref_dynamic_nonweak
;
2146 hi
->dynamic_def
|= h
->dynamic_def
;
2148 /* If we first saw a reference to @VER symbol with
2149 non-default visibility, merge that visibility to the
2151 elf_merge_st_other (abfd
, h
, hi
->other
, sec
, true, dynamic
);
2153 /* See if the new flags lead us to realize that the symbol
2159 if (! bfd_link_executable (info
)
2165 if (hi
->ref_regular
)
2174 /* This routine is used to export all defined symbols into the dynamic
2175 symbol table. It is called via elf_link_hash_traverse. */
2178 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
2180 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2182 /* Ignore indirect symbols. These are added by the versioning code. */
2183 if (h
->root
.type
== bfd_link_hash_indirect
)
2186 /* Ignore this if we won't export it. */
2187 if (!eif
->info
->export_dynamic
&& !h
->dynamic
)
2190 if (h
->dynindx
== -1
2191 && (h
->def_regular
|| h
->ref_regular
)
2192 && ! bfd_hide_sym_by_version (eif
->info
->version_info
,
2193 h
->root
.root
.string
))
2195 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2205 /* Look through the symbols which are defined in other shared
2206 libraries and referenced here. Update the list of version
2207 dependencies. This will be put into the .gnu.version_r section.
2208 This function is called via elf_link_hash_traverse. */
2211 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
2214 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
2215 Elf_Internal_Verneed
*t
;
2216 Elf_Internal_Vernaux
*a
;
2219 /* We only care about symbols defined in shared objects with version
2224 || h
->verinfo
.verdef
== NULL
2225 || (elf_dyn_lib_class (h
->verinfo
.verdef
->vd_bfd
)
2226 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
| DYN_NO_NEEDED
)))
2229 /* See if we already know about this version. */
2230 for (t
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
2234 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
2237 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2238 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
2244 /* This is a new version. Add it to tree we are building. */
2249 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
2252 rinfo
->failed
= true;
2256 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
2257 t
->vn_nextref
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
2258 elf_tdata (rinfo
->info
->output_bfd
)->verref
= t
;
2262 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
2265 rinfo
->failed
= true;
2269 /* Note that we are copying a string pointer here, and testing it
2270 above. If bfd_elf_string_from_elf_section is ever changed to
2271 discard the string data when low in memory, this will have to be
2273 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
2275 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
2276 a
->vna_nextptr
= t
->vn_auxptr
;
2278 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
2281 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
2288 /* Return TRUE and set *HIDE to TRUE if the versioned symbol is
2289 hidden. Set *T_P to NULL if there is no match. */
2292 _bfd_elf_link_hide_versioned_symbol (struct bfd_link_info
*info
,
2293 struct elf_link_hash_entry
*h
,
2294 const char *version_p
,
2295 struct bfd_elf_version_tree
**t_p
,
2298 struct bfd_elf_version_tree
*t
;
2300 /* Look for the version. If we find it, it is no longer weak. */
2301 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
2303 if (strcmp (t
->name
, version_p
) == 0)
2307 struct bfd_elf_version_expr
*d
;
2309 len
= version_p
- h
->root
.root
.string
;
2310 alc
= (char *) bfd_malloc (len
);
2313 memcpy (alc
, h
->root
.root
.string
, len
- 1);
2314 alc
[len
- 1] = '\0';
2315 if (alc
[len
- 2] == ELF_VER_CHR
)
2316 alc
[len
- 2] = '\0';
2318 h
->verinfo
.vertree
= t
;
2322 if (t
->globals
.list
!= NULL
)
2323 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
2325 /* See if there is anything to force this symbol to
2327 if (d
== NULL
&& t
->locals
.list
!= NULL
)
2329 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
2332 && ! info
->export_dynamic
)
2346 /* Return TRUE if the symbol H is hidden by version script. */
2349 _bfd_elf_link_hide_sym_by_version (struct bfd_link_info
*info
,
2350 struct elf_link_hash_entry
*h
)
2354 const struct elf_backend_data
*bed
2355 = get_elf_backend_data (info
->output_bfd
);
2357 /* Version script only hides symbols defined in regular objects. */
2358 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
2361 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
2362 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
2364 struct bfd_elf_version_tree
*t
;
2367 if (*p
== ELF_VER_CHR
)
2371 && _bfd_elf_link_hide_versioned_symbol (info
, h
, p
, &t
, &hide
)
2375 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
2380 /* If we don't have a version for this symbol, see if we can find
2382 if (h
->verinfo
.vertree
== NULL
&& info
->version_info
!= NULL
)
2385 = bfd_find_version_for_sym (info
->version_info
,
2386 h
->root
.root
.string
, &hide
);
2387 if (h
->verinfo
.vertree
!= NULL
&& hide
)
2389 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
2397 /* Figure out appropriate versions for all the symbols. We may not
2398 have the version number script until we have read all of the input
2399 files, so until that point we don't know which symbols should be
2400 local. This function is called via elf_link_hash_traverse. */
2403 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
2405 struct elf_info_failed
*sinfo
;
2406 struct bfd_link_info
*info
;
2407 const struct elf_backend_data
*bed
;
2408 struct elf_info_failed eif
;
2412 sinfo
= (struct elf_info_failed
*) data
;
2415 /* Fix the symbol flags. */
2418 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
2421 sinfo
->failed
= true;
2425 bed
= get_elf_backend_data (info
->output_bfd
);
2427 /* We only need version numbers for symbols defined in regular
2429 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
2431 /* Hide symbols defined in discarded input sections. */
2432 if ((h
->root
.type
== bfd_link_hash_defined
2433 || h
->root
.type
== bfd_link_hash_defweak
)
2434 && discarded_section (h
->root
.u
.def
.section
))
2435 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
2440 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
2441 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
2443 struct bfd_elf_version_tree
*t
;
2446 if (*p
== ELF_VER_CHR
)
2449 /* If there is no version string, we can just return out. */
2453 if (!_bfd_elf_link_hide_versioned_symbol (info
, h
, p
, &t
, &hide
))
2455 sinfo
->failed
= true;
2460 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
2462 /* If we are building an application, we need to create a
2463 version node for this version. */
2464 if (t
== NULL
&& bfd_link_executable (info
))
2466 struct bfd_elf_version_tree
**pp
;
2469 /* If we aren't going to export this symbol, we don't need
2470 to worry about it. */
2471 if (h
->dynindx
== -1)
2474 t
= (struct bfd_elf_version_tree
*) bfd_zalloc (info
->output_bfd
,
2478 sinfo
->failed
= true;
2483 t
->name_indx
= (unsigned int) -1;
2487 /* Don't count anonymous version tag. */
2488 if (sinfo
->info
->version_info
!= NULL
2489 && sinfo
->info
->version_info
->vernum
== 0)
2491 for (pp
= &sinfo
->info
->version_info
;
2495 t
->vernum
= version_index
;
2499 h
->verinfo
.vertree
= t
;
2503 /* We could not find the version for a symbol when
2504 generating a shared archive. Return an error. */
2506 /* xgettext:c-format */
2507 (_("%pB: version node not found for symbol %s"),
2508 info
->output_bfd
, h
->root
.root
.string
);
2509 bfd_set_error (bfd_error_bad_value
);
2510 sinfo
->failed
= true;
2515 /* If we don't have a version for this symbol, see if we can find
2518 && h
->verinfo
.vertree
== NULL
2519 && sinfo
->info
->version_info
!= NULL
)
2522 = bfd_find_version_for_sym (sinfo
->info
->version_info
,
2523 h
->root
.root
.string
, &hide
);
2524 if (h
->verinfo
.vertree
!= NULL
&& hide
)
2525 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
2531 /* Read and swap the relocs from the section indicated by SHDR. This
2532 may be either a REL or a RELA section. The relocations are
2533 translated into RELA relocations and stored in INTERNAL_RELOCS,
2534 which should have already been allocated to contain enough space.
2535 The EXTERNAL_RELOCS are a buffer where the external form of the
2536 relocations should be stored.
2538 Returns FALSE if something goes wrong. */
2541 elf_link_read_relocs_from_section (bfd
*abfd
,
2543 Elf_Internal_Shdr
*shdr
,
2544 void *external_relocs
,
2545 Elf_Internal_Rela
*internal_relocs
)
2547 const struct elf_backend_data
*bed
;
2548 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2549 const bfd_byte
*erela
;
2550 const bfd_byte
*erelaend
;
2551 Elf_Internal_Rela
*irela
;
2552 Elf_Internal_Shdr
*symtab_hdr
;
2555 /* Position ourselves at the start of the section. */
2556 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2559 /* Read the relocations. */
2560 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
2563 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2564 nsyms
= NUM_SHDR_ENTRIES (symtab_hdr
);
2566 bed
= get_elf_backend_data (abfd
);
2568 /* Convert the external relocations to the internal format. */
2569 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2570 swap_in
= bed
->s
->swap_reloc_in
;
2571 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2572 swap_in
= bed
->s
->swap_reloca_in
;
2575 bfd_set_error (bfd_error_wrong_format
);
2579 erela
= (const bfd_byte
*) external_relocs
;
2580 /* Setting erelaend like this and comparing with <= handles case of
2581 a fuzzed object with sh_size not a multiple of sh_entsize. */
2582 erelaend
= erela
+ shdr
->sh_size
- shdr
->sh_entsize
;
2583 irela
= internal_relocs
;
2584 while (erela
<= erelaend
)
2588 (*swap_in
) (abfd
, erela
, irela
);
2589 r_symndx
= ELF32_R_SYM (irela
->r_info
);
2590 if (bed
->s
->arch_size
== 64)
2594 if ((size_t) r_symndx
>= nsyms
)
2597 /* xgettext:c-format */
2598 (_("%pB: bad reloc symbol index (%#" PRIx64
" >= %#lx)"
2599 " for offset %#" PRIx64
" in section `%pA'"),
2600 abfd
, (uint64_t) r_symndx
, (unsigned long) nsyms
,
2601 (uint64_t) irela
->r_offset
, sec
);
2602 bfd_set_error (bfd_error_bad_value
);
2606 else if (r_symndx
!= STN_UNDEF
)
2609 /* xgettext:c-format */
2610 (_("%pB: non-zero symbol index (%#" PRIx64
")"
2611 " for offset %#" PRIx64
" in section `%pA'"
2612 " when the object file has no symbol table"),
2613 abfd
, (uint64_t) r_symndx
,
2614 (uint64_t) irela
->r_offset
, sec
);
2615 bfd_set_error (bfd_error_bad_value
);
2618 irela
+= bed
->s
->int_rels_per_ext_rel
;
2619 erela
+= shdr
->sh_entsize
;
2625 /* Read and swap the relocs for a section O. They may have been
2626 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2627 not NULL, they are used as buffers to read into. They are known to
2628 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2629 the return value is allocated using either malloc or bfd_alloc,
2630 according to the KEEP_MEMORY argument. If O has two relocation
2631 sections (both REL and RELA relocations), then the REL_HDR
2632 relocations will appear first in INTERNAL_RELOCS, followed by the
2633 RELA_HDR relocations. If INFO isn't NULL and KEEP_MEMORY is true,
2634 update cache_size. */
2637 _bfd_elf_link_info_read_relocs (bfd
*abfd
,
2638 struct bfd_link_info
*info
,
2640 void *external_relocs
,
2641 Elf_Internal_Rela
*internal_relocs
,
2644 void *alloc1
= NULL
;
2645 Elf_Internal_Rela
*alloc2
= NULL
;
2646 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2647 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
2648 Elf_Internal_Rela
*internal_rela_relocs
;
2650 if (esdo
->relocs
!= NULL
)
2651 return esdo
->relocs
;
2653 if (o
->reloc_count
== 0)
2656 if (internal_relocs
== NULL
)
2660 size
= (bfd_size_type
) o
->reloc_count
* sizeof (Elf_Internal_Rela
);
2663 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2665 info
->cache_size
+= size
;
2668 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2669 if (internal_relocs
== NULL
)
2673 if (external_relocs
== NULL
)
2675 bfd_size_type size
= 0;
2678 size
+= esdo
->rel
.hdr
->sh_size
;
2680 size
+= esdo
->rela
.hdr
->sh_size
;
2682 alloc1
= bfd_malloc (size
);
2685 external_relocs
= alloc1
;
2688 internal_rela_relocs
= internal_relocs
;
2691 if (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rel
.hdr
,
2695 external_relocs
= (((bfd_byte
*) external_relocs
)
2696 + esdo
->rel
.hdr
->sh_size
);
2697 internal_rela_relocs
+= (NUM_SHDR_ENTRIES (esdo
->rel
.hdr
)
2698 * bed
->s
->int_rels_per_ext_rel
);
2702 && (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rela
.hdr
,
2704 internal_rela_relocs
)))
2707 /* Cache the results for next time, if we can. */
2709 esdo
->relocs
= internal_relocs
;
2713 /* Don't free alloc2, since if it was allocated we are passing it
2714 back (under the name of internal_relocs). */
2716 return internal_relocs
;
2723 bfd_release (abfd
, alloc2
);
2730 /* This is similar to _bfd_elf_link_info_read_relocs, except for that
2731 NULL is passed to _bfd_elf_link_info_read_relocs for pointer to
2732 struct bfd_link_info. */
2735 _bfd_elf_link_read_relocs (bfd
*abfd
,
2737 void *external_relocs
,
2738 Elf_Internal_Rela
*internal_relocs
,
2741 return _bfd_elf_link_info_read_relocs (abfd
, NULL
, o
, external_relocs
,
2742 internal_relocs
, keep_memory
);
2746 /* Compute the size of, and allocate space for, REL_HDR which is the
2747 section header for a section containing relocations for O. */
2750 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2751 struct bfd_elf_section_reloc_data
*reldata
)
2753 Elf_Internal_Shdr
*rel_hdr
= reldata
->hdr
;
2755 /* That allows us to calculate the size of the section. */
2756 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reldata
->count
;
2758 /* The contents field must last into write_object_contents, so we
2759 allocate it with bfd_alloc rather than malloc. Also since we
2760 cannot be sure that the contents will actually be filled in,
2761 we zero the allocated space. */
2762 rel_hdr
->contents
= (unsigned char *) bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2763 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2766 if (reldata
->hashes
== NULL
&& reldata
->count
)
2768 struct elf_link_hash_entry
**p
;
2770 p
= ((struct elf_link_hash_entry
**)
2771 bfd_zmalloc (reldata
->count
* sizeof (*p
)));
2775 reldata
->hashes
= p
;
2781 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2782 originated from the section given by INPUT_REL_HDR) to the
2786 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2787 asection
*input_section
,
2788 Elf_Internal_Shdr
*input_rel_hdr
,
2789 Elf_Internal_Rela
*internal_relocs
,
2790 struct elf_link_hash_entry
**rel_hash
2793 Elf_Internal_Rela
*irela
;
2794 Elf_Internal_Rela
*irelaend
;
2796 struct bfd_elf_section_reloc_data
*output_reldata
;
2797 asection
*output_section
;
2798 const struct elf_backend_data
*bed
;
2799 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2800 struct bfd_elf_section_data
*esdo
;
2802 output_section
= input_section
->output_section
;
2804 bed
= get_elf_backend_data (output_bfd
);
2805 esdo
= elf_section_data (output_section
);
2806 if (esdo
->rel
.hdr
&& esdo
->rel
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2808 output_reldata
= &esdo
->rel
;
2809 swap_out
= bed
->s
->swap_reloc_out
;
2811 else if (esdo
->rela
.hdr
2812 && esdo
->rela
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2814 output_reldata
= &esdo
->rela
;
2815 swap_out
= bed
->s
->swap_reloca_out
;
2820 /* xgettext:c-format */
2821 (_("%pB: relocation size mismatch in %pB section %pA"),
2822 output_bfd
, input_section
->owner
, input_section
);
2823 bfd_set_error (bfd_error_wrong_format
);
2827 erel
= output_reldata
->hdr
->contents
;
2828 erel
+= output_reldata
->count
* input_rel_hdr
->sh_entsize
;
2829 irela
= internal_relocs
;
2830 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2831 * bed
->s
->int_rels_per_ext_rel
);
2832 while (irela
< irelaend
)
2834 (*swap_out
) (output_bfd
, irela
, erel
);
2835 irela
+= bed
->s
->int_rels_per_ext_rel
;
2836 erel
+= input_rel_hdr
->sh_entsize
;
2839 /* Bump the counter, so that we know where to add the next set of
2841 output_reldata
->count
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2846 /* Make weak undefined symbols in PIE dynamic. */
2849 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info
*info
,
2850 struct elf_link_hash_entry
*h
)
2852 if (bfd_link_pie (info
)
2854 && h
->root
.type
== bfd_link_hash_undefweak
)
2855 return bfd_elf_link_record_dynamic_symbol (info
, h
);
2860 /* Fix up the flags for a symbol. This handles various cases which
2861 can only be fixed after all the input files are seen. This is
2862 currently called by both adjust_dynamic_symbol and
2863 assign_sym_version, which is unnecessary but perhaps more robust in
2864 the face of future changes. */
2867 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2868 struct elf_info_failed
*eif
)
2870 const struct elf_backend_data
*bed
;
2872 /* If this symbol was mentioned in a non-ELF file, try to set
2873 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2874 permit a non-ELF file to correctly refer to a symbol defined in
2875 an ELF dynamic object. */
2878 while (h
->root
.type
== bfd_link_hash_indirect
)
2879 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2881 if (h
->root
.type
!= bfd_link_hash_defined
2882 && h
->root
.type
!= bfd_link_hash_defweak
)
2885 h
->ref_regular_nonweak
= 1;
2889 if (h
->root
.u
.def
.section
->owner
!= NULL
2890 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2891 == bfd_target_elf_flavour
))
2894 h
->ref_regular_nonweak
= 1;
2900 if (h
->dynindx
== -1
2904 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2913 /* Unfortunately, NON_ELF is only correct if the symbol
2914 was first seen in a non-ELF file. Fortunately, if the symbol
2915 was first seen in an ELF file, we're probably OK unless the
2916 symbol was defined in a non-ELF file. Catch that case here.
2917 FIXME: We're still in trouble if the symbol was first seen in
2918 a dynamic object, and then later in a non-ELF regular object. */
2919 if ((h
->root
.type
== bfd_link_hash_defined
2920 || h
->root
.type
== bfd_link_hash_defweak
)
2922 && (h
->root
.u
.def
.section
->owner
!= NULL
2923 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2924 != bfd_target_elf_flavour
)
2925 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2926 && !h
->def_dynamic
)))
2930 /* Backend specific symbol fixup. */
2931 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2932 if (bed
->elf_backend_fixup_symbol
2933 && !(*bed
->elf_backend_fixup_symbol
) (eif
->info
, h
))
2936 /* If this is a final link, and the symbol was defined as a common
2937 symbol in a regular object file, and there was no definition in
2938 any dynamic object, then the linker will have allocated space for
2939 the symbol in a common section but the DEF_REGULAR
2940 flag will not have been set. */
2941 if (h
->root
.type
== bfd_link_hash_defined
2945 && (h
->root
.u
.def
.section
->owner
->flags
& (DYNAMIC
| BFD_PLUGIN
)) == 0)
2948 /* Symbols defined in discarded sections shouldn't be dynamic. */
2949 if (h
->root
.type
== bfd_link_hash_undefined
&& h
->indx
== -3)
2950 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, true);
2952 /* If a weak undefined symbol has non-default visibility, we also
2953 hide it from the dynamic linker. */
2954 else if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2955 && h
->root
.type
== bfd_link_hash_undefweak
)
2956 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, true);
2958 /* A hidden versioned symbol in executable should be forced local if
2959 it is is locally defined, not referenced by shared library and not
2961 else if (bfd_link_executable (eif
->info
)
2962 && h
->versioned
== versioned_hidden
2963 && !eif
->info
->export_dynamic
2967 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, true);
2969 /* If -Bsymbolic was used (which means to bind references to global
2970 symbols to the definition within the shared object), and this
2971 symbol was defined in a regular object, then it actually doesn't
2972 need a PLT entry. Likewise, if the symbol has non-default
2973 visibility. If the symbol has hidden or internal visibility, we
2974 will force it local. */
2975 else if (h
->needs_plt
2976 && bfd_link_pic (eif
->info
)
2977 && is_elf_hash_table (eif
->info
->hash
)
2978 && (SYMBOLIC_BIND (eif
->info
, h
)
2979 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2984 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2985 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2986 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2989 /* If this is a weak defined symbol in a dynamic object, and we know
2990 the real definition in the dynamic object, copy interesting flags
2991 over to the real definition. */
2992 if (h
->is_weakalias
)
2994 struct elf_link_hash_entry
*def
= weakdef (h
);
2996 /* If the real definition is defined by a regular object file,
2997 don't do anything special. See the longer description in
2998 _bfd_elf_adjust_dynamic_symbol, below. If the def is not
2999 bfd_link_hash_defined as it was when put on the alias list
3000 then it must have originally been a versioned symbol (for
3001 which a non-versioned indirect symbol is created) and later
3002 a definition for the non-versioned symbol is found. In that
3003 case the indirection is flipped with the versioned symbol
3004 becoming an indirect pointing at the non-versioned symbol.
3005 Thus, not an alias any more. */
3006 if (def
->def_regular
3007 || def
->root
.type
!= bfd_link_hash_defined
)
3010 while ((h
= h
->u
.alias
) != def
)
3011 h
->is_weakalias
= 0;
3015 while (h
->root
.type
== bfd_link_hash_indirect
)
3016 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3017 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
3018 || h
->root
.type
== bfd_link_hash_defweak
);
3019 BFD_ASSERT (def
->def_dynamic
);
3020 (*bed
->elf_backend_copy_indirect_symbol
) (eif
->info
, def
, h
);
3027 /* Make the backend pick a good value for a dynamic symbol. This is
3028 called via elf_link_hash_traverse, and also calls itself
3032 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
3034 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
3035 struct elf_link_hash_table
*htab
;
3036 const struct elf_backend_data
*bed
;
3038 if (! is_elf_hash_table (eif
->info
->hash
))
3041 /* Ignore indirect symbols. These are added by the versioning code. */
3042 if (h
->root
.type
== bfd_link_hash_indirect
)
3045 /* Fix the symbol flags. */
3046 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
3049 htab
= elf_hash_table (eif
->info
);
3050 bed
= get_elf_backend_data (htab
->dynobj
);
3052 if (h
->root
.type
== bfd_link_hash_undefweak
)
3054 if (eif
->info
->dynamic_undefined_weak
== 0)
3055 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, true);
3056 else if (eif
->info
->dynamic_undefined_weak
> 0
3058 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3059 && !bfd_hide_sym_by_version (eif
->info
->version_info
,
3060 h
->root
.root
.string
))
3062 if (!bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3070 /* If this symbol does not require a PLT entry, and it is not
3071 defined by a dynamic object, or is not referenced by a regular
3072 object, ignore it. We do have to handle a weak defined symbol,
3073 even if no regular object refers to it, if we decided to add it
3074 to the dynamic symbol table. FIXME: Do we normally need to worry
3075 about symbols which are defined by one dynamic object and
3076 referenced by another one? */
3078 && h
->type
!= STT_GNU_IFUNC
3082 && (!h
->is_weakalias
|| weakdef (h
)->dynindx
== -1))))
3084 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
3088 /* If we've already adjusted this symbol, don't do it again. This
3089 can happen via a recursive call. */
3090 if (h
->dynamic_adjusted
)
3093 /* Don't look at this symbol again. Note that we must set this
3094 after checking the above conditions, because we may look at a
3095 symbol once, decide not to do anything, and then get called
3096 recursively later after REF_REGULAR is set below. */
3097 h
->dynamic_adjusted
= 1;
3099 /* If this is a weak definition, and we know a real definition, and
3100 the real symbol is not itself defined by a regular object file,
3101 then get a good value for the real definition. We handle the
3102 real symbol first, for the convenience of the backend routine.
3104 Note that there is a confusing case here. If the real definition
3105 is defined by a regular object file, we don't get the real symbol
3106 from the dynamic object, but we do get the weak symbol. If the
3107 processor backend uses a COPY reloc, then if some routine in the
3108 dynamic object changes the real symbol, we will not see that
3109 change in the corresponding weak symbol. This is the way other
3110 ELF linkers work as well, and seems to be a result of the shared
3113 I will clarify this issue. Most SVR4 shared libraries define the
3114 variable _timezone and define timezone as a weak synonym. The
3115 tzset call changes _timezone. If you write
3116 extern int timezone;
3118 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
3119 you might expect that, since timezone is a synonym for _timezone,
3120 the same number will print both times. However, if the processor
3121 backend uses a COPY reloc, then actually timezone will be copied
3122 into your process image, and, since you define _timezone
3123 yourself, _timezone will not. Thus timezone and _timezone will
3124 wind up at different memory locations. The tzset call will set
3125 _timezone, leaving timezone unchanged. */
3127 if (h
->is_weakalias
)
3129 struct elf_link_hash_entry
*def
= weakdef (h
);
3131 /* If we get to this point, there is an implicit reference to
3132 the alias by a regular object file via the weak symbol H. */
3133 def
->ref_regular
= 1;
3135 /* Ensure that the backend adjust_dynamic_symbol function sees
3136 the strong alias before H by recursively calling ourselves. */
3137 if (!_bfd_elf_adjust_dynamic_symbol (def
, eif
))
3141 /* If a symbol has no type and no size and does not require a PLT
3142 entry, then we are probably about to do the wrong thing here: we
3143 are probably going to create a COPY reloc for an empty object.
3144 This case can arise when a shared object is built with assembly
3145 code, and the assembly code fails to set the symbol type. */
3147 && h
->type
== STT_NOTYPE
3150 (_("warning: type and size of dynamic symbol `%s' are not defined"),
3151 h
->root
.root
.string
);
3153 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
3162 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
3166 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info
*info
,
3167 struct elf_link_hash_entry
*h
,
3170 unsigned int power_of_two
;
3172 asection
*sec
= h
->root
.u
.def
.section
;
3174 /* The section alignment of the definition is the maximum alignment
3175 requirement of symbols defined in the section. Since we don't
3176 know the symbol alignment requirement, we start with the
3177 maximum alignment and check low bits of the symbol address
3178 for the minimum alignment. */
3179 power_of_two
= bfd_section_alignment (sec
);
3180 mask
= ((bfd_vma
) 1 << power_of_two
) - 1;
3181 while ((h
->root
.u
.def
.value
& mask
) != 0)
3187 if (power_of_two
> bfd_section_alignment (dynbss
))
3189 /* Adjust the section alignment if needed. */
3190 if (!bfd_set_section_alignment (dynbss
, power_of_two
))
3194 /* We make sure that the symbol will be aligned properly. */
3195 dynbss
->size
= BFD_ALIGN (dynbss
->size
, mask
+ 1);
3197 /* Define the symbol as being at this point in DYNBSS. */
3198 h
->root
.u
.def
.section
= dynbss
;
3199 h
->root
.u
.def
.value
= dynbss
->size
;
3201 /* Increment the size of DYNBSS to make room for the symbol. */
3202 dynbss
->size
+= h
->size
;
3204 /* No error if extern_protected_data is true. */
3205 if (h
->protected_def
3206 && (!info
->extern_protected_data
3207 || (info
->extern_protected_data
< 0
3208 && !get_elf_backend_data (dynbss
->owner
)->extern_protected_data
)))
3209 info
->callbacks
->einfo
3210 (_("%P: copy reloc against protected `%pT' is dangerous\n"),
3211 h
->root
.root
.string
);
3216 /* Adjust all external symbols pointing into SEC_MERGE sections
3217 to reflect the object merging within the sections. */
3220 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
3224 if ((h
->root
.type
== bfd_link_hash_defined
3225 || h
->root
.type
== bfd_link_hash_defweak
)
3226 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
3227 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3229 bfd
*output_bfd
= (bfd
*) data
;
3231 h
->root
.u
.def
.value
=
3232 _bfd_merged_section_offset (output_bfd
,
3233 &h
->root
.u
.def
.section
,
3234 elf_section_data (sec
)->sec_info
,
3235 h
->root
.u
.def
.value
);
3241 /* Returns false if the symbol referred to by H should be considered
3242 to resolve local to the current module, and true if it should be
3243 considered to bind dynamically. */
3246 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
3247 struct bfd_link_info
*info
,
3248 bool not_local_protected
)
3250 bool binding_stays_local_p
;
3251 const struct elf_backend_data
*bed
;
3252 struct elf_link_hash_table
*hash_table
;
3257 while (h
->root
.type
== bfd_link_hash_indirect
3258 || h
->root
.type
== bfd_link_hash_warning
)
3259 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3261 /* If it was forced local, then clearly it's not dynamic. */
3262 if (h
->dynindx
== -1)
3264 if (h
->forced_local
)
3267 /* Identify the cases where name binding rules say that a
3268 visible symbol resolves locally. */
3269 binding_stays_local_p
= (bfd_link_executable (info
)
3270 || SYMBOLIC_BIND (info
, h
));
3272 switch (ELF_ST_VISIBILITY (h
->other
))
3279 hash_table
= elf_hash_table (info
);
3280 if (!is_elf_hash_table (&hash_table
->root
))
3283 bed
= get_elf_backend_data (hash_table
->dynobj
);
3285 /* Proper resolution for function pointer equality may require
3286 that these symbols perhaps be resolved dynamically, even though
3287 we should be resolving them to the current module. */
3288 if (!not_local_protected
|| !bed
->is_function_type (h
->type
))
3289 binding_stays_local_p
= true;
3296 /* If it isn't defined locally, then clearly it's dynamic. */
3297 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
3300 /* Otherwise, the symbol is dynamic if binding rules don't tell
3301 us that it remains local. */
3302 return !binding_stays_local_p
;
3305 /* Return true if the symbol referred to by H should be considered
3306 to resolve local to the current module, and false otherwise. Differs
3307 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
3308 undefined symbols. The two functions are virtually identical except
3309 for the place where dynindx == -1 is tested. If that test is true,
3310 _bfd_elf_dynamic_symbol_p will say the symbol is local, while
3311 _bfd_elf_symbol_refs_local_p will say the symbol is local only for
3313 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
3314 !_bfd_elf_symbol_refs_local_p, except that targets differ in their
3315 treatment of undefined weak symbols. For those that do not make
3316 undefined weak symbols dynamic, both functions may return false. */
3319 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
3320 struct bfd_link_info
*info
,
3321 bool local_protected
)
3323 const struct elf_backend_data
*bed
;
3324 struct elf_link_hash_table
*hash_table
;
3326 /* If it's a local sym, of course we resolve locally. */
3330 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
3331 if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
3332 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
3335 /* Forced local symbols resolve locally. */
3336 if (h
->forced_local
)
3339 /* Common symbols that become definitions don't get the DEF_REGULAR
3340 flag set, so test it first, and don't bail out. */
3341 if (ELF_COMMON_DEF_P (h
))
3343 /* If we don't have a definition in a regular file, then we can't
3344 resolve locally. The sym is either undefined or dynamic. */
3345 else if (!h
->def_regular
)
3348 /* Non-dynamic symbols resolve locally. */
3349 if (h
->dynindx
== -1)
3352 /* At this point, we know the symbol is defined and dynamic. In an
3353 executable it must resolve locally, likewise when building symbolic
3354 shared libraries. */
3355 if (bfd_link_executable (info
) || SYMBOLIC_BIND (info
, h
))
3358 /* Now deal with defined dynamic symbols in shared libraries. Ones
3359 with default visibility might not resolve locally. */
3360 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3363 hash_table
= elf_hash_table (info
);
3364 if (!is_elf_hash_table (&hash_table
->root
))
3367 /* STV_PROTECTED symbols with indirect external access are local. */
3368 if (info
->indirect_extern_access
> 0)
3371 bed
= get_elf_backend_data (hash_table
->dynobj
);
3373 /* If extern_protected_data is false, STV_PROTECTED non-function
3374 symbols are local. */
3375 if ((!info
->extern_protected_data
3376 || (info
->extern_protected_data
< 0
3377 && !bed
->extern_protected_data
))
3378 && !bed
->is_function_type (h
->type
))
3381 /* Function pointer equality tests may require that STV_PROTECTED
3382 symbols be treated as dynamic symbols. If the address of a
3383 function not defined in an executable is set to that function's
3384 plt entry in the executable, then the address of the function in
3385 a shared library must also be the plt entry in the executable. */
3386 return local_protected
;
3389 /* Caches some TLS segment info, and ensures that the TLS segment vma is
3390 aligned. Returns the first TLS output section. */
3392 struct bfd_section
*
3393 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
3395 struct bfd_section
*sec
, *tls
;
3396 unsigned int align
= 0;
3398 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3399 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
3403 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
3404 if (sec
->alignment_power
> align
)
3405 align
= sec
->alignment_power
;
3407 elf_hash_table (info
)->tls_sec
= tls
;
3409 /* Ensure the alignment of the first section (usually .tdata) is the largest
3410 alignment, so that the tls segment starts aligned. */
3412 tls
->alignment_power
= align
;
3417 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
3419 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
3420 Elf_Internal_Sym
*sym
)
3422 const struct elf_backend_data
*bed
;
3424 /* Local symbols do not count, but target specific ones might. */
3425 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
3426 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
3429 bed
= get_elf_backend_data (abfd
);
3430 /* Function symbols do not count. */
3431 if (bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)))
3434 /* If the section is undefined, then so is the symbol. */
3435 if (sym
->st_shndx
== SHN_UNDEF
)
3438 /* If the symbol is defined in the common section, then
3439 it is a common definition and so does not count. */
3440 if (bed
->common_definition (sym
))
3443 /* If the symbol is in a target specific section then we
3444 must rely upon the backend to tell us what it is. */
3445 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
3446 /* FIXME - this function is not coded yet:
3448 return _bfd_is_global_symbol_definition (abfd, sym);
3450 Instead for now assume that the definition is not global,
3451 Even if this is wrong, at least the linker will behave
3452 in the same way that it used to do. */
3458 /* Search the symbol table of the archive element of the archive ABFD
3459 whose archive map contains a mention of SYMDEF, and determine if
3460 the symbol is defined in this element. */
3462 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
3464 Elf_Internal_Shdr
* hdr
;
3468 Elf_Internal_Sym
*isymbuf
;
3469 Elf_Internal_Sym
*isym
;
3470 Elf_Internal_Sym
*isymend
;
3473 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3477 if (! bfd_check_format (abfd
, bfd_object
))
3480 /* Select the appropriate symbol table. If we don't know if the
3481 object file is an IR object, give linker LTO plugin a chance to
3482 get the correct symbol table. */
3483 if (abfd
->plugin_format
== bfd_plugin_yes
3484 #if BFD_SUPPORTS_PLUGINS
3485 || (abfd
->plugin_format
== bfd_plugin_unknown
3486 && bfd_link_plugin_object_p (abfd
))
3490 /* Use the IR symbol table if the object has been claimed by
3492 abfd
= abfd
->plugin_dummy_bfd
;
3493 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3495 else if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
3496 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3498 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3500 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3502 /* The sh_info field of the symtab header tells us where the
3503 external symbols start. We don't care about the local symbols. */
3504 if (elf_bad_symtab (abfd
))
3506 extsymcount
= symcount
;
3511 extsymcount
= symcount
- hdr
->sh_info
;
3512 extsymoff
= hdr
->sh_info
;
3515 if (extsymcount
== 0)
3518 /* Read in the symbol table. */
3519 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3521 if (isymbuf
== NULL
)
3524 /* Scan the symbol table looking for SYMDEF. */
3526 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
3530 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3535 if (strcmp (name
, symdef
->name
) == 0)
3537 result
= is_global_data_symbol_definition (abfd
, isym
);
3547 /* Add an entry to the .dynamic table. */
3550 _bfd_elf_add_dynamic_entry (struct bfd_link_info
*info
,
3554 struct elf_link_hash_table
*hash_table
;
3555 const struct elf_backend_data
*bed
;
3557 bfd_size_type newsize
;
3558 bfd_byte
*newcontents
;
3559 Elf_Internal_Dyn dyn
;
3561 hash_table
= elf_hash_table (info
);
3562 if (! is_elf_hash_table (&hash_table
->root
))
3565 if (tag
== DT_RELA
|| tag
== DT_REL
)
3566 hash_table
->dynamic_relocs
= true;
3568 bed
= get_elf_backend_data (hash_table
->dynobj
);
3569 s
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3570 BFD_ASSERT (s
!= NULL
);
3572 newsize
= s
->size
+ bed
->s
->sizeof_dyn
;
3573 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
3574 if (newcontents
== NULL
)
3578 dyn
.d_un
.d_val
= val
;
3579 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
, newcontents
+ s
->size
);
3582 s
->contents
= newcontents
;
3587 /* Strip zero-sized dynamic sections. */
3590 _bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info
*info
)
3592 struct elf_link_hash_table
*hash_table
;
3593 const struct elf_backend_data
*bed
;
3594 asection
*s
, *sdynamic
, **pp
;
3595 asection
*rela_dyn
, *rel_dyn
;
3596 Elf_Internal_Dyn dyn
;
3597 bfd_byte
*extdyn
, *next
;
3598 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
3599 bool strip_zero_sized
;
3600 bool strip_zero_sized_plt
;
3602 if (bfd_link_relocatable (info
))
3605 hash_table
= elf_hash_table (info
);
3606 if (!is_elf_hash_table (&hash_table
->root
))
3609 if (!hash_table
->dynobj
)
3612 sdynamic
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3616 bed
= get_elf_backend_data (hash_table
->dynobj
);
3617 swap_dyn_in
= bed
->s
->swap_dyn_in
;
3619 strip_zero_sized
= false;
3620 strip_zero_sized_plt
= false;
3622 /* Strip zero-sized dynamic sections. */
3623 rela_dyn
= bfd_get_section_by_name (info
->output_bfd
, ".rela.dyn");
3624 rel_dyn
= bfd_get_section_by_name (info
->output_bfd
, ".rel.dyn");
3625 for (pp
= &info
->output_bfd
->sections
; (s
= *pp
) != NULL
;)
3629 || s
== hash_table
->srelplt
->output_section
3630 || s
== hash_table
->splt
->output_section
))
3633 info
->output_bfd
->section_count
--;
3634 strip_zero_sized
= true;
3639 else if (s
== hash_table
->splt
->output_section
)
3641 s
= hash_table
->splt
;
3642 strip_zero_sized_plt
= true;
3645 s
= hash_table
->srelplt
;
3646 s
->flags
|= SEC_EXCLUDE
;
3647 s
->output_section
= bfd_abs_section_ptr
;
3652 if (strip_zero_sized_plt
&& sdynamic
->size
!= 0)
3653 for (extdyn
= sdynamic
->contents
;
3654 extdyn
< sdynamic
->contents
+ sdynamic
->size
;
3657 next
= extdyn
+ bed
->s
->sizeof_dyn
;
3658 swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
3666 /* Strip DT_PLTRELSZ, DT_JMPREL and DT_PLTREL entries if
3667 the procedure linkage table (the .plt section) has been
3669 memmove (extdyn
, next
,
3670 sdynamic
->size
- (next
- sdynamic
->contents
));
3675 if (strip_zero_sized
)
3677 /* Regenerate program headers. */
3678 elf_seg_map (info
->output_bfd
) = NULL
;
3679 return _bfd_elf_map_sections_to_segments (info
->output_bfd
, info
);
3685 /* Add a DT_NEEDED entry for this dynamic object. Returns -1 on error,
3686 1 if a DT_NEEDED tag already exists, and 0 on success. */
3689 bfd_elf_add_dt_needed_tag (bfd
*abfd
, struct bfd_link_info
*info
)
3691 struct elf_link_hash_table
*hash_table
;
3695 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
3698 hash_table
= elf_hash_table (info
);
3699 soname
= elf_dt_name (abfd
);
3700 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, soname
, false);
3701 if (strindex
== (size_t) -1)
3704 if (_bfd_elf_strtab_refcount (hash_table
->dynstr
, strindex
) != 1)
3707 const struct elf_backend_data
*bed
;
3710 bed
= get_elf_backend_data (hash_table
->dynobj
);
3711 sdyn
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3712 if (sdyn
!= NULL
&& sdyn
->size
!= 0)
3713 for (extdyn
= sdyn
->contents
;
3714 extdyn
< sdyn
->contents
+ sdyn
->size
;
3715 extdyn
+= bed
->s
->sizeof_dyn
)
3717 Elf_Internal_Dyn dyn
;
3719 bed
->s
->swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
3720 if (dyn
.d_tag
== DT_NEEDED
3721 && dyn
.d_un
.d_val
== strindex
)
3723 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3729 if (!_bfd_elf_link_create_dynamic_sections (hash_table
->dynobj
, info
))
3732 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
3738 /* Return true if SONAME is on the needed list between NEEDED and STOP
3739 (or the end of list if STOP is NULL), and needed by a library that
3743 on_needed_list (const char *soname
,
3744 struct bfd_link_needed_list
*needed
,
3745 struct bfd_link_needed_list
*stop
)
3747 struct bfd_link_needed_list
*look
;
3748 for (look
= needed
; look
!= stop
; look
= look
->next
)
3749 if (strcmp (soname
, look
->name
) == 0
3750 && ((elf_dyn_lib_class (look
->by
) & DYN_AS_NEEDED
) == 0
3751 /* If needed by a library that itself is not directly
3752 needed, recursively check whether that library is
3753 indirectly needed. Since we add DT_NEEDED entries to
3754 the end of the list, library dependencies appear after
3755 the library. Therefore search prior to the current
3756 LOOK, preventing possible infinite recursion. */
3757 || on_needed_list (elf_dt_name (look
->by
), needed
, look
)))
3763 /* Sort symbol by value, section, size, and type. */
3765 elf_sort_symbol (const void *arg1
, const void *arg2
)
3767 const struct elf_link_hash_entry
*h1
;
3768 const struct elf_link_hash_entry
*h2
;
3769 bfd_signed_vma vdiff
;
3774 h1
= *(const struct elf_link_hash_entry
**) arg1
;
3775 h2
= *(const struct elf_link_hash_entry
**) arg2
;
3776 vdiff
= h1
->root
.u
.def
.value
- h2
->root
.u
.def
.value
;
3778 return vdiff
> 0 ? 1 : -1;
3780 sdiff
= h1
->root
.u
.def
.section
->id
- h2
->root
.u
.def
.section
->id
;
3784 /* Sort so that sized symbols are selected over zero size symbols. */
3785 vdiff
= h1
->size
- h2
->size
;
3787 return vdiff
> 0 ? 1 : -1;
3789 /* Sort so that STT_OBJECT is selected over STT_NOTYPE. */
3790 if (h1
->type
!= h2
->type
)
3791 return h1
->type
- h2
->type
;
3793 /* If symbols are properly sized and typed, and multiple strong
3794 aliases are not defined in a shared library by the user we
3795 shouldn't get here. Unfortunately linker script symbols like
3796 __bss_start sometimes match a user symbol defined at the start of
3797 .bss without proper size and type. We'd like to preference the
3798 user symbol over reserved system symbols. Sort on leading
3800 n1
= h1
->root
.root
.string
;
3801 n2
= h2
->root
.root
.string
;
3814 /* Final sort on name selects user symbols like '_u' over reserved
3815 system symbols like '_Z' and also will avoid qsort instability. */
3819 /* This function is used to adjust offsets into .dynstr for
3820 dynamic symbols. This is called via elf_link_hash_traverse. */
3823 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
3825 struct elf_strtab_hash
*dynstr
= (struct elf_strtab_hash
*) data
;
3827 if (h
->dynindx
!= -1)
3828 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
3832 /* Assign string offsets in .dynstr, update all structures referencing
3836 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
3838 struct elf_link_hash_table
*hash_table
= elf_hash_table (info
);
3839 struct elf_link_local_dynamic_entry
*entry
;
3840 struct elf_strtab_hash
*dynstr
= hash_table
->dynstr
;
3841 bfd
*dynobj
= hash_table
->dynobj
;
3844 const struct elf_backend_data
*bed
;
3847 _bfd_elf_strtab_finalize (dynstr
);
3848 size
= _bfd_elf_strtab_size (dynstr
);
3850 /* Allow the linker to examine the dynsymtab now it's fully populated. */
3852 if (info
->callbacks
->examine_strtab
)
3853 info
->callbacks
->examine_strtab (dynstr
);
3855 bed
= get_elf_backend_data (dynobj
);
3856 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3857 BFD_ASSERT (sdyn
!= NULL
);
3859 /* Update all .dynamic entries referencing .dynstr strings. */
3860 for (extdyn
= sdyn
->contents
;
3861 extdyn
< PTR_ADD (sdyn
->contents
, sdyn
->size
);
3862 extdyn
+= bed
->s
->sizeof_dyn
)
3864 Elf_Internal_Dyn dyn
;
3866 bed
->s
->swap_dyn_in (dynobj
, extdyn
, &dyn
);
3870 dyn
.d_un
.d_val
= size
;
3880 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
3885 bed
->s
->swap_dyn_out (dynobj
, &dyn
, extdyn
);
3888 /* Now update local dynamic symbols. */
3889 for (entry
= hash_table
->dynlocal
; entry
; entry
= entry
->next
)
3890 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
3891 entry
->isym
.st_name
);
3893 /* And the rest of dynamic symbols. */
3894 elf_link_hash_traverse (hash_table
, elf_adjust_dynstr_offsets
, dynstr
);
3896 /* Adjust version definitions. */
3897 if (elf_tdata (output_bfd
)->cverdefs
)
3902 Elf_Internal_Verdef def
;
3903 Elf_Internal_Verdaux defaux
;
3905 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
3909 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
3911 p
+= sizeof (Elf_External_Verdef
);
3912 if (def
.vd_aux
!= sizeof (Elf_External_Verdef
))
3914 for (i
= 0; i
< def
.vd_cnt
; ++i
)
3916 _bfd_elf_swap_verdaux_in (output_bfd
,
3917 (Elf_External_Verdaux
*) p
, &defaux
);
3918 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
3920 _bfd_elf_swap_verdaux_out (output_bfd
,
3921 &defaux
, (Elf_External_Verdaux
*) p
);
3922 p
+= sizeof (Elf_External_Verdaux
);
3925 while (def
.vd_next
);
3928 /* Adjust version references. */
3929 if (elf_tdata (output_bfd
)->verref
)
3934 Elf_Internal_Verneed need
;
3935 Elf_Internal_Vernaux needaux
;
3937 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
3941 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
3943 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
3944 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
3945 (Elf_External_Verneed
*) p
);
3946 p
+= sizeof (Elf_External_Verneed
);
3947 for (i
= 0; i
< need
.vn_cnt
; ++i
)
3949 _bfd_elf_swap_vernaux_in (output_bfd
,
3950 (Elf_External_Vernaux
*) p
, &needaux
);
3951 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
3953 _bfd_elf_swap_vernaux_out (output_bfd
,
3955 (Elf_External_Vernaux
*) p
);
3956 p
+= sizeof (Elf_External_Vernaux
);
3959 while (need
.vn_next
);
3965 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3966 The default is to only match when the INPUT and OUTPUT are exactly
3970 _bfd_elf_default_relocs_compatible (const bfd_target
*input
,
3971 const bfd_target
*output
)
3973 return input
== output
;
3976 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3977 This version is used when different targets for the same architecture
3978 are virtually identical. */
3981 _bfd_elf_relocs_compatible (const bfd_target
*input
,
3982 const bfd_target
*output
)
3984 const struct elf_backend_data
*obed
, *ibed
;
3986 if (input
== output
)
3989 ibed
= xvec_get_elf_backend_data (input
);
3990 obed
= xvec_get_elf_backend_data (output
);
3992 if (ibed
->arch
!= obed
->arch
)
3995 /* If both backends are using this function, deem them compatible. */
3996 return ibed
->relocs_compatible
== obed
->relocs_compatible
;
3999 /* Make a special call to the linker "notice" function to tell it that
4000 we are about to handle an as-needed lib, or have finished
4001 processing the lib. */
4004 _bfd_elf_notice_as_needed (bfd
*ibfd
,
4005 struct bfd_link_info
*info
,
4006 enum notice_asneeded_action act
)
4008 return (*info
->callbacks
->notice
) (info
, NULL
, NULL
, ibfd
, NULL
, act
, 0);
4011 /* Check relocations an ELF object file. */
4014 _bfd_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
4016 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4017 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4019 /* If this object is the same format as the output object, and it is
4020 not a shared library, then let the backend look through the
4023 This is required to build global offset table entries and to
4024 arrange for dynamic relocs. It is not required for the
4025 particular common case of linking non PIC code, even when linking
4026 against shared libraries, but unfortunately there is no way of
4027 knowing whether an object file has been compiled PIC or not.
4028 Looking through the relocs is not particularly time consuming.
4029 The problem is that we must either (1) keep the relocs in memory,
4030 which causes the linker to require additional runtime memory or
4031 (2) read the relocs twice from the input file, which wastes time.
4032 This would be a good case for using mmap.
4034 I have no idea how to handle linking PIC code into a file of a
4035 different format. It probably can't be done. */
4036 if ((abfd
->flags
& DYNAMIC
) == 0
4037 && is_elf_hash_table (&htab
->root
)
4038 && bed
->check_relocs
!= NULL
4039 && elf_object_id (abfd
) == elf_hash_table_id (htab
)
4040 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
4044 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4046 Elf_Internal_Rela
*internal_relocs
;
4049 /* Don't check relocations in excluded sections. Don't do
4050 anything special with non-loaded, non-alloced sections.
4051 In particular, any relocs in such sections should not
4052 affect GOT and PLT reference counting (ie. we don't
4053 allow them to create GOT or PLT entries), there's no
4054 possibility or desire to optimize TLS relocs, and
4055 there's not much point in propagating relocs to shared
4056 libs that the dynamic linker won't relocate. */
4057 if ((o
->flags
& SEC_ALLOC
) == 0
4058 || (o
->flags
& SEC_RELOC
) == 0
4059 || (o
->flags
& SEC_EXCLUDE
) != 0
4060 || o
->reloc_count
== 0
4061 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
4062 && (o
->flags
& SEC_DEBUGGING
) != 0)
4063 || bfd_is_abs_section (o
->output_section
))
4066 internal_relocs
= _bfd_elf_link_info_read_relocs (abfd
, info
,
4069 _bfd_link_keep_memory (info
));
4070 if (internal_relocs
== NULL
)
4073 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
4075 if (elf_section_data (o
)->relocs
!= internal_relocs
)
4076 free (internal_relocs
);
4086 /* Add symbols from an ELF object file to the linker hash table. */
4089 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4091 Elf_Internal_Ehdr
*ehdr
;
4092 Elf_Internal_Shdr
*hdr
;
4096 struct elf_link_hash_entry
**sym_hash
;
4098 Elf_External_Versym
*extversym
= NULL
;
4099 Elf_External_Versym
*extversym_end
= NULL
;
4100 Elf_External_Versym
*ever
;
4101 struct elf_link_hash_entry
*weaks
;
4102 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
4103 size_t nondeflt_vers_cnt
= 0;
4104 Elf_Internal_Sym
*isymbuf
= NULL
;
4105 Elf_Internal_Sym
*isym
;
4106 Elf_Internal_Sym
*isymend
;
4107 const struct elf_backend_data
*bed
;
4109 struct elf_link_hash_table
*htab
;
4110 void *alloc_mark
= NULL
;
4111 struct bfd_hash_entry
**old_table
= NULL
;
4112 unsigned int old_size
= 0;
4113 unsigned int old_count
= 0;
4114 void *old_tab
= NULL
;
4116 struct bfd_link_hash_entry
*old_undefs
= NULL
;
4117 struct bfd_link_hash_entry
*old_undefs_tail
= NULL
;
4118 void *old_strtab
= NULL
;
4123 htab
= elf_hash_table (info
);
4124 bed
= get_elf_backend_data (abfd
);
4126 if ((abfd
->flags
& DYNAMIC
) == 0)
4132 /* You can't use -r against a dynamic object. Also, there's no
4133 hope of using a dynamic object which does not exactly match
4134 the format of the output file. */
4135 if (bfd_link_relocatable (info
)
4136 || !is_elf_hash_table (&htab
->root
)
4137 || info
->output_bfd
->xvec
!= abfd
->xvec
)
4139 if (bfd_link_relocatable (info
))
4140 bfd_set_error (bfd_error_invalid_operation
);
4142 bfd_set_error (bfd_error_wrong_format
);
4147 ehdr
= elf_elfheader (abfd
);
4148 if (info
->warn_alternate_em
4149 && bed
->elf_machine_code
!= ehdr
->e_machine
4150 && ((bed
->elf_machine_alt1
!= 0
4151 && ehdr
->e_machine
== bed
->elf_machine_alt1
)
4152 || (bed
->elf_machine_alt2
!= 0
4153 && ehdr
->e_machine
== bed
->elf_machine_alt2
)))
4155 /* xgettext:c-format */
4156 (_("alternate ELF machine code found (%d) in %pB, expecting %d"),
4157 ehdr
->e_machine
, abfd
, bed
->elf_machine_code
);
4159 /* As a GNU extension, any input sections which are named
4160 .gnu.warning.SYMBOL are treated as warning symbols for the given
4161 symbol. This differs from .gnu.warning sections, which generate
4162 warnings when they are included in an output file. */
4163 /* PR 12761: Also generate this warning when building shared libraries. */
4164 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4168 name
= bfd_section_name (s
);
4169 if (startswith (name
, ".gnu.warning."))
4174 name
+= sizeof ".gnu.warning." - 1;
4176 /* If this is a shared object, then look up the symbol
4177 in the hash table. If it is there, and it is already
4178 been defined, then we will not be using the entry
4179 from this shared object, so we don't need to warn.
4180 FIXME: If we see the definition in a regular object
4181 later on, we will warn, but we shouldn't. The only
4182 fix is to keep track of what warnings we are supposed
4183 to emit, and then handle them all at the end of the
4187 struct elf_link_hash_entry
*h
;
4189 h
= elf_link_hash_lookup (htab
, name
, false, false, true);
4191 /* FIXME: What about bfd_link_hash_common? */
4193 && (h
->root
.type
== bfd_link_hash_defined
4194 || h
->root
.type
== bfd_link_hash_defweak
))
4199 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
4203 if (! bfd_get_section_contents (abfd
, s
, msg
, 0, sz
))
4208 if (! (_bfd_generic_link_add_one_symbol
4209 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
4210 false, bed
->collect
, NULL
)))
4213 if (bfd_link_executable (info
))
4215 /* Clobber the section size so that the warning does
4216 not get copied into the output file. */
4219 /* Also set SEC_EXCLUDE, so that symbols defined in
4220 the warning section don't get copied to the output. */
4221 s
->flags
|= SEC_EXCLUDE
;
4226 just_syms
= ((s
= abfd
->sections
) != NULL
4227 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
);
4232 /* If we are creating a shared library, create all the dynamic
4233 sections immediately. We need to attach them to something,
4234 so we attach them to this BFD, provided it is the right
4235 format and is not from ld --just-symbols. Always create the
4236 dynamic sections for -E/--dynamic-list. FIXME: If there
4237 are no input BFD's of the same format as the output, we can't
4238 make a shared library. */
4240 && (bfd_link_pic (info
)
4241 || (!bfd_link_relocatable (info
)
4243 && (info
->export_dynamic
|| info
->dynamic
)))
4244 && is_elf_hash_table (&htab
->root
)
4245 && info
->output_bfd
->xvec
== abfd
->xvec
4246 && !htab
->dynamic_sections_created
)
4248 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
4252 else if (!is_elf_hash_table (&htab
->root
))
4256 const char *soname
= NULL
;
4258 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
4259 const Elf_Internal_Phdr
*phdr
;
4260 struct elf_link_loaded_list
*loaded_lib
;
4262 /* ld --just-symbols and dynamic objects don't mix very well.
4263 ld shouldn't allow it. */
4267 /* If this dynamic lib was specified on the command line with
4268 --as-needed in effect, then we don't want to add a DT_NEEDED
4269 tag unless the lib is actually used. Similary for libs brought
4270 in by another lib's DT_NEEDED. When --no-add-needed is used
4271 on a dynamic lib, we don't want to add a DT_NEEDED entry for
4272 any dynamic library in DT_NEEDED tags in the dynamic lib at
4274 add_needed
= (elf_dyn_lib_class (abfd
)
4275 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
4276 | DYN_NO_NEEDED
)) == 0;
4278 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4279 if (s
!= NULL
&& s
->size
!= 0)
4283 unsigned int elfsec
;
4284 unsigned long shlink
;
4286 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
4293 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
4294 if (elfsec
== SHN_BAD
)
4295 goto error_free_dyn
;
4296 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
4298 for (extdyn
= dynbuf
;
4299 extdyn
<= dynbuf
+ s
->size
- bed
->s
->sizeof_dyn
;
4300 extdyn
+= bed
->s
->sizeof_dyn
)
4302 Elf_Internal_Dyn dyn
;
4304 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
4305 if (dyn
.d_tag
== DT_SONAME
)
4307 unsigned int tagv
= dyn
.d_un
.d_val
;
4308 soname
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
4310 goto error_free_dyn
;
4312 if (dyn
.d_tag
== DT_NEEDED
)
4314 struct bfd_link_needed_list
*n
, **pn
;
4316 unsigned int tagv
= dyn
.d_un
.d_val
;
4317 size_t amt
= sizeof (struct bfd_link_needed_list
);
4319 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
4320 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
4321 if (n
== NULL
|| fnm
== NULL
)
4322 goto error_free_dyn
;
4323 amt
= strlen (fnm
) + 1;
4324 anm
= (char *) bfd_alloc (abfd
, amt
);
4326 goto error_free_dyn
;
4327 memcpy (anm
, fnm
, amt
);
4331 for (pn
= &htab
->needed
; *pn
!= NULL
; pn
= &(*pn
)->next
)
4335 if (dyn
.d_tag
== DT_RUNPATH
)
4337 struct bfd_link_needed_list
*n
, **pn
;
4339 unsigned int tagv
= dyn
.d_un
.d_val
;
4340 size_t amt
= sizeof (struct bfd_link_needed_list
);
4342 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
4343 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
4344 if (n
== NULL
|| fnm
== NULL
)
4345 goto error_free_dyn
;
4346 amt
= strlen (fnm
) + 1;
4347 anm
= (char *) bfd_alloc (abfd
, amt
);
4349 goto error_free_dyn
;
4350 memcpy (anm
, fnm
, amt
);
4354 for (pn
= & runpath
;
4360 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
4361 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
4363 struct bfd_link_needed_list
*n
, **pn
;
4365 unsigned int tagv
= dyn
.d_un
.d_val
;
4366 size_t amt
= sizeof (struct bfd_link_needed_list
);
4368 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
4369 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
4370 if (n
== NULL
|| fnm
== NULL
)
4371 goto error_free_dyn
;
4372 amt
= strlen (fnm
) + 1;
4373 anm
= (char *) bfd_alloc (abfd
, amt
);
4375 goto error_free_dyn
;
4376 memcpy (anm
, fnm
, amt
);
4386 if (dyn
.d_tag
== DT_AUDIT
)
4388 unsigned int tagv
= dyn
.d_un
.d_val
;
4389 audit
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
4391 if (dyn
.d_tag
== DT_FLAGS_1
)
4392 elf_tdata (abfd
)->is_pie
= (dyn
.d_un
.d_val
& DF_1_PIE
) != 0;
4398 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
4399 frees all more recently bfd_alloc'd blocks as well. */
4405 struct bfd_link_needed_list
**pn
;
4406 for (pn
= &htab
->runpath
; *pn
!= NULL
; pn
= &(*pn
)->next
)
4411 /* If we have a PT_GNU_RELRO program header, mark as read-only
4412 all sections contained fully therein. This makes relro
4413 shared library sections appear as they will at run-time. */
4414 phdr
= elf_tdata (abfd
)->phdr
+ elf_elfheader (abfd
)->e_phnum
;
4415 while (phdr
-- > elf_tdata (abfd
)->phdr
)
4416 if (phdr
->p_type
== PT_GNU_RELRO
)
4418 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4420 unsigned int opb
= bfd_octets_per_byte (abfd
, s
);
4422 if ((s
->flags
& SEC_ALLOC
) != 0
4423 && s
->vma
* opb
>= phdr
->p_vaddr
4424 && s
->vma
* opb
+ s
->size
<= phdr
->p_vaddr
+ phdr
->p_memsz
)
4425 s
->flags
|= SEC_READONLY
;
4430 /* We do not want to include any of the sections in a dynamic
4431 object in the output file. We hack by simply clobbering the
4432 list of sections in the BFD. This could be handled more
4433 cleanly by, say, a new section flag; the existing
4434 SEC_NEVER_LOAD flag is not the one we want, because that one
4435 still implies that the section takes up space in the output
4437 bfd_section_list_clear (abfd
);
4439 /* Find the name to use in a DT_NEEDED entry that refers to this
4440 object. If the object has a DT_SONAME entry, we use it.
4441 Otherwise, if the generic linker stuck something in
4442 elf_dt_name, we use that. Otherwise, we just use the file
4444 if (soname
== NULL
|| *soname
== '\0')
4446 soname
= elf_dt_name (abfd
);
4447 if (soname
== NULL
|| *soname
== '\0')
4448 soname
= bfd_get_filename (abfd
);
4451 /* Save the SONAME because sometimes the linker emulation code
4452 will need to know it. */
4453 elf_dt_name (abfd
) = soname
;
4455 /* If we have already included this dynamic object in the
4456 link, just ignore it. There is no reason to include a
4457 particular dynamic object more than once. */
4458 for (loaded_lib
= htab
->dyn_loaded
;
4460 loaded_lib
= loaded_lib
->next
)
4462 if (strcmp (elf_dt_name (loaded_lib
->abfd
), soname
) == 0)
4466 /* Create dynamic sections for backends that require that be done
4467 before setup_gnu_properties. */
4469 && !_bfd_elf_link_create_dynamic_sections (abfd
, info
))
4472 /* Save the DT_AUDIT entry for the linker emulation code. */
4473 elf_dt_audit (abfd
) = audit
;
4476 /* If this is a dynamic object, we always link against the .dynsym
4477 symbol table, not the .symtab symbol table. The dynamic linker
4478 will only see the .dynsym symbol table, so there is no reason to
4479 look at .symtab for a dynamic object. */
4481 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
4482 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4484 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
4486 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
4488 /* The sh_info field of the symtab header tells us where the
4489 external symbols start. We don't care about the local symbols at
4491 if (elf_bad_symtab (abfd
))
4493 extsymcount
= symcount
;
4498 extsymcount
= symcount
- hdr
->sh_info
;
4499 extsymoff
= hdr
->sh_info
;
4502 sym_hash
= elf_sym_hashes (abfd
);
4503 if (extsymcount
!= 0)
4505 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
4507 if (isymbuf
== NULL
)
4510 if (sym_hash
== NULL
)
4512 /* We store a pointer to the hash table entry for each
4514 size_t amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4515 sym_hash
= (struct elf_link_hash_entry
**) bfd_zalloc (abfd
, amt
);
4516 if (sym_hash
== NULL
)
4517 goto error_free_sym
;
4518 elf_sym_hashes (abfd
) = sym_hash
;
4524 /* Read in any version definitions. */
4525 if (!_bfd_elf_slurp_version_tables (abfd
,
4526 info
->default_imported_symver
))
4527 goto error_free_sym
;
4529 /* Read in the symbol versions, but don't bother to convert them
4530 to internal format. */
4531 if (elf_dynversym (abfd
) != 0)
4533 Elf_Internal_Shdr
*versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
4534 bfd_size_type amt
= versymhdr
->sh_size
;
4536 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0)
4537 goto error_free_sym
;
4538 extversym
= (Elf_External_Versym
*)
4539 _bfd_malloc_and_read (abfd
, amt
, amt
);
4540 if (extversym
== NULL
)
4541 goto error_free_sym
;
4542 extversym_end
= extversym
+ amt
/ sizeof (*extversym
);
4546 /* If we are loading an as-needed shared lib, save the symbol table
4547 state before we start adding symbols. If the lib turns out
4548 to be unneeded, restore the state. */
4549 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4554 for (entsize
= 0, i
= 0; i
< htab
->root
.table
.size
; i
++)
4556 struct bfd_hash_entry
*p
;
4557 struct elf_link_hash_entry
*h
;
4559 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4561 h
= (struct elf_link_hash_entry
*) p
;
4562 entsize
+= htab
->root
.table
.entsize
;
4563 if (h
->root
.type
== bfd_link_hash_warning
)
4565 entsize
+= htab
->root
.table
.entsize
;
4566 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4568 if (h
->root
.type
== bfd_link_hash_common
)
4569 entsize
+= sizeof (*h
->root
.u
.c
.p
);
4573 tabsize
= htab
->root
.table
.size
* sizeof (struct bfd_hash_entry
*);
4574 old_tab
= bfd_malloc (tabsize
+ entsize
);
4575 if (old_tab
== NULL
)
4576 goto error_free_vers
;
4578 /* Remember the current objalloc pointer, so that all mem for
4579 symbols added can later be reclaimed. */
4580 alloc_mark
= bfd_hash_allocate (&htab
->root
.table
, 1);
4581 if (alloc_mark
== NULL
)
4582 goto error_free_vers
;
4584 /* Make a special call to the linker "notice" function to
4585 tell it that we are about to handle an as-needed lib. */
4586 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_as_needed
))
4587 goto error_free_vers
;
4589 /* Clone the symbol table. Remember some pointers into the
4590 symbol table, and dynamic symbol count. */
4591 old_ent
= (char *) old_tab
+ tabsize
;
4592 memcpy (old_tab
, htab
->root
.table
.table
, tabsize
);
4593 old_undefs
= htab
->root
.undefs
;
4594 old_undefs_tail
= htab
->root
.undefs_tail
;
4595 old_table
= htab
->root
.table
.table
;
4596 old_size
= htab
->root
.table
.size
;
4597 old_count
= htab
->root
.table
.count
;
4599 if (htab
->dynstr
!= NULL
)
4601 old_strtab
= _bfd_elf_strtab_save (htab
->dynstr
);
4602 if (old_strtab
== NULL
)
4603 goto error_free_vers
;
4606 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4608 struct bfd_hash_entry
*p
;
4609 struct elf_link_hash_entry
*h
;
4611 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4613 h
= (struct elf_link_hash_entry
*) p
;
4614 memcpy (old_ent
, h
, htab
->root
.table
.entsize
);
4615 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4616 if (h
->root
.type
== bfd_link_hash_warning
)
4618 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4619 memcpy (old_ent
, h
, htab
->root
.table
.entsize
);
4620 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4622 if (h
->root
.type
== bfd_link_hash_common
)
4624 memcpy (old_ent
, h
->root
.u
.c
.p
, sizeof (*h
->root
.u
.c
.p
));
4625 old_ent
= (char *) old_ent
+ sizeof (*h
->root
.u
.c
.p
);
4632 if (extversym
== NULL
)
4634 else if (extversym
+ extsymoff
< extversym_end
)
4635 ever
= extversym
+ extsymoff
;
4638 /* xgettext:c-format */
4639 _bfd_error_handler (_("%pB: invalid version offset %lx (max %lx)"),
4640 abfd
, (long) extsymoff
,
4641 (long) (extversym_end
- extversym
) / sizeof (* extversym
));
4642 bfd_set_error (bfd_error_bad_value
);
4643 goto error_free_vers
;
4646 if (!bfd_link_relocatable (info
)
4647 && abfd
->lto_slim_object
)
4650 (_("%pB: plugin needed to handle lto object"), abfd
);
4653 for (isym
= isymbuf
, isymend
= PTR_ADD (isymbuf
, extsymcount
);
4655 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
4659 asection
*sec
, *new_sec
;
4662 struct elf_link_hash_entry
*h
;
4663 struct elf_link_hash_entry
*hi
;
4665 bool size_change_ok
;
4666 bool type_change_ok
;
4672 unsigned int old_alignment
;
4673 unsigned int shindex
;
4679 flags
= BSF_NO_FLAGS
;
4681 value
= isym
->st_value
;
4682 common
= bed
->common_definition (isym
);
4683 if (common
&& info
->inhibit_common_definition
)
4685 /* Treat common symbol as undefined for --no-define-common. */
4686 isym
->st_shndx
= SHN_UNDEF
;
4691 bind
= ELF_ST_BIND (isym
->st_info
);
4695 /* This should be impossible, since ELF requires that all
4696 global symbols follow all local symbols, and that sh_info
4697 point to the first global symbol. Unfortunately, Irix 5
4699 if (elf_bad_symtab (abfd
))
4702 /* If we aren't prepared to handle locals within the globals
4703 then we'll likely segfault on a NULL symbol hash if the
4704 symbol is ever referenced in relocations. */
4705 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
4706 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, hdr
->sh_name
);
4707 _bfd_error_handler (_("%pB: %s local symbol at index %lu"
4708 " (>= sh_info of %lu)"),
4709 abfd
, name
, (long) (isym
- isymbuf
+ extsymoff
),
4712 /* Dynamic object relocations are not processed by ld, so
4713 ld won't run into the problem mentioned above. */
4716 bfd_set_error (bfd_error_bad_value
);
4717 goto error_free_vers
;
4720 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
4728 case STB_GNU_UNIQUE
:
4729 flags
= BSF_GNU_UNIQUE
;
4733 /* Leave it up to the processor backend. */
4737 if (isym
->st_shndx
== SHN_UNDEF
)
4738 sec
= bfd_und_section_ptr
;
4739 else if (isym
->st_shndx
== SHN_ABS
)
4740 sec
= bfd_abs_section_ptr
;
4741 else if (isym
->st_shndx
== SHN_COMMON
)
4743 sec
= bfd_com_section_ptr
;
4744 /* What ELF calls the size we call the value. What ELF
4745 calls the value we call the alignment. */
4746 value
= isym
->st_size
;
4750 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4752 sec
= bfd_abs_section_ptr
;
4753 else if (discarded_section (sec
))
4755 /* Symbols from discarded section are undefined. We keep
4757 sec
= bfd_und_section_ptr
;
4759 isym
->st_shndx
= SHN_UNDEF
;
4761 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
4765 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4768 goto error_free_vers
;
4770 if (isym
->st_shndx
== SHN_COMMON
4771 && (abfd
->flags
& BFD_PLUGIN
) != 0)
4773 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
4777 flagword sflags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
4779 xc
= bfd_make_section_with_flags (abfd
, "COMMON", sflags
);
4781 goto error_free_vers
;
4785 else if (isym
->st_shndx
== SHN_COMMON
4786 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
4787 && !bfd_link_relocatable (info
))
4789 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
4793 flagword sflags
= (SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_IS_COMMON
4794 | SEC_LINKER_CREATED
);
4795 tcomm
= bfd_make_section_with_flags (abfd
, ".tcommon", sflags
);
4797 goto error_free_vers
;
4801 else if (bed
->elf_add_symbol_hook
)
4803 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
4805 goto error_free_vers
;
4807 /* The hook function sets the name to NULL if this symbol
4808 should be skipped for some reason. */
4813 /* Sanity check that all possibilities were handled. */
4817 /* Silently discard TLS symbols from --just-syms. There's
4818 no way to combine a static TLS block with a new TLS block
4819 for this executable. */
4820 if (ELF_ST_TYPE (isym
->st_info
) == STT_TLS
4821 && sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4824 if (bfd_is_und_section (sec
)
4825 || bfd_is_com_section (sec
))
4830 size_change_ok
= false;
4831 type_change_ok
= bed
->type_change_ok
;
4838 if (is_elf_hash_table (&htab
->root
))
4840 Elf_Internal_Versym iver
;
4841 unsigned int vernum
= 0;
4846 if (info
->default_imported_symver
)
4847 /* Use the default symbol version created earlier. */
4848 iver
.vs_vers
= elf_tdata (abfd
)->cverdefs
;
4852 else if (ever
>= extversym_end
)
4854 /* xgettext:c-format */
4855 _bfd_error_handler (_("%pB: not enough version information"),
4857 bfd_set_error (bfd_error_bad_value
);
4858 goto error_free_vers
;
4861 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
4863 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
4865 /* If this is a hidden symbol, or if it is not version
4866 1, we append the version name to the symbol name.
4867 However, we do not modify a non-hidden absolute symbol
4868 if it is not a function, because it might be the version
4869 symbol itself. FIXME: What if it isn't? */
4870 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
4872 && (!bfd_is_abs_section (sec
)
4873 || bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
)))))
4876 size_t namelen
, verlen
, newlen
;
4879 if (isym
->st_shndx
!= SHN_UNDEF
)
4881 if (vernum
> elf_tdata (abfd
)->cverdefs
)
4883 else if (vernum
> 1)
4885 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
4892 /* xgettext:c-format */
4893 (_("%pB: %s: invalid version %u (max %d)"),
4895 elf_tdata (abfd
)->cverdefs
);
4896 bfd_set_error (bfd_error_bad_value
);
4897 goto error_free_vers
;
4902 /* We cannot simply test for the number of
4903 entries in the VERNEED section since the
4904 numbers for the needed versions do not start
4906 Elf_Internal_Verneed
*t
;
4909 for (t
= elf_tdata (abfd
)->verref
;
4913 Elf_Internal_Vernaux
*a
;
4915 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
4917 if (a
->vna_other
== vernum
)
4919 verstr
= a
->vna_nodename
;
4929 /* xgettext:c-format */
4930 (_("%pB: %s: invalid needed version %d"),
4931 abfd
, name
, vernum
);
4932 bfd_set_error (bfd_error_bad_value
);
4933 goto error_free_vers
;
4937 namelen
= strlen (name
);
4938 verlen
= strlen (verstr
);
4939 newlen
= namelen
+ verlen
+ 2;
4940 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4941 && isym
->st_shndx
!= SHN_UNDEF
)
4944 newname
= (char *) bfd_hash_allocate (&htab
->root
.table
, newlen
);
4945 if (newname
== NULL
)
4946 goto error_free_vers
;
4947 memcpy (newname
, name
, namelen
);
4948 p
= newname
+ namelen
;
4950 /* If this is a defined non-hidden version symbol,
4951 we add another @ to the name. This indicates the
4952 default version of the symbol. */
4953 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4954 && isym
->st_shndx
!= SHN_UNDEF
)
4956 memcpy (p
, verstr
, verlen
+ 1);
4961 /* If this symbol has default visibility and the user has
4962 requested we not re-export it, then mark it as hidden. */
4963 if (!bfd_is_und_section (sec
)
4966 && ELF_ST_VISIBILITY (isym
->st_other
) != STV_INTERNAL
)
4967 isym
->st_other
= (STV_HIDDEN
4968 | (isym
->st_other
& ~ELF_ST_VISIBILITY (-1)));
4970 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
, &value
,
4971 sym_hash
, &old_bfd
, &old_weak
,
4972 &old_alignment
, &skip
, &override
,
4973 &type_change_ok
, &size_change_ok
,
4975 goto error_free_vers
;
4980 /* Override a definition only if the new symbol matches the
4982 if (override
&& matched
)
4986 while (h
->root
.type
== bfd_link_hash_indirect
4987 || h
->root
.type
== bfd_link_hash_warning
)
4988 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4990 if (h
->versioned
!= unversioned
4991 && elf_tdata (abfd
)->verdef
!= NULL
4994 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
4997 if (! (_bfd_generic_link_add_one_symbol
4998 (info
, override
? override
: abfd
, name
, flags
, sec
, value
,
4999 NULL
, false, bed
->collect
,
5000 (struct bfd_link_hash_entry
**) sym_hash
)))
5001 goto error_free_vers
;
5004 /* We need to make sure that indirect symbol dynamic flags are
5007 while (h
->root
.type
== bfd_link_hash_indirect
5008 || h
->root
.type
== bfd_link_hash_warning
)
5009 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5013 /* Setting the index to -3 tells elf_link_output_extsym that
5014 this symbol is defined in a discarded section. */
5015 if (discarded
&& is_elf_hash_table (&htab
->root
))
5018 new_weak
= (flags
& BSF_WEAK
) != 0;
5022 && !bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
))
5023 && is_elf_hash_table (&htab
->root
)
5024 && h
->u
.alias
== NULL
)
5026 /* Keep a list of all weak defined non function symbols from
5027 a dynamic object, using the alias field. Later in this
5028 function we will set the alias field to the correct
5029 value. We only put non-function symbols from dynamic
5030 objects on this list, because that happens to be the only
5031 time we need to know the normal symbol corresponding to a
5032 weak symbol, and the information is time consuming to
5033 figure out. If the alias field is not already NULL,
5034 then this symbol was already defined by some previous
5035 dynamic object, and we will be using that previous
5036 definition anyhow. */
5042 /* Set the alignment of a common symbol. */
5043 if ((common
|| bfd_is_com_section (sec
))
5044 && h
->root
.type
== bfd_link_hash_common
)
5049 align
= bfd_log2 (isym
->st_value
);
5052 /* The new symbol is a common symbol in a shared object.
5053 We need to get the alignment from the section. */
5054 align
= new_sec
->alignment_power
;
5056 if (align
> old_alignment
)
5057 h
->root
.u
.c
.p
->alignment_power
= align
;
5059 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
5062 if (is_elf_hash_table (&htab
->root
))
5064 /* Set a flag in the hash table entry indicating the type of
5065 reference or definition we just found. A dynamic symbol
5066 is one which is referenced or defined by both a regular
5067 object and a shared object. */
5068 bool dynsym
= false;
5070 /* Plugin symbols aren't normal. Don't set def/ref flags. */
5071 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
5073 /* Except for this flag to track nonweak references. */
5075 && bind
!= STB_WEAK
)
5076 h
->ref_ir_nonweak
= 1;
5083 if (bind
!= STB_WEAK
)
5084 h
->ref_regular_nonweak
= 1;
5101 hi
->ref_dynamic
= 1;
5106 hi
->def_dynamic
= 1;
5110 /* If an indirect symbol has been forced local, don't
5111 make the real symbol dynamic. */
5112 if (h
!= hi
&& hi
->forced_local
)
5116 if (bfd_link_dll (info
)
5126 && weakdef (h
)->dynindx
!= -1))
5130 /* Check to see if we need to add an indirect symbol for
5131 the default name. */
5133 || (!override
&& h
->root
.type
== bfd_link_hash_common
))
5135 && hi
->versioned
== versioned_hidden
))
5136 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
5137 sec
, value
, &old_bfd
, &dynsym
))
5138 goto error_free_vers
;
5140 /* Check the alignment when a common symbol is involved. This
5141 can change when a common symbol is overridden by a normal
5142 definition or a common symbol is ignored due to the old
5143 normal definition. We need to make sure the maximum
5144 alignment is maintained. */
5145 if ((old_alignment
|| common
)
5146 && h
->root
.type
!= bfd_link_hash_common
)
5148 unsigned int common_align
;
5149 unsigned int normal_align
;
5150 unsigned int symbol_align
;
5154 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5155 || h
->root
.type
== bfd_link_hash_defweak
);
5157 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
5158 if (h
->root
.u
.def
.section
->owner
!= NULL
5159 && (h
->root
.u
.def
.section
->owner
->flags
5160 & (DYNAMIC
| BFD_PLUGIN
)) == 0)
5162 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
5163 if (normal_align
> symbol_align
)
5164 normal_align
= symbol_align
;
5167 normal_align
= symbol_align
;
5171 common_align
= old_alignment
;
5172 common_bfd
= old_bfd
;
5177 common_align
= bfd_log2 (isym
->st_value
);
5179 normal_bfd
= old_bfd
;
5182 if (normal_align
< common_align
)
5184 /* PR binutils/2735 */
5185 if (normal_bfd
== NULL
)
5187 /* xgettext:c-format */
5188 (_("warning: alignment %u of common symbol `%s' in %pB is"
5189 " greater than the alignment (%u) of its section %pA"),
5190 1 << common_align
, name
, common_bfd
,
5191 1 << normal_align
, h
->root
.u
.def
.section
);
5194 /* xgettext:c-format */
5195 (_("warning: alignment %u of symbol `%s' in %pB"
5196 " is smaller than %u in %pB"),
5197 1 << normal_align
, name
, normal_bfd
,
5198 1 << common_align
, common_bfd
);
5202 /* Remember the symbol size if it isn't undefined. */
5203 if (isym
->st_size
!= 0
5204 && isym
->st_shndx
!= SHN_UNDEF
5205 && (definition
|| h
->size
== 0))
5208 && h
->size
!= isym
->st_size
5209 && ! size_change_ok
)
5211 /* xgettext:c-format */
5212 (_("warning: size of symbol `%s' changed"
5213 " from %" PRIu64
" in %pB to %" PRIu64
" in %pB"),
5214 name
, (uint64_t) h
->size
, old_bfd
,
5215 (uint64_t) isym
->st_size
, abfd
);
5217 h
->size
= isym
->st_size
;
5220 /* If this is a common symbol, then we always want H->SIZE
5221 to be the size of the common symbol. The code just above
5222 won't fix the size if a common symbol becomes larger. We
5223 don't warn about a size change here, because that is
5224 covered by --warn-common. Allow changes between different
5226 if (h
->root
.type
== bfd_link_hash_common
)
5227 h
->size
= h
->root
.u
.c
.size
;
5229 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
5230 && ((definition
&& !new_weak
)
5231 || (old_weak
&& h
->root
.type
== bfd_link_hash_common
)
5232 || h
->type
== STT_NOTYPE
))
5234 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
5236 /* Turn an IFUNC symbol from a DSO into a normal FUNC
5238 if (type
== STT_GNU_IFUNC
5239 && (abfd
->flags
& DYNAMIC
) != 0)
5242 if (h
->type
!= type
)
5244 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
5245 /* xgettext:c-format */
5247 (_("warning: type of symbol `%s' changed"
5248 " from %d to %d in %pB"),
5249 name
, h
->type
, type
, abfd
);
5255 /* Merge st_other field. */
5256 elf_merge_st_other (abfd
, h
, isym
->st_other
, sec
,
5257 definition
, dynamic
);
5259 /* We don't want to make debug symbol dynamic. */
5261 && (sec
->flags
& SEC_DEBUGGING
)
5262 && !bfd_link_relocatable (info
))
5265 /* Nor should we make plugin symbols dynamic. */
5266 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
5271 h
->target_internal
= isym
->st_target_internal
;
5272 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
5275 if (definition
&& !dynamic
)
5277 char *p
= strchr (name
, ELF_VER_CHR
);
5278 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
5280 /* Queue non-default versions so that .symver x, x@FOO
5281 aliases can be checked. */
5284 size_t amt
= ((isymend
- isym
+ 1)
5285 * sizeof (struct elf_link_hash_entry
*));
5287 = (struct elf_link_hash_entry
**) bfd_malloc (amt
);
5289 goto error_free_vers
;
5291 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
5295 if (dynsym
&& h
->dynindx
== -1)
5297 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5298 goto error_free_vers
;
5300 && weakdef (h
)->dynindx
== -1)
5302 if (!bfd_elf_link_record_dynamic_symbol (info
, weakdef (h
)))
5303 goto error_free_vers
;
5306 else if (h
->dynindx
!= -1)
5307 /* If the symbol already has a dynamic index, but
5308 visibility says it should not be visible, turn it into
5310 switch (ELF_ST_VISIBILITY (h
->other
))
5314 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
5322 && h
->root
.type
!= bfd_link_hash_indirect
5324 && h
->ref_regular_nonweak
)
5326 && (old_bfd
->flags
& BFD_PLUGIN
) != 0
5327 && h
->ref_ir_nonweak
5328 && !info
->lto_all_symbols_read
)
5329 || (h
->ref_dynamic_nonweak
5330 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0
5331 && !on_needed_list (elf_dt_name (abfd
),
5332 htab
->needed
, NULL
))))
5334 const char *soname
= elf_dt_name (abfd
);
5336 info
->callbacks
->minfo ("%!", soname
, old_bfd
,
5337 h
->root
.root
.string
);
5339 /* A symbol from a library loaded via DT_NEEDED of some
5340 other library is referenced by a regular object.
5341 Add a DT_NEEDED entry for it. Issue an error if
5342 --no-add-needed is used and the reference was not
5345 && (elf_dyn_lib_class (abfd
) & DYN_NO_NEEDED
) != 0)
5348 /* xgettext:c-format */
5349 (_("%pB: undefined reference to symbol '%s'"),
5351 bfd_set_error (bfd_error_missing_dso
);
5352 goto error_free_vers
;
5355 elf_dyn_lib_class (abfd
) = (enum dynamic_lib_link_class
)
5356 (elf_dyn_lib_class (abfd
) & ~DYN_AS_NEEDED
);
5358 /* Create dynamic sections for backends that require
5359 that be done before setup_gnu_properties. */
5360 if (!_bfd_elf_link_create_dynamic_sections (abfd
, info
))
5367 if (info
->lto_plugin_active
5368 && !bfd_link_relocatable (info
)
5369 && (abfd
->flags
& BFD_PLUGIN
) == 0
5375 if (bed
->s
->arch_size
== 32)
5380 /* If linker plugin is enabled, set non_ir_ref_regular on symbols
5381 referenced in regular objects so that linker plugin will get
5382 the correct symbol resolution. */
5384 sym_hash
= elf_sym_hashes (abfd
);
5385 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5387 Elf_Internal_Rela
*internal_relocs
;
5388 Elf_Internal_Rela
*rel
, *relend
;
5390 /* Don't check relocations in excluded sections. */
5391 if ((s
->flags
& SEC_RELOC
) == 0
5392 || s
->reloc_count
== 0
5393 || (s
->flags
& SEC_EXCLUDE
) != 0
5394 || ((info
->strip
== strip_all
5395 || info
->strip
== strip_debugger
)
5396 && (s
->flags
& SEC_DEBUGGING
) != 0))
5399 internal_relocs
= _bfd_elf_link_info_read_relocs (abfd
, info
,
5402 _bfd_link_keep_memory (info
));
5403 if (internal_relocs
== NULL
)
5404 goto error_free_vers
;
5406 rel
= internal_relocs
;
5407 relend
= rel
+ s
->reloc_count
;
5408 for ( ; rel
< relend
; rel
++)
5410 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
5411 struct elf_link_hash_entry
*h
;
5413 /* Skip local symbols. */
5414 if (r_symndx
< extsymoff
)
5417 h
= sym_hash
[r_symndx
- extsymoff
];
5419 h
->root
.non_ir_ref_regular
= 1;
5422 if (elf_section_data (s
)->relocs
!= internal_relocs
)
5423 free (internal_relocs
);
5432 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
5436 /* Restore the symbol table. */
5437 old_ent
= (char *) old_tab
+ tabsize
;
5438 memset (elf_sym_hashes (abfd
), 0,
5439 extsymcount
* sizeof (struct elf_link_hash_entry
*));
5440 htab
->root
.table
.table
= old_table
;
5441 htab
->root
.table
.size
= old_size
;
5442 htab
->root
.table
.count
= old_count
;
5443 memcpy (htab
->root
.table
.table
, old_tab
, tabsize
);
5444 htab
->root
.undefs
= old_undefs
;
5445 htab
->root
.undefs_tail
= old_undefs_tail
;
5446 if (htab
->dynstr
!= NULL
)
5447 _bfd_elf_strtab_restore (htab
->dynstr
, old_strtab
);
5450 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
5452 struct bfd_hash_entry
*p
;
5453 struct elf_link_hash_entry
*h
;
5454 unsigned int non_ir_ref_dynamic
;
5456 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
5458 /* Preserve non_ir_ref_dynamic so that this symbol
5459 will be exported when the dynamic lib becomes needed
5460 in the second pass. */
5461 h
= (struct elf_link_hash_entry
*) p
;
5462 if (h
->root
.type
== bfd_link_hash_warning
)
5463 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5464 non_ir_ref_dynamic
= h
->root
.non_ir_ref_dynamic
;
5466 h
= (struct elf_link_hash_entry
*) p
;
5467 memcpy (h
, old_ent
, htab
->root
.table
.entsize
);
5468 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
5469 if (h
->root
.type
== bfd_link_hash_warning
)
5471 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5472 memcpy (h
, old_ent
, htab
->root
.table
.entsize
);
5473 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
5475 if (h
->root
.type
== bfd_link_hash_common
)
5477 memcpy (h
->root
.u
.c
.p
, old_ent
, sizeof (*h
->root
.u
.c
.p
));
5478 old_ent
= (char *) old_ent
+ sizeof (*h
->root
.u
.c
.p
);
5480 h
->root
.non_ir_ref_dynamic
= non_ir_ref_dynamic
;
5484 /* Make a special call to the linker "notice" function to
5485 tell it that symbols added for crefs may need to be removed. */
5486 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_not_needed
))
5487 goto error_free_vers
;
5490 objalloc_free_block ((struct objalloc
*) htab
->root
.table
.memory
,
5492 free (nondeflt_vers
);
5496 if (old_tab
!= NULL
)
5498 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_needed
))
5499 goto error_free_vers
;
5504 /* Now that all the symbols from this input file are created, if
5505 not performing a relocatable link, handle .symver foo, foo@BAR
5506 such that any relocs against foo become foo@BAR. */
5507 if (!bfd_link_relocatable (info
) && nondeflt_vers
!= NULL
)
5511 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
5513 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
5514 char *shortname
, *p
;
5517 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
5519 || (h
->root
.type
!= bfd_link_hash_defined
5520 && h
->root
.type
!= bfd_link_hash_defweak
))
5523 amt
= p
- h
->root
.root
.string
;
5524 shortname
= (char *) bfd_malloc (amt
+ 1);
5526 goto error_free_vers
;
5527 memcpy (shortname
, h
->root
.root
.string
, amt
);
5528 shortname
[amt
] = '\0';
5530 hi
= (struct elf_link_hash_entry
*)
5531 bfd_link_hash_lookup (&htab
->root
, shortname
,
5532 false, false, false);
5534 && hi
->root
.type
== h
->root
.type
5535 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
5536 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
5538 (*bed
->elf_backend_hide_symbol
) (info
, hi
, true);
5539 hi
->root
.type
= bfd_link_hash_indirect
;
5540 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
5541 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
5542 sym_hash
= elf_sym_hashes (abfd
);
5544 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
5545 if (sym_hash
[symidx
] == hi
)
5547 sym_hash
[symidx
] = h
;
5553 free (nondeflt_vers
);
5554 nondeflt_vers
= NULL
;
5557 /* Now set the alias field correctly for all the weak defined
5558 symbols we found. The only way to do this is to search all the
5559 symbols. Since we only need the information for non functions in
5560 dynamic objects, that's the only time we actually put anything on
5561 the list WEAKS. We need this information so that if a regular
5562 object refers to a symbol defined weakly in a dynamic object, the
5563 real symbol in the dynamic object is also put in the dynamic
5564 symbols; we also must arrange for both symbols to point to the
5565 same memory location. We could handle the general case of symbol
5566 aliasing, but a general symbol alias can only be generated in
5567 assembler code, handling it correctly would be very time
5568 consuming, and other ELF linkers don't handle general aliasing
5572 struct elf_link_hash_entry
**hpp
;
5573 struct elf_link_hash_entry
**hppend
;
5574 struct elf_link_hash_entry
**sorted_sym_hash
;
5575 struct elf_link_hash_entry
*h
;
5576 size_t sym_count
, amt
;
5578 /* Since we have to search the whole symbol list for each weak
5579 defined symbol, search time for N weak defined symbols will be
5580 O(N^2). Binary search will cut it down to O(NlogN). */
5581 amt
= extsymcount
* sizeof (*sorted_sym_hash
);
5582 sorted_sym_hash
= bfd_malloc (amt
);
5583 if (sorted_sym_hash
== NULL
)
5585 sym_hash
= sorted_sym_hash
;
5586 hpp
= elf_sym_hashes (abfd
);
5587 hppend
= hpp
+ extsymcount
;
5589 for (; hpp
< hppend
; hpp
++)
5593 && h
->root
.type
== bfd_link_hash_defined
5594 && !bed
->is_function_type (h
->type
))
5602 qsort (sorted_sym_hash
, sym_count
, sizeof (*sorted_sym_hash
),
5605 while (weaks
!= NULL
)
5607 struct elf_link_hash_entry
*hlook
;
5610 size_t i
, j
, idx
= 0;
5613 weaks
= hlook
->u
.alias
;
5614 hlook
->u
.alias
= NULL
;
5616 if (hlook
->root
.type
!= bfd_link_hash_defined
5617 && hlook
->root
.type
!= bfd_link_hash_defweak
)
5620 slook
= hlook
->root
.u
.def
.section
;
5621 vlook
= hlook
->root
.u
.def
.value
;
5627 bfd_signed_vma vdiff
;
5629 h
= sorted_sym_hash
[idx
];
5630 vdiff
= vlook
- h
->root
.u
.def
.value
;
5637 int sdiff
= slook
->id
- h
->root
.u
.def
.section
->id
;
5647 /* We didn't find a value/section match. */
5651 /* With multiple aliases, or when the weak symbol is already
5652 strongly defined, we have multiple matching symbols and
5653 the binary search above may land on any of them. Step
5654 one past the matching symbol(s). */
5657 h
= sorted_sym_hash
[idx
];
5658 if (h
->root
.u
.def
.section
!= slook
5659 || h
->root
.u
.def
.value
!= vlook
)
5663 /* Now look back over the aliases. Since we sorted by size
5664 as well as value and section, we'll choose the one with
5665 the largest size. */
5668 h
= sorted_sym_hash
[idx
];
5670 /* Stop if value or section doesn't match. */
5671 if (h
->root
.u
.def
.section
!= slook
5672 || h
->root
.u
.def
.value
!= vlook
)
5674 else if (h
!= hlook
)
5676 struct elf_link_hash_entry
*t
;
5679 hlook
->is_weakalias
= 1;
5681 if (t
->u
.alias
!= NULL
)
5682 while (t
->u
.alias
!= h
)
5686 /* If the weak definition is in the list of dynamic
5687 symbols, make sure the real definition is put
5689 if (hlook
->dynindx
!= -1 && h
->dynindx
== -1)
5691 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5694 free (sorted_sym_hash
);
5699 /* If the real definition is in the list of dynamic
5700 symbols, make sure the weak definition is put
5701 there as well. If we don't do this, then the
5702 dynamic loader might not merge the entries for the
5703 real definition and the weak definition. */
5704 if (h
->dynindx
!= -1 && hlook
->dynindx
== -1)
5706 if (! bfd_elf_link_record_dynamic_symbol (info
, hlook
))
5707 goto err_free_sym_hash
;
5714 free (sorted_sym_hash
);
5717 if (bed
->check_directives
5718 && !(*bed
->check_directives
) (abfd
, info
))
5721 /* If this is a non-traditional link, try to optimize the handling
5722 of the .stab/.stabstr sections. */
5724 && ! info
->traditional_format
5725 && is_elf_hash_table (&htab
->root
)
5726 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
5730 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
5731 if (stabstr
!= NULL
)
5733 bfd_size_type string_offset
= 0;
5736 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
5737 if (startswith (stab
->name
, ".stab")
5738 && (!stab
->name
[5] ||
5739 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
5740 && (stab
->flags
& SEC_MERGE
) == 0
5741 && !bfd_is_abs_section (stab
->output_section
))
5743 struct bfd_elf_section_data
*secdata
;
5745 secdata
= elf_section_data (stab
);
5746 if (! _bfd_link_section_stabs (abfd
, &htab
->stab_info
, stab
,
5747 stabstr
, &secdata
->sec_info
,
5750 if (secdata
->sec_info
)
5751 stab
->sec_info_type
= SEC_INFO_TYPE_STABS
;
5756 if (dynamic
&& add_needed
)
5758 /* Add this bfd to the loaded list. */
5759 struct elf_link_loaded_list
*n
;
5761 n
= (struct elf_link_loaded_list
*) bfd_alloc (abfd
, sizeof (*n
));
5765 n
->next
= htab
->dyn_loaded
;
5766 htab
->dyn_loaded
= n
;
5768 if (dynamic
&& !add_needed
5769 && (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) != 0)
5770 elf_dyn_lib_class (abfd
) |= DYN_NO_NEEDED
;
5777 free (nondeflt_vers
);
5785 /* Return the linker hash table entry of a symbol that might be
5786 satisfied by an archive symbol. Return -1 on error. */
5788 struct bfd_link_hash_entry
*
5789 _bfd_elf_archive_symbol_lookup (bfd
*abfd
,
5790 struct bfd_link_info
*info
,
5793 struct bfd_link_hash_entry
*h
;
5797 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
5801 /* If this is a default version (the name contains @@), look up the
5802 symbol again with only one `@' as well as without the version.
5803 The effect is that references to the symbol with and without the
5804 version will be matched by the default symbol in the archive. */
5806 p
= strchr (name
, ELF_VER_CHR
);
5807 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
5810 /* First check with only one `@'. */
5811 len
= strlen (name
);
5812 copy
= (char *) bfd_alloc (abfd
, len
);
5814 return (struct bfd_link_hash_entry
*) -1;
5816 first
= p
- name
+ 1;
5817 memcpy (copy
, name
, first
);
5818 memcpy (copy
+ first
, name
+ first
+ 1, len
- first
);
5820 h
= bfd_link_hash_lookup (info
->hash
, copy
, false, false, true);
5823 /* We also need to check references to the symbol without the
5825 copy
[first
- 1] = '\0';
5826 h
= bfd_link_hash_lookup (info
->hash
, copy
, false, false, true);
5829 bfd_release (abfd
, copy
);
5833 /* Add symbols from an ELF archive file to the linker hash table. We
5834 don't use _bfd_generic_link_add_archive_symbols because we need to
5835 handle versioned symbols.
5837 Fortunately, ELF archive handling is simpler than that done by
5838 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
5839 oddities. In ELF, if we find a symbol in the archive map, and the
5840 symbol is currently undefined, we know that we must pull in that
5843 Unfortunately, we do have to make multiple passes over the symbol
5844 table until nothing further is resolved. */
5847 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5850 unsigned char *included
= NULL
;
5854 const struct elf_backend_data
*bed
;
5855 struct bfd_link_hash_entry
* (*archive_symbol_lookup
)
5856 (bfd
*, struct bfd_link_info
*, const char *);
5858 if (! bfd_has_map (abfd
))
5860 /* An empty archive is a special case. */
5861 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
5863 bfd_set_error (bfd_error_no_armap
);
5867 /* Keep track of all symbols we know to be already defined, and all
5868 files we know to be already included. This is to speed up the
5869 second and subsequent passes. */
5870 c
= bfd_ardata (abfd
)->symdef_count
;
5873 amt
= c
* sizeof (*included
);
5874 included
= (unsigned char *) bfd_zmalloc (amt
);
5875 if (included
== NULL
)
5878 symdefs
= bfd_ardata (abfd
)->symdefs
;
5879 bed
= get_elf_backend_data (abfd
);
5880 archive_symbol_lookup
= bed
->elf_backend_archive_symbol_lookup
;
5893 symdefend
= symdef
+ c
;
5894 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
5896 struct bfd_link_hash_entry
*h
;
5898 struct bfd_link_hash_entry
*undefs_tail
;
5903 if (symdef
->file_offset
== last
)
5909 h
= archive_symbol_lookup (abfd
, info
, symdef
->name
);
5910 if (h
== (struct bfd_link_hash_entry
*) -1)
5916 if (h
->type
== bfd_link_hash_undefined
)
5918 /* If the archive element has already been loaded then one
5919 of the symbols defined by that element might have been
5920 made undefined due to being in a discarded section. */
5921 if (is_elf_hash_table (info
->hash
)
5922 && ((struct elf_link_hash_entry
*) h
)->indx
== -3)
5925 else if (h
->type
== bfd_link_hash_common
)
5927 /* We currently have a common symbol. The archive map contains
5928 a reference to this symbol, so we may want to include it. We
5929 only want to include it however, if this archive element
5930 contains a definition of the symbol, not just another common
5933 Unfortunately some archivers (including GNU ar) will put
5934 declarations of common symbols into their archive maps, as
5935 well as real definitions, so we cannot just go by the archive
5936 map alone. Instead we must read in the element's symbol
5937 table and check that to see what kind of symbol definition
5939 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
5944 if (h
->type
!= bfd_link_hash_undefweak
)
5945 /* Symbol must be defined. Don't check it again. */
5950 /* We need to include this archive member. */
5951 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
5952 if (element
== NULL
)
5955 if (! bfd_check_format (element
, bfd_object
))
5958 undefs_tail
= info
->hash
->undefs_tail
;
5960 if (!(*info
->callbacks
5961 ->add_archive_element
) (info
, element
, symdef
->name
, &element
))
5963 if (!bfd_link_add_symbols (element
, info
))
5966 /* If there are any new undefined symbols, we need to make
5967 another pass through the archive in order to see whether
5968 they can be defined. FIXME: This isn't perfect, because
5969 common symbols wind up on undefs_tail and because an
5970 undefined symbol which is defined later on in this pass
5971 does not require another pass. This isn't a bug, but it
5972 does make the code less efficient than it could be. */
5973 if (undefs_tail
!= info
->hash
->undefs_tail
)
5976 /* Look backward to mark all symbols from this object file
5977 which we have already seen in this pass. */
5981 included
[mark
] = true;
5986 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
5988 /* We mark subsequent symbols from this object file as we go
5989 on through the loop. */
5990 last
= symdef
->file_offset
;
6003 /* Given an ELF BFD, add symbols to the global hash table as
6007 bfd_elf_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
6009 switch (bfd_get_format (abfd
))
6012 return elf_link_add_object_symbols (abfd
, info
);
6014 return elf_link_add_archive_symbols (abfd
, info
);
6016 bfd_set_error (bfd_error_wrong_format
);
6021 struct hash_codes_info
6023 unsigned long *hashcodes
;
6027 /* This function will be called though elf_link_hash_traverse to store
6028 all hash value of the exported symbols in an array. */
6031 elf_collect_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
6033 struct hash_codes_info
*inf
= (struct hash_codes_info
*) data
;
6038 /* Ignore indirect symbols. These are added by the versioning code. */
6039 if (h
->dynindx
== -1)
6042 name
= h
->root
.root
.string
;
6043 if (h
->versioned
>= versioned
)
6045 char *p
= strchr (name
, ELF_VER_CHR
);
6048 alc
= (char *) bfd_malloc (p
- name
+ 1);
6054 memcpy (alc
, name
, p
- name
);
6055 alc
[p
- name
] = '\0';
6060 /* Compute the hash value. */
6061 ha
= bfd_elf_hash (name
);
6063 /* Store the found hash value in the array given as the argument. */
6064 *(inf
->hashcodes
)++ = ha
;
6066 /* And store it in the struct so that we can put it in the hash table
6068 h
->u
.elf_hash_value
= ha
;
6074 struct collect_gnu_hash_codes
6077 const struct elf_backend_data
*bed
;
6078 unsigned long int nsyms
;
6079 unsigned long int maskbits
;
6080 unsigned long int *hashcodes
;
6081 unsigned long int *hashval
;
6082 unsigned long int *indx
;
6083 unsigned long int *counts
;
6087 long int min_dynindx
;
6088 unsigned long int bucketcount
;
6089 unsigned long int symindx
;
6090 long int local_indx
;
6091 long int shift1
, shift2
;
6092 unsigned long int mask
;
6096 /* This function will be called though elf_link_hash_traverse to store
6097 all hash value of the exported symbols in an array. */
6100 elf_collect_gnu_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
6102 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
6107 /* Ignore indirect symbols. These are added by the versioning code. */
6108 if (h
->dynindx
== -1)
6111 /* Ignore also local symbols and undefined symbols. */
6112 if (! (*s
->bed
->elf_hash_symbol
) (h
))
6115 name
= h
->root
.root
.string
;
6116 if (h
->versioned
>= versioned
)
6118 char *p
= strchr (name
, ELF_VER_CHR
);
6121 alc
= (char *) bfd_malloc (p
- name
+ 1);
6127 memcpy (alc
, name
, p
- name
);
6128 alc
[p
- name
] = '\0';
6133 /* Compute the hash value. */
6134 ha
= bfd_elf_gnu_hash (name
);
6136 /* Store the found hash value in the array for compute_bucket_count,
6137 and also for .dynsym reordering purposes. */
6138 s
->hashcodes
[s
->nsyms
] = ha
;
6139 s
->hashval
[h
->dynindx
] = ha
;
6141 if (s
->min_dynindx
< 0 || s
->min_dynindx
> h
->dynindx
)
6142 s
->min_dynindx
= h
->dynindx
;
6148 /* This function will be called though elf_link_hash_traverse to do
6149 final dynamic symbol renumbering in case of .gnu.hash.
6150 If using .MIPS.xhash, invoke record_xhash_symbol to add symbol index
6151 to the translation table. */
6154 elf_gnu_hash_process_symidx (struct elf_link_hash_entry
*h
, void *data
)
6156 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
6157 unsigned long int bucket
;
6158 unsigned long int val
;
6160 /* Ignore indirect symbols. */
6161 if (h
->dynindx
== -1)
6164 /* Ignore also local symbols and undefined symbols. */
6165 if (! (*s
->bed
->elf_hash_symbol
) (h
))
6167 if (h
->dynindx
>= s
->min_dynindx
)
6169 if (s
->bed
->record_xhash_symbol
!= NULL
)
6171 (*s
->bed
->record_xhash_symbol
) (h
, 0);
6175 h
->dynindx
= s
->local_indx
++;
6180 bucket
= s
->hashval
[h
->dynindx
] % s
->bucketcount
;
6181 val
= (s
->hashval
[h
->dynindx
] >> s
->shift1
)
6182 & ((s
->maskbits
>> s
->shift1
) - 1);
6183 s
->bitmask
[val
] |= ((bfd_vma
) 1) << (s
->hashval
[h
->dynindx
] & s
->mask
);
6185 |= ((bfd_vma
) 1) << ((s
->hashval
[h
->dynindx
] >> s
->shift2
) & s
->mask
);
6186 val
= s
->hashval
[h
->dynindx
] & ~(unsigned long int) 1;
6187 if (s
->counts
[bucket
] == 1)
6188 /* Last element terminates the chain. */
6190 bfd_put_32 (s
->output_bfd
, val
,
6191 s
->contents
+ (s
->indx
[bucket
] - s
->symindx
) * 4);
6192 --s
->counts
[bucket
];
6193 if (s
->bed
->record_xhash_symbol
!= NULL
)
6195 bfd_vma xlat_loc
= s
->xlat
+ (s
->indx
[bucket
]++ - s
->symindx
) * 4;
6197 (*s
->bed
->record_xhash_symbol
) (h
, xlat_loc
);
6200 h
->dynindx
= s
->indx
[bucket
]++;
6204 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6207 _bfd_elf_hash_symbol (struct elf_link_hash_entry
*h
)
6209 return !(h
->forced_local
6210 || h
->root
.type
== bfd_link_hash_undefined
6211 || h
->root
.type
== bfd_link_hash_undefweak
6212 || ((h
->root
.type
== bfd_link_hash_defined
6213 || h
->root
.type
== bfd_link_hash_defweak
)
6214 && h
->root
.u
.def
.section
->output_section
== NULL
));
6217 /* Array used to determine the number of hash table buckets to use
6218 based on the number of symbols there are. If there are fewer than
6219 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
6220 fewer than 37 we use 17 buckets, and so forth. We never use more
6221 than 32771 buckets. */
6223 static const size_t elf_buckets
[] =
6225 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
6229 /* Compute bucket count for hashing table. We do not use a static set
6230 of possible tables sizes anymore. Instead we determine for all
6231 possible reasonable sizes of the table the outcome (i.e., the
6232 number of collisions etc) and choose the best solution. The
6233 weighting functions are not too simple to allow the table to grow
6234 without bounds. Instead one of the weighting factors is the size.
6235 Therefore the result is always a good payoff between few collisions
6236 (= short chain lengths) and table size. */
6238 compute_bucket_count (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6239 unsigned long int *hashcodes ATTRIBUTE_UNUSED
,
6240 unsigned long int nsyms
,
6243 size_t best_size
= 0;
6244 unsigned long int i
;
6246 /* We have a problem here. The following code to optimize the table
6247 size requires an integer type with more the 32 bits. If
6248 BFD_HOST_U_64_BIT is set we know about such a type. */
6249 #ifdef BFD_HOST_U_64_BIT
6254 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
6255 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
6256 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
6257 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
6258 unsigned long int *counts
;
6260 unsigned int no_improvement_count
= 0;
6262 /* Possible optimization parameters: if we have NSYMS symbols we say
6263 that the hashing table must at least have NSYMS/4 and at most
6265 minsize
= nsyms
/ 4;
6268 best_size
= maxsize
= nsyms
* 2;
6273 if ((best_size
& 31) == 0)
6277 /* Create array where we count the collisions in. We must use bfd_malloc
6278 since the size could be large. */
6280 amt
*= sizeof (unsigned long int);
6281 counts
= (unsigned long int *) bfd_malloc (amt
);
6285 /* Compute the "optimal" size for the hash table. The criteria is a
6286 minimal chain length. The minor criteria is (of course) the size
6288 for (i
= minsize
; i
< maxsize
; ++i
)
6290 /* Walk through the array of hashcodes and count the collisions. */
6291 BFD_HOST_U_64_BIT max
;
6292 unsigned long int j
;
6293 unsigned long int fact
;
6295 if (gnu_hash
&& (i
& 31) == 0)
6298 memset (counts
, '\0', i
* sizeof (unsigned long int));
6300 /* Determine how often each hash bucket is used. */
6301 for (j
= 0; j
< nsyms
; ++j
)
6302 ++counts
[hashcodes
[j
] % i
];
6304 /* For the weight function we need some information about the
6305 pagesize on the target. This is information need not be 100%
6306 accurate. Since this information is not available (so far) we
6307 define it here to a reasonable default value. If it is crucial
6308 to have a better value some day simply define this value. */
6309 # ifndef BFD_TARGET_PAGESIZE
6310 # define BFD_TARGET_PAGESIZE (4096)
6313 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
6315 max
= (2 + dynsymcount
) * bed
->s
->sizeof_hash_entry
;
6318 /* Variant 1: optimize for short chains. We add the squares
6319 of all the chain lengths (which favors many small chain
6320 over a few long chains). */
6321 for (j
= 0; j
< i
; ++j
)
6322 max
+= counts
[j
] * counts
[j
];
6324 /* This adds penalties for the overall size of the table. */
6325 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
6328 /* Variant 2: Optimize a lot more for small table. Here we
6329 also add squares of the size but we also add penalties for
6330 empty slots (the +1 term). */
6331 for (j
= 0; j
< i
; ++j
)
6332 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
6334 /* The overall size of the table is considered, but not as
6335 strong as in variant 1, where it is squared. */
6336 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
6340 /* Compare with current best results. */
6341 if (max
< best_chlen
)
6345 no_improvement_count
= 0;
6347 /* PR 11843: Avoid futile long searches for the best bucket size
6348 when there are a large number of symbols. */
6349 else if (++no_improvement_count
== 100)
6356 #endif /* defined (BFD_HOST_U_64_BIT) */
6358 /* This is the fallback solution if no 64bit type is available or if we
6359 are not supposed to spend much time on optimizations. We select the
6360 bucket count using a fixed set of numbers. */
6361 for (i
= 0; elf_buckets
[i
] != 0; i
++)
6363 best_size
= elf_buckets
[i
];
6364 if (nsyms
< elf_buckets
[i
+ 1])
6367 if (gnu_hash
&& best_size
< 2)
6374 /* Size any SHT_GROUP section for ld -r. */
6377 _bfd_elf_size_group_sections (struct bfd_link_info
*info
)
6382 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
6383 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
6384 && (s
= ibfd
->sections
) != NULL
6385 && s
->sec_info_type
!= SEC_INFO_TYPE_JUST_SYMS
6386 && !_bfd_elf_fixup_group_sections (ibfd
, bfd_abs_section_ptr
))
6391 /* Set a default stack segment size. The value in INFO wins. If it
6392 is unset, LEGACY_SYMBOL's value is used, and if that symbol is
6393 undefined it is initialized. */
6396 bfd_elf_stack_segment_size (bfd
*output_bfd
,
6397 struct bfd_link_info
*info
,
6398 const char *legacy_symbol
,
6399 bfd_vma default_size
)
6401 struct elf_link_hash_entry
*h
= NULL
;
6403 /* Look for legacy symbol. */
6405 h
= elf_link_hash_lookup (elf_hash_table (info
), legacy_symbol
,
6406 false, false, false);
6407 if (h
&& (h
->root
.type
== bfd_link_hash_defined
6408 || h
->root
.type
== bfd_link_hash_defweak
)
6410 && (h
->type
== STT_NOTYPE
|| h
->type
== STT_OBJECT
))
6412 /* The symbol has no type if specified on the command line. */
6413 h
->type
= STT_OBJECT
;
6414 if (info
->stacksize
)
6415 /* xgettext:c-format */
6416 _bfd_error_handler (_("%pB: stack size specified and %s set"),
6417 output_bfd
, legacy_symbol
);
6418 else if (h
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
6419 /* xgettext:c-format */
6420 _bfd_error_handler (_("%pB: %s not absolute"),
6421 output_bfd
, legacy_symbol
);
6423 info
->stacksize
= h
->root
.u
.def
.value
;
6426 if (!info
->stacksize
)
6427 /* If the user didn't set a size, or explicitly inhibit the
6428 size, set it now. */
6429 info
->stacksize
= default_size
;
6431 /* Provide the legacy symbol, if it is referenced. */
6432 if (h
&& (h
->root
.type
== bfd_link_hash_undefined
6433 || h
->root
.type
== bfd_link_hash_undefweak
))
6435 struct bfd_link_hash_entry
*bh
= NULL
;
6437 if (!(_bfd_generic_link_add_one_symbol
6438 (info
, output_bfd
, legacy_symbol
,
6439 BSF_GLOBAL
, bfd_abs_section_ptr
,
6440 info
->stacksize
>= 0 ? info
->stacksize
: 0,
6441 NULL
, false, get_elf_backend_data (output_bfd
)->collect
, &bh
)))
6444 h
= (struct elf_link_hash_entry
*) bh
;
6446 h
->type
= STT_OBJECT
;
6452 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
6454 struct elf_gc_sweep_symbol_info
6456 struct bfd_link_info
*info
;
6457 void (*hide_symbol
) (struct bfd_link_info
*, struct elf_link_hash_entry
*,
6462 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *data
)
6465 && (((h
->root
.type
== bfd_link_hash_defined
6466 || h
->root
.type
== bfd_link_hash_defweak
)
6467 && !((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
6468 && h
->root
.u
.def
.section
->gc_mark
))
6469 || h
->root
.type
== bfd_link_hash_undefined
6470 || h
->root
.type
== bfd_link_hash_undefweak
))
6472 struct elf_gc_sweep_symbol_info
*inf
;
6474 inf
= (struct elf_gc_sweep_symbol_info
*) data
;
6475 (*inf
->hide_symbol
) (inf
->info
, h
, true);
6478 h
->ref_regular_nonweak
= 0;
6484 /* Set up the sizes and contents of the ELF dynamic sections. This is
6485 called by the ELF linker emulation before_allocation routine. We
6486 must set the sizes of the sections before the linker sets the
6487 addresses of the various sections. */
6490 bfd_elf_size_dynamic_sections (bfd
*output_bfd
,
6493 const char *filter_shlib
,
6495 const char *depaudit
,
6496 const char * const *auxiliary_filters
,
6497 struct bfd_link_info
*info
,
6498 asection
**sinterpptr
)
6501 const struct elf_backend_data
*bed
;
6505 if (!is_elf_hash_table (info
->hash
))
6508 dynobj
= elf_hash_table (info
)->dynobj
;
6510 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
6512 struct bfd_elf_version_tree
*verdefs
;
6513 struct elf_info_failed asvinfo
;
6514 struct bfd_elf_version_tree
*t
;
6515 struct bfd_elf_version_expr
*d
;
6519 /* If we are supposed to export all symbols into the dynamic symbol
6520 table (this is not the normal case), then do so. */
6521 if (info
->export_dynamic
6522 || (bfd_link_executable (info
) && info
->dynamic
))
6524 struct elf_info_failed eif
;
6528 elf_link_hash_traverse (elf_hash_table (info
),
6529 _bfd_elf_export_symbol
,
6537 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6539 if (soname_indx
== (size_t) -1
6540 || !_bfd_elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
6544 soname_indx
= (size_t) -1;
6546 /* Make all global versions with definition. */
6547 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
6548 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
6549 if (!d
->symver
&& d
->literal
)
6551 const char *verstr
, *name
;
6552 size_t namelen
, verlen
, newlen
;
6553 char *newname
, *p
, leading_char
;
6554 struct elf_link_hash_entry
*newh
;
6556 leading_char
= bfd_get_symbol_leading_char (output_bfd
);
6558 namelen
= strlen (name
) + (leading_char
!= '\0');
6560 verlen
= strlen (verstr
);
6561 newlen
= namelen
+ verlen
+ 3;
6563 newname
= (char *) bfd_malloc (newlen
);
6564 if (newname
== NULL
)
6566 newname
[0] = leading_char
;
6567 memcpy (newname
+ (leading_char
!= '\0'), name
, namelen
);
6569 /* Check the hidden versioned definition. */
6570 p
= newname
+ namelen
;
6572 memcpy (p
, verstr
, verlen
+ 1);
6573 newh
= elf_link_hash_lookup (elf_hash_table (info
),
6574 newname
, false, false,
6577 || (newh
->root
.type
!= bfd_link_hash_defined
6578 && newh
->root
.type
!= bfd_link_hash_defweak
))
6580 /* Check the default versioned definition. */
6582 memcpy (p
, verstr
, verlen
+ 1);
6583 newh
= elf_link_hash_lookup (elf_hash_table (info
),
6584 newname
, false, false,
6589 /* Mark this version if there is a definition and it is
6590 not defined in a shared object. */
6592 && !newh
->def_dynamic
6593 && (newh
->root
.type
== bfd_link_hash_defined
6594 || newh
->root
.type
== bfd_link_hash_defweak
))
6598 /* Attach all the symbols to their version information. */
6599 asvinfo
.info
= info
;
6600 asvinfo
.failed
= false;
6602 elf_link_hash_traverse (elf_hash_table (info
),
6603 _bfd_elf_link_assign_sym_version
,
6608 if (!info
->allow_undefined_version
)
6610 /* Check if all global versions have a definition. */
6611 bool all_defined
= true;
6612 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
6613 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
6614 if (d
->literal
&& !d
->symver
&& !d
->script
)
6617 (_("%s: undefined version: %s"),
6618 d
->pattern
, t
->name
);
6619 all_defined
= false;
6624 bfd_set_error (bfd_error_bad_value
);
6629 /* Set up the version definition section. */
6630 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
6631 BFD_ASSERT (s
!= NULL
);
6633 /* We may have created additional version definitions if we are
6634 just linking a regular application. */
6635 verdefs
= info
->version_info
;
6637 /* Skip anonymous version tag. */
6638 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
6639 verdefs
= verdefs
->next
;
6641 if (verdefs
== NULL
&& !info
->create_default_symver
)
6642 s
->flags
|= SEC_EXCLUDE
;
6648 Elf_Internal_Verdef def
;
6649 Elf_Internal_Verdaux defaux
;
6650 struct bfd_link_hash_entry
*bh
;
6651 struct elf_link_hash_entry
*h
;
6657 /* Make space for the base version. */
6658 size
+= sizeof (Elf_External_Verdef
);
6659 size
+= sizeof (Elf_External_Verdaux
);
6662 /* Make space for the default version. */
6663 if (info
->create_default_symver
)
6665 size
+= sizeof (Elf_External_Verdef
);
6669 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6671 struct bfd_elf_version_deps
*n
;
6673 /* Don't emit base version twice. */
6677 size
+= sizeof (Elf_External_Verdef
);
6678 size
+= sizeof (Elf_External_Verdaux
);
6681 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6682 size
+= sizeof (Elf_External_Verdaux
);
6686 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6687 if (s
->contents
== NULL
&& s
->size
!= 0)
6690 /* Fill in the version definition section. */
6694 def
.vd_version
= VER_DEF_CURRENT
;
6695 def
.vd_flags
= VER_FLG_BASE
;
6698 if (info
->create_default_symver
)
6700 def
.vd_aux
= 2 * sizeof (Elf_External_Verdef
);
6701 def
.vd_next
= sizeof (Elf_External_Verdef
);
6705 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6706 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6707 + sizeof (Elf_External_Verdaux
));
6710 if (soname_indx
!= (size_t) -1)
6712 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6714 def
.vd_hash
= bfd_elf_hash (soname
);
6715 defaux
.vda_name
= soname_indx
;
6722 name
= lbasename (bfd_get_filename (output_bfd
));
6723 def
.vd_hash
= bfd_elf_hash (name
);
6724 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6726 if (indx
== (size_t) -1)
6728 defaux
.vda_name
= indx
;
6730 defaux
.vda_next
= 0;
6732 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6733 (Elf_External_Verdef
*) p
);
6734 p
+= sizeof (Elf_External_Verdef
);
6735 if (info
->create_default_symver
)
6737 /* Add a symbol representing this version. */
6739 if (! (_bfd_generic_link_add_one_symbol
6740 (info
, dynobj
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6742 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6744 h
= (struct elf_link_hash_entry
*) bh
;
6747 h
->type
= STT_OBJECT
;
6748 h
->verinfo
.vertree
= NULL
;
6750 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6753 /* Create a duplicate of the base version with the same
6754 aux block, but different flags. */
6757 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6759 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6760 + sizeof (Elf_External_Verdaux
));
6763 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6764 (Elf_External_Verdef
*) p
);
6765 p
+= sizeof (Elf_External_Verdef
);
6767 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6768 (Elf_External_Verdaux
*) p
);
6769 p
+= sizeof (Elf_External_Verdaux
);
6771 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6774 struct bfd_elf_version_deps
*n
;
6776 /* Don't emit the base version twice. */
6781 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6784 /* Add a symbol representing this version. */
6786 if (! (_bfd_generic_link_add_one_symbol
6787 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6789 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6791 h
= (struct elf_link_hash_entry
*) bh
;
6794 h
->type
= STT_OBJECT
;
6795 h
->verinfo
.vertree
= t
;
6797 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6800 def
.vd_version
= VER_DEF_CURRENT
;
6802 if (t
->globals
.list
== NULL
6803 && t
->locals
.list
== NULL
6805 def
.vd_flags
|= VER_FLG_WEAK
;
6806 def
.vd_ndx
= t
->vernum
+ (info
->create_default_symver
? 2 : 1);
6807 def
.vd_cnt
= cdeps
+ 1;
6808 def
.vd_hash
= bfd_elf_hash (t
->name
);
6809 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6812 /* If a basever node is next, it *must* be the last node in
6813 the chain, otherwise Verdef construction breaks. */
6814 if (t
->next
!= NULL
&& t
->next
->vernum
== 0)
6815 BFD_ASSERT (t
->next
->next
== NULL
);
6817 if (t
->next
!= NULL
&& t
->next
->vernum
!= 0)
6818 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6819 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
6821 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6822 (Elf_External_Verdef
*) p
);
6823 p
+= sizeof (Elf_External_Verdef
);
6825 defaux
.vda_name
= h
->dynstr_index
;
6826 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6828 defaux
.vda_next
= 0;
6829 if (t
->deps
!= NULL
)
6830 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6831 t
->name_indx
= defaux
.vda_name
;
6833 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6834 (Elf_External_Verdaux
*) p
);
6835 p
+= sizeof (Elf_External_Verdaux
);
6837 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6839 if (n
->version_needed
== NULL
)
6841 /* This can happen if there was an error in the
6843 defaux
.vda_name
= 0;
6847 defaux
.vda_name
= n
->version_needed
->name_indx
;
6848 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6851 if (n
->next
== NULL
)
6852 defaux
.vda_next
= 0;
6854 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6856 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6857 (Elf_External_Verdaux
*) p
);
6858 p
+= sizeof (Elf_External_Verdaux
);
6862 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
6866 bed
= get_elf_backend_data (output_bfd
);
6868 if (info
->gc_sections
&& bed
->can_gc_sections
)
6870 struct elf_gc_sweep_symbol_info sweep_info
;
6872 /* Remove the symbols that were in the swept sections from the
6873 dynamic symbol table. */
6874 sweep_info
.info
= info
;
6875 sweep_info
.hide_symbol
= bed
->elf_backend_hide_symbol
;
6876 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
,
6880 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
6883 struct elf_find_verdep_info sinfo
;
6885 /* Work out the size of the version reference section. */
6887 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
6888 BFD_ASSERT (s
!= NULL
);
6891 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
6892 if (sinfo
.vers
== 0)
6894 sinfo
.failed
= false;
6896 elf_link_hash_traverse (elf_hash_table (info
),
6897 _bfd_elf_link_find_version_dependencies
,
6902 if (elf_tdata (output_bfd
)->verref
== NULL
)
6903 s
->flags
|= SEC_EXCLUDE
;
6906 Elf_Internal_Verneed
*vn
;
6911 /* Build the version dependency section. */
6914 for (vn
= elf_tdata (output_bfd
)->verref
;
6916 vn
= vn
->vn_nextref
)
6918 Elf_Internal_Vernaux
*a
;
6920 size
+= sizeof (Elf_External_Verneed
);
6922 for (a
= vn
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6923 size
+= sizeof (Elf_External_Vernaux
);
6927 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6928 if (s
->contents
== NULL
)
6932 for (vn
= elf_tdata (output_bfd
)->verref
;
6934 vn
= vn
->vn_nextref
)
6937 Elf_Internal_Vernaux
*a
;
6941 for (a
= vn
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6944 vn
->vn_version
= VER_NEED_CURRENT
;
6946 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6947 elf_dt_name (vn
->vn_bfd
) != NULL
6948 ? elf_dt_name (vn
->vn_bfd
)
6949 : lbasename (bfd_get_filename
6952 if (indx
== (size_t) -1)
6955 vn
->vn_aux
= sizeof (Elf_External_Verneed
);
6956 if (vn
->vn_nextref
== NULL
)
6959 vn
->vn_next
= (sizeof (Elf_External_Verneed
)
6960 + caux
* sizeof (Elf_External_Vernaux
));
6962 _bfd_elf_swap_verneed_out (output_bfd
, vn
,
6963 (Elf_External_Verneed
*) p
);
6964 p
+= sizeof (Elf_External_Verneed
);
6966 for (a
= vn
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6968 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
6969 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6970 a
->vna_nodename
, false);
6971 if (indx
== (size_t) -1)
6974 if (a
->vna_nextptr
== NULL
)
6977 a
->vna_next
= sizeof (Elf_External_Vernaux
);
6979 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
6980 (Elf_External_Vernaux
*) p
);
6981 p
+= sizeof (Elf_External_Vernaux
);
6985 elf_tdata (output_bfd
)->cverrefs
= crefs
;
6989 /* Any syms created from now on start with -1 in
6990 got.refcount/offset and plt.refcount/offset. */
6991 elf_hash_table (info
)->init_got_refcount
6992 = elf_hash_table (info
)->init_got_offset
;
6993 elf_hash_table (info
)->init_plt_refcount
6994 = elf_hash_table (info
)->init_plt_offset
;
6996 if (bfd_link_relocatable (info
)
6997 && !_bfd_elf_size_group_sections (info
))
7000 /* The backend may have to create some sections regardless of whether
7001 we're dynamic or not. */
7002 if (bed
->elf_backend_always_size_sections
7003 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
7006 /* Determine any GNU_STACK segment requirements, after the backend
7007 has had a chance to set a default segment size. */
7008 if (info
->execstack
)
7009 elf_stack_flags (output_bfd
) = PF_R
| PF_W
| PF_X
;
7010 else if (info
->noexecstack
)
7011 elf_stack_flags (output_bfd
) = PF_R
| PF_W
;
7015 asection
*notesec
= NULL
;
7018 for (inputobj
= info
->input_bfds
;
7020 inputobj
= inputobj
->link
.next
)
7025 & (DYNAMIC
| EXEC_P
| BFD_PLUGIN
| BFD_LINKER_CREATED
))
7027 s
= inputobj
->sections
;
7028 if (s
== NULL
|| s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7031 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
7034 if (s
->flags
& SEC_CODE
)
7038 else if (bed
->default_execstack
)
7041 if (notesec
|| info
->stacksize
> 0)
7042 elf_stack_flags (output_bfd
) = PF_R
| PF_W
| exec
;
7043 if (notesec
&& exec
&& bfd_link_relocatable (info
)
7044 && notesec
->output_section
!= bfd_abs_section_ptr
)
7045 notesec
->output_section
->flags
|= SEC_CODE
;
7048 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
7050 struct elf_info_failed eif
;
7051 struct elf_link_hash_entry
*h
;
7055 *sinterpptr
= bfd_get_linker_section (dynobj
, ".interp");
7056 BFD_ASSERT (*sinterpptr
!= NULL
|| !bfd_link_executable (info
) || info
->nointerp
);
7060 if (!_bfd_elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
7062 info
->flags
|= DF_SYMBOLIC
;
7070 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
7072 if (indx
== (size_t) -1)
7075 tag
= info
->new_dtags
? DT_RUNPATH
: DT_RPATH
;
7076 if (!_bfd_elf_add_dynamic_entry (info
, tag
, indx
))
7080 if (filter_shlib
!= NULL
)
7084 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
7085 filter_shlib
, true);
7086 if (indx
== (size_t) -1
7087 || !_bfd_elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
7091 if (auxiliary_filters
!= NULL
)
7093 const char * const *p
;
7095 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
7099 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
7101 if (indx
== (size_t) -1
7102 || !_bfd_elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
7111 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, audit
,
7113 if (indx
== (size_t) -1
7114 || !_bfd_elf_add_dynamic_entry (info
, DT_AUDIT
, indx
))
7118 if (depaudit
!= NULL
)
7122 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, depaudit
,
7124 if (indx
== (size_t) -1
7125 || !_bfd_elf_add_dynamic_entry (info
, DT_DEPAUDIT
, indx
))
7132 /* Find all symbols which were defined in a dynamic object and make
7133 the backend pick a reasonable value for them. */
7134 elf_link_hash_traverse (elf_hash_table (info
),
7135 _bfd_elf_adjust_dynamic_symbol
,
7140 /* Add some entries to the .dynamic section. We fill in some of the
7141 values later, in bfd_elf_final_link, but we must add the entries
7142 now so that we know the final size of the .dynamic section. */
7144 /* If there are initialization and/or finalization functions to
7145 call then add the corresponding DT_INIT/DT_FINI entries. */
7146 h
= (info
->init_function
7147 ? elf_link_hash_lookup (elf_hash_table (info
),
7148 info
->init_function
, false,
7155 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT
, 0))
7158 h
= (info
->fini_function
7159 ? elf_link_hash_lookup (elf_hash_table (info
),
7160 info
->fini_function
, false,
7167 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI
, 0))
7171 s
= bfd_get_section_by_name (output_bfd
, ".preinit_array");
7172 if (s
!= NULL
&& s
->linker_has_input
)
7174 /* DT_PREINIT_ARRAY is not allowed in shared library. */
7175 if (! bfd_link_executable (info
))
7180 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
7181 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
7182 && (o
= sub
->sections
) != NULL
7183 && o
->sec_info_type
!= SEC_INFO_TYPE_JUST_SYMS
)
7184 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
7185 if (elf_section_data (o
)->this_hdr
.sh_type
7186 == SHT_PREINIT_ARRAY
)
7189 (_("%pB: .preinit_array section is not allowed in DSO"),
7194 bfd_set_error (bfd_error_nonrepresentable_section
);
7198 if (!_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
7199 || !_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
7202 s
= bfd_get_section_by_name (output_bfd
, ".init_array");
7203 if (s
!= NULL
&& s
->linker_has_input
)
7205 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
7206 || !_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
7209 s
= bfd_get_section_by_name (output_bfd
, ".fini_array");
7210 if (s
!= NULL
&& s
->linker_has_input
)
7212 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
7213 || !_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
7217 dynstr
= bfd_get_linker_section (dynobj
, ".dynstr");
7218 /* If .dynstr is excluded from the link, we don't want any of
7219 these tags. Strictly, we should be checking each section
7220 individually; This quick check covers for the case where
7221 someone does a /DISCARD/ : { *(*) }. */
7222 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
7224 bfd_size_type strsize
;
7226 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
7227 if ((info
->emit_hash
7228 && !_bfd_elf_add_dynamic_entry (info
, DT_HASH
, 0))
7229 || (info
->emit_gnu_hash
7230 && (bed
->record_xhash_symbol
== NULL
7231 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_HASH
, 0)))
7232 || !_bfd_elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
7233 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
7234 || !_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
7235 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMENT
,
7237 || (info
->gnu_flags_1
7238 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_FLAGS_1
,
7239 info
->gnu_flags_1
)))
7244 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
7247 /* The backend must work out the sizes of all the other dynamic
7250 && bed
->elf_backend_size_dynamic_sections
!= NULL
7251 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
7254 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
7256 if (elf_tdata (output_bfd
)->cverdefs
)
7258 unsigned int crefs
= elf_tdata (output_bfd
)->cverdefs
;
7260 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
7261 || !_bfd_elf_add_dynamic_entry (info
, DT_VERDEFNUM
, crefs
))
7265 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
7267 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
7270 else if (info
->flags
& DF_BIND_NOW
)
7272 if (!_bfd_elf_add_dynamic_entry (info
, DT_BIND_NOW
, 0))
7278 if (bfd_link_executable (info
))
7279 info
->flags_1
&= ~ (DF_1_INITFIRST
7282 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
7286 if (elf_tdata (output_bfd
)->cverrefs
)
7288 unsigned int crefs
= elf_tdata (output_bfd
)->cverrefs
;
7290 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
7291 || !_bfd_elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
7295 if ((elf_tdata (output_bfd
)->cverrefs
== 0
7296 && elf_tdata (output_bfd
)->cverdefs
== 0)
7297 || _bfd_elf_link_renumber_dynsyms (output_bfd
, info
, NULL
) <= 1)
7301 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
7302 s
->flags
|= SEC_EXCLUDE
;
7308 /* Find the first non-excluded output section. We'll use its
7309 section symbol for some emitted relocs. */
7311 _bfd_elf_init_1_index_section (bfd
*output_bfd
, struct bfd_link_info
*info
)
7314 asection
*found
= NULL
;
7316 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7317 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
7318 && !_bfd_elf_omit_section_dynsym_default (output_bfd
, info
, s
))
7321 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
7324 elf_hash_table (info
)->text_index_section
= found
;
7327 /* Find two non-excluded output sections, one for code, one for data.
7328 We'll use their section symbols for some emitted relocs. */
7330 _bfd_elf_init_2_index_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
7333 asection
*found
= NULL
;
7335 /* Data first, since setting text_index_section changes
7336 _bfd_elf_omit_section_dynsym_default. */
7337 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7338 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
7339 && !(s
->flags
& SEC_READONLY
)
7340 && !_bfd_elf_omit_section_dynsym_default (output_bfd
, info
, s
))
7343 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
7346 elf_hash_table (info
)->data_index_section
= found
;
7348 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7349 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
7350 && (s
->flags
& SEC_READONLY
)
7351 && !_bfd_elf_omit_section_dynsym_default (output_bfd
, info
, s
))
7356 elf_hash_table (info
)->text_index_section
= found
;
7359 #define GNU_HASH_SECTION_NAME(bed) \
7360 (bed)->record_xhash_symbol != NULL ? ".MIPS.xhash" : ".gnu.hash"
7363 bfd_elf_size_dynsym_hash_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
7365 const struct elf_backend_data
*bed
;
7366 unsigned long section_sym_count
;
7367 bfd_size_type dynsymcount
= 0;
7369 if (!is_elf_hash_table (info
->hash
))
7372 bed
= get_elf_backend_data (output_bfd
);
7373 (*bed
->elf_backend_init_index_section
) (output_bfd
, info
);
7375 /* Assign dynsym indices. In a shared library we generate a section
7376 symbol for each output section, which come first. Next come all
7377 of the back-end allocated local dynamic syms, followed by the rest
7378 of the global symbols.
7380 This is usually not needed for static binaries, however backends
7381 can request to always do it, e.g. the MIPS backend uses dynamic
7382 symbol counts to lay out GOT, which will be produced in the
7383 presence of GOT relocations even in static binaries (holding fixed
7384 data in that case, to satisfy those relocations). */
7386 if (elf_hash_table (info
)->dynamic_sections_created
7387 || bed
->always_renumber_dynsyms
)
7388 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
7389 §ion_sym_count
);
7391 if (elf_hash_table (info
)->dynamic_sections_created
)
7395 unsigned int dtagcount
;
7397 dynobj
= elf_hash_table (info
)->dynobj
;
7399 /* Work out the size of the symbol version section. */
7400 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
7401 BFD_ASSERT (s
!= NULL
);
7402 if ((s
->flags
& SEC_EXCLUDE
) == 0)
7404 s
->size
= dynsymcount
* sizeof (Elf_External_Versym
);
7405 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
7406 if (s
->contents
== NULL
)
7409 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
7413 /* Set the size of the .dynsym and .hash sections. We counted
7414 the number of dynamic symbols in elf_link_add_object_symbols.
7415 We will build the contents of .dynsym and .hash when we build
7416 the final symbol table, because until then we do not know the
7417 correct value to give the symbols. We built the .dynstr
7418 section as we went along in elf_link_add_object_symbols. */
7419 s
= elf_hash_table (info
)->dynsym
;
7420 BFD_ASSERT (s
!= NULL
);
7421 s
->size
= dynsymcount
* bed
->s
->sizeof_sym
;
7423 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
7424 if (s
->contents
== NULL
)
7427 /* The first entry in .dynsym is a dummy symbol. Clear all the
7428 section syms, in case we don't output them all. */
7429 ++section_sym_count
;
7430 memset (s
->contents
, 0, section_sym_count
* bed
->s
->sizeof_sym
);
7432 elf_hash_table (info
)->bucketcount
= 0;
7434 /* Compute the size of the hashing table. As a side effect this
7435 computes the hash values for all the names we export. */
7436 if (info
->emit_hash
)
7438 unsigned long int *hashcodes
;
7439 struct hash_codes_info hashinf
;
7441 unsigned long int nsyms
;
7443 size_t hash_entry_size
;
7445 /* Compute the hash values for all exported symbols. At the same
7446 time store the values in an array so that we could use them for
7448 amt
= dynsymcount
* sizeof (unsigned long int);
7449 hashcodes
= (unsigned long int *) bfd_malloc (amt
);
7450 if (hashcodes
== NULL
)
7452 hashinf
.hashcodes
= hashcodes
;
7453 hashinf
.error
= false;
7455 /* Put all hash values in HASHCODES. */
7456 elf_link_hash_traverse (elf_hash_table (info
),
7457 elf_collect_hash_codes
, &hashinf
);
7464 nsyms
= hashinf
.hashcodes
- hashcodes
;
7466 = compute_bucket_count (info
, hashcodes
, nsyms
, 0);
7469 if (bucketcount
== 0 && nsyms
> 0)
7472 elf_hash_table (info
)->bucketcount
= bucketcount
;
7474 s
= bfd_get_linker_section (dynobj
, ".hash");
7475 BFD_ASSERT (s
!= NULL
);
7476 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
7477 s
->size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
7478 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
7479 if (s
->contents
== NULL
)
7482 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
7483 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
7484 s
->contents
+ hash_entry_size
);
7487 if (info
->emit_gnu_hash
)
7490 unsigned char *contents
;
7491 struct collect_gnu_hash_codes cinfo
;
7495 memset (&cinfo
, 0, sizeof (cinfo
));
7497 /* Compute the hash values for all exported symbols. At the same
7498 time store the values in an array so that we could use them for
7500 amt
= dynsymcount
* 2 * sizeof (unsigned long int);
7501 cinfo
.hashcodes
= (long unsigned int *) bfd_malloc (amt
);
7502 if (cinfo
.hashcodes
== NULL
)
7505 cinfo
.hashval
= cinfo
.hashcodes
+ dynsymcount
;
7506 cinfo
.min_dynindx
= -1;
7507 cinfo
.output_bfd
= output_bfd
;
7510 /* Put all hash values in HASHCODES. */
7511 elf_link_hash_traverse (elf_hash_table (info
),
7512 elf_collect_gnu_hash_codes
, &cinfo
);
7515 free (cinfo
.hashcodes
);
7520 = compute_bucket_count (info
, cinfo
.hashcodes
, cinfo
.nsyms
, 1);
7522 if (bucketcount
== 0)
7524 free (cinfo
.hashcodes
);
7528 s
= bfd_get_linker_section (dynobj
, GNU_HASH_SECTION_NAME (bed
));
7529 BFD_ASSERT (s
!= NULL
);
7531 if (cinfo
.nsyms
== 0)
7533 /* Empty .gnu.hash or .MIPS.xhash section is special. */
7534 BFD_ASSERT (cinfo
.min_dynindx
== -1);
7535 free (cinfo
.hashcodes
);
7536 s
->size
= 5 * 4 + bed
->s
->arch_size
/ 8;
7537 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
7538 if (contents
== NULL
)
7540 s
->contents
= contents
;
7541 /* 1 empty bucket. */
7542 bfd_put_32 (output_bfd
, 1, contents
);
7543 /* SYMIDX above the special symbol 0. */
7544 bfd_put_32 (output_bfd
, 1, contents
+ 4);
7545 /* Just one word for bitmask. */
7546 bfd_put_32 (output_bfd
, 1, contents
+ 8);
7547 /* Only hash fn bloom filter. */
7548 bfd_put_32 (output_bfd
, 0, contents
+ 12);
7549 /* No hashes are valid - empty bitmask. */
7550 bfd_put (bed
->s
->arch_size
, output_bfd
, 0, contents
+ 16);
7551 /* No hashes in the only bucket. */
7552 bfd_put_32 (output_bfd
, 0,
7553 contents
+ 16 + bed
->s
->arch_size
/ 8);
7557 unsigned long int maskwords
, maskbitslog2
, x
;
7558 BFD_ASSERT (cinfo
.min_dynindx
!= -1);
7562 while ((x
>>= 1) != 0)
7564 if (maskbitslog2
< 3)
7566 else if ((1 << (maskbitslog2
- 2)) & cinfo
.nsyms
)
7567 maskbitslog2
= maskbitslog2
+ 3;
7569 maskbitslog2
= maskbitslog2
+ 2;
7570 if (bed
->s
->arch_size
== 64)
7572 if (maskbitslog2
== 5)
7578 cinfo
.mask
= (1 << cinfo
.shift1
) - 1;
7579 cinfo
.shift2
= maskbitslog2
;
7580 cinfo
.maskbits
= 1 << maskbitslog2
;
7581 maskwords
= 1 << (maskbitslog2
- cinfo
.shift1
);
7582 amt
= bucketcount
* sizeof (unsigned long int) * 2;
7583 amt
+= maskwords
* sizeof (bfd_vma
);
7584 cinfo
.bitmask
= (bfd_vma
*) bfd_malloc (amt
);
7585 if (cinfo
.bitmask
== NULL
)
7587 free (cinfo
.hashcodes
);
7591 cinfo
.counts
= (long unsigned int *) (cinfo
.bitmask
+ maskwords
);
7592 cinfo
.indx
= cinfo
.counts
+ bucketcount
;
7593 cinfo
.symindx
= dynsymcount
- cinfo
.nsyms
;
7594 memset (cinfo
.bitmask
, 0, maskwords
* sizeof (bfd_vma
));
7596 /* Determine how often each hash bucket is used. */
7597 memset (cinfo
.counts
, 0, bucketcount
* sizeof (cinfo
.counts
[0]));
7598 for (i
= 0; i
< cinfo
.nsyms
; ++i
)
7599 ++cinfo
.counts
[cinfo
.hashcodes
[i
] % bucketcount
];
7601 for (i
= 0, cnt
= cinfo
.symindx
; i
< bucketcount
; ++i
)
7602 if (cinfo
.counts
[i
] != 0)
7604 cinfo
.indx
[i
] = cnt
;
7605 cnt
+= cinfo
.counts
[i
];
7607 BFD_ASSERT (cnt
== dynsymcount
);
7608 cinfo
.bucketcount
= bucketcount
;
7609 cinfo
.local_indx
= cinfo
.min_dynindx
;
7611 s
->size
= (4 + bucketcount
+ cinfo
.nsyms
) * 4;
7612 s
->size
+= cinfo
.maskbits
/ 8;
7613 if (bed
->record_xhash_symbol
!= NULL
)
7614 s
->size
+= cinfo
.nsyms
* 4;
7615 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
7616 if (contents
== NULL
)
7618 free (cinfo
.bitmask
);
7619 free (cinfo
.hashcodes
);
7623 s
->contents
= contents
;
7624 bfd_put_32 (output_bfd
, bucketcount
, contents
);
7625 bfd_put_32 (output_bfd
, cinfo
.symindx
, contents
+ 4);
7626 bfd_put_32 (output_bfd
, maskwords
, contents
+ 8);
7627 bfd_put_32 (output_bfd
, cinfo
.shift2
, contents
+ 12);
7628 contents
+= 16 + cinfo
.maskbits
/ 8;
7630 for (i
= 0; i
< bucketcount
; ++i
)
7632 if (cinfo
.counts
[i
] == 0)
7633 bfd_put_32 (output_bfd
, 0, contents
);
7635 bfd_put_32 (output_bfd
, cinfo
.indx
[i
], contents
);
7639 cinfo
.contents
= contents
;
7641 cinfo
.xlat
= contents
+ cinfo
.nsyms
* 4 - s
->contents
;
7642 /* Renumber dynamic symbols, if populating .gnu.hash section.
7643 If using .MIPS.xhash, populate the translation table. */
7644 elf_link_hash_traverse (elf_hash_table (info
),
7645 elf_gnu_hash_process_symidx
, &cinfo
);
7647 contents
= s
->contents
+ 16;
7648 for (i
= 0; i
< maskwords
; ++i
)
7650 bfd_put (bed
->s
->arch_size
, output_bfd
, cinfo
.bitmask
[i
],
7652 contents
+= bed
->s
->arch_size
/ 8;
7655 free (cinfo
.bitmask
);
7656 free (cinfo
.hashcodes
);
7660 s
= bfd_get_linker_section (dynobj
, ".dynstr");
7661 BFD_ASSERT (s
!= NULL
);
7663 elf_finalize_dynstr (output_bfd
, info
);
7665 s
->size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
7667 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
7668 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0))
7675 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
7678 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7681 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
);
7682 sec
->sec_info_type
= SEC_INFO_TYPE_NONE
;
7685 /* Finish SHF_MERGE section merging. */
7688 _bfd_elf_merge_sections (bfd
*obfd
, struct bfd_link_info
*info
)
7693 if (!is_elf_hash_table (info
->hash
))
7696 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7697 if ((ibfd
->flags
& DYNAMIC
) == 0
7698 && bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
7699 && (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
7700 == get_elf_backend_data (obfd
)->s
->elfclass
))
7701 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7702 if ((sec
->flags
& SEC_MERGE
) != 0
7703 && !bfd_is_abs_section (sec
->output_section
))
7705 struct bfd_elf_section_data
*secdata
;
7707 secdata
= elf_section_data (sec
);
7708 if (! _bfd_add_merge_section (obfd
,
7709 &elf_hash_table (info
)->merge_info
,
7710 sec
, &secdata
->sec_info
))
7712 else if (secdata
->sec_info
)
7713 sec
->sec_info_type
= SEC_INFO_TYPE_MERGE
;
7716 if (elf_hash_table (info
)->merge_info
!= NULL
)
7717 _bfd_merge_sections (obfd
, info
, elf_hash_table (info
)->merge_info
,
7718 merge_sections_remove_hook
);
7722 /* Create an entry in an ELF linker hash table. */
7724 struct bfd_hash_entry
*
7725 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
7726 struct bfd_hash_table
*table
,
7729 /* Allocate the structure if it has not already been allocated by a
7733 entry
= (struct bfd_hash_entry
*)
7734 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
7739 /* Call the allocation method of the superclass. */
7740 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
7743 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
7744 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
7746 /* Set local fields. */
7749 ret
->got
= htab
->init_got_refcount
;
7750 ret
->plt
= htab
->init_plt_refcount
;
7751 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
7752 - offsetof (struct elf_link_hash_entry
, size
)));
7753 /* Assume that we have been called by a non-ELF symbol reader.
7754 This flag is then reset by the code which reads an ELF input
7755 file. This ensures that a symbol created by a non-ELF symbol
7756 reader will have the flag set correctly. */
7763 /* Copy data from an indirect symbol to its direct symbol, hiding the
7764 old indirect symbol. Also used for copying flags to a weakdef. */
7767 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info
*info
,
7768 struct elf_link_hash_entry
*dir
,
7769 struct elf_link_hash_entry
*ind
)
7771 struct elf_link_hash_table
*htab
;
7773 if (ind
->dyn_relocs
!= NULL
)
7775 if (dir
->dyn_relocs
!= NULL
)
7777 struct elf_dyn_relocs
**pp
;
7778 struct elf_dyn_relocs
*p
;
7780 /* Add reloc counts against the indirect sym to the direct sym
7781 list. Merge any entries against the same section. */
7782 for (pp
= &ind
->dyn_relocs
; (p
= *pp
) != NULL
; )
7784 struct elf_dyn_relocs
*q
;
7786 for (q
= dir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
7787 if (q
->sec
== p
->sec
)
7789 q
->pc_count
+= p
->pc_count
;
7790 q
->count
+= p
->count
;
7797 *pp
= dir
->dyn_relocs
;
7800 dir
->dyn_relocs
= ind
->dyn_relocs
;
7801 ind
->dyn_relocs
= NULL
;
7804 /* Copy down any references that we may have already seen to the
7805 symbol which just became indirect. */
7807 if (dir
->versioned
!= versioned_hidden
)
7808 dir
->ref_dynamic
|= ind
->ref_dynamic
;
7809 dir
->ref_regular
|= ind
->ref_regular
;
7810 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
7811 dir
->non_got_ref
|= ind
->non_got_ref
;
7812 dir
->needs_plt
|= ind
->needs_plt
;
7813 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
7815 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7818 /* Copy over the global and procedure linkage table refcount entries.
7819 These may have been already set up by a check_relocs routine. */
7820 htab
= elf_hash_table (info
);
7821 if (ind
->got
.refcount
> htab
->init_got_refcount
.refcount
)
7823 if (dir
->got
.refcount
< 0)
7824 dir
->got
.refcount
= 0;
7825 dir
->got
.refcount
+= ind
->got
.refcount
;
7826 ind
->got
.refcount
= htab
->init_got_refcount
.refcount
;
7829 if (ind
->plt
.refcount
> htab
->init_plt_refcount
.refcount
)
7831 if (dir
->plt
.refcount
< 0)
7832 dir
->plt
.refcount
= 0;
7833 dir
->plt
.refcount
+= ind
->plt
.refcount
;
7834 ind
->plt
.refcount
= htab
->init_plt_refcount
.refcount
;
7837 if (ind
->dynindx
!= -1)
7839 if (dir
->dynindx
!= -1)
7840 _bfd_elf_strtab_delref (htab
->dynstr
, dir
->dynstr_index
);
7841 dir
->dynindx
= ind
->dynindx
;
7842 dir
->dynstr_index
= ind
->dynstr_index
;
7844 ind
->dynstr_index
= 0;
7849 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
7850 struct elf_link_hash_entry
*h
,
7853 /* STT_GNU_IFUNC symbol must go through PLT. */
7854 if (h
->type
!= STT_GNU_IFUNC
)
7856 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
7861 h
->forced_local
= 1;
7862 if (h
->dynindx
!= -1)
7864 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7867 h
->dynstr_index
= 0;
7872 /* Hide a symbol. */
7875 _bfd_elf_link_hide_symbol (bfd
*output_bfd
,
7876 struct bfd_link_info
*info
,
7877 struct bfd_link_hash_entry
*h
)
7879 if (is_elf_hash_table (info
->hash
))
7881 const struct elf_backend_data
*bed
7882 = get_elf_backend_data (output_bfd
);
7883 struct elf_link_hash_entry
*eh
7884 = (struct elf_link_hash_entry
*) h
;
7885 bed
->elf_backend_hide_symbol (info
, eh
, true);
7886 eh
->def_dynamic
= 0;
7887 eh
->ref_dynamic
= 0;
7888 eh
->dynamic_def
= 0;
7892 /* Initialize an ELF linker hash table. *TABLE has been zeroed by our
7896 _bfd_elf_link_hash_table_init
7897 (struct elf_link_hash_table
*table
,
7899 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
7900 struct bfd_hash_table
*,
7902 unsigned int entsize
,
7903 enum elf_target_id target_id
)
7906 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
7908 table
->init_got_refcount
.refcount
= can_refcount
- 1;
7909 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
7910 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
7911 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
7912 /* The first dynamic symbol is a dummy. */
7913 table
->dynsymcount
= 1;
7915 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
7917 table
->root
.type
= bfd_link_elf_hash_table
;
7918 table
->hash_table_id
= target_id
;
7919 table
->target_os
= get_elf_backend_data (abfd
)->target_os
;
7924 /* Create an ELF linker hash table. */
7926 struct bfd_link_hash_table
*
7927 _bfd_elf_link_hash_table_create (bfd
*abfd
)
7929 struct elf_link_hash_table
*ret
;
7930 size_t amt
= sizeof (struct elf_link_hash_table
);
7932 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
7936 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
,
7937 sizeof (struct elf_link_hash_entry
),
7943 ret
->root
.hash_table_free
= _bfd_elf_link_hash_table_free
;
7948 /* Destroy an ELF linker hash table. */
7951 _bfd_elf_link_hash_table_free (bfd
*obfd
)
7953 struct elf_link_hash_table
*htab
;
7955 htab
= (struct elf_link_hash_table
*) obfd
->link
.hash
;
7956 if (htab
->dynstr
!= NULL
)
7957 _bfd_elf_strtab_free (htab
->dynstr
);
7958 _bfd_merge_sections_free (htab
->merge_info
);
7959 _bfd_generic_link_hash_table_free (obfd
);
7962 /* This is a hook for the ELF emulation code in the generic linker to
7963 tell the backend linker what file name to use for the DT_NEEDED
7964 entry for a dynamic object. */
7967 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
7969 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7970 && bfd_get_format (abfd
) == bfd_object
)
7971 elf_dt_name (abfd
) = name
;
7975 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
7978 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7979 && bfd_get_format (abfd
) == bfd_object
)
7980 lib_class
= elf_dyn_lib_class (abfd
);
7987 bfd_elf_set_dyn_lib_class (bfd
*abfd
, enum dynamic_lib_link_class lib_class
)
7989 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7990 && bfd_get_format (abfd
) == bfd_object
)
7991 elf_dyn_lib_class (abfd
) = lib_class
;
7994 /* Get the list of DT_NEEDED entries for a link. This is a hook for
7995 the linker ELF emulation code. */
7997 struct bfd_link_needed_list
*
7998 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
7999 struct bfd_link_info
*info
)
8001 if (! is_elf_hash_table (info
->hash
))
8003 return elf_hash_table (info
)->needed
;
8006 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
8007 hook for the linker ELF emulation code. */
8009 struct bfd_link_needed_list
*
8010 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
8011 struct bfd_link_info
*info
)
8013 if (! is_elf_hash_table (info
->hash
))
8015 return elf_hash_table (info
)->runpath
;
8018 /* Get the name actually used for a dynamic object for a link. This
8019 is the SONAME entry if there is one. Otherwise, it is the string
8020 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
8023 bfd_elf_get_dt_soname (bfd
*abfd
)
8025 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
8026 && bfd_get_format (abfd
) == bfd_object
)
8027 return elf_dt_name (abfd
);
8031 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
8032 the ELF linker emulation code. */
8035 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
8036 struct bfd_link_needed_list
**pneeded
)
8039 bfd_byte
*dynbuf
= NULL
;
8040 unsigned int elfsec
;
8041 unsigned long shlink
;
8042 bfd_byte
*extdyn
, *extdynend
;
8044 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
8048 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
8049 || bfd_get_format (abfd
) != bfd_object
)
8052 s
= bfd_get_section_by_name (abfd
, ".dynamic");
8053 if (s
== NULL
|| s
->size
== 0)
8056 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
8059 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
8060 if (elfsec
== SHN_BAD
)
8063 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
8065 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
8066 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
8069 extdynend
= extdyn
+ s
->size
;
8070 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
8072 Elf_Internal_Dyn dyn
;
8074 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
8076 if (dyn
.d_tag
== DT_NULL
)
8079 if (dyn
.d_tag
== DT_NEEDED
)
8082 struct bfd_link_needed_list
*l
;
8083 unsigned int tagv
= dyn
.d_un
.d_val
;
8086 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
8091 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
8111 struct elf_symbuf_symbol
8113 unsigned long st_name
; /* Symbol name, index in string tbl */
8114 unsigned char st_info
; /* Type and binding attributes */
8115 unsigned char st_other
; /* Visibilty, and target specific */
8118 struct elf_symbuf_head
8120 struct elf_symbuf_symbol
*ssym
;
8122 unsigned int st_shndx
;
8129 Elf_Internal_Sym
*isym
;
8130 struct elf_symbuf_symbol
*ssym
;
8136 /* Sort references to symbols by ascending section number. */
8139 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
8141 const Elf_Internal_Sym
*s1
= *(const Elf_Internal_Sym
**) arg1
;
8142 const Elf_Internal_Sym
*s2
= *(const Elf_Internal_Sym
**) arg2
;
8144 if (s1
->st_shndx
!= s2
->st_shndx
)
8145 return s1
->st_shndx
> s2
->st_shndx
? 1 : -1;
8146 /* Final sort by the address of the sym in the symbuf ensures
8149 return s1
> s2
? 1 : -1;
8154 elf_sym_name_compare (const void *arg1
, const void *arg2
)
8156 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
8157 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
8158 int ret
= strcmp (s1
->name
, s2
->name
);
8161 if (s1
->u
.p
!= s2
->u
.p
)
8162 return s1
->u
.p
> s2
->u
.p
? 1 : -1;
8166 static struct elf_symbuf_head
*
8167 elf_create_symbuf (size_t symcount
, Elf_Internal_Sym
*isymbuf
)
8169 Elf_Internal_Sym
**ind
, **indbufend
, **indbuf
;
8170 struct elf_symbuf_symbol
*ssym
;
8171 struct elf_symbuf_head
*ssymbuf
, *ssymhead
;
8172 size_t i
, shndx_count
, total_size
, amt
;
8174 amt
= symcount
* sizeof (*indbuf
);
8175 indbuf
= (Elf_Internal_Sym
**) bfd_malloc (amt
);
8179 for (ind
= indbuf
, i
= 0; i
< symcount
; i
++)
8180 if (isymbuf
[i
].st_shndx
!= SHN_UNDEF
)
8181 *ind
++ = &isymbuf
[i
];
8184 qsort (indbuf
, indbufend
- indbuf
, sizeof (Elf_Internal_Sym
*),
8185 elf_sort_elf_symbol
);
8188 if (indbufend
> indbuf
)
8189 for (ind
= indbuf
, shndx_count
++; ind
< indbufend
- 1; ind
++)
8190 if (ind
[0]->st_shndx
!= ind
[1]->st_shndx
)
8193 total_size
= ((shndx_count
+ 1) * sizeof (*ssymbuf
)
8194 + (indbufend
- indbuf
) * sizeof (*ssym
));
8195 ssymbuf
= (struct elf_symbuf_head
*) bfd_malloc (total_size
);
8196 if (ssymbuf
== NULL
)
8202 ssym
= (struct elf_symbuf_symbol
*) (ssymbuf
+ shndx_count
+ 1);
8203 ssymbuf
->ssym
= NULL
;
8204 ssymbuf
->count
= shndx_count
;
8205 ssymbuf
->st_shndx
= 0;
8206 for (ssymhead
= ssymbuf
, ind
= indbuf
; ind
< indbufend
; ssym
++, ind
++)
8208 if (ind
== indbuf
|| ssymhead
->st_shndx
!= (*ind
)->st_shndx
)
8211 ssymhead
->ssym
= ssym
;
8212 ssymhead
->count
= 0;
8213 ssymhead
->st_shndx
= (*ind
)->st_shndx
;
8215 ssym
->st_name
= (*ind
)->st_name
;
8216 ssym
->st_info
= (*ind
)->st_info
;
8217 ssym
->st_other
= (*ind
)->st_other
;
8220 BFD_ASSERT ((size_t) (ssymhead
- ssymbuf
) == shndx_count
8221 && (((bfd_hostptr_t
) ssym
- (bfd_hostptr_t
) ssymbuf
)
8228 /* Check if 2 sections define the same set of local and global
8232 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
,
8233 struct bfd_link_info
*info
)
8236 const struct elf_backend_data
*bed1
, *bed2
;
8237 Elf_Internal_Shdr
*hdr1
, *hdr2
;
8238 size_t symcount1
, symcount2
;
8239 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
8240 struct elf_symbuf_head
*ssymbuf1
, *ssymbuf2
;
8241 Elf_Internal_Sym
*isym
, *isymend
;
8242 struct elf_symbol
*symtable1
= NULL
, *symtable2
= NULL
;
8243 size_t count1
, count2
, sec_count1
, sec_count2
, i
;
8244 unsigned int shndx1
, shndx2
;
8246 bool ignore_section_symbol_p
;
8251 /* Both sections have to be in ELF. */
8252 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
8253 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
8256 if (elf_section_type (sec1
) != elf_section_type (sec2
))
8259 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
8260 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
8261 if (shndx1
== SHN_BAD
|| shndx2
== SHN_BAD
)
8264 bed1
= get_elf_backend_data (bfd1
);
8265 bed2
= get_elf_backend_data (bfd2
);
8266 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
8267 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
8268 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
8269 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
8271 if (symcount1
== 0 || symcount2
== 0)
8277 ssymbuf1
= (struct elf_symbuf_head
*) elf_tdata (bfd1
)->symbuf
;
8278 ssymbuf2
= (struct elf_symbuf_head
*) elf_tdata (bfd2
)->symbuf
;
8280 /* Ignore section symbols only when matching non-debugging sections
8281 or linkonce section with comdat section. */
8282 ignore_section_symbol_p
8283 = ((sec1
->flags
& SEC_DEBUGGING
) == 0
8284 || ((elf_section_flags (sec1
) & SHF_GROUP
)
8285 != (elf_section_flags (sec2
) & SHF_GROUP
)));
8287 if (ssymbuf1
== NULL
)
8289 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
8291 if (isymbuf1
== NULL
)
8294 if (info
!= NULL
&& !info
->reduce_memory_overheads
)
8296 ssymbuf1
= elf_create_symbuf (symcount1
, isymbuf1
);
8297 elf_tdata (bfd1
)->symbuf
= ssymbuf1
;
8301 if (ssymbuf1
== NULL
|| ssymbuf2
== NULL
)
8303 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
8305 if (isymbuf2
== NULL
)
8308 if (ssymbuf1
!= NULL
&& info
!= NULL
&& !info
->reduce_memory_overheads
)
8310 ssymbuf2
= elf_create_symbuf (symcount2
, isymbuf2
);
8311 elf_tdata (bfd2
)->symbuf
= ssymbuf2
;
8315 if (ssymbuf1
!= NULL
&& ssymbuf2
!= NULL
)
8317 /* Optimized faster version. */
8319 struct elf_symbol
*symp
;
8320 struct elf_symbuf_symbol
*ssym
, *ssymend
;
8323 hi
= ssymbuf1
->count
;
8329 mid
= (lo
+ hi
) / 2;
8330 if (shndx1
< ssymbuf1
[mid
].st_shndx
)
8332 else if (shndx1
> ssymbuf1
[mid
].st_shndx
)
8336 count1
= ssymbuf1
[mid
].count
;
8341 if (ignore_section_symbol_p
)
8343 for (i
= 0; i
< count1
; i
++)
8344 if (ELF_ST_TYPE (ssymbuf1
->ssym
[i
].st_info
) == STT_SECTION
)
8346 count1
-= sec_count1
;
8350 hi
= ssymbuf2
->count
;
8356 mid
= (lo
+ hi
) / 2;
8357 if (shndx2
< ssymbuf2
[mid
].st_shndx
)
8359 else if (shndx2
> ssymbuf2
[mid
].st_shndx
)
8363 count2
= ssymbuf2
[mid
].count
;
8368 if (ignore_section_symbol_p
)
8370 for (i
= 0; i
< count2
; i
++)
8371 if (ELF_ST_TYPE (ssymbuf2
->ssym
[i
].st_info
) == STT_SECTION
)
8373 count2
-= sec_count2
;
8376 if (count1
== 0 || count2
== 0 || count1
!= count2
)
8380 = (struct elf_symbol
*) bfd_malloc (count1
* sizeof (*symtable1
));
8382 = (struct elf_symbol
*) bfd_malloc (count2
* sizeof (*symtable2
));
8383 if (symtable1
== NULL
|| symtable2
== NULL
)
8387 for (ssym
= ssymbuf1
->ssym
, ssymend
= ssym
+ count1
+ sec_count1
;
8388 ssym
< ssymend
; ssym
++)
8390 || ELF_ST_TYPE (ssym
->st_info
) != STT_SECTION
)
8392 symp
->u
.ssym
= ssym
;
8393 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
8400 for (ssym
= ssymbuf2
->ssym
, ssymend
= ssym
+ count2
+ sec_count2
;
8401 ssym
< ssymend
; ssym
++)
8403 || ELF_ST_TYPE (ssym
->st_info
) != STT_SECTION
)
8405 symp
->u
.ssym
= ssym
;
8406 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
8412 /* Sort symbol by name. */
8413 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
8414 elf_sym_name_compare
);
8415 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
8416 elf_sym_name_compare
);
8418 for (i
= 0; i
< count1
; i
++)
8419 /* Two symbols must have the same binding, type and name. */
8420 if (symtable1
[i
].u
.ssym
->st_info
!= symtable2
[i
].u
.ssym
->st_info
8421 || symtable1
[i
].u
.ssym
->st_other
!= symtable2
[i
].u
.ssym
->st_other
8422 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
8429 symtable1
= (struct elf_symbol
*)
8430 bfd_malloc (symcount1
* sizeof (struct elf_symbol
));
8431 symtable2
= (struct elf_symbol
*)
8432 bfd_malloc (symcount2
* sizeof (struct elf_symbol
));
8433 if (symtable1
== NULL
|| symtable2
== NULL
)
8436 /* Count definitions in the section. */
8438 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
; isym
< isymend
; isym
++)
8439 if (isym
->st_shndx
== shndx1
8440 && (!ignore_section_symbol_p
8441 || ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
))
8442 symtable1
[count1
++].u
.isym
= isym
;
8445 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
; isym
< isymend
; isym
++)
8446 if (isym
->st_shndx
== shndx2
8447 && (!ignore_section_symbol_p
8448 || ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
))
8449 symtable2
[count2
++].u
.isym
= isym
;
8451 if (count1
== 0 || count2
== 0 || count1
!= count2
)
8454 for (i
= 0; i
< count1
; i
++)
8456 = bfd_elf_string_from_elf_section (bfd1
, hdr1
->sh_link
,
8457 symtable1
[i
].u
.isym
->st_name
);
8459 for (i
= 0; i
< count2
; i
++)
8461 = bfd_elf_string_from_elf_section (bfd2
, hdr2
->sh_link
,
8462 symtable2
[i
].u
.isym
->st_name
);
8464 /* Sort symbol by name. */
8465 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
8466 elf_sym_name_compare
);
8467 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
8468 elf_sym_name_compare
);
8470 for (i
= 0; i
< count1
; i
++)
8471 /* Two symbols must have the same binding, type and name. */
8472 if (symtable1
[i
].u
.isym
->st_info
!= symtable2
[i
].u
.isym
->st_info
8473 || symtable1
[i
].u
.isym
->st_other
!= symtable2
[i
].u
.isym
->st_other
8474 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
8488 /* Return TRUE if 2 section types are compatible. */
8491 _bfd_elf_match_sections_by_type (bfd
*abfd
, const asection
*asec
,
8492 bfd
*bbfd
, const asection
*bsec
)
8496 || abfd
->xvec
->flavour
!= bfd_target_elf_flavour
8497 || bbfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8500 return elf_section_type (asec
) == elf_section_type (bsec
);
8503 /* Final phase of ELF linker. */
8505 /* A structure we use to avoid passing large numbers of arguments. */
8507 struct elf_final_link_info
8509 /* General link information. */
8510 struct bfd_link_info
*info
;
8513 /* Symbol string table. */
8514 struct elf_strtab_hash
*symstrtab
;
8515 /* .hash section. */
8517 /* symbol version section (.gnu.version). */
8518 asection
*symver_sec
;
8519 /* Buffer large enough to hold contents of any section. */
8521 /* Buffer large enough to hold external relocs of any section. */
8522 void *external_relocs
;
8523 /* Buffer large enough to hold internal relocs of any section. */
8524 Elf_Internal_Rela
*internal_relocs
;
8525 /* Buffer large enough to hold external local symbols of any input
8527 bfd_byte
*external_syms
;
8528 /* And a buffer for symbol section indices. */
8529 Elf_External_Sym_Shndx
*locsym_shndx
;
8530 /* Buffer large enough to hold internal local symbols of any input
8532 Elf_Internal_Sym
*internal_syms
;
8533 /* Array large enough to hold a symbol index for each local symbol
8534 of any input BFD. */
8536 /* Array large enough to hold a section pointer for each local
8537 symbol of any input BFD. */
8538 asection
**sections
;
8539 /* Buffer for SHT_SYMTAB_SHNDX section. */
8540 Elf_External_Sym_Shndx
*symshndxbuf
;
8541 /* Number of STT_FILE syms seen. */
8542 size_t filesym_count
;
8543 /* Local symbol hash table. */
8544 struct bfd_hash_table local_hash_table
;
8547 struct local_hash_entry
8549 /* Base hash table entry structure. */
8550 struct bfd_hash_entry root
;
8551 /* Size of the local symbol name. */
8553 /* Number of the duplicated local symbol names. */
8557 /* Create an entry in the local symbol hash table. */
8559 static struct bfd_hash_entry
*
8560 local_hash_newfunc (struct bfd_hash_entry
*entry
,
8561 struct bfd_hash_table
*table
,
8565 /* Allocate the structure if it has not already been allocated by a
8569 entry
= bfd_hash_allocate (table
,
8570 sizeof (struct local_hash_entry
));
8575 /* Call the allocation method of the superclass. */
8576 entry
= bfd_hash_newfunc (entry
, table
, string
);
8579 ((struct local_hash_entry
*) entry
)->count
= 0;
8580 ((struct local_hash_entry
*) entry
)->size
= 0;
8586 /* This struct is used to pass information to elf_link_output_extsym. */
8588 struct elf_outext_info
8593 struct elf_final_link_info
*flinfo
;
8597 /* Support for evaluating a complex relocation.
8599 Complex relocations are generalized, self-describing relocations. The
8600 implementation of them consists of two parts: complex symbols, and the
8601 relocations themselves.
8603 The relocations use a reserved elf-wide relocation type code (R_RELC
8604 external / BFD_RELOC_RELC internal) and an encoding of relocation field
8605 information (start bit, end bit, word width, etc) into the addend. This
8606 information is extracted from CGEN-generated operand tables within gas.
8608 Complex symbols are mangled symbols (STT_RELC external / BSF_RELC
8609 internal) representing prefix-notation expressions, including but not
8610 limited to those sorts of expressions normally encoded as addends in the
8611 addend field. The symbol mangling format is:
8614 | <unary-operator> ':' <node>
8615 | <binary-operator> ':' <node> ':' <node>
8618 <literal> := 's' <digits=N> ':' <N character symbol name>
8619 | 'S' <digits=N> ':' <N character section name>
8623 <binary-operator> := as in C
8624 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
8627 set_symbol_value (bfd
*bfd_with_globals
,
8628 Elf_Internal_Sym
*isymbuf
,
8633 struct elf_link_hash_entry
**sym_hashes
;
8634 struct elf_link_hash_entry
*h
;
8635 size_t extsymoff
= locsymcount
;
8637 if (symidx
< locsymcount
)
8639 Elf_Internal_Sym
*sym
;
8641 sym
= isymbuf
+ symidx
;
8642 if (ELF_ST_BIND (sym
->st_info
) == STB_LOCAL
)
8644 /* It is a local symbol: move it to the
8645 "absolute" section and give it a value. */
8646 sym
->st_shndx
= SHN_ABS
;
8647 sym
->st_value
= val
;
8650 BFD_ASSERT (elf_bad_symtab (bfd_with_globals
));
8654 /* It is a global symbol: set its link type
8655 to "defined" and give it a value. */
8657 sym_hashes
= elf_sym_hashes (bfd_with_globals
);
8658 h
= sym_hashes
[symidx
- extsymoff
];
8659 while (h
->root
.type
== bfd_link_hash_indirect
8660 || h
->root
.type
== bfd_link_hash_warning
)
8661 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8662 h
->root
.type
= bfd_link_hash_defined
;
8663 h
->root
.u
.def
.value
= val
;
8664 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
8668 resolve_symbol (const char *name
,
8670 struct elf_final_link_info
*flinfo
,
8672 Elf_Internal_Sym
*isymbuf
,
8675 Elf_Internal_Sym
*sym
;
8676 struct bfd_link_hash_entry
*global_entry
;
8677 const char *candidate
= NULL
;
8678 Elf_Internal_Shdr
*symtab_hdr
;
8681 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
8683 for (i
= 0; i
< locsymcount
; ++ i
)
8687 if (ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
8690 candidate
= bfd_elf_string_from_elf_section (input_bfd
,
8691 symtab_hdr
->sh_link
,
8694 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
8695 name
, candidate
, (unsigned long) sym
->st_value
);
8697 if (candidate
&& strcmp (candidate
, name
) == 0)
8699 asection
*sec
= flinfo
->sections
[i
];
8701 *result
= _bfd_elf_rel_local_sym (input_bfd
, sym
, &sec
, 0);
8702 *result
+= sec
->output_offset
+ sec
->output_section
->vma
;
8704 printf ("Found symbol with value %8.8lx\n",
8705 (unsigned long) *result
);
8711 /* Hmm, haven't found it yet. perhaps it is a global. */
8712 global_entry
= bfd_link_hash_lookup (flinfo
->info
->hash
, name
,
8713 false, false, true);
8717 if (global_entry
->type
== bfd_link_hash_defined
8718 || global_entry
->type
== bfd_link_hash_defweak
)
8720 *result
= (global_entry
->u
.def
.value
8721 + global_entry
->u
.def
.section
->output_section
->vma
8722 + global_entry
->u
.def
.section
->output_offset
);
8724 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
8725 global_entry
->root
.string
, (unsigned long) *result
);
8733 /* Looks up NAME in SECTIONS. If found sets RESULT to NAME's address (in
8734 bytes) and returns TRUE, otherwise returns FALSE. Accepts pseudo-section
8735 names like "foo.end" which is the end address of section "foo". */
8738 resolve_section (const char *name
,
8746 for (curr
= sections
; curr
; curr
= curr
->next
)
8747 if (strcmp (curr
->name
, name
) == 0)
8749 *result
= curr
->vma
;
8753 /* Hmm. still haven't found it. try pseudo-section names. */
8754 /* FIXME: This could be coded more efficiently... */
8755 for (curr
= sections
; curr
; curr
= curr
->next
)
8757 len
= strlen (curr
->name
);
8758 if (len
> strlen (name
))
8761 if (strncmp (curr
->name
, name
, len
) == 0)
8763 if (startswith (name
+ len
, ".end"))
8765 *result
= (curr
->vma
8766 + curr
->size
/ bfd_octets_per_byte (abfd
, curr
));
8770 /* Insert more pseudo-section names here, if you like. */
8778 undefined_reference (const char *reftype
, const char *name
)
8780 /* xgettext:c-format */
8781 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
8783 bfd_set_error (bfd_error_bad_value
);
8787 eval_symbol (bfd_vma
*result
,
8790 struct elf_final_link_info
*flinfo
,
8792 Elf_Internal_Sym
*isymbuf
,
8801 const char *sym
= *symp
;
8803 bool symbol_is_section
= false;
8808 if (len
< 1 || len
> sizeof (symbuf
))
8810 bfd_set_error (bfd_error_invalid_operation
);
8823 *result
= strtoul (sym
, (char **) symp
, 16);
8827 symbol_is_section
= true;
8831 symlen
= strtol (sym
, (char **) symp
, 10);
8832 sym
= *symp
+ 1; /* Skip the trailing ':'. */
8834 if (symend
< sym
|| symlen
+ 1 > sizeof (symbuf
))
8836 bfd_set_error (bfd_error_invalid_operation
);
8840 memcpy (symbuf
, sym
, symlen
);
8841 symbuf
[symlen
] = '\0';
8842 *symp
= sym
+ symlen
;
8844 /* Is it always possible, with complex symbols, that gas "mis-guessed"
8845 the symbol as a section, or vice-versa. so we're pretty liberal in our
8846 interpretation here; section means "try section first", not "must be a
8847 section", and likewise with symbol. */
8849 if (symbol_is_section
)
8851 if (!resolve_section (symbuf
, flinfo
->output_bfd
->sections
, result
, input_bfd
)
8852 && !resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
8853 isymbuf
, locsymcount
))
8855 undefined_reference ("section", symbuf
);
8861 if (!resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
8862 isymbuf
, locsymcount
)
8863 && !resolve_section (symbuf
, flinfo
->output_bfd
->sections
,
8866 undefined_reference ("symbol", symbuf
);
8873 /* All that remains are operators. */
8875 #define UNARY_OP(op) \
8876 if (startswith (sym, #op)) \
8878 sym += strlen (#op); \
8882 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
8883 isymbuf, locsymcount, signed_p)) \
8886 *result = op ((bfd_signed_vma) a); \
8892 #define BINARY_OP_HEAD(op) \
8893 if (startswith (sym, #op)) \
8895 sym += strlen (#op); \
8899 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
8900 isymbuf, locsymcount, signed_p)) \
8903 if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
8904 isymbuf, locsymcount, signed_p)) \
8906 #define BINARY_OP_TAIL(op) \
8908 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
8913 #define BINARY_OP(op) BINARY_OP_HEAD(op) BINARY_OP_TAIL(op)
8917 BINARY_OP_HEAD (<<);
8918 if (b
>= sizeof (a
) * CHAR_BIT
)
8924 BINARY_OP_TAIL (<<);
8925 BINARY_OP_HEAD (>>);
8926 if (b
>= sizeof (a
) * CHAR_BIT
)
8928 *result
= signed_p
&& (bfd_signed_vma
) a
< 0 ? -1 : 0;
8931 BINARY_OP_TAIL (>>);
8944 _bfd_error_handler (_("division by zero"));
8945 bfd_set_error (bfd_error_bad_value
);
8952 _bfd_error_handler (_("division by zero"));
8953 bfd_set_error (bfd_error_bad_value
);
8966 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym
);
8967 bfd_set_error (bfd_error_invalid_operation
);
8973 put_value (bfd_vma size
,
8974 unsigned long chunksz
,
8979 location
+= (size
- chunksz
);
8981 for (; size
; size
-= chunksz
, location
-= chunksz
)
8986 bfd_put_8 (input_bfd
, x
, location
);
8990 bfd_put_16 (input_bfd
, x
, location
);
8994 bfd_put_32 (input_bfd
, x
, location
);
8995 /* Computed this way because x >>= 32 is undefined if x is a 32-bit value. */
9001 bfd_put_64 (input_bfd
, x
, location
);
9002 /* Computed this way because x >>= 64 is undefined if x is a 64-bit value. */
9015 get_value (bfd_vma size
,
9016 unsigned long chunksz
,
9023 /* Sanity checks. */
9024 BFD_ASSERT (chunksz
<= sizeof (x
)
9027 && (size
% chunksz
) == 0
9028 && input_bfd
!= NULL
9029 && location
!= NULL
);
9031 if (chunksz
== sizeof (x
))
9033 BFD_ASSERT (size
== chunksz
);
9035 /* Make sure that we do not perform an undefined shift operation.
9036 We know that size == chunksz so there will only be one iteration
9037 of the loop below. */
9041 shift
= 8 * chunksz
;
9043 for (; size
; size
-= chunksz
, location
+= chunksz
)
9048 x
= (x
<< shift
) | bfd_get_8 (input_bfd
, location
);
9051 x
= (x
<< shift
) | bfd_get_16 (input_bfd
, location
);
9054 x
= (x
<< shift
) | bfd_get_32 (input_bfd
, location
);
9058 x
= (x
<< shift
) | bfd_get_64 (input_bfd
, location
);
9069 decode_complex_addend (unsigned long *start
, /* in bits */
9070 unsigned long *oplen
, /* in bits */
9071 unsigned long *len
, /* in bits */
9072 unsigned long *wordsz
, /* in bytes */
9073 unsigned long *chunksz
, /* in bytes */
9074 unsigned long *lsb0_p
,
9075 unsigned long *signed_p
,
9076 unsigned long *trunc_p
,
9077 unsigned long encoded
)
9079 * start
= encoded
& 0x3F;
9080 * len
= (encoded
>> 6) & 0x3F;
9081 * oplen
= (encoded
>> 12) & 0x3F;
9082 * wordsz
= (encoded
>> 18) & 0xF;
9083 * chunksz
= (encoded
>> 22) & 0xF;
9084 * lsb0_p
= (encoded
>> 27) & 1;
9085 * signed_p
= (encoded
>> 28) & 1;
9086 * trunc_p
= (encoded
>> 29) & 1;
9089 bfd_reloc_status_type
9090 bfd_elf_perform_complex_relocation (bfd
*input_bfd
,
9091 asection
*input_section
,
9093 Elf_Internal_Rela
*rel
,
9096 bfd_vma shift
, x
, mask
;
9097 unsigned long start
, oplen
, len
, wordsz
, chunksz
, lsb0_p
, signed_p
, trunc_p
;
9098 bfd_reloc_status_type r
;
9099 bfd_size_type octets
;
9101 /* Perform this reloc, since it is complex.
9102 (this is not to say that it necessarily refers to a complex
9103 symbol; merely that it is a self-describing CGEN based reloc.
9104 i.e. the addend has the complete reloc information (bit start, end,
9105 word size, etc) encoded within it.). */
9107 decode_complex_addend (&start
, &oplen
, &len
, &wordsz
,
9108 &chunksz
, &lsb0_p
, &signed_p
,
9109 &trunc_p
, rel
->r_addend
);
9111 mask
= (((1L << (len
- 1)) - 1) << 1) | 1;
9114 shift
= (start
+ 1) - len
;
9116 shift
= (8 * wordsz
) - (start
+ len
);
9118 octets
= rel
->r_offset
* bfd_octets_per_byte (input_bfd
, input_section
);
9119 x
= get_value (wordsz
, chunksz
, input_bfd
, contents
+ octets
);
9122 printf ("Doing complex reloc: "
9123 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
9124 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
9125 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
9126 lsb0_p
, signed_p
, trunc_p
, wordsz
, chunksz
, start
, len
,
9127 oplen
, (unsigned long) x
, (unsigned long) mask
,
9128 (unsigned long) relocation
);
9133 /* Now do an overflow check. */
9134 r
= bfd_check_overflow ((signed_p
9135 ? complain_overflow_signed
9136 : complain_overflow_unsigned
),
9137 len
, 0, (8 * wordsz
),
9141 x
= (x
& ~(mask
<< shift
)) | ((relocation
& mask
) << shift
);
9144 printf (" relocation: %8.8lx\n"
9145 " shifted mask: %8.8lx\n"
9146 " shifted/masked reloc: %8.8lx\n"
9147 " result: %8.8lx\n",
9148 (unsigned long) relocation
, (unsigned long) (mask
<< shift
),
9149 (unsigned long) ((relocation
& mask
) << shift
), (unsigned long) x
);
9151 put_value (wordsz
, chunksz
, input_bfd
, x
, contents
+ octets
);
9155 /* Functions to read r_offset from external (target order) reloc
9156 entry. Faster than bfd_getl32 et al, because we let the compiler
9157 know the value is aligned. */
9160 ext32l_r_offset (const void *p
)
9167 const union aligned32
*a
9168 = (const union aligned32
*) &((const Elf32_External_Rel
*) p
)->r_offset
;
9170 uint32_t aval
= ( (uint32_t) a
->c
[0]
9171 | (uint32_t) a
->c
[1] << 8
9172 | (uint32_t) a
->c
[2] << 16
9173 | (uint32_t) a
->c
[3] << 24);
9178 ext32b_r_offset (const void *p
)
9185 const union aligned32
*a
9186 = (const union aligned32
*) &((const Elf32_External_Rel
*) p
)->r_offset
;
9188 uint32_t aval
= ( (uint32_t) a
->c
[0] << 24
9189 | (uint32_t) a
->c
[1] << 16
9190 | (uint32_t) a
->c
[2] << 8
9191 | (uint32_t) a
->c
[3]);
9195 #ifdef BFD_HOST_64_BIT
9197 ext64l_r_offset (const void *p
)
9204 const union aligned64
*a
9205 = (const union aligned64
*) &((const Elf64_External_Rel
*) p
)->r_offset
;
9207 uint64_t aval
= ( (uint64_t) a
->c
[0]
9208 | (uint64_t) a
->c
[1] << 8
9209 | (uint64_t) a
->c
[2] << 16
9210 | (uint64_t) a
->c
[3] << 24
9211 | (uint64_t) a
->c
[4] << 32
9212 | (uint64_t) a
->c
[5] << 40
9213 | (uint64_t) a
->c
[6] << 48
9214 | (uint64_t) a
->c
[7] << 56);
9219 ext64b_r_offset (const void *p
)
9226 const union aligned64
*a
9227 = (const union aligned64
*) &((const Elf64_External_Rel
*) p
)->r_offset
;
9229 uint64_t aval
= ( (uint64_t) a
->c
[0] << 56
9230 | (uint64_t) a
->c
[1] << 48
9231 | (uint64_t) a
->c
[2] << 40
9232 | (uint64_t) a
->c
[3] << 32
9233 | (uint64_t) a
->c
[4] << 24
9234 | (uint64_t) a
->c
[5] << 16
9235 | (uint64_t) a
->c
[6] << 8
9236 | (uint64_t) a
->c
[7]);
9241 /* When performing a relocatable link, the input relocations are
9242 preserved. But, if they reference global symbols, the indices
9243 referenced must be updated. Update all the relocations found in
9247 elf_link_adjust_relocs (bfd
*abfd
,
9249 struct bfd_elf_section_reloc_data
*reldata
,
9251 struct bfd_link_info
*info
)
9254 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9256 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
9257 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
9258 bfd_vma r_type_mask
;
9260 unsigned int count
= reldata
->count
;
9261 struct elf_link_hash_entry
**rel_hash
= reldata
->hashes
;
9263 if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
9265 swap_in
= bed
->s
->swap_reloc_in
;
9266 swap_out
= bed
->s
->swap_reloc_out
;
9268 else if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
9270 swap_in
= bed
->s
->swap_reloca_in
;
9271 swap_out
= bed
->s
->swap_reloca_out
;
9276 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
9279 if (bed
->s
->arch_size
== 32)
9286 r_type_mask
= 0xffffffff;
9290 erela
= reldata
->hdr
->contents
;
9291 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= reldata
->hdr
->sh_entsize
)
9293 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
9296 if (*rel_hash
== NULL
)
9299 if ((*rel_hash
)->indx
== -2
9300 && info
->gc_sections
9301 && ! info
->gc_keep_exported
)
9303 /* PR 21524: Let the user know if a symbol was removed by garbage collection. */
9304 _bfd_error_handler (_("%pB:%pA: error: relocation references symbol %s which was removed by garbage collection"),
9306 (*rel_hash
)->root
.root
.string
);
9307 _bfd_error_handler (_("%pB:%pA: error: try relinking with --gc-keep-exported enabled"),
9309 bfd_set_error (bfd_error_invalid_operation
);
9312 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
9314 (*swap_in
) (abfd
, erela
, irela
);
9315 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
9316 irela
[j
].r_info
= ((bfd_vma
) (*rel_hash
)->indx
<< r_sym_shift
9317 | (irela
[j
].r_info
& r_type_mask
));
9318 (*swap_out
) (abfd
, irela
, erela
);
9321 if (bed
->elf_backend_update_relocs
)
9322 (*bed
->elf_backend_update_relocs
) (sec
, reldata
);
9324 if (sort
&& count
!= 0)
9326 bfd_vma (*ext_r_off
) (const void *);
9329 bfd_byte
*base
, *end
, *p
, *loc
;
9330 bfd_byte
*buf
= NULL
;
9332 if (bed
->s
->arch_size
== 32)
9334 if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)
9335 ext_r_off
= ext32l_r_offset
;
9336 else if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
9337 ext_r_off
= ext32b_r_offset
;
9343 #ifdef BFD_HOST_64_BIT
9344 if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)
9345 ext_r_off
= ext64l_r_offset
;
9346 else if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
9347 ext_r_off
= ext64b_r_offset
;
9353 /* Must use a stable sort here. A modified insertion sort,
9354 since the relocs are mostly sorted already. */
9355 elt_size
= reldata
->hdr
->sh_entsize
;
9356 base
= reldata
->hdr
->contents
;
9357 end
= base
+ count
* elt_size
;
9358 if (elt_size
> sizeof (Elf64_External_Rela
))
9361 /* Ensure the first element is lowest. This acts as a sentinel,
9362 speeding the main loop below. */
9363 r_off
= (*ext_r_off
) (base
);
9364 for (p
= loc
= base
; (p
+= elt_size
) < end
; )
9366 bfd_vma r_off2
= (*ext_r_off
) (p
);
9375 /* Don't just swap *base and *loc as that changes the order
9376 of the original base[0] and base[1] if they happen to
9377 have the same r_offset. */
9378 bfd_byte onebuf
[sizeof (Elf64_External_Rela
)];
9379 memcpy (onebuf
, loc
, elt_size
);
9380 memmove (base
+ elt_size
, base
, loc
- base
);
9381 memcpy (base
, onebuf
, elt_size
);
9384 for (p
= base
+ elt_size
; (p
+= elt_size
) < end
; )
9386 /* base to p is sorted, *p is next to insert. */
9387 r_off
= (*ext_r_off
) (p
);
9388 /* Search the sorted region for location to insert. */
9390 while (r_off
< (*ext_r_off
) (loc
))
9395 /* Chances are there is a run of relocs to insert here,
9396 from one of more input files. Files are not always
9397 linked in order due to the way elf_link_input_bfd is
9398 called. See pr17666. */
9399 size_t sortlen
= p
- loc
;
9400 bfd_vma r_off2
= (*ext_r_off
) (loc
);
9401 size_t runlen
= elt_size
;
9402 size_t buf_size
= 96 * 1024;
9403 while (p
+ runlen
< end
9404 && (sortlen
<= buf_size
9405 || runlen
+ elt_size
<= buf_size
)
9406 && r_off2
> (*ext_r_off
) (p
+ runlen
))
9410 buf
= bfd_malloc (buf_size
);
9414 if (runlen
< sortlen
)
9416 memcpy (buf
, p
, runlen
);
9417 memmove (loc
+ runlen
, loc
, sortlen
);
9418 memcpy (loc
, buf
, runlen
);
9422 memcpy (buf
, loc
, sortlen
);
9423 memmove (loc
, p
, runlen
);
9424 memcpy (loc
+ runlen
, buf
, sortlen
);
9426 p
+= runlen
- elt_size
;
9429 /* Hashes are no longer valid. */
9430 free (reldata
->hashes
);
9431 reldata
->hashes
= NULL
;
9437 struct elf_link_sort_rela
9443 enum elf_reloc_type_class type
;
9444 /* We use this as an array of size int_rels_per_ext_rel. */
9445 Elf_Internal_Rela rela
[1];
9448 /* qsort stability here and for cmp2 is only an issue if multiple
9449 dynamic relocations are emitted at the same address. But targets
9450 that apply a series of dynamic relocations each operating on the
9451 result of the prior relocation can't use -z combreloc as
9452 implemented anyway. Such schemes tend to be broken by sorting on
9453 symbol index. That leaves dynamic NONE relocs as the only other
9454 case where ld might emit multiple relocs at the same address, and
9455 those are only emitted due to target bugs. */
9458 elf_link_sort_cmp1 (const void *A
, const void *B
)
9460 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
9461 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
9462 int relativea
, relativeb
;
9464 relativea
= a
->type
== reloc_class_relative
;
9465 relativeb
= b
->type
== reloc_class_relative
;
9467 if (relativea
< relativeb
)
9469 if (relativea
> relativeb
)
9471 if ((a
->rela
->r_info
& a
->u
.sym_mask
) < (b
->rela
->r_info
& b
->u
.sym_mask
))
9473 if ((a
->rela
->r_info
& a
->u
.sym_mask
) > (b
->rela
->r_info
& b
->u
.sym_mask
))
9475 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
9477 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
9483 elf_link_sort_cmp2 (const void *A
, const void *B
)
9485 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
9486 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
9488 if (a
->type
< b
->type
)
9490 if (a
->type
> b
->type
)
9492 if (a
->u
.offset
< b
->u
.offset
)
9494 if (a
->u
.offset
> b
->u
.offset
)
9496 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
9498 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
9504 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
9506 asection
*dynamic_relocs
;
9509 bfd_size_type count
, size
;
9510 size_t i
, ret
, sort_elt
, ext_size
;
9511 bfd_byte
*sort
, *s_non_relative
, *p
;
9512 struct elf_link_sort_rela
*sq
;
9513 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9514 int i2e
= bed
->s
->int_rels_per_ext_rel
;
9515 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
9516 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
9517 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
9518 struct bfd_link_order
*lo
;
9522 /* Find a dynamic reloc section. */
9523 rela_dyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
9524 rel_dyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
9525 if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0
9526 && rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
9528 bool use_rela_initialised
= false;
9530 /* This is just here to stop gcc from complaining.
9531 Its initialization checking code is not perfect. */
9534 /* Both sections are present. Examine the sizes
9535 of the indirect sections to help us choose. */
9536 for (lo
= rela_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
9537 if (lo
->type
== bfd_indirect_link_order
)
9539 asection
*o
= lo
->u
.indirect
.section
;
9541 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
9543 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
9544 /* Section size is divisible by both rel and rela sizes.
9545 It is of no help to us. */
9549 /* Section size is only divisible by rela. */
9550 if (use_rela_initialised
&& !use_rela
)
9552 _bfd_error_handler (_("%pB: unable to sort relocs - "
9553 "they are in more than one size"),
9555 bfd_set_error (bfd_error_invalid_operation
);
9561 use_rela_initialised
= true;
9565 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
9567 /* Section size is only divisible by rel. */
9568 if (use_rela_initialised
&& use_rela
)
9570 _bfd_error_handler (_("%pB: unable to sort relocs - "
9571 "they are in more than one size"),
9573 bfd_set_error (bfd_error_invalid_operation
);
9579 use_rela_initialised
= true;
9584 /* The section size is not divisible by either -
9585 something is wrong. */
9586 _bfd_error_handler (_("%pB: unable to sort relocs - "
9587 "they are of an unknown size"), abfd
);
9588 bfd_set_error (bfd_error_invalid_operation
);
9593 for (lo
= rel_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
9594 if (lo
->type
== bfd_indirect_link_order
)
9596 asection
*o
= lo
->u
.indirect
.section
;
9598 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
9600 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
9601 /* Section size is divisible by both rel and rela sizes.
9602 It is of no help to us. */
9606 /* Section size is only divisible by rela. */
9607 if (use_rela_initialised
&& !use_rela
)
9609 _bfd_error_handler (_("%pB: unable to sort relocs - "
9610 "they are in more than one size"),
9612 bfd_set_error (bfd_error_invalid_operation
);
9618 use_rela_initialised
= true;
9622 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
9624 /* Section size is only divisible by rel. */
9625 if (use_rela_initialised
&& use_rela
)
9627 _bfd_error_handler (_("%pB: unable to sort relocs - "
9628 "they are in more than one size"),
9630 bfd_set_error (bfd_error_invalid_operation
);
9636 use_rela_initialised
= true;
9641 /* The section size is not divisible by either -
9642 something is wrong. */
9643 _bfd_error_handler (_("%pB: unable to sort relocs - "
9644 "they are of an unknown size"), abfd
);
9645 bfd_set_error (bfd_error_invalid_operation
);
9650 if (! use_rela_initialised
)
9654 else if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0)
9656 else if (rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
9663 dynamic_relocs
= rela_dyn
;
9664 ext_size
= bed
->s
->sizeof_rela
;
9665 swap_in
= bed
->s
->swap_reloca_in
;
9666 swap_out
= bed
->s
->swap_reloca_out
;
9670 dynamic_relocs
= rel_dyn
;
9671 ext_size
= bed
->s
->sizeof_rel
;
9672 swap_in
= bed
->s
->swap_reloc_in
;
9673 swap_out
= bed
->s
->swap_reloc_out
;
9677 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
9678 if (lo
->type
== bfd_indirect_link_order
)
9679 size
+= lo
->u
.indirect
.section
->size
;
9681 if (size
!= dynamic_relocs
->size
)
9684 sort_elt
= (sizeof (struct elf_link_sort_rela
)
9685 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
9687 count
= dynamic_relocs
->size
/ ext_size
;
9690 sort
= (bfd_byte
*) bfd_zmalloc (sort_elt
* count
);
9694 (*info
->callbacks
->warning
)
9695 (info
, _("not enough memory to sort relocations"), 0, abfd
, 0, 0);
9699 if (bed
->s
->arch_size
== 32)
9700 r_sym_mask
= ~(bfd_vma
) 0xff;
9702 r_sym_mask
= ~(bfd_vma
) 0xffffffff;
9704 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
9705 if (lo
->type
== bfd_indirect_link_order
)
9707 bfd_byte
*erel
, *erelend
;
9708 asection
*o
= lo
->u
.indirect
.section
;
9710 if (o
->contents
== NULL
&& o
->size
!= 0)
9712 /* This is a reloc section that is being handled as a normal
9713 section. See bfd_section_from_shdr. We can't combine
9714 relocs in this case. */
9719 erelend
= o
->contents
+ o
->size
;
9720 p
= sort
+ o
->output_offset
* opb
/ ext_size
* sort_elt
;
9722 while (erel
< erelend
)
9724 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
9726 (*swap_in
) (abfd
, erel
, s
->rela
);
9727 s
->type
= (*bed
->elf_backend_reloc_type_class
) (info
, o
, s
->rela
);
9728 s
->u
.sym_mask
= r_sym_mask
;
9734 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
9736 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
9738 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
9739 if (s
->type
!= reloc_class_relative
)
9745 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
9746 for (; i
< count
; i
++, p
+= sort_elt
)
9748 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
9749 if (((sp
->rela
->r_info
^ sq
->rela
->r_info
) & r_sym_mask
) != 0)
9751 sp
->u
.offset
= sq
->rela
->r_offset
;
9754 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
9756 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9757 if (htab
->srelplt
&& htab
->srelplt
->output_section
== dynamic_relocs
)
9759 /* We have plt relocs in .rela.dyn. */
9760 sq
= (struct elf_link_sort_rela
*) sort
;
9761 for (i
= 0; i
< count
; i
++)
9762 if (sq
[count
- i
- 1].type
!= reloc_class_plt
)
9764 if (i
!= 0 && htab
->srelplt
->size
== i
* ext_size
)
9766 struct bfd_link_order
**plo
;
9767 /* Put srelplt link_order last. This is so the output_offset
9768 set in the next loop is correct for DT_JMPREL. */
9769 for (plo
= &dynamic_relocs
->map_head
.link_order
; *plo
!= NULL
; )
9770 if ((*plo
)->type
== bfd_indirect_link_order
9771 && (*plo
)->u
.indirect
.section
== htab
->srelplt
)
9777 plo
= &(*plo
)->next
;
9780 dynamic_relocs
->map_tail
.link_order
= lo
;
9785 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
9786 if (lo
->type
== bfd_indirect_link_order
)
9788 bfd_byte
*erel
, *erelend
;
9789 asection
*o
= lo
->u
.indirect
.section
;
9792 erelend
= o
->contents
+ o
->size
;
9793 o
->output_offset
= (p
- sort
) / sort_elt
* ext_size
/ opb
;
9794 while (erel
< erelend
)
9796 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
9797 (*swap_out
) (abfd
, s
->rela
, erel
);
9804 *psec
= dynamic_relocs
;
9808 /* Add a symbol to the output symbol string table. */
9811 elf_link_output_symstrtab (void *finf
,
9813 Elf_Internal_Sym
*elfsym
,
9814 asection
*input_sec
,
9815 struct elf_link_hash_entry
*h
)
9817 struct elf_final_link_info
*flinfo
= finf
;
9818 int (*output_symbol_hook
)
9819 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*, asection
*,
9820 struct elf_link_hash_entry
*);
9821 struct elf_link_hash_table
*hash_table
;
9822 const struct elf_backend_data
*bed
;
9823 bfd_size_type strtabsize
;
9825 BFD_ASSERT (elf_onesymtab (flinfo
->output_bfd
));
9827 bed
= get_elf_backend_data (flinfo
->output_bfd
);
9828 output_symbol_hook
= bed
->elf_backend_link_output_symbol_hook
;
9829 if (output_symbol_hook
!= NULL
)
9831 int ret
= (*output_symbol_hook
) (flinfo
->info
, name
, elfsym
, input_sec
, h
);
9836 if (ELF_ST_TYPE (elfsym
->st_info
) == STT_GNU_IFUNC
)
9837 elf_tdata (flinfo
->output_bfd
)->has_gnu_osabi
|= elf_gnu_osabi_ifunc
;
9838 if (ELF_ST_BIND (elfsym
->st_info
) == STB_GNU_UNIQUE
)
9839 elf_tdata (flinfo
->output_bfd
)->has_gnu_osabi
|= elf_gnu_osabi_unique
;
9843 || (input_sec
->flags
& SEC_EXCLUDE
))
9844 elfsym
->st_name
= (unsigned long) -1;
9847 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
9848 to get the final offset for st_name. */
9849 char *versioned_name
= (char *) name
;
9852 if (h
->versioned
== versioned
&& h
->def_dynamic
)
9854 /* Keep only one '@' for versioned symbols defined in
9856 char *version
= strrchr (name
, ELF_VER_CHR
);
9857 char *base_end
= strchr (name
, ELF_VER_CHR
);
9858 if (version
!= base_end
)
9861 size_t len
= strlen (name
);
9862 versioned_name
= bfd_alloc (flinfo
->output_bfd
, len
);
9863 if (versioned_name
== NULL
)
9865 base_len
= base_end
- name
;
9866 memcpy (versioned_name
, name
, base_len
);
9867 memcpy (versioned_name
+ base_len
, version
,
9872 else if (flinfo
->info
->unique_symbol
9873 && ELF_ST_BIND (elfsym
->st_info
) == STB_LOCAL
)
9875 struct local_hash_entry
*lh
;
9879 switch (ELF_ST_TYPE (elfsym
->st_info
))
9885 lh
= (struct local_hash_entry
*) bfd_hash_lookup
9886 (&flinfo
->local_hash_table
, name
, true, false);
9889 /* Always append ".COUNT" to local symbols to avoid
9890 potential conflicts with local symbol "XXX.COUNT". */
9891 sprintf (buf
, "%lx", lh
->count
);
9892 base_len
= lh
->size
;
9895 base_len
= strlen (name
);
9896 lh
->size
= base_len
;
9898 count_len
= strlen (buf
);
9899 versioned_name
= bfd_alloc (flinfo
->output_bfd
,
9900 base_len
+ count_len
+ 2);
9901 if (versioned_name
== NULL
)
9903 memcpy (versioned_name
, name
, base_len
);
9904 versioned_name
[base_len
] = '.';
9905 memcpy (versioned_name
+ base_len
+ 1, buf
,
9912 = (unsigned long) _bfd_elf_strtab_add (flinfo
->symstrtab
,
9913 versioned_name
, false);
9914 if (elfsym
->st_name
== (unsigned long) -1)
9918 hash_table
= elf_hash_table (flinfo
->info
);
9919 strtabsize
= hash_table
->strtabsize
;
9920 if (strtabsize
<= flinfo
->output_bfd
->symcount
)
9922 strtabsize
+= strtabsize
;
9923 hash_table
->strtabsize
= strtabsize
;
9924 strtabsize
*= sizeof (*hash_table
->strtab
);
9926 = (struct elf_sym_strtab
*) bfd_realloc (hash_table
->strtab
,
9928 if (hash_table
->strtab
== NULL
)
9931 hash_table
->strtab
[flinfo
->output_bfd
->symcount
].sym
= *elfsym
;
9932 hash_table
->strtab
[flinfo
->output_bfd
->symcount
].dest_index
9933 = flinfo
->output_bfd
->symcount
;
9934 flinfo
->output_bfd
->symcount
+= 1;
9939 /* Swap symbols out to the symbol table and flush the output symbols to
9943 elf_link_swap_symbols_out (struct elf_final_link_info
*flinfo
)
9945 struct elf_link_hash_table
*hash_table
= elf_hash_table (flinfo
->info
);
9948 const struct elf_backend_data
*bed
;
9950 Elf_Internal_Shdr
*hdr
;
9954 if (flinfo
->output_bfd
->symcount
== 0)
9957 BFD_ASSERT (elf_onesymtab (flinfo
->output_bfd
));
9959 bed
= get_elf_backend_data (flinfo
->output_bfd
);
9961 amt
= bed
->s
->sizeof_sym
* flinfo
->output_bfd
->symcount
;
9962 symbuf
= (bfd_byte
*) bfd_malloc (amt
);
9966 if (flinfo
->symshndxbuf
)
9968 amt
= sizeof (Elf_External_Sym_Shndx
);
9969 amt
*= bfd_get_symcount (flinfo
->output_bfd
);
9970 flinfo
->symshndxbuf
= (Elf_External_Sym_Shndx
*) bfd_zmalloc (amt
);
9971 if (flinfo
->symshndxbuf
== NULL
)
9978 /* Now swap out the symbols. */
9979 for (i
= 0; i
< flinfo
->output_bfd
->symcount
; i
++)
9981 struct elf_sym_strtab
*elfsym
= &hash_table
->strtab
[i
];
9982 if (elfsym
->sym
.st_name
== (unsigned long) -1)
9983 elfsym
->sym
.st_name
= 0;
9986 = (unsigned long) _bfd_elf_strtab_offset (flinfo
->symstrtab
,
9987 elfsym
->sym
.st_name
);
9989 /* Inform the linker of the addition of this symbol. */
9991 if (flinfo
->info
->callbacks
->ctf_new_symbol
)
9992 flinfo
->info
->callbacks
->ctf_new_symbol (elfsym
->dest_index
,
9995 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, &elfsym
->sym
,
9996 ((bfd_byte
*) symbuf
9997 + (elfsym
->dest_index
9998 * bed
->s
->sizeof_sym
)),
9999 NPTR_ADD (flinfo
->symshndxbuf
,
10000 elfsym
->dest_index
));
10003 hdr
= &elf_tdata (flinfo
->output_bfd
)->symtab_hdr
;
10004 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
10005 amt
= bed
->s
->sizeof_sym
* flinfo
->output_bfd
->symcount
;
10006 if (bfd_seek (flinfo
->output_bfd
, pos
, SEEK_SET
) == 0
10007 && bfd_bwrite (symbuf
, amt
, flinfo
->output_bfd
) == amt
)
10009 hdr
->sh_size
+= amt
;
10017 free (hash_table
->strtab
);
10018 hash_table
->strtab
= NULL
;
10023 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
10026 check_dynsym (bfd
*abfd
, Elf_Internal_Sym
*sym
)
10028 if (sym
->st_shndx
>= (SHN_LORESERVE
& 0xffff)
10029 && sym
->st_shndx
< SHN_LORESERVE
)
10031 /* The gABI doesn't support dynamic symbols in output sections
10034 /* xgettext:c-format */
10035 (_("%pB: too many sections: %d (>= %d)"),
10036 abfd
, bfd_count_sections (abfd
), SHN_LORESERVE
& 0xffff);
10037 bfd_set_error (bfd_error_nonrepresentable_section
);
10043 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
10044 allowing an unsatisfied unversioned symbol in the DSO to match a
10045 versioned symbol that would normally require an explicit version.
10046 We also handle the case that a DSO references a hidden symbol
10047 which may be satisfied by a versioned symbol in another DSO. */
10050 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
10051 const struct elf_backend_data
*bed
,
10052 struct elf_link_hash_entry
*h
)
10055 struct elf_link_loaded_list
*loaded
;
10057 if (!is_elf_hash_table (info
->hash
))
10060 /* Check indirect symbol. */
10061 while (h
->root
.type
== bfd_link_hash_indirect
)
10062 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10064 switch (h
->root
.type
)
10070 case bfd_link_hash_undefined
:
10071 case bfd_link_hash_undefweak
:
10072 abfd
= h
->root
.u
.undef
.abfd
;
10074 || (abfd
->flags
& DYNAMIC
) == 0
10075 || (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) == 0)
10079 case bfd_link_hash_defined
:
10080 case bfd_link_hash_defweak
:
10081 abfd
= h
->root
.u
.def
.section
->owner
;
10084 case bfd_link_hash_common
:
10085 abfd
= h
->root
.u
.c
.p
->section
->owner
;
10088 BFD_ASSERT (abfd
!= NULL
);
10090 for (loaded
= elf_hash_table (info
)->dyn_loaded
;
10092 loaded
= loaded
->next
)
10095 Elf_Internal_Shdr
*hdr
;
10097 size_t extsymcount
;
10099 Elf_Internal_Shdr
*versymhdr
;
10100 Elf_Internal_Sym
*isym
;
10101 Elf_Internal_Sym
*isymend
;
10102 Elf_Internal_Sym
*isymbuf
;
10103 Elf_External_Versym
*ever
;
10104 Elf_External_Versym
*extversym
;
10106 input
= loaded
->abfd
;
10108 /* We check each DSO for a possible hidden versioned definition. */
10110 || elf_dynversym (input
) == 0)
10113 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
10115 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
10116 if (elf_bad_symtab (input
))
10118 extsymcount
= symcount
;
10123 extsymcount
= symcount
- hdr
->sh_info
;
10124 extsymoff
= hdr
->sh_info
;
10127 if (extsymcount
== 0)
10130 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
10132 if (isymbuf
== NULL
)
10135 /* Read in any version definitions. */
10136 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
10137 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
10138 || (extversym
= (Elf_External_Versym
*)
10139 _bfd_malloc_and_read (input
, versymhdr
->sh_size
,
10140 versymhdr
->sh_size
)) == NULL
)
10146 ever
= extversym
+ extsymoff
;
10147 isymend
= isymbuf
+ extsymcount
;
10148 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
10151 Elf_Internal_Versym iver
;
10152 unsigned short version_index
;
10154 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
10155 || isym
->st_shndx
== SHN_UNDEF
)
10158 name
= bfd_elf_string_from_elf_section (input
,
10161 if (strcmp (name
, h
->root
.root
.string
) != 0)
10164 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
10166 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
10167 && !(h
->def_regular
10168 && h
->forced_local
))
10170 /* If we have a non-hidden versioned sym, then it should
10171 have provided a definition for the undefined sym unless
10172 it is defined in a non-shared object and forced local.
10177 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
10178 if (version_index
== 1 || version_index
== 2)
10180 /* This is the base or first version. We can use it. */
10194 /* Convert ELF common symbol TYPE. */
10197 elf_link_convert_common_type (struct bfd_link_info
*info
, int type
)
10199 /* Commom symbol can only appear in relocatable link. */
10200 if (!bfd_link_relocatable (info
))
10202 switch (info
->elf_stt_common
)
10206 case elf_stt_common
:
10209 case no_elf_stt_common
:
10216 /* Add an external symbol to the symbol table. This is called from
10217 the hash table traversal routine. When generating a shared object,
10218 we go through the symbol table twice. The first time we output
10219 anything that might have been forced to local scope in a version
10220 script. The second time we output the symbols that are still
10224 elf_link_output_extsym (struct bfd_hash_entry
*bh
, void *data
)
10226 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
10227 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
10228 struct elf_final_link_info
*flinfo
= eoinfo
->flinfo
;
10230 Elf_Internal_Sym sym
;
10231 asection
*input_sec
;
10232 const struct elf_backend_data
*bed
;
10237 if (h
->root
.type
== bfd_link_hash_warning
)
10239 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10240 if (h
->root
.type
== bfd_link_hash_new
)
10244 /* Decide whether to output this symbol in this pass. */
10245 if (eoinfo
->localsyms
)
10247 if (!h
->forced_local
)
10252 if (h
->forced_local
)
10256 bed
= get_elf_backend_data (flinfo
->output_bfd
);
10258 if (h
->root
.type
== bfd_link_hash_undefined
)
10260 /* If we have an undefined symbol reference here then it must have
10261 come from a shared library that is being linked in. (Undefined
10262 references in regular files have already been handled unless
10263 they are in unreferenced sections which are removed by garbage
10265 bool ignore_undef
= false;
10267 /* Some symbols may be special in that the fact that they're
10268 undefined can be safely ignored - let backend determine that. */
10269 if (bed
->elf_backend_ignore_undef_symbol
)
10270 ignore_undef
= bed
->elf_backend_ignore_undef_symbol (h
);
10272 /* If we are reporting errors for this situation then do so now. */
10274 && h
->ref_dynamic_nonweak
10275 && (!h
->ref_regular
|| flinfo
->info
->gc_sections
)
10276 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
)
10277 && flinfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
10279 flinfo
->info
->callbacks
->undefined_symbol
10280 (flinfo
->info
, h
->root
.root
.string
,
10281 h
->ref_regular
? NULL
: h
->root
.u
.undef
.abfd
, NULL
, 0,
10282 flinfo
->info
->unresolved_syms_in_shared_libs
== RM_DIAGNOSE
10283 && !flinfo
->info
->warn_unresolved_syms
);
10286 /* Strip a global symbol defined in a discarded section. */
10291 /* We should also warn if a forced local symbol is referenced from
10292 shared libraries. */
10293 if (bfd_link_executable (flinfo
->info
)
10298 && h
->ref_dynamic_nonweak
10299 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
))
10303 struct elf_link_hash_entry
*hi
= h
;
10305 /* Check indirect symbol. */
10306 while (hi
->root
.type
== bfd_link_hash_indirect
)
10307 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
10309 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
10310 /* xgettext:c-format */
10311 msg
= _("%pB: internal symbol `%s' in %pB is referenced by DSO");
10312 else if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
10313 /* xgettext:c-format */
10314 msg
= _("%pB: hidden symbol `%s' in %pB is referenced by DSO");
10316 /* xgettext:c-format */
10317 msg
= _("%pB: local symbol `%s' in %pB is referenced by DSO");
10318 def_bfd
= flinfo
->output_bfd
;
10319 if (hi
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
10320 def_bfd
= hi
->root
.u
.def
.section
->owner
;
10321 _bfd_error_handler (msg
, flinfo
->output_bfd
,
10322 h
->root
.root
.string
, def_bfd
);
10323 bfd_set_error (bfd_error_bad_value
);
10324 eoinfo
->failed
= true;
10328 /* We don't want to output symbols that have never been mentioned by
10329 a regular file, or that we have been told to strip. However, if
10330 h->indx is set to -2, the symbol is used by a reloc and we must
10335 else if ((h
->def_dynamic
10337 || h
->root
.type
== bfd_link_hash_new
)
10339 && !h
->ref_regular
)
10341 else if (flinfo
->info
->strip
== strip_all
)
10343 else if (flinfo
->info
->strip
== strip_some
10344 && bfd_hash_lookup (flinfo
->info
->keep_hash
,
10345 h
->root
.root
.string
, false, false) == NULL
)
10347 else if ((h
->root
.type
== bfd_link_hash_defined
10348 || h
->root
.type
== bfd_link_hash_defweak
)
10349 && ((flinfo
->info
->strip_discarded
10350 && discarded_section (h
->root
.u
.def
.section
))
10351 || ((h
->root
.u
.def
.section
->flags
& SEC_LINKER_CREATED
) == 0
10352 && h
->root
.u
.def
.section
->owner
!= NULL
10353 && (h
->root
.u
.def
.section
->owner
->flags
& BFD_PLUGIN
) != 0)))
10355 else if ((h
->root
.type
== bfd_link_hash_undefined
10356 || h
->root
.type
== bfd_link_hash_undefweak
)
10357 && h
->root
.u
.undef
.abfd
!= NULL
10358 && (h
->root
.u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0)
10363 /* If we're stripping it, and it's not a dynamic symbol, there's
10364 nothing else to do. However, if it is a forced local symbol or
10365 an ifunc symbol we need to give the backend finish_dynamic_symbol
10366 function a chance to make it dynamic. */
10368 && h
->dynindx
== -1
10369 && type
!= STT_GNU_IFUNC
10370 && !h
->forced_local
)
10374 sym
.st_size
= h
->size
;
10375 sym
.st_other
= h
->other
;
10376 switch (h
->root
.type
)
10379 case bfd_link_hash_new
:
10380 case bfd_link_hash_warning
:
10384 case bfd_link_hash_undefined
:
10385 case bfd_link_hash_undefweak
:
10386 input_sec
= bfd_und_section_ptr
;
10387 sym
.st_shndx
= SHN_UNDEF
;
10390 case bfd_link_hash_defined
:
10391 case bfd_link_hash_defweak
:
10393 input_sec
= h
->root
.u
.def
.section
;
10394 if (input_sec
->output_section
!= NULL
)
10397 _bfd_elf_section_from_bfd_section (flinfo
->output_bfd
,
10398 input_sec
->output_section
);
10399 if (sym
.st_shndx
== SHN_BAD
)
10402 /* xgettext:c-format */
10403 (_("%pB: could not find output section %pA for input section %pA"),
10404 flinfo
->output_bfd
, input_sec
->output_section
, input_sec
);
10405 bfd_set_error (bfd_error_nonrepresentable_section
);
10406 eoinfo
->failed
= true;
10410 /* ELF symbols in relocatable files are section relative,
10411 but in nonrelocatable files they are virtual
10413 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
10414 if (!bfd_link_relocatable (flinfo
->info
))
10416 sym
.st_value
+= input_sec
->output_section
->vma
;
10417 if (h
->type
== STT_TLS
)
10419 asection
*tls_sec
= elf_hash_table (flinfo
->info
)->tls_sec
;
10420 if (tls_sec
!= NULL
)
10421 sym
.st_value
-= tls_sec
->vma
;
10427 BFD_ASSERT (input_sec
->owner
== NULL
10428 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
10429 sym
.st_shndx
= SHN_UNDEF
;
10430 input_sec
= bfd_und_section_ptr
;
10435 case bfd_link_hash_common
:
10436 input_sec
= h
->root
.u
.c
.p
->section
;
10437 sym
.st_shndx
= bed
->common_section_index (input_sec
);
10438 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
10441 case bfd_link_hash_indirect
:
10442 /* These symbols are created by symbol versioning. They point
10443 to the decorated version of the name. For example, if the
10444 symbol foo@@GNU_1.2 is the default, which should be used when
10445 foo is used with no version, then we add an indirect symbol
10446 foo which points to foo@@GNU_1.2. We ignore these symbols,
10447 since the indirected symbol is already in the hash table. */
10451 if (type
== STT_COMMON
|| type
== STT_OBJECT
)
10452 switch (h
->root
.type
)
10454 case bfd_link_hash_common
:
10455 type
= elf_link_convert_common_type (flinfo
->info
, type
);
10457 case bfd_link_hash_defined
:
10458 case bfd_link_hash_defweak
:
10459 if (bed
->common_definition (&sym
))
10460 type
= elf_link_convert_common_type (flinfo
->info
, type
);
10464 case bfd_link_hash_undefined
:
10465 case bfd_link_hash_undefweak
:
10471 if (h
->forced_local
)
10473 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, type
);
10474 /* Turn off visibility on local symbol. */
10475 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
10477 /* Set STB_GNU_UNIQUE only if symbol is defined in regular object. */
10478 else if (h
->unique_global
&& h
->def_regular
)
10479 sym
.st_info
= ELF_ST_INFO (STB_GNU_UNIQUE
, type
);
10480 else if (h
->root
.type
== bfd_link_hash_undefweak
10481 || h
->root
.type
== bfd_link_hash_defweak
)
10482 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, type
);
10484 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
10485 sym
.st_target_internal
= h
->target_internal
;
10487 /* Give the processor backend a chance to tweak the symbol value,
10488 and also to finish up anything that needs to be done for this
10489 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
10490 forced local syms when non-shared is due to a historical quirk.
10491 STT_GNU_IFUNC symbol must go through PLT. */
10492 if ((h
->type
== STT_GNU_IFUNC
10494 && !bfd_link_relocatable (flinfo
->info
))
10495 || ((h
->dynindx
!= -1
10496 || h
->forced_local
)
10497 && ((bfd_link_pic (flinfo
->info
)
10498 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
10499 || h
->root
.type
!= bfd_link_hash_undefweak
))
10500 || !h
->forced_local
)
10501 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
))
10503 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
10504 (flinfo
->output_bfd
, flinfo
->info
, h
, &sym
)))
10506 eoinfo
->failed
= true;
10511 /* If we are marking the symbol as undefined, and there are no
10512 non-weak references to this symbol from a regular object, then
10513 mark the symbol as weak undefined; if there are non-weak
10514 references, mark the symbol as strong. We can't do this earlier,
10515 because it might not be marked as undefined until the
10516 finish_dynamic_symbol routine gets through with it. */
10517 if (sym
.st_shndx
== SHN_UNDEF
10519 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
10520 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
10523 type
= ELF_ST_TYPE (sym
.st_info
);
10525 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
10526 if (type
== STT_GNU_IFUNC
)
10529 if (h
->ref_regular_nonweak
)
10530 bindtype
= STB_GLOBAL
;
10532 bindtype
= STB_WEAK
;
10533 sym
.st_info
= ELF_ST_INFO (bindtype
, type
);
10536 /* If this is a symbol defined in a dynamic library, don't use the
10537 symbol size from the dynamic library. Relinking an executable
10538 against a new library may introduce gratuitous changes in the
10539 executable's symbols if we keep the size. */
10540 if (sym
.st_shndx
== SHN_UNDEF
10545 /* If a non-weak symbol with non-default visibility is not defined
10546 locally, it is a fatal error. */
10547 if (!bfd_link_relocatable (flinfo
->info
)
10548 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
10549 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
10550 && h
->root
.type
== bfd_link_hash_undefined
10551 && !h
->def_regular
)
10555 if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
)
10556 /* xgettext:c-format */
10557 msg
= _("%pB: protected symbol `%s' isn't defined");
10558 else if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
)
10559 /* xgettext:c-format */
10560 msg
= _("%pB: internal symbol `%s' isn't defined");
10562 /* xgettext:c-format */
10563 msg
= _("%pB: hidden symbol `%s' isn't defined");
10564 _bfd_error_handler (msg
, flinfo
->output_bfd
, h
->root
.root
.string
);
10565 bfd_set_error (bfd_error_bad_value
);
10566 eoinfo
->failed
= true;
10570 /* If this symbol should be put in the .dynsym section, then put it
10571 there now. We already know the symbol index. We also fill in
10572 the entry in the .hash section. */
10573 if (h
->dynindx
!= -1
10574 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
10575 && elf_hash_table (flinfo
->info
)->dynsym
!= NULL
10576 && !discarded_section (elf_hash_table (flinfo
->info
)->dynsym
))
10580 /* Since there is no version information in the dynamic string,
10581 if there is no version info in symbol version section, we will
10582 have a run-time problem if not linking executable, referenced
10583 by shared library, or not bound locally. */
10584 if (h
->verinfo
.verdef
== NULL
10585 && (!bfd_link_executable (flinfo
->info
)
10587 || !h
->def_regular
))
10589 char *p
= strrchr (h
->root
.root
.string
, ELF_VER_CHR
);
10591 if (p
&& p
[1] != '\0')
10594 /* xgettext:c-format */
10595 (_("%pB: no symbol version section for versioned symbol `%s'"),
10596 flinfo
->output_bfd
, h
->root
.root
.string
);
10597 eoinfo
->failed
= true;
10602 sym
.st_name
= h
->dynstr_index
;
10603 esym
= (elf_hash_table (flinfo
->info
)->dynsym
->contents
10604 + h
->dynindx
* bed
->s
->sizeof_sym
);
10605 if (!check_dynsym (flinfo
->output_bfd
, &sym
))
10607 eoinfo
->failed
= true;
10611 /* Inform the linker of the addition of this symbol. */
10613 if (flinfo
->info
->callbacks
->ctf_new_dynsym
)
10614 flinfo
->info
->callbacks
->ctf_new_dynsym (h
->dynindx
, &sym
);
10616 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, &sym
, esym
, 0);
10618 if (flinfo
->hash_sec
!= NULL
)
10620 size_t hash_entry_size
;
10621 bfd_byte
*bucketpos
;
10623 size_t bucketcount
;
10626 bucketcount
= elf_hash_table (flinfo
->info
)->bucketcount
;
10627 bucket
= h
->u
.elf_hash_value
% bucketcount
;
10630 = elf_section_data (flinfo
->hash_sec
)->this_hdr
.sh_entsize
;
10631 bucketpos
= ((bfd_byte
*) flinfo
->hash_sec
->contents
10632 + (bucket
+ 2) * hash_entry_size
);
10633 chain
= bfd_get (8 * hash_entry_size
, flinfo
->output_bfd
, bucketpos
);
10634 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, h
->dynindx
,
10636 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, chain
,
10637 ((bfd_byte
*) flinfo
->hash_sec
->contents
10638 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
10641 if (flinfo
->symver_sec
!= NULL
&& flinfo
->symver_sec
->contents
!= NULL
)
10643 Elf_Internal_Versym iversym
;
10644 Elf_External_Versym
*eversym
;
10646 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
10648 if (h
->verinfo
.verdef
== NULL
10649 || (elf_dyn_lib_class (h
->verinfo
.verdef
->vd_bfd
)
10650 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
| DYN_NO_NEEDED
)))
10651 iversym
.vs_vers
= 1;
10653 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
10657 if (h
->verinfo
.vertree
== NULL
)
10658 iversym
.vs_vers
= 1;
10660 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
10661 if (flinfo
->info
->create_default_symver
)
10665 /* Turn on VERSYM_HIDDEN only if the hidden versioned symbol is
10666 defined locally. */
10667 if (h
->versioned
== versioned_hidden
&& h
->def_regular
)
10668 iversym
.vs_vers
|= VERSYM_HIDDEN
;
10670 eversym
= (Elf_External_Versym
*) flinfo
->symver_sec
->contents
;
10671 eversym
+= h
->dynindx
;
10672 _bfd_elf_swap_versym_out (flinfo
->output_bfd
, &iversym
, eversym
);
10676 /* If the symbol is undefined, and we didn't output it to .dynsym,
10677 strip it from .symtab too. Obviously we can't do this for
10678 relocatable output or when needed for --emit-relocs. */
10679 else if (input_sec
== bfd_und_section_ptr
10681 /* PR 22319 Do not strip global undefined symbols marked as being needed. */
10682 && (h
->mark
!= 1 || ELF_ST_BIND (sym
.st_info
) != STB_GLOBAL
)
10683 && !bfd_link_relocatable (flinfo
->info
))
10686 /* Also strip others that we couldn't earlier due to dynamic symbol
10690 if ((input_sec
->flags
& SEC_EXCLUDE
) != 0)
10693 /* Output a FILE symbol so that following locals are not associated
10694 with the wrong input file. We need one for forced local symbols
10695 if we've seen more than one FILE symbol or when we have exactly
10696 one FILE symbol but global symbols are present in a file other
10697 than the one with the FILE symbol. We also need one if linker
10698 defined symbols are present. In practice these conditions are
10699 always met, so just emit the FILE symbol unconditionally. */
10700 if (eoinfo
->localsyms
10701 && !eoinfo
->file_sym_done
10702 && eoinfo
->flinfo
->filesym_count
!= 0)
10704 Elf_Internal_Sym fsym
;
10706 memset (&fsym
, 0, sizeof (fsym
));
10707 fsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
10708 fsym
.st_shndx
= SHN_ABS
;
10709 if (!elf_link_output_symstrtab (eoinfo
->flinfo
, NULL
, &fsym
,
10710 bfd_und_section_ptr
, NULL
))
10713 eoinfo
->file_sym_done
= true;
10716 indx
= bfd_get_symcount (flinfo
->output_bfd
);
10717 ret
= elf_link_output_symstrtab (flinfo
, h
->root
.root
.string
, &sym
,
10721 eoinfo
->failed
= true;
10726 else if (h
->indx
== -2)
10732 /* Return TRUE if special handling is done for relocs in SEC against
10733 symbols defined in discarded sections. */
10736 elf_section_ignore_discarded_relocs (asection
*sec
)
10738 const struct elf_backend_data
*bed
;
10740 switch (sec
->sec_info_type
)
10742 case SEC_INFO_TYPE_STABS
:
10743 case SEC_INFO_TYPE_EH_FRAME
:
10744 case SEC_INFO_TYPE_EH_FRAME_ENTRY
:
10750 bed
= get_elf_backend_data (sec
->owner
);
10751 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
10752 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))
10758 /* Return a mask saying how ld should treat relocations in SEC against
10759 symbols defined in discarded sections. If this function returns
10760 COMPLAIN set, ld will issue a warning message. If this function
10761 returns PRETEND set, and the discarded section was link-once and the
10762 same size as the kept link-once section, ld will pretend that the
10763 symbol was actually defined in the kept section. Otherwise ld will
10764 zero the reloc (at least that is the intent, but some cooperation by
10765 the target dependent code is needed, particularly for REL targets). */
10768 _bfd_elf_default_action_discarded (asection
*sec
)
10770 if (sec
->flags
& SEC_DEBUGGING
)
10773 if (strcmp (".eh_frame", sec
->name
) == 0)
10776 if (strcmp (".gcc_except_table", sec
->name
) == 0)
10779 return COMPLAIN
| PRETEND
;
10782 /* Find a match between a section and a member of a section group. */
10785 match_group_member (asection
*sec
, asection
*group
,
10786 struct bfd_link_info
*info
)
10788 asection
*first
= elf_next_in_group (group
);
10789 asection
*s
= first
;
10793 if (bfd_elf_match_symbols_in_sections (s
, sec
, info
))
10796 s
= elf_next_in_group (s
);
10804 /* Check if the kept section of a discarded section SEC can be used
10805 to replace it. Return the replacement if it is OK. Otherwise return
10809 _bfd_elf_check_kept_section (asection
*sec
, struct bfd_link_info
*info
)
10813 kept
= sec
->kept_section
;
10816 if ((kept
->flags
& SEC_GROUP
) != 0)
10817 kept
= match_group_member (sec
, kept
, info
);
10820 if ((sec
->rawsize
!= 0 ? sec
->rawsize
: sec
->size
)
10821 != (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
))
10825 /* Get the real kept section. */
10827 for (next
= kept
->kept_section
;
10829 next
= next
->kept_section
)
10833 sec
->kept_section
= kept
;
10838 /* Link an input file into the linker output file. This function
10839 handles all the sections and relocations of the input file at once.
10840 This is so that we only have to read the local symbols once, and
10841 don't have to keep them in memory. */
10844 elf_link_input_bfd (struct elf_final_link_info
*flinfo
, bfd
*input_bfd
)
10846 int (*relocate_section
)
10847 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
10848 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
10850 Elf_Internal_Shdr
*symtab_hdr
;
10851 size_t locsymcount
;
10853 Elf_Internal_Sym
*isymbuf
;
10854 Elf_Internal_Sym
*isym
;
10855 Elf_Internal_Sym
*isymend
;
10857 asection
**ppsection
;
10859 const struct elf_backend_data
*bed
;
10860 struct elf_link_hash_entry
**sym_hashes
;
10861 bfd_size_type address_size
;
10862 bfd_vma r_type_mask
;
10864 bool have_file_sym
= false;
10866 output_bfd
= flinfo
->output_bfd
;
10867 bed
= get_elf_backend_data (output_bfd
);
10868 relocate_section
= bed
->elf_backend_relocate_section
;
10870 /* If this is a dynamic object, we don't want to do anything here:
10871 we don't want the local symbols, and we don't want the section
10873 if ((input_bfd
->flags
& DYNAMIC
) != 0)
10876 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
10877 if (elf_bad_symtab (input_bfd
))
10879 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
10884 locsymcount
= symtab_hdr
->sh_info
;
10885 extsymoff
= symtab_hdr
->sh_info
;
10888 /* Enable GNU OSABI features in the output BFD that are used in the input
10890 if (bed
->elf_osabi
== ELFOSABI_NONE
10891 || bed
->elf_osabi
== ELFOSABI_GNU
10892 || bed
->elf_osabi
== ELFOSABI_FREEBSD
)
10893 elf_tdata (output_bfd
)->has_gnu_osabi
10894 |= (elf_tdata (input_bfd
)->has_gnu_osabi
10895 & (bfd_link_relocatable (flinfo
->info
)
10896 ? -1 : ~elf_gnu_osabi_retain
));
10898 /* Read the local symbols. */
10899 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
10900 if (isymbuf
== NULL
&& locsymcount
!= 0)
10902 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
10903 flinfo
->internal_syms
,
10904 flinfo
->external_syms
,
10905 flinfo
->locsym_shndx
);
10906 if (isymbuf
== NULL
)
10910 /* Find local symbol sections and adjust values of symbols in
10911 SEC_MERGE sections. Write out those local symbols we know are
10912 going into the output file. */
10913 isymend
= PTR_ADD (isymbuf
, locsymcount
);
10914 for (isym
= isymbuf
, pindex
= flinfo
->indices
, ppsection
= flinfo
->sections
;
10916 isym
++, pindex
++, ppsection
++)
10920 Elf_Internal_Sym osym
;
10926 if (elf_bad_symtab (input_bfd
))
10928 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
10935 if (isym
->st_shndx
== SHN_UNDEF
)
10936 isec
= bfd_und_section_ptr
;
10937 else if (isym
->st_shndx
== SHN_ABS
)
10938 isec
= bfd_abs_section_ptr
;
10939 else if (isym
->st_shndx
== SHN_COMMON
)
10940 isec
= bfd_com_section_ptr
;
10943 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
10946 /* Don't attempt to output symbols with st_shnx in the
10947 reserved range other than SHN_ABS and SHN_COMMON. */
10948 isec
= bfd_und_section_ptr
;
10950 else if (isec
->sec_info_type
== SEC_INFO_TYPE_MERGE
10951 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
10953 _bfd_merged_section_offset (output_bfd
, &isec
,
10954 elf_section_data (isec
)->sec_info
,
10960 /* Don't output the first, undefined, symbol. In fact, don't
10961 output any undefined local symbol. */
10962 if (isec
== bfd_und_section_ptr
)
10965 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
10967 /* We never output section symbols. Instead, we use the
10968 section symbol of the corresponding section in the output
10973 /* If we are stripping all symbols, we don't want to output this
10975 if (flinfo
->info
->strip
== strip_all
)
10978 /* If we are discarding all local symbols, we don't want to
10979 output this one. If we are generating a relocatable output
10980 file, then some of the local symbols may be required by
10981 relocs; we output them below as we discover that they are
10983 if (flinfo
->info
->discard
== discard_all
)
10986 /* If this symbol is defined in a section which we are
10987 discarding, we don't need to keep it. */
10988 if (isym
->st_shndx
!= SHN_UNDEF
10989 && isym
->st_shndx
< SHN_LORESERVE
10990 && isec
->output_section
== NULL
10991 && flinfo
->info
->non_contiguous_regions
10992 && flinfo
->info
->non_contiguous_regions_warnings
)
10994 _bfd_error_handler (_("warning: --enable-non-contiguous-regions "
10995 "discards section `%s' from '%s'\n"),
10996 isec
->name
, bfd_get_filename (isec
->owner
));
11000 if (isym
->st_shndx
!= SHN_UNDEF
11001 && isym
->st_shndx
< SHN_LORESERVE
11002 && bfd_section_removed_from_list (output_bfd
,
11003 isec
->output_section
))
11006 /* Get the name of the symbol. */
11007 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
11012 /* See if we are discarding symbols with this name. */
11013 if ((flinfo
->info
->strip
== strip_some
11014 && (bfd_hash_lookup (flinfo
->info
->keep_hash
, name
, false, false)
11016 || (((flinfo
->info
->discard
== discard_sec_merge
11017 && (isec
->flags
& SEC_MERGE
)
11018 && !bfd_link_relocatable (flinfo
->info
))
11019 || flinfo
->info
->discard
== discard_l
)
11020 && bfd_is_local_label_name (input_bfd
, name
)))
11023 if (ELF_ST_TYPE (isym
->st_info
) == STT_FILE
)
11025 if (input_bfd
->lto_output
)
11026 /* -flto puts a temp file name here. This means builds
11027 are not reproducible. Discard the symbol. */
11029 have_file_sym
= true;
11030 flinfo
->filesym_count
+= 1;
11032 if (!have_file_sym
)
11034 /* In the absence of debug info, bfd_find_nearest_line uses
11035 FILE symbols to determine the source file for local
11036 function symbols. Provide a FILE symbol here if input
11037 files lack such, so that their symbols won't be
11038 associated with a previous input file. It's not the
11039 source file, but the best we can do. */
11040 const char *filename
;
11041 have_file_sym
= true;
11042 flinfo
->filesym_count
+= 1;
11043 memset (&osym
, 0, sizeof (osym
));
11044 osym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
11045 osym
.st_shndx
= SHN_ABS
;
11046 if (input_bfd
->lto_output
)
11049 filename
= lbasename (bfd_get_filename (input_bfd
));
11050 if (!elf_link_output_symstrtab (flinfo
, filename
, &osym
,
11051 bfd_abs_section_ptr
, NULL
))
11057 /* Adjust the section index for the output file. */
11058 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
11059 isec
->output_section
);
11060 if (osym
.st_shndx
== SHN_BAD
)
11063 /* ELF symbols in relocatable files are section relative, but
11064 in executable files they are virtual addresses. Note that
11065 this code assumes that all ELF sections have an associated
11066 BFD section with a reasonable value for output_offset; below
11067 we assume that they also have a reasonable value for
11068 output_section. Any special sections must be set up to meet
11069 these requirements. */
11070 osym
.st_value
+= isec
->output_offset
;
11071 if (!bfd_link_relocatable (flinfo
->info
))
11073 osym
.st_value
+= isec
->output_section
->vma
;
11074 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
11076 /* STT_TLS symbols are relative to PT_TLS segment base. */
11077 if (elf_hash_table (flinfo
->info
)->tls_sec
!= NULL
)
11078 osym
.st_value
-= elf_hash_table (flinfo
->info
)->tls_sec
->vma
;
11080 osym
.st_info
= ELF_ST_INFO (ELF_ST_BIND (osym
.st_info
),
11085 indx
= bfd_get_symcount (output_bfd
);
11086 ret
= elf_link_output_symstrtab (flinfo
, name
, &osym
, isec
, NULL
);
11093 if (bed
->s
->arch_size
== 32)
11095 r_type_mask
= 0xff;
11101 r_type_mask
= 0xffffffff;
11106 /* Relocate the contents of each section. */
11107 sym_hashes
= elf_sym_hashes (input_bfd
);
11108 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
11110 bfd_byte
*contents
;
11112 if (! o
->linker_mark
)
11114 /* This section was omitted from the link. */
11118 if (!flinfo
->info
->resolve_section_groups
11119 && (o
->flags
& (SEC_LINKER_CREATED
| SEC_GROUP
)) == SEC_GROUP
)
11121 /* Deal with the group signature symbol. */
11122 struct bfd_elf_section_data
*sec_data
= elf_section_data (o
);
11123 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
11124 asection
*osec
= o
->output_section
;
11126 BFD_ASSERT (bfd_link_relocatable (flinfo
->info
));
11127 if (symndx
>= locsymcount
11128 || (elf_bad_symtab (input_bfd
)
11129 && flinfo
->sections
[symndx
] == NULL
))
11131 struct elf_link_hash_entry
*h
= sym_hashes
[symndx
- extsymoff
];
11132 while (h
->root
.type
== bfd_link_hash_indirect
11133 || h
->root
.type
== bfd_link_hash_warning
)
11134 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11135 /* Arrange for symbol to be output. */
11137 elf_section_data (osec
)->this_hdr
.sh_info
= -2;
11139 else if (ELF_ST_TYPE (isymbuf
[symndx
].st_info
) == STT_SECTION
)
11141 /* We'll use the output section target_index. */
11142 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
11143 elf_section_data (osec
)->this_hdr
.sh_info
= sec
->target_index
;
11147 if (flinfo
->indices
[symndx
] == -1)
11149 /* Otherwise output the local symbol now. */
11150 Elf_Internal_Sym sym
= isymbuf
[symndx
];
11151 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
11156 name
= bfd_elf_string_from_elf_section (input_bfd
,
11157 symtab_hdr
->sh_link
,
11162 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
11164 if (sym
.st_shndx
== SHN_BAD
)
11167 sym
.st_value
+= o
->output_offset
;
11169 indx
= bfd_get_symcount (output_bfd
);
11170 ret
= elf_link_output_symstrtab (flinfo
, name
, &sym
, o
,
11175 flinfo
->indices
[symndx
] = indx
;
11179 elf_section_data (osec
)->this_hdr
.sh_info
11180 = flinfo
->indices
[symndx
];
11184 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
11185 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
11188 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
11190 /* Section was created by _bfd_elf_link_create_dynamic_sections
11195 /* Get the contents of the section. They have been cached by a
11196 relaxation routine. Note that o is a section in an input
11197 file, so the contents field will not have been set by any of
11198 the routines which work on output files. */
11199 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
11201 contents
= elf_section_data (o
)->this_hdr
.contents
;
11202 if (bed
->caches_rawsize
11204 && o
->rawsize
< o
->size
)
11206 memcpy (flinfo
->contents
, contents
, o
->rawsize
);
11207 contents
= flinfo
->contents
;
11212 contents
= flinfo
->contents
;
11213 if (! bfd_get_full_section_contents (input_bfd
, o
, &contents
))
11217 if ((o
->flags
& SEC_RELOC
) != 0)
11219 Elf_Internal_Rela
*internal_relocs
;
11220 Elf_Internal_Rela
*rel
, *relend
;
11221 int action_discarded
;
11224 /* Get the swapped relocs. */
11226 = _bfd_elf_link_info_read_relocs (input_bfd
, flinfo
->info
, o
,
11227 flinfo
->external_relocs
,
11228 flinfo
->internal_relocs
,
11230 if (internal_relocs
== NULL
11231 && o
->reloc_count
> 0)
11234 /* We need to reverse-copy input .ctors/.dtors sections if
11235 they are placed in .init_array/.finit_array for output. */
11236 if (o
->size
> address_size
11237 && ((startswith (o
->name
, ".ctors")
11238 && strcmp (o
->output_section
->name
,
11239 ".init_array") == 0)
11240 || (startswith (o
->name
, ".dtors")
11241 && strcmp (o
->output_section
->name
,
11242 ".fini_array") == 0))
11243 && (o
->name
[6] == 0 || o
->name
[6] == '.'))
11245 if (o
->size
* bed
->s
->int_rels_per_ext_rel
11246 != o
->reloc_count
* address_size
)
11249 /* xgettext:c-format */
11250 (_("error: %pB: size of section %pA is not "
11251 "multiple of address size"),
11253 bfd_set_error (bfd_error_bad_value
);
11256 o
->flags
|= SEC_ELF_REVERSE_COPY
;
11259 action_discarded
= -1;
11260 if (!elf_section_ignore_discarded_relocs (o
))
11261 action_discarded
= (*bed
->action_discarded
) (o
);
11263 /* Run through the relocs evaluating complex reloc symbols and
11264 looking for relocs against symbols from discarded sections
11265 or section symbols from removed link-once sections.
11266 Complain about relocs against discarded sections. Zero
11267 relocs against removed link-once sections. */
11269 rel
= internal_relocs
;
11270 relend
= rel
+ o
->reloc_count
;
11271 for ( ; rel
< relend
; rel
++)
11273 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
11274 unsigned int s_type
;
11275 asection
**ps
, *sec
;
11276 struct elf_link_hash_entry
*h
= NULL
;
11277 const char *sym_name
;
11279 if (r_symndx
== STN_UNDEF
)
11282 if (r_symndx
>= locsymcount
11283 || (elf_bad_symtab (input_bfd
)
11284 && flinfo
->sections
[r_symndx
] == NULL
))
11286 h
= sym_hashes
[r_symndx
- extsymoff
];
11288 /* Badly formatted input files can contain relocs that
11289 reference non-existant symbols. Check here so that
11290 we do not seg fault. */
11294 /* xgettext:c-format */
11295 (_("error: %pB contains a reloc (%#" PRIx64
") for section %pA "
11296 "that references a non-existent global symbol"),
11297 input_bfd
, (uint64_t) rel
->r_info
, o
);
11298 bfd_set_error (bfd_error_bad_value
);
11302 while (h
->root
.type
== bfd_link_hash_indirect
11303 || h
->root
.type
== bfd_link_hash_warning
)
11304 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11308 /* If a plugin symbol is referenced from a non-IR file,
11309 mark the symbol as undefined. Note that the
11310 linker may attach linker created dynamic sections
11311 to the plugin bfd. Symbols defined in linker
11312 created sections are not plugin symbols. */
11313 if ((h
->root
.non_ir_ref_regular
11314 || h
->root
.non_ir_ref_dynamic
)
11315 && (h
->root
.type
== bfd_link_hash_defined
11316 || h
->root
.type
== bfd_link_hash_defweak
)
11317 && (h
->root
.u
.def
.section
->flags
11318 & SEC_LINKER_CREATED
) == 0
11319 && h
->root
.u
.def
.section
->owner
!= NULL
11320 && (h
->root
.u
.def
.section
->owner
->flags
11321 & BFD_PLUGIN
) != 0)
11323 h
->root
.type
= bfd_link_hash_undefined
;
11324 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
11328 if (h
->root
.type
== bfd_link_hash_defined
11329 || h
->root
.type
== bfd_link_hash_defweak
)
11330 ps
= &h
->root
.u
.def
.section
;
11332 sym_name
= h
->root
.root
.string
;
11336 Elf_Internal_Sym
*sym
= isymbuf
+ r_symndx
;
11338 s_type
= ELF_ST_TYPE (sym
->st_info
);
11339 ps
= &flinfo
->sections
[r_symndx
];
11340 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
11344 if ((s_type
== STT_RELC
|| s_type
== STT_SRELC
)
11345 && !bfd_link_relocatable (flinfo
->info
))
11348 bfd_vma dot
= (rel
->r_offset
11349 + o
->output_offset
+ o
->output_section
->vma
);
11351 printf ("Encountered a complex symbol!");
11352 printf (" (input_bfd %s, section %s, reloc %ld\n",
11353 bfd_get_filename (input_bfd
), o
->name
,
11354 (long) (rel
- internal_relocs
));
11355 printf (" symbol: idx %8.8lx, name %s\n",
11356 r_symndx
, sym_name
);
11357 printf (" reloc : info %8.8lx, addr %8.8lx\n",
11358 (unsigned long) rel
->r_info
,
11359 (unsigned long) rel
->r_offset
);
11361 if (!eval_symbol (&val
, &sym_name
, input_bfd
, flinfo
, dot
,
11362 isymbuf
, locsymcount
, s_type
== STT_SRELC
))
11365 /* Symbol evaluated OK. Update to absolute value. */
11366 set_symbol_value (input_bfd
, isymbuf
, locsymcount
,
11371 if (action_discarded
!= -1 && ps
!= NULL
)
11373 /* Complain if the definition comes from a
11374 discarded section. */
11375 if ((sec
= *ps
) != NULL
&& discarded_section (sec
))
11377 BFD_ASSERT (r_symndx
!= STN_UNDEF
);
11378 if (action_discarded
& COMPLAIN
)
11379 (*flinfo
->info
->callbacks
->einfo
)
11380 /* xgettext:c-format */
11381 (_("%X`%s' referenced in section `%pA' of %pB: "
11382 "defined in discarded section `%pA' of %pB\n"),
11383 sym_name
, o
, input_bfd
, sec
, sec
->owner
);
11385 /* Try to do the best we can to support buggy old
11386 versions of gcc. Pretend that the symbol is
11387 really defined in the kept linkonce section.
11388 FIXME: This is quite broken. Modifying the
11389 symbol here means we will be changing all later
11390 uses of the symbol, not just in this section. */
11391 if (action_discarded
& PRETEND
)
11395 kept
= _bfd_elf_check_kept_section (sec
,
11407 /* Relocate the section by invoking a back end routine.
11409 The back end routine is responsible for adjusting the
11410 section contents as necessary, and (if using Rela relocs
11411 and generating a relocatable output file) adjusting the
11412 reloc addend as necessary.
11414 The back end routine does not have to worry about setting
11415 the reloc address or the reloc symbol index.
11417 The back end routine is given a pointer to the swapped in
11418 internal symbols, and can access the hash table entries
11419 for the external symbols via elf_sym_hashes (input_bfd).
11421 When generating relocatable output, the back end routine
11422 must handle STB_LOCAL/STT_SECTION symbols specially. The
11423 output symbol is going to be a section symbol
11424 corresponding to the output section, which will require
11425 the addend to be adjusted. */
11427 ret
= (*relocate_section
) (output_bfd
, flinfo
->info
,
11428 input_bfd
, o
, contents
,
11436 || bfd_link_relocatable (flinfo
->info
)
11437 || flinfo
->info
->emitrelocations
)
11439 Elf_Internal_Rela
*irela
;
11440 Elf_Internal_Rela
*irelaend
, *irelamid
;
11441 bfd_vma last_offset
;
11442 struct elf_link_hash_entry
**rel_hash
;
11443 struct elf_link_hash_entry
**rel_hash_list
, **rela_hash_list
;
11444 Elf_Internal_Shdr
*input_rel_hdr
, *input_rela_hdr
;
11445 unsigned int next_erel
;
11447 struct bfd_elf_section_data
*esdi
, *esdo
;
11449 esdi
= elf_section_data (o
);
11450 esdo
= elf_section_data (o
->output_section
);
11451 rela_normal
= false;
11453 /* Adjust the reloc addresses and symbol indices. */
11455 irela
= internal_relocs
;
11456 irelaend
= irela
+ o
->reloc_count
;
11457 rel_hash
= PTR_ADD (esdo
->rel
.hashes
, esdo
->rel
.count
);
11458 /* We start processing the REL relocs, if any. When we reach
11459 IRELAMID in the loop, we switch to the RELA relocs. */
11461 if (esdi
->rel
.hdr
!= NULL
)
11462 irelamid
+= (NUM_SHDR_ENTRIES (esdi
->rel
.hdr
)
11463 * bed
->s
->int_rels_per_ext_rel
);
11464 rel_hash_list
= rel_hash
;
11465 rela_hash_list
= NULL
;
11466 last_offset
= o
->output_offset
;
11467 if (!bfd_link_relocatable (flinfo
->info
))
11468 last_offset
+= o
->output_section
->vma
;
11469 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
11471 unsigned long r_symndx
;
11473 Elf_Internal_Sym sym
;
11475 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
11481 if (irela
== irelamid
)
11483 rel_hash
= PTR_ADD (esdo
->rela
.hashes
, esdo
->rela
.count
);
11484 rela_hash_list
= rel_hash
;
11485 rela_normal
= bed
->rela_normal
;
11488 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
11491 if (irela
->r_offset
>= (bfd_vma
) -2)
11493 /* This is a reloc for a deleted entry or somesuch.
11494 Turn it into an R_*_NONE reloc, at the same
11495 offset as the last reloc. elf_eh_frame.c and
11496 bfd_elf_discard_info rely on reloc offsets
11498 irela
->r_offset
= last_offset
;
11500 irela
->r_addend
= 0;
11504 irela
->r_offset
+= o
->output_offset
;
11506 /* Relocs in an executable have to be virtual addresses. */
11507 if (!bfd_link_relocatable (flinfo
->info
))
11508 irela
->r_offset
+= o
->output_section
->vma
;
11510 last_offset
= irela
->r_offset
;
11512 r_symndx
= irela
->r_info
>> r_sym_shift
;
11513 if (r_symndx
== STN_UNDEF
)
11516 if (r_symndx
>= locsymcount
11517 || (elf_bad_symtab (input_bfd
)
11518 && flinfo
->sections
[r_symndx
] == NULL
))
11520 struct elf_link_hash_entry
*rh
;
11521 unsigned long indx
;
11523 /* This is a reloc against a global symbol. We
11524 have not yet output all the local symbols, so
11525 we do not know the symbol index of any global
11526 symbol. We set the rel_hash entry for this
11527 reloc to point to the global hash table entry
11528 for this symbol. The symbol index is then
11529 set at the end of bfd_elf_final_link. */
11530 indx
= r_symndx
- extsymoff
;
11531 rh
= elf_sym_hashes (input_bfd
)[indx
];
11532 while (rh
->root
.type
== bfd_link_hash_indirect
11533 || rh
->root
.type
== bfd_link_hash_warning
)
11534 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
11536 /* Setting the index to -2 tells
11537 elf_link_output_extsym that this symbol is
11538 used by a reloc. */
11539 BFD_ASSERT (rh
->indx
< 0);
11546 /* This is a reloc against a local symbol. */
11549 sym
= isymbuf
[r_symndx
];
11550 sec
= flinfo
->sections
[r_symndx
];
11551 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
11553 /* I suppose the backend ought to fill in the
11554 section of any STT_SECTION symbol against a
11555 processor specific section. */
11556 r_symndx
= STN_UNDEF
;
11557 if (bfd_is_abs_section (sec
))
11559 else if (sec
== NULL
|| sec
->owner
== NULL
)
11561 bfd_set_error (bfd_error_bad_value
);
11566 asection
*osec
= sec
->output_section
;
11568 /* If we have discarded a section, the output
11569 section will be the absolute section. In
11570 case of discarded SEC_MERGE sections, use
11571 the kept section. relocate_section should
11572 have already handled discarded linkonce
11574 if (bfd_is_abs_section (osec
)
11575 && sec
->kept_section
!= NULL
11576 && sec
->kept_section
->output_section
!= NULL
)
11578 osec
= sec
->kept_section
->output_section
;
11579 irela
->r_addend
-= osec
->vma
;
11582 if (!bfd_is_abs_section (osec
))
11584 r_symndx
= osec
->target_index
;
11585 if (r_symndx
== STN_UNDEF
)
11587 irela
->r_addend
+= osec
->vma
;
11588 osec
= _bfd_nearby_section (output_bfd
, osec
,
11590 irela
->r_addend
-= osec
->vma
;
11591 r_symndx
= osec
->target_index
;
11596 /* Adjust the addend according to where the
11597 section winds up in the output section. */
11599 irela
->r_addend
+= sec
->output_offset
;
11603 if (flinfo
->indices
[r_symndx
] == -1)
11605 unsigned long shlink
;
11610 if (flinfo
->info
->strip
== strip_all
)
11612 /* You can't do ld -r -s. */
11613 bfd_set_error (bfd_error_invalid_operation
);
11617 /* This symbol was skipped earlier, but
11618 since it is needed by a reloc, we
11619 must output it now. */
11620 shlink
= symtab_hdr
->sh_link
;
11621 name
= (bfd_elf_string_from_elf_section
11622 (input_bfd
, shlink
, sym
.st_name
));
11626 osec
= sec
->output_section
;
11628 _bfd_elf_section_from_bfd_section (output_bfd
,
11630 if (sym
.st_shndx
== SHN_BAD
)
11633 sym
.st_value
+= sec
->output_offset
;
11634 if (!bfd_link_relocatable (flinfo
->info
))
11636 sym
.st_value
+= osec
->vma
;
11637 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
11639 struct elf_link_hash_table
*htab
11640 = elf_hash_table (flinfo
->info
);
11642 /* STT_TLS symbols are relative to PT_TLS
11644 if (htab
->tls_sec
!= NULL
)
11645 sym
.st_value
-= htab
->tls_sec
->vma
;
11648 = ELF_ST_INFO (ELF_ST_BIND (sym
.st_info
),
11653 indx
= bfd_get_symcount (output_bfd
);
11654 ret
= elf_link_output_symstrtab (flinfo
, name
,
11660 flinfo
->indices
[r_symndx
] = indx
;
11665 r_symndx
= flinfo
->indices
[r_symndx
];
11668 irela
->r_info
= ((bfd_vma
) r_symndx
<< r_sym_shift
11669 | (irela
->r_info
& r_type_mask
));
11672 /* Swap out the relocs. */
11673 input_rel_hdr
= esdi
->rel
.hdr
;
11674 if (input_rel_hdr
&& input_rel_hdr
->sh_size
!= 0)
11676 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
11681 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
11682 * bed
->s
->int_rels_per_ext_rel
);
11683 rel_hash_list
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
11686 input_rela_hdr
= esdi
->rela
.hdr
;
11687 if (input_rela_hdr
&& input_rela_hdr
->sh_size
!= 0)
11689 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
11698 /* Write out the modified section contents. */
11699 if (bed
->elf_backend_write_section
11700 && (*bed
->elf_backend_write_section
) (output_bfd
, flinfo
->info
, o
,
11703 /* Section written out. */
11705 else switch (o
->sec_info_type
)
11707 case SEC_INFO_TYPE_STABS
:
11708 if (! (_bfd_write_section_stabs
11710 &elf_hash_table (flinfo
->info
)->stab_info
,
11711 o
, &elf_section_data (o
)->sec_info
, contents
)))
11714 case SEC_INFO_TYPE_MERGE
:
11715 if (! _bfd_write_merged_section (output_bfd
, o
,
11716 elf_section_data (o
)->sec_info
))
11719 case SEC_INFO_TYPE_EH_FRAME
:
11721 if (! _bfd_elf_write_section_eh_frame (output_bfd
, flinfo
->info
,
11726 case SEC_INFO_TYPE_EH_FRAME_ENTRY
:
11728 if (! _bfd_elf_write_section_eh_frame_entry (output_bfd
,
11736 if (! (o
->flags
& SEC_EXCLUDE
))
11738 file_ptr offset
= (file_ptr
) o
->output_offset
;
11739 bfd_size_type todo
= o
->size
;
11741 offset
*= bfd_octets_per_byte (output_bfd
, o
);
11743 if ((o
->flags
& SEC_ELF_REVERSE_COPY
))
11745 /* Reverse-copy input section to output. */
11748 todo
-= address_size
;
11749 if (! bfd_set_section_contents (output_bfd
,
11757 offset
+= address_size
;
11761 else if (! bfd_set_section_contents (output_bfd
,
11775 /* Generate a reloc when linking an ELF file. This is a reloc
11776 requested by the linker, and does not come from any input file. This
11777 is used to build constructor and destructor tables when linking
11781 elf_reloc_link_order (bfd
*output_bfd
,
11782 struct bfd_link_info
*info
,
11783 asection
*output_section
,
11784 struct bfd_link_order
*link_order
)
11786 reloc_howto_type
*howto
;
11790 struct bfd_elf_section_reloc_data
*reldata
;
11791 struct elf_link_hash_entry
**rel_hash_ptr
;
11792 Elf_Internal_Shdr
*rel_hdr
;
11793 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
11794 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
11797 struct bfd_elf_section_data
*esdo
= elf_section_data (output_section
);
11799 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
11802 bfd_set_error (bfd_error_bad_value
);
11806 addend
= link_order
->u
.reloc
.p
->addend
;
11809 reldata
= &esdo
->rel
;
11810 else if (esdo
->rela
.hdr
)
11811 reldata
= &esdo
->rela
;
11818 /* Figure out the symbol index. */
11819 rel_hash_ptr
= reldata
->hashes
+ reldata
->count
;
11820 if (link_order
->type
== bfd_section_reloc_link_order
)
11822 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
11823 BFD_ASSERT (indx
!= 0);
11824 *rel_hash_ptr
= NULL
;
11828 struct elf_link_hash_entry
*h
;
11830 /* Treat a reloc against a defined symbol as though it were
11831 actually against the section. */
11832 h
= ((struct elf_link_hash_entry
*)
11833 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
11834 link_order
->u
.reloc
.p
->u
.name
,
11835 false, false, true));
11837 && (h
->root
.type
== bfd_link_hash_defined
11838 || h
->root
.type
== bfd_link_hash_defweak
))
11842 section
= h
->root
.u
.def
.section
;
11843 indx
= section
->output_section
->target_index
;
11844 *rel_hash_ptr
= NULL
;
11845 /* It seems that we ought to add the symbol value to the
11846 addend here, but in practice it has already been added
11847 because it was passed to constructor_callback. */
11848 addend
+= section
->output_section
->vma
+ section
->output_offset
;
11850 else if (h
!= NULL
)
11852 /* Setting the index to -2 tells elf_link_output_extsym that
11853 this symbol is used by a reloc. */
11860 (*info
->callbacks
->unattached_reloc
)
11861 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0);
11866 /* If this is an inplace reloc, we must write the addend into the
11868 if (howto
->partial_inplace
&& addend
!= 0)
11870 bfd_size_type size
;
11871 bfd_reloc_status_type rstat
;
11874 const char *sym_name
;
11875 bfd_size_type octets
;
11877 size
= (bfd_size_type
) bfd_get_reloc_size (howto
);
11878 buf
= (bfd_byte
*) bfd_zmalloc (size
);
11879 if (buf
== NULL
&& size
!= 0)
11881 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
11888 case bfd_reloc_outofrange
:
11891 case bfd_reloc_overflow
:
11892 if (link_order
->type
== bfd_section_reloc_link_order
)
11893 sym_name
= bfd_section_name (link_order
->u
.reloc
.p
->u
.section
);
11895 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
11896 (*info
->callbacks
->reloc_overflow
) (info
, NULL
, sym_name
,
11897 howto
->name
, addend
, NULL
, NULL
,
11902 octets
= link_order
->offset
* bfd_octets_per_byte (output_bfd
,
11904 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
11911 /* The address of a reloc is relative to the section in a
11912 relocatable file, and is a virtual address in an executable
11914 offset
= link_order
->offset
;
11915 if (! bfd_link_relocatable (info
))
11916 offset
+= output_section
->vma
;
11918 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
11920 irel
[i
].r_offset
= offset
;
11921 irel
[i
].r_info
= 0;
11922 irel
[i
].r_addend
= 0;
11924 if (bed
->s
->arch_size
== 32)
11925 irel
[0].r_info
= ELF32_R_INFO (indx
, howto
->type
);
11927 irel
[0].r_info
= ELF64_R_INFO (indx
, howto
->type
);
11929 rel_hdr
= reldata
->hdr
;
11930 erel
= rel_hdr
->contents
;
11931 if (rel_hdr
->sh_type
== SHT_REL
)
11933 erel
+= reldata
->count
* bed
->s
->sizeof_rel
;
11934 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
11938 irel
[0].r_addend
= addend
;
11939 erel
+= reldata
->count
* bed
->s
->sizeof_rela
;
11940 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
11948 /* Generate an import library in INFO->implib_bfd from symbols in ABFD.
11949 Returns TRUE upon success, FALSE otherwise. */
11952 elf_output_implib (bfd
*abfd
, struct bfd_link_info
*info
)
11956 const struct elf_backend_data
*bed
;
11958 enum bfd_architecture arch
;
11960 asymbol
**sympp
= NULL
;
11964 elf_symbol_type
*osymbuf
;
11967 implib_bfd
= info
->out_implib_bfd
;
11968 bed
= get_elf_backend_data (abfd
);
11970 if (!bfd_set_format (implib_bfd
, bfd_object
))
11973 /* Use flag from executable but make it a relocatable object. */
11974 flags
= bfd_get_file_flags (abfd
);
11975 flags
&= ~HAS_RELOC
;
11976 if (!bfd_set_start_address (implib_bfd
, 0)
11977 || !bfd_set_file_flags (implib_bfd
, flags
& ~EXEC_P
))
11980 /* Copy architecture of output file to import library file. */
11981 arch
= bfd_get_arch (abfd
);
11982 mach
= bfd_get_mach (abfd
);
11983 if (!bfd_set_arch_mach (implib_bfd
, arch
, mach
)
11984 && (abfd
->target_defaulted
11985 || bfd_get_arch (abfd
) != bfd_get_arch (implib_bfd
)))
11988 /* Get symbol table size. */
11989 symsize
= bfd_get_symtab_upper_bound (abfd
);
11993 /* Read in the symbol table. */
11994 sympp
= (asymbol
**) bfd_malloc (symsize
);
11998 symcount
= bfd_canonicalize_symtab (abfd
, sympp
);
12002 /* Allow the BFD backend to copy any private header data it
12003 understands from the output BFD to the import library BFD. */
12004 if (! bfd_copy_private_header_data (abfd
, implib_bfd
))
12007 /* Filter symbols to appear in the import library. */
12008 if (bed
->elf_backend_filter_implib_symbols
)
12009 symcount
= bed
->elf_backend_filter_implib_symbols (abfd
, info
, sympp
,
12012 symcount
= _bfd_elf_filter_global_symbols (abfd
, info
, sympp
, symcount
);
12015 bfd_set_error (bfd_error_no_symbols
);
12016 _bfd_error_handler (_("%pB: no symbol found for import library"),
12022 /* Make symbols absolute. */
12023 amt
= symcount
* sizeof (*osymbuf
);
12024 osymbuf
= (elf_symbol_type
*) bfd_alloc (implib_bfd
, amt
);
12025 if (osymbuf
== NULL
)
12028 for (src_count
= 0; src_count
< symcount
; src_count
++)
12030 memcpy (&osymbuf
[src_count
], (elf_symbol_type
*) sympp
[src_count
],
12031 sizeof (*osymbuf
));
12032 osymbuf
[src_count
].symbol
.section
= bfd_abs_section_ptr
;
12033 osymbuf
[src_count
].internal_elf_sym
.st_shndx
= SHN_ABS
;
12034 osymbuf
[src_count
].symbol
.value
+= sympp
[src_count
]->section
->vma
;
12035 osymbuf
[src_count
].internal_elf_sym
.st_value
=
12036 osymbuf
[src_count
].symbol
.value
;
12037 sympp
[src_count
] = &osymbuf
[src_count
].symbol
;
12040 bfd_set_symtab (implib_bfd
, sympp
, symcount
);
12042 /* Allow the BFD backend to copy any private data it understands
12043 from the output BFD to the import library BFD. This is done last
12044 to permit the routine to look at the filtered symbol table. */
12045 if (! bfd_copy_private_bfd_data (abfd
, implib_bfd
))
12048 if (!bfd_close (implib_bfd
))
12059 elf_final_link_free (bfd
*obfd
, struct elf_final_link_info
*flinfo
)
12063 if (flinfo
->symstrtab
!= NULL
)
12064 _bfd_elf_strtab_free (flinfo
->symstrtab
);
12065 free (flinfo
->contents
);
12066 free (flinfo
->external_relocs
);
12067 free (flinfo
->internal_relocs
);
12068 free (flinfo
->external_syms
);
12069 free (flinfo
->locsym_shndx
);
12070 free (flinfo
->internal_syms
);
12071 free (flinfo
->indices
);
12072 free (flinfo
->sections
);
12073 if (flinfo
->symshndxbuf
!= (Elf_External_Sym_Shndx
*) -1)
12074 free (flinfo
->symshndxbuf
);
12075 for (o
= obfd
->sections
; o
!= NULL
; o
= o
->next
)
12077 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
12078 free (esdo
->rel
.hashes
);
12079 free (esdo
->rela
.hashes
);
12083 /* Do the final step of an ELF link. */
12086 bfd_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
12091 struct elf_final_link_info flinfo
;
12093 struct bfd_link_order
*p
;
12095 bfd_size_type max_contents_size
;
12096 bfd_size_type max_external_reloc_size
;
12097 bfd_size_type max_internal_reloc_count
;
12098 bfd_size_type max_sym_count
;
12099 bfd_size_type max_sym_shndx_count
;
12100 Elf_Internal_Sym elfsym
;
12102 Elf_Internal_Shdr
*symtab_hdr
;
12103 Elf_Internal_Shdr
*symtab_shndx_hdr
;
12104 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12105 struct elf_outext_info eoinfo
;
12107 size_t relativecount
= 0;
12108 asection
*reldyn
= 0;
12110 asection
*attr_section
= NULL
;
12111 bfd_vma attr_size
= 0;
12112 const char *std_attrs_section
;
12113 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
12114 bool sections_removed
;
12117 if (!is_elf_hash_table (&htab
->root
))
12120 if (bfd_link_pic (info
))
12121 abfd
->flags
|= DYNAMIC
;
12123 dynamic
= htab
->dynamic_sections_created
;
12124 dynobj
= htab
->dynobj
;
12126 emit_relocs
= (bfd_link_relocatable (info
)
12127 || info
->emitrelocations
);
12129 memset (&flinfo
, 0, sizeof (flinfo
));
12130 flinfo
.info
= info
;
12131 flinfo
.output_bfd
= abfd
;
12132 flinfo
.symstrtab
= _bfd_elf_strtab_init ();
12133 if (flinfo
.symstrtab
== NULL
)
12138 flinfo
.hash_sec
= NULL
;
12139 flinfo
.symver_sec
= NULL
;
12143 flinfo
.hash_sec
= bfd_get_linker_section (dynobj
, ".hash");
12144 /* Note that dynsym_sec can be NULL (on VMS). */
12145 flinfo
.symver_sec
= bfd_get_linker_section (dynobj
, ".gnu.version");
12146 /* Note that it is OK if symver_sec is NULL. */
12149 if (info
->unique_symbol
12150 && !bfd_hash_table_init (&flinfo
.local_hash_table
,
12151 local_hash_newfunc
,
12152 sizeof (struct local_hash_entry
)))
12155 /* The object attributes have been merged. Remove the input
12156 sections from the link, and set the contents of the output
12158 sections_removed
= false;
12159 std_attrs_section
= get_elf_backend_data (abfd
)->obj_attrs_section
;
12160 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
12162 bool remove_section
= false;
12164 if ((std_attrs_section
&& strcmp (o
->name
, std_attrs_section
) == 0)
12165 || strcmp (o
->name
, ".gnu.attributes") == 0)
12167 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
12169 asection
*input_section
;
12171 if (p
->type
!= bfd_indirect_link_order
)
12173 input_section
= p
->u
.indirect
.section
;
12174 /* Hack: reset the SEC_HAS_CONTENTS flag so that
12175 elf_link_input_bfd ignores this section. */
12176 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
12179 attr_size
= bfd_elf_obj_attr_size (abfd
);
12180 bfd_set_section_size (o
, attr_size
);
12181 /* Skip this section later on. */
12182 o
->map_head
.link_order
= NULL
;
12186 remove_section
= true;
12188 else if ((o
->flags
& SEC_GROUP
) != 0 && o
->size
== 0)
12190 /* Remove empty group section from linker output. */
12191 remove_section
= true;
12193 if (remove_section
)
12195 o
->flags
|= SEC_EXCLUDE
;
12196 bfd_section_list_remove (abfd
, o
);
12197 abfd
->section_count
--;
12198 sections_removed
= true;
12201 if (sections_removed
)
12202 _bfd_fix_excluded_sec_syms (abfd
, info
);
12204 /* Count up the number of relocations we will output for each output
12205 section, so that we know the sizes of the reloc sections. We
12206 also figure out some maximum sizes. */
12207 max_contents_size
= 0;
12208 max_external_reloc_size
= 0;
12209 max_internal_reloc_count
= 0;
12211 max_sym_shndx_count
= 0;
12213 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
12215 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
12216 o
->reloc_count
= 0;
12218 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
12220 unsigned int reloc_count
= 0;
12221 unsigned int additional_reloc_count
= 0;
12222 struct bfd_elf_section_data
*esdi
= NULL
;
12224 if (p
->type
== bfd_section_reloc_link_order
12225 || p
->type
== bfd_symbol_reloc_link_order
)
12227 else if (p
->type
== bfd_indirect_link_order
)
12231 sec
= p
->u
.indirect
.section
;
12233 /* Mark all sections which are to be included in the
12234 link. This will normally be every section. We need
12235 to do this so that we can identify any sections which
12236 the linker has decided to not include. */
12237 sec
->linker_mark
= true;
12239 if (sec
->flags
& SEC_MERGE
)
12242 if (sec
->rawsize
> max_contents_size
)
12243 max_contents_size
= sec
->rawsize
;
12244 if (sec
->size
> max_contents_size
)
12245 max_contents_size
= sec
->size
;
12247 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
12248 && (sec
->owner
->flags
& DYNAMIC
) == 0)
12252 /* We are interested in just local symbols, not all
12254 if (elf_bad_symtab (sec
->owner
))
12255 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
12256 / bed
->s
->sizeof_sym
);
12258 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
12260 if (sym_count
> max_sym_count
)
12261 max_sym_count
= sym_count
;
12263 if (sym_count
> max_sym_shndx_count
12264 && elf_symtab_shndx_list (sec
->owner
) != NULL
)
12265 max_sym_shndx_count
= sym_count
;
12267 if (esdo
->this_hdr
.sh_type
== SHT_REL
12268 || esdo
->this_hdr
.sh_type
== SHT_RELA
)
12269 /* Some backends use reloc_count in relocation sections
12270 to count particular types of relocs. Of course,
12271 reloc sections themselves can't have relocations. */
12273 else if (emit_relocs
)
12275 reloc_count
= sec
->reloc_count
;
12276 if (bed
->elf_backend_count_additional_relocs
)
12279 c
= (*bed
->elf_backend_count_additional_relocs
) (sec
);
12280 additional_reloc_count
+= c
;
12283 else if (bed
->elf_backend_count_relocs
)
12284 reloc_count
= (*bed
->elf_backend_count_relocs
) (info
, sec
);
12286 esdi
= elf_section_data (sec
);
12288 if ((sec
->flags
& SEC_RELOC
) != 0)
12290 size_t ext_size
= 0;
12292 if (esdi
->rel
.hdr
!= NULL
)
12293 ext_size
= esdi
->rel
.hdr
->sh_size
;
12294 if (esdi
->rela
.hdr
!= NULL
)
12295 ext_size
+= esdi
->rela
.hdr
->sh_size
;
12297 if (ext_size
> max_external_reloc_size
)
12298 max_external_reloc_size
= ext_size
;
12299 if (sec
->reloc_count
> max_internal_reloc_count
)
12300 max_internal_reloc_count
= sec
->reloc_count
;
12305 if (reloc_count
== 0)
12308 reloc_count
+= additional_reloc_count
;
12309 o
->reloc_count
+= reloc_count
;
12311 if (p
->type
== bfd_indirect_link_order
&& emit_relocs
)
12315 esdo
->rel
.count
+= NUM_SHDR_ENTRIES (esdi
->rel
.hdr
);
12316 esdo
->rel
.count
+= additional_reloc_count
;
12318 if (esdi
->rela
.hdr
)
12320 esdo
->rela
.count
+= NUM_SHDR_ENTRIES (esdi
->rela
.hdr
);
12321 esdo
->rela
.count
+= additional_reloc_count
;
12327 esdo
->rela
.count
+= reloc_count
;
12329 esdo
->rel
.count
+= reloc_count
;
12333 if (o
->reloc_count
> 0)
12334 o
->flags
|= SEC_RELOC
;
12337 /* Explicitly clear the SEC_RELOC flag. The linker tends to
12338 set it (this is probably a bug) and if it is set
12339 assign_section_numbers will create a reloc section. */
12340 o
->flags
&=~ SEC_RELOC
;
12343 /* If the SEC_ALLOC flag is not set, force the section VMA to
12344 zero. This is done in elf_fake_sections as well, but forcing
12345 the VMA to 0 here will ensure that relocs against these
12346 sections are handled correctly. */
12347 if ((o
->flags
& SEC_ALLOC
) == 0
12348 && ! o
->user_set_vma
)
12352 if (! bfd_link_relocatable (info
) && merged
)
12353 elf_link_hash_traverse (htab
, _bfd_elf_link_sec_merge_syms
, abfd
);
12355 /* Figure out the file positions for everything but the symbol table
12356 and the relocs. We set symcount to force assign_section_numbers
12357 to create a symbol table. */
12358 abfd
->symcount
= info
->strip
!= strip_all
|| emit_relocs
;
12359 BFD_ASSERT (! abfd
->output_has_begun
);
12360 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
12363 /* Set sizes, and assign file positions for reloc sections. */
12364 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
12366 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
12367 if ((o
->flags
& SEC_RELOC
) != 0)
12370 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rel
)))
12374 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rela
)))
12378 /* _bfd_elf_compute_section_file_positions makes temporary use
12379 of target_index. Reset it. */
12380 o
->target_index
= 0;
12382 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
12383 to count upwards while actually outputting the relocations. */
12384 esdo
->rel
.count
= 0;
12385 esdo
->rela
.count
= 0;
12387 if ((esdo
->this_hdr
.sh_offset
== (file_ptr
) -1)
12388 && !bfd_section_is_ctf (o
))
12390 /* Cache the section contents so that they can be compressed
12391 later. Use bfd_malloc since it will be freed by
12392 bfd_compress_section_contents. */
12393 unsigned char *contents
= esdo
->this_hdr
.contents
;
12394 if ((o
->flags
& SEC_ELF_COMPRESS
) == 0 || contents
!= NULL
)
12397 = (unsigned char *) bfd_malloc (esdo
->this_hdr
.sh_size
);
12398 if (contents
== NULL
)
12400 esdo
->this_hdr
.contents
= contents
;
12404 /* We have now assigned file positions for all the sections except .symtab,
12405 .strtab, and non-loaded reloc and compressed debugging sections. We start
12406 the .symtab section at the current file position, and write directly to it.
12407 We build the .strtab section in memory. */
12408 abfd
->symcount
= 0;
12409 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
12410 /* sh_name is set in prep_headers. */
12411 symtab_hdr
->sh_type
= SHT_SYMTAB
;
12412 /* sh_flags, sh_addr and sh_size all start off zero. */
12413 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
12414 /* sh_link is set in assign_section_numbers. */
12415 /* sh_info is set below. */
12416 /* sh_offset is set just below. */
12417 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
12419 if (max_sym_count
< 20)
12420 max_sym_count
= 20;
12421 htab
->strtabsize
= max_sym_count
;
12422 amt
= max_sym_count
* sizeof (struct elf_sym_strtab
);
12423 htab
->strtab
= (struct elf_sym_strtab
*) bfd_malloc (amt
);
12424 if (htab
->strtab
== NULL
)
12426 /* The real buffer will be allocated in elf_link_swap_symbols_out. */
12428 = (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF)
12429 ? (Elf_External_Sym_Shndx
*) -1 : NULL
);
12431 if (info
->strip
!= strip_all
|| emit_relocs
)
12433 file_ptr off
= elf_next_file_pos (abfd
);
12435 _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
12437 /* Note that at this point elf_next_file_pos (abfd) is
12438 incorrect. We do not yet know the size of the .symtab section.
12439 We correct next_file_pos below, after we do know the size. */
12441 /* Start writing out the symbol table. The first symbol is always a
12443 elfsym
.st_value
= 0;
12444 elfsym
.st_size
= 0;
12445 elfsym
.st_info
= 0;
12446 elfsym
.st_other
= 0;
12447 elfsym
.st_shndx
= SHN_UNDEF
;
12448 elfsym
.st_target_internal
= 0;
12449 if (elf_link_output_symstrtab (&flinfo
, NULL
, &elfsym
,
12450 bfd_und_section_ptr
, NULL
) != 1)
12453 /* Output a symbol for each section if asked or they are used for
12454 relocs. These symbols usually have no names. We store the
12455 index of each one in the index field of the section, so that
12456 we can find it again when outputting relocs. */
12458 if (bfd_keep_unused_section_symbols (abfd
) || emit_relocs
)
12460 bool name_local_sections
12461 = (bed
->elf_backend_name_local_section_symbols
12462 && bed
->elf_backend_name_local_section_symbols (abfd
));
12463 const char *name
= NULL
;
12465 elfsym
.st_size
= 0;
12466 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
12467 elfsym
.st_other
= 0;
12468 elfsym
.st_value
= 0;
12469 elfsym
.st_target_internal
= 0;
12470 for (i
= 1; i
< elf_numsections (abfd
); i
++)
12472 o
= bfd_section_from_elf_index (abfd
, i
);
12475 o
->target_index
= bfd_get_symcount (abfd
);
12476 elfsym
.st_shndx
= i
;
12477 if (!bfd_link_relocatable (info
))
12478 elfsym
.st_value
= o
->vma
;
12479 if (name_local_sections
)
12481 if (elf_link_output_symstrtab (&flinfo
, name
, &elfsym
, o
,
12489 /* On some targets like Irix 5 the symbol split between local and global
12490 ones recorded in the sh_info field needs to be done between section
12491 and all other symbols. */
12492 if (bed
->elf_backend_elfsym_local_is_section
12493 && bed
->elf_backend_elfsym_local_is_section (abfd
))
12494 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
12496 /* Allocate some memory to hold information read in from the input
12498 if (max_contents_size
!= 0)
12500 flinfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
12501 if (flinfo
.contents
== NULL
)
12505 if (max_external_reloc_size
!= 0)
12507 flinfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
12508 if (flinfo
.external_relocs
== NULL
)
12512 if (max_internal_reloc_count
!= 0)
12514 amt
= max_internal_reloc_count
* sizeof (Elf_Internal_Rela
);
12515 flinfo
.internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
12516 if (flinfo
.internal_relocs
== NULL
)
12520 if (max_sym_count
!= 0)
12522 amt
= max_sym_count
* bed
->s
->sizeof_sym
;
12523 flinfo
.external_syms
= (bfd_byte
*) bfd_malloc (amt
);
12524 if (flinfo
.external_syms
== NULL
)
12527 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
12528 flinfo
.internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
12529 if (flinfo
.internal_syms
== NULL
)
12532 amt
= max_sym_count
* sizeof (long);
12533 flinfo
.indices
= (long int *) bfd_malloc (amt
);
12534 if (flinfo
.indices
== NULL
)
12537 amt
= max_sym_count
* sizeof (asection
*);
12538 flinfo
.sections
= (asection
**) bfd_malloc (amt
);
12539 if (flinfo
.sections
== NULL
)
12543 if (max_sym_shndx_count
!= 0)
12545 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
12546 flinfo
.locsym_shndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
12547 if (flinfo
.locsym_shndx
== NULL
)
12553 bfd_vma base
, end
= 0; /* Both bytes. */
12556 for (sec
= htab
->tls_sec
;
12557 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
12560 bfd_size_type size
= sec
->size
;
12561 unsigned int opb
= bfd_octets_per_byte (abfd
, sec
);
12564 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
12566 struct bfd_link_order
*ord
= sec
->map_tail
.link_order
;
12569 size
= ord
->offset
* opb
+ ord
->size
;
12571 end
= sec
->vma
+ size
/ opb
;
12573 base
= htab
->tls_sec
->vma
;
12574 /* Only align end of TLS section if static TLS doesn't have special
12575 alignment requirements. */
12576 if (bed
->static_tls_alignment
== 1)
12577 end
= align_power (end
, htab
->tls_sec
->alignment_power
);
12578 htab
->tls_size
= end
- base
;
12581 if (!_bfd_elf_fixup_eh_frame_hdr (info
))
12584 /* Since ELF permits relocations to be against local symbols, we
12585 must have the local symbols available when we do the relocations.
12586 Since we would rather only read the local symbols once, and we
12587 would rather not keep them in memory, we handle all the
12588 relocations for a single input file at the same time.
12590 Unfortunately, there is no way to know the total number of local
12591 symbols until we have seen all of them, and the local symbol
12592 indices precede the global symbol indices. This means that when
12593 we are generating relocatable output, and we see a reloc against
12594 a global symbol, we can not know the symbol index until we have
12595 finished examining all the local symbols to see which ones we are
12596 going to output. To deal with this, we keep the relocations in
12597 memory, and don't output them until the end of the link. This is
12598 an unfortunate waste of memory, but I don't see a good way around
12599 it. Fortunately, it only happens when performing a relocatable
12600 link, which is not the common case. FIXME: If keep_memory is set
12601 we could write the relocs out and then read them again; I don't
12602 know how bad the memory loss will be. */
12604 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
12605 sub
->output_has_begun
= false;
12606 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
12608 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
12610 if (p
->type
== bfd_indirect_link_order
12611 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
12612 == bfd_target_elf_flavour
)
12613 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
12615 if (! sub
->output_has_begun
)
12617 if (! elf_link_input_bfd (&flinfo
, sub
))
12619 sub
->output_has_begun
= true;
12622 else if (p
->type
== bfd_section_reloc_link_order
12623 || p
->type
== bfd_symbol_reloc_link_order
)
12625 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
12630 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
12632 if (p
->type
== bfd_indirect_link_order
12633 && (bfd_get_flavour (sub
)
12634 == bfd_target_elf_flavour
)
12635 && (elf_elfheader (sub
)->e_ident
[EI_CLASS
]
12636 != bed
->s
->elfclass
))
12638 const char *iclass
, *oclass
;
12640 switch (bed
->s
->elfclass
)
12642 case ELFCLASS64
: oclass
= "ELFCLASS64"; break;
12643 case ELFCLASS32
: oclass
= "ELFCLASS32"; break;
12644 case ELFCLASSNONE
: oclass
= "ELFCLASSNONE"; break;
12648 switch (elf_elfheader (sub
)->e_ident
[EI_CLASS
])
12650 case ELFCLASS64
: iclass
= "ELFCLASS64"; break;
12651 case ELFCLASS32
: iclass
= "ELFCLASS32"; break;
12652 case ELFCLASSNONE
: iclass
= "ELFCLASSNONE"; break;
12656 bfd_set_error (bfd_error_wrong_format
);
12658 /* xgettext:c-format */
12659 (_("%pB: file class %s incompatible with %s"),
12660 sub
, iclass
, oclass
);
12669 /* Free symbol buffer if needed. */
12670 if (!info
->reduce_memory_overheads
)
12672 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
12673 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
)
12675 free (elf_tdata (sub
)->symbuf
);
12676 elf_tdata (sub
)->symbuf
= NULL
;
12682 /* Output any global symbols that got converted to local in a
12683 version script or due to symbol visibility. We do this in a
12684 separate step since ELF requires all local symbols to appear
12685 prior to any global symbols. FIXME: We should only do this if
12686 some global symbols were, in fact, converted to become local.
12687 FIXME: Will this work correctly with the Irix 5 linker? */
12688 eoinfo
.failed
= false;
12689 eoinfo
.flinfo
= &flinfo
;
12690 eoinfo
.localsyms
= true;
12691 eoinfo
.file_sym_done
= false;
12692 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
12696 goto return_local_hash_table
;
12699 /* If backend needs to output some local symbols not present in the hash
12700 table, do it now. */
12701 if (bed
->elf_backend_output_arch_local_syms
12702 && (info
->strip
!= strip_all
|| emit_relocs
))
12704 if (! ((*bed
->elf_backend_output_arch_local_syms
)
12705 (abfd
, info
, &flinfo
, elf_link_output_symstrtab
)))
12708 goto return_local_hash_table
;
12712 /* That wrote out all the local symbols. Finish up the symbol table
12713 with the global symbols. Even if we want to strip everything we
12714 can, we still need to deal with those global symbols that got
12715 converted to local in a version script. */
12717 /* The sh_info field records the index of the first non local symbol. */
12718 if (!symtab_hdr
->sh_info
)
12719 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
12722 && htab
->dynsym
!= NULL
12723 && htab
->dynsym
->output_section
!= bfd_abs_section_ptr
)
12725 Elf_Internal_Sym sym
;
12726 bfd_byte
*dynsym
= htab
->dynsym
->contents
;
12728 o
= htab
->dynsym
->output_section
;
12729 elf_section_data (o
)->this_hdr
.sh_info
= htab
->local_dynsymcount
+ 1;
12731 /* Write out the section symbols for the output sections. */
12732 if (bfd_link_pic (info
)
12733 || htab
->is_relocatable_executable
)
12739 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
12741 sym
.st_target_internal
= 0;
12743 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12749 dynindx
= elf_section_data (s
)->dynindx
;
12752 indx
= elf_section_data (s
)->this_idx
;
12753 BFD_ASSERT (indx
> 0);
12754 sym
.st_shndx
= indx
;
12755 if (! check_dynsym (abfd
, &sym
))
12758 goto return_local_hash_table
;
12760 sym
.st_value
= s
->vma
;
12761 dest
= dynsym
+ dynindx
* bed
->s
->sizeof_sym
;
12763 /* Inform the linker of the addition of this symbol. */
12765 if (info
->callbacks
->ctf_new_dynsym
)
12766 info
->callbacks
->ctf_new_dynsym (dynindx
, &sym
);
12768 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
12772 /* Write out the local dynsyms. */
12773 if (htab
->dynlocal
)
12775 struct elf_link_local_dynamic_entry
*e
;
12776 for (e
= htab
->dynlocal
; e
; e
= e
->next
)
12781 /* Copy the internal symbol and turn off visibility.
12782 Note that we saved a word of storage and overwrote
12783 the original st_name with the dynstr_index. */
12785 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
12786 sym
.st_shndx
= SHN_UNDEF
;
12788 s
= bfd_section_from_elf_index (e
->input_bfd
,
12791 && s
->output_section
!= NULL
12792 && elf_section_data (s
->output_section
) != NULL
)
12795 elf_section_data (s
->output_section
)->this_idx
;
12796 if (! check_dynsym (abfd
, &sym
))
12799 goto return_local_hash_table
;
12801 sym
.st_value
= (s
->output_section
->vma
12803 + e
->isym
.st_value
);
12806 /* Inform the linker of the addition of this symbol. */
12808 if (info
->callbacks
->ctf_new_dynsym
)
12809 info
->callbacks
->ctf_new_dynsym (e
->dynindx
, &sym
);
12811 dest
= dynsym
+ e
->dynindx
* bed
->s
->sizeof_sym
;
12812 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
12817 /* We get the global symbols from the hash table. */
12818 eoinfo
.failed
= false;
12819 eoinfo
.localsyms
= false;
12820 eoinfo
.flinfo
= &flinfo
;
12821 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
12825 goto return_local_hash_table
;
12828 /* If backend needs to output some symbols not present in the hash
12829 table, do it now. */
12830 if (bed
->elf_backend_output_arch_syms
12831 && (info
->strip
!= strip_all
|| emit_relocs
))
12833 if (! ((*bed
->elf_backend_output_arch_syms
)
12834 (abfd
, info
, &flinfo
, elf_link_output_symstrtab
)))
12837 goto return_local_hash_table
;
12841 /* Finalize the .strtab section. */
12842 _bfd_elf_strtab_finalize (flinfo
.symstrtab
);
12844 /* Swap out the .strtab section. */
12845 if (!elf_link_swap_symbols_out (&flinfo
))
12848 goto return_local_hash_table
;
12851 /* Now we know the size of the symtab section. */
12852 if (bfd_get_symcount (abfd
) > 0)
12854 /* Finish up and write out the symbol string table (.strtab)
12856 Elf_Internal_Shdr
*symstrtab_hdr
= NULL
;
12857 file_ptr off
= symtab_hdr
->sh_offset
+ symtab_hdr
->sh_size
;
12859 if (elf_symtab_shndx_list (abfd
))
12861 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
12863 if (symtab_shndx_hdr
!= NULL
&& symtab_shndx_hdr
->sh_name
!= 0)
12865 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
12866 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
12867 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
12868 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
12869 symtab_shndx_hdr
->sh_size
= amt
;
12871 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
12874 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
12875 || (bfd_bwrite (flinfo
.symshndxbuf
, amt
, abfd
) != amt
))
12878 goto return_local_hash_table
;
12883 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
12884 /* sh_name was set in prep_headers. */
12885 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
12886 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
12887 symstrtab_hdr
->sh_addr
= 0;
12888 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (flinfo
.symstrtab
);
12889 symstrtab_hdr
->sh_entsize
= 0;
12890 symstrtab_hdr
->sh_link
= 0;
12891 symstrtab_hdr
->sh_info
= 0;
12892 /* sh_offset is set just below. */
12893 symstrtab_hdr
->sh_addralign
= 1;
12895 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
,
12897 elf_next_file_pos (abfd
) = off
;
12899 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
12900 || ! _bfd_elf_strtab_emit (abfd
, flinfo
.symstrtab
))
12903 goto return_local_hash_table
;
12907 if (info
->out_implib_bfd
&& !elf_output_implib (abfd
, info
))
12909 _bfd_error_handler (_("%pB: failed to generate import library"),
12910 info
->out_implib_bfd
);
12912 goto return_local_hash_table
;
12915 /* Adjust the relocs to have the correct symbol indices. */
12916 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
12918 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
12921 if ((o
->flags
& SEC_RELOC
) == 0)
12924 sort
= bed
->sort_relocs_p
== NULL
|| (*bed
->sort_relocs_p
) (o
);
12925 if (esdo
->rel
.hdr
!= NULL
12926 && !elf_link_adjust_relocs (abfd
, o
, &esdo
->rel
, sort
, info
))
12929 goto return_local_hash_table
;
12931 if (esdo
->rela
.hdr
!= NULL
12932 && !elf_link_adjust_relocs (abfd
, o
, &esdo
->rela
, sort
, info
))
12935 goto return_local_hash_table
;
12938 /* Set the reloc_count field to 0 to prevent write_relocs from
12939 trying to swap the relocs out itself. */
12940 o
->reloc_count
= 0;
12943 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
12944 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
12946 /* If we are linking against a dynamic object, or generating a
12947 shared library, finish up the dynamic linking information. */
12950 bfd_byte
*dyncon
, *dynconend
;
12952 /* Fix up .dynamic entries. */
12953 o
= bfd_get_linker_section (dynobj
, ".dynamic");
12954 BFD_ASSERT (o
!= NULL
);
12956 dyncon
= o
->contents
;
12957 dynconend
= PTR_ADD (o
->contents
, o
->size
);
12958 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
12960 Elf_Internal_Dyn dyn
;
12963 bfd_size_type sh_size
;
12966 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
12973 if (relativecount
> 0 && dyncon
+ bed
->s
->sizeof_dyn
< dynconend
)
12975 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
12977 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
12978 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
12981 dyn
.d_un
.d_val
= relativecount
;
12988 name
= info
->init_function
;
12991 name
= info
->fini_function
;
12994 struct elf_link_hash_entry
*h
;
12996 h
= elf_link_hash_lookup (htab
, name
, false, false, true);
12998 && (h
->root
.type
== bfd_link_hash_defined
12999 || h
->root
.type
== bfd_link_hash_defweak
))
13001 dyn
.d_un
.d_ptr
= h
->root
.u
.def
.value
;
13002 o
= h
->root
.u
.def
.section
;
13003 if (o
->output_section
!= NULL
)
13004 dyn
.d_un
.d_ptr
+= (o
->output_section
->vma
13005 + o
->output_offset
);
13008 /* The symbol is imported from another shared
13009 library and does not apply to this one. */
13010 dyn
.d_un
.d_ptr
= 0;
13017 case DT_PREINIT_ARRAYSZ
:
13018 name
= ".preinit_array";
13020 case DT_INIT_ARRAYSZ
:
13021 name
= ".init_array";
13023 case DT_FINI_ARRAYSZ
:
13024 name
= ".fini_array";
13026 o
= bfd_get_section_by_name (abfd
, name
);
13030 (_("could not find section %s"), name
);
13035 (_("warning: %s section has zero size"), name
);
13036 dyn
.d_un
.d_val
= o
->size
;
13039 case DT_PREINIT_ARRAY
:
13040 name
= ".preinit_array";
13042 case DT_INIT_ARRAY
:
13043 name
= ".init_array";
13045 case DT_FINI_ARRAY
:
13046 name
= ".fini_array";
13048 o
= bfd_get_section_by_name (abfd
, name
);
13055 name
= ".gnu.hash";
13064 name
= ".gnu.version_d";
13067 name
= ".gnu.version_r";
13070 name
= ".gnu.version";
13072 o
= bfd_get_linker_section (dynobj
, name
);
13074 if (o
== NULL
|| bfd_is_abs_section (o
->output_section
))
13077 (_("could not find section %s"), name
);
13080 if (elf_section_data (o
->output_section
)->this_hdr
.sh_type
== SHT_NOTE
)
13083 (_("warning: section '%s' is being made into a note"), name
);
13084 bfd_set_error (bfd_error_nonrepresentable_section
);
13087 dyn
.d_un
.d_ptr
= o
->output_section
->vma
+ o
->output_offset
;
13094 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
13100 for (i
= 1; i
< elf_numsections (abfd
); i
++)
13102 Elf_Internal_Shdr
*hdr
;
13104 hdr
= elf_elfsections (abfd
)[i
];
13105 if (hdr
->sh_type
== type
13106 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
13108 sh_size
+= hdr
->sh_size
;
13110 || sh_addr
> hdr
->sh_addr
)
13111 sh_addr
= hdr
->sh_addr
;
13115 if (bed
->dtrel_excludes_plt
&& htab
->srelplt
!= NULL
)
13117 unsigned int opb
= bfd_octets_per_byte (abfd
, o
);
13119 /* Don't count procedure linkage table relocs in the
13120 overall reloc count. */
13121 sh_size
-= htab
->srelplt
->size
;
13123 /* If the size is zero, make the address zero too.
13124 This is to avoid a glibc bug. If the backend
13125 emits DT_RELA/DT_RELASZ even when DT_RELASZ is
13126 zero, then we'll put DT_RELA at the end of
13127 DT_JMPREL. glibc will interpret the end of
13128 DT_RELA matching the end of DT_JMPREL as the
13129 case where DT_RELA includes DT_JMPREL, and for
13130 LD_BIND_NOW will decide that processing DT_RELA
13131 will process the PLT relocs too. Net result:
13132 No PLT relocs applied. */
13135 /* If .rela.plt is the first .rela section, exclude
13136 it from DT_RELA. */
13137 else if (sh_addr
== (htab
->srelplt
->output_section
->vma
13138 + htab
->srelplt
->output_offset
) * opb
)
13139 sh_addr
+= htab
->srelplt
->size
;
13142 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
13143 dyn
.d_un
.d_val
= sh_size
;
13145 dyn
.d_un
.d_ptr
= sh_addr
;
13148 bed
->s
->swap_dyn_out (dynobj
, &dyn
, dyncon
);
13152 /* If we have created any dynamic sections, then output them. */
13153 if (dynobj
!= NULL
)
13155 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
13158 /* Check for DT_TEXTREL (late, in case the backend removes it). */
13159 if (bfd_link_textrel_check (info
)
13160 && (o
= bfd_get_linker_section (dynobj
, ".dynamic")) != NULL
13163 bfd_byte
*dyncon
, *dynconend
;
13165 dyncon
= o
->contents
;
13166 dynconend
= o
->contents
+ o
->size
;
13167 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
13169 Elf_Internal_Dyn dyn
;
13171 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
13173 if (dyn
.d_tag
== DT_TEXTREL
)
13175 if (info
->textrel_check
== textrel_check_error
)
13176 info
->callbacks
->einfo
13177 (_("%P%X: read-only segment has dynamic relocations\n"));
13178 else if (bfd_link_dll (info
))
13179 info
->callbacks
->einfo
13180 (_("%P: warning: creating DT_TEXTREL in a shared object\n"));
13181 else if (bfd_link_pde (info
))
13182 info
->callbacks
->einfo
13183 (_("%P: warning: creating DT_TEXTREL in a PDE\n"));
13185 info
->callbacks
->einfo
13186 (_("%P: warning: creating DT_TEXTREL in a PIE\n"));
13192 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
13194 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
13196 || o
->output_section
== bfd_abs_section_ptr
)
13198 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
13200 /* At this point, we are only interested in sections
13201 created by _bfd_elf_link_create_dynamic_sections. */
13204 if (htab
->stab_info
.stabstr
== o
)
13206 if (htab
->eh_info
.hdr_sec
== o
)
13208 if (strcmp (o
->name
, ".dynstr") != 0)
13210 bfd_size_type octets
= ((file_ptr
) o
->output_offset
13211 * bfd_octets_per_byte (abfd
, o
));
13212 if (!bfd_set_section_contents (abfd
, o
->output_section
,
13213 o
->contents
, octets
, o
->size
))
13218 /* The contents of the .dynstr section are actually in a
13222 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
13223 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
13224 || !_bfd_elf_strtab_emit (abfd
, htab
->dynstr
))
13230 if (!info
->resolve_section_groups
)
13232 bool failed
= false;
13234 BFD_ASSERT (bfd_link_relocatable (info
));
13235 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
13240 /* If we have optimized stabs strings, output them. */
13241 if (htab
->stab_info
.stabstr
!= NULL
)
13243 if (!_bfd_write_stab_strings (abfd
, &htab
->stab_info
))
13247 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
13250 if (info
->callbacks
->emit_ctf
)
13251 info
->callbacks
->emit_ctf ();
13253 elf_final_link_free (abfd
, &flinfo
);
13257 bfd_byte
*contents
= (bfd_byte
*) bfd_malloc (attr_size
);
13258 if (contents
== NULL
)
13260 /* Bail out and fail. */
13262 goto return_local_hash_table
;
13264 bfd_elf_set_obj_attr_contents (abfd
, contents
, attr_size
);
13265 bfd_set_section_contents (abfd
, attr_section
, contents
, 0, attr_size
);
13269 return_local_hash_table
:
13270 if (info
->unique_symbol
)
13271 bfd_hash_table_free (&flinfo
.local_hash_table
);
13275 elf_final_link_free (abfd
, &flinfo
);
13277 goto return_local_hash_table
;
13280 /* Initialize COOKIE for input bfd ABFD. */
13283 init_reloc_cookie (struct elf_reloc_cookie
*cookie
,
13284 struct bfd_link_info
*info
, bfd
*abfd
)
13286 Elf_Internal_Shdr
*symtab_hdr
;
13287 const struct elf_backend_data
*bed
;
13289 bed
= get_elf_backend_data (abfd
);
13290 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
13292 cookie
->abfd
= abfd
;
13293 cookie
->sym_hashes
= elf_sym_hashes (abfd
);
13294 cookie
->bad_symtab
= elf_bad_symtab (abfd
);
13295 if (cookie
->bad_symtab
)
13297 cookie
->locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
13298 cookie
->extsymoff
= 0;
13302 cookie
->locsymcount
= symtab_hdr
->sh_info
;
13303 cookie
->extsymoff
= symtab_hdr
->sh_info
;
13306 if (bed
->s
->arch_size
== 32)
13307 cookie
->r_sym_shift
= 8;
13309 cookie
->r_sym_shift
= 32;
13311 cookie
->locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
13312 if (cookie
->locsyms
== NULL
&& cookie
->locsymcount
!= 0)
13314 cookie
->locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
13315 cookie
->locsymcount
, 0,
13317 if (cookie
->locsyms
== NULL
)
13319 info
->callbacks
->einfo (_("%P%X: can not read symbols: %E\n"));
13322 if (_bfd_link_keep_memory (info
) )
13324 symtab_hdr
->contents
= (bfd_byte
*) cookie
->locsyms
;
13325 info
->cache_size
+= (cookie
->locsymcount
13326 * sizeof (Elf_External_Sym_Shndx
));
13332 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
13335 fini_reloc_cookie (struct elf_reloc_cookie
*cookie
, bfd
*abfd
)
13337 Elf_Internal_Shdr
*symtab_hdr
;
13339 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
13340 if (symtab_hdr
->contents
!= (unsigned char *) cookie
->locsyms
)
13341 free (cookie
->locsyms
);
13344 /* Initialize the relocation information in COOKIE for input section SEC
13345 of input bfd ABFD. */
13348 init_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
13349 struct bfd_link_info
*info
, bfd
*abfd
,
13352 if (sec
->reloc_count
== 0)
13354 cookie
->rels
= NULL
;
13355 cookie
->relend
= NULL
;
13359 cookie
->rels
= _bfd_elf_link_info_read_relocs (abfd
, info
, sec
,
13361 _bfd_link_keep_memory (info
));
13362 if (cookie
->rels
== NULL
)
13364 cookie
->rel
= cookie
->rels
;
13365 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
13367 cookie
->rel
= cookie
->rels
;
13371 /* Free the memory allocated by init_reloc_cookie_rels,
13375 fini_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
13378 if (elf_section_data (sec
)->relocs
!= cookie
->rels
)
13379 free (cookie
->rels
);
13382 /* Initialize the whole of COOKIE for input section SEC. */
13385 init_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
13386 struct bfd_link_info
*info
,
13389 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
13391 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
13396 fini_reloc_cookie (cookie
, sec
->owner
);
13401 /* Free the memory allocated by init_reloc_cookie_for_section,
13405 fini_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
13408 fini_reloc_cookie_rels (cookie
, sec
);
13409 fini_reloc_cookie (cookie
, sec
->owner
);
13412 /* Garbage collect unused sections. */
13414 /* Default gc_mark_hook. */
13417 _bfd_elf_gc_mark_hook (asection
*sec
,
13418 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
13419 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
13420 struct elf_link_hash_entry
*h
,
13421 Elf_Internal_Sym
*sym
)
13425 switch (h
->root
.type
)
13427 case bfd_link_hash_defined
:
13428 case bfd_link_hash_defweak
:
13429 return h
->root
.u
.def
.section
;
13431 case bfd_link_hash_common
:
13432 return h
->root
.u
.c
.p
->section
;
13439 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
13444 /* Return the debug definition section. */
13447 elf_gc_mark_debug_section (asection
*sec ATTRIBUTE_UNUSED
,
13448 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
13449 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
13450 struct elf_link_hash_entry
*h
,
13451 Elf_Internal_Sym
*sym
)
13455 /* Return the global debug definition section. */
13456 if ((h
->root
.type
== bfd_link_hash_defined
13457 || h
->root
.type
== bfd_link_hash_defweak
)
13458 && (h
->root
.u
.def
.section
->flags
& SEC_DEBUGGING
) != 0)
13459 return h
->root
.u
.def
.section
;
13463 /* Return the local debug definition section. */
13464 asection
*isec
= bfd_section_from_elf_index (sec
->owner
,
13466 if ((isec
->flags
& SEC_DEBUGGING
) != 0)
13473 /* COOKIE->rel describes a relocation against section SEC, which is
13474 a section we've decided to keep. Return the section that contains
13475 the relocation symbol, or NULL if no section contains it. */
13478 _bfd_elf_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
13479 elf_gc_mark_hook_fn gc_mark_hook
,
13480 struct elf_reloc_cookie
*cookie
,
13483 unsigned long r_symndx
;
13484 struct elf_link_hash_entry
*h
, *hw
;
13486 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
13487 if (r_symndx
== STN_UNDEF
)
13490 if (r_symndx
>= cookie
->locsymcount
13491 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
13495 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
13498 info
->callbacks
->einfo (_("%F%P: corrupt input: %pB\n"),
13502 while (h
->root
.type
== bfd_link_hash_indirect
13503 || h
->root
.type
== bfd_link_hash_warning
)
13504 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
13506 was_marked
= h
->mark
;
13508 /* Keep all aliases of the symbol too. If an object symbol
13509 needs to be copied into .dynbss then all of its aliases
13510 should be present as dynamic symbols, not just the one used
13511 on the copy relocation. */
13513 while (hw
->is_weakalias
)
13519 if (!was_marked
&& h
->start_stop
&& !h
->root
.ldscript_def
)
13521 if (info
->start_stop_gc
)
13524 /* To work around a glibc bug, mark XXX input sections
13525 when there is a reference to __start_XXX or __stop_XXX
13527 else if (start_stop
!= NULL
)
13529 asection
*s
= h
->u2
.start_stop_section
;
13530 *start_stop
= true;
13535 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
13538 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
13539 &cookie
->locsyms
[r_symndx
]);
13542 /* COOKIE->rel describes a relocation against section SEC, which is
13543 a section we've decided to keep. Mark the section that contains
13544 the relocation symbol. */
13547 _bfd_elf_gc_mark_reloc (struct bfd_link_info
*info
,
13549 elf_gc_mark_hook_fn gc_mark_hook
,
13550 struct elf_reloc_cookie
*cookie
)
13553 bool start_stop
= false;
13555 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
, &start_stop
);
13556 while (rsec
!= NULL
)
13558 if (!rsec
->gc_mark
)
13560 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
13561 || (rsec
->owner
->flags
& DYNAMIC
) != 0)
13563 else if (!_bfd_elf_gc_mark (info
, rsec
, gc_mark_hook
))
13568 rsec
= bfd_get_next_section_by_name (rsec
->owner
, rsec
);
13573 /* The mark phase of garbage collection. For a given section, mark
13574 it and any sections in this section's group, and all the sections
13575 which define symbols to which it refers. */
13578 _bfd_elf_gc_mark (struct bfd_link_info
*info
,
13580 elf_gc_mark_hook_fn gc_mark_hook
)
13583 asection
*group_sec
, *eh_frame
;
13587 /* Mark all the sections in the group. */
13588 group_sec
= elf_section_data (sec
)->next_in_group
;
13589 if (group_sec
&& !group_sec
->gc_mark
)
13590 if (!_bfd_elf_gc_mark (info
, group_sec
, gc_mark_hook
))
13593 /* Look through the section relocs. */
13595 eh_frame
= elf_eh_frame_section (sec
->owner
);
13596 if ((sec
->flags
& SEC_RELOC
) != 0
13597 && sec
->reloc_count
> 0
13598 && sec
!= eh_frame
)
13600 struct elf_reloc_cookie cookie
;
13602 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
13606 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
13607 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
13612 fini_reloc_cookie_for_section (&cookie
, sec
);
13616 if (ret
&& eh_frame
&& elf_fde_list (sec
))
13618 struct elf_reloc_cookie cookie
;
13620 if (!init_reloc_cookie_for_section (&cookie
, info
, eh_frame
))
13624 if (!_bfd_elf_gc_mark_fdes (info
, sec
, eh_frame
,
13625 gc_mark_hook
, &cookie
))
13627 fini_reloc_cookie_for_section (&cookie
, eh_frame
);
13631 eh_frame
= elf_section_eh_frame_entry (sec
);
13632 if (ret
&& eh_frame
&& !eh_frame
->gc_mark
)
13633 if (!_bfd_elf_gc_mark (info
, eh_frame
, gc_mark_hook
))
13639 /* Scan and mark sections in a special or debug section group. */
13642 _bfd_elf_gc_mark_debug_special_section_group (asection
*grp
)
13644 /* Point to first section of section group. */
13646 /* Used to iterate the section group. */
13649 bool is_special_grp
= true;
13650 bool is_debug_grp
= true;
13652 /* First scan to see if group contains any section other than debug
13653 and special section. */
13654 ssec
= msec
= elf_next_in_group (grp
);
13657 if ((msec
->flags
& SEC_DEBUGGING
) == 0)
13658 is_debug_grp
= false;
13660 if ((msec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) != 0)
13661 is_special_grp
= false;
13663 msec
= elf_next_in_group (msec
);
13665 while (msec
!= ssec
);
13667 /* If this is a pure debug section group or pure special section group,
13668 keep all sections in this group. */
13669 if (is_debug_grp
|| is_special_grp
)
13674 msec
= elf_next_in_group (msec
);
13676 while (msec
!= ssec
);
13680 /* Keep debug and special sections. */
13683 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
13684 elf_gc_mark_hook_fn mark_hook
)
13688 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
13692 bool debug_frag_seen
;
13693 bool has_kept_debug_info
;
13695 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
13697 isec
= ibfd
->sections
;
13698 if (isec
== NULL
|| isec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
13701 /* Ensure all linker created sections are kept,
13702 see if any other section is already marked,
13703 and note if we have any fragmented debug sections. */
13704 debug_frag_seen
= some_kept
= has_kept_debug_info
= false;
13705 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
13707 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
13709 else if (isec
->gc_mark
13710 && (isec
->flags
& SEC_ALLOC
) != 0
13711 && elf_section_type (isec
) != SHT_NOTE
)
13715 /* Since all sections, except for backend specific ones,
13716 have been garbage collected, call mark_hook on this
13717 section if any of its linked-to sections is marked. */
13718 asection
*linked_to_sec
;
13719 for (linked_to_sec
= elf_linked_to_section (isec
);
13720 linked_to_sec
!= NULL
&& !linked_to_sec
->linker_mark
;
13721 linked_to_sec
= elf_linked_to_section (linked_to_sec
))
13723 if (linked_to_sec
->gc_mark
)
13725 if (!_bfd_elf_gc_mark (info
, isec
, mark_hook
))
13729 linked_to_sec
->linker_mark
= 1;
13731 for (linked_to_sec
= elf_linked_to_section (isec
);
13732 linked_to_sec
!= NULL
&& linked_to_sec
->linker_mark
;
13733 linked_to_sec
= elf_linked_to_section (linked_to_sec
))
13734 linked_to_sec
->linker_mark
= 0;
13737 if (!debug_frag_seen
13738 && (isec
->flags
& SEC_DEBUGGING
)
13739 && startswith (isec
->name
, ".debug_line."))
13740 debug_frag_seen
= true;
13741 else if (strcmp (bfd_section_name (isec
),
13742 "__patchable_function_entries") == 0
13743 && elf_linked_to_section (isec
) == NULL
)
13744 info
->callbacks
->einfo (_("%F%P: %pB(%pA): error: "
13745 "need linked-to section "
13746 "for --gc-sections\n"),
13747 isec
->owner
, isec
);
13750 /* If no non-note alloc section in this file will be kept, then
13751 we can toss out the debug and special sections. */
13755 /* Keep debug and special sections like .comment when they are
13756 not part of a group. Also keep section groups that contain
13757 just debug sections or special sections. NB: Sections with
13758 linked-to section has been handled above. */
13759 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
13761 if ((isec
->flags
& SEC_GROUP
) != 0)
13762 _bfd_elf_gc_mark_debug_special_section_group (isec
);
13763 else if (((isec
->flags
& SEC_DEBUGGING
) != 0
13764 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
13765 && elf_next_in_group (isec
) == NULL
13766 && elf_linked_to_section (isec
) == NULL
)
13768 if (isec
->gc_mark
&& (isec
->flags
& SEC_DEBUGGING
) != 0)
13769 has_kept_debug_info
= true;
13772 /* Look for CODE sections which are going to be discarded,
13773 and find and discard any fragmented debug sections which
13774 are associated with that code section. */
13775 if (debug_frag_seen
)
13776 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
13777 if ((isec
->flags
& SEC_CODE
) != 0
13778 && isec
->gc_mark
== 0)
13783 ilen
= strlen (isec
->name
);
13785 /* Association is determined by the name of the debug
13786 section containing the name of the code section as
13787 a suffix. For example .debug_line.text.foo is a
13788 debug section associated with .text.foo. */
13789 for (dsec
= ibfd
->sections
; dsec
!= NULL
; dsec
= dsec
->next
)
13793 if (dsec
->gc_mark
== 0
13794 || (dsec
->flags
& SEC_DEBUGGING
) == 0)
13797 dlen
= strlen (dsec
->name
);
13800 && strncmp (dsec
->name
+ (dlen
- ilen
),
13801 isec
->name
, ilen
) == 0)
13806 /* Mark debug sections referenced by kept debug sections. */
13807 if (has_kept_debug_info
)
13808 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
13810 && (isec
->flags
& SEC_DEBUGGING
) != 0)
13811 if (!_bfd_elf_gc_mark (info
, isec
,
13812 elf_gc_mark_debug_section
))
13819 elf_gc_sweep (bfd
*abfd
, struct bfd_link_info
*info
)
13822 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13824 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
13828 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
13829 || elf_object_id (sub
) != elf_hash_table_id (elf_hash_table (info
))
13830 || !(*bed
->relocs_compatible
) (sub
->xvec
, abfd
->xvec
))
13833 if (o
== NULL
|| o
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
13836 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
13838 /* When any section in a section group is kept, we keep all
13839 sections in the section group. If the first member of
13840 the section group is excluded, we will also exclude the
13842 if (o
->flags
& SEC_GROUP
)
13844 asection
*first
= elf_next_in_group (o
);
13845 o
->gc_mark
= first
->gc_mark
;
13851 /* Skip sweeping sections already excluded. */
13852 if (o
->flags
& SEC_EXCLUDE
)
13855 /* Since this is early in the link process, it is simple
13856 to remove a section from the output. */
13857 o
->flags
|= SEC_EXCLUDE
;
13859 if (info
->print_gc_sections
&& o
->size
!= 0)
13860 /* xgettext:c-format */
13861 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
13869 /* Propagate collected vtable information. This is called through
13870 elf_link_hash_traverse. */
13873 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
13875 /* Those that are not vtables. */
13877 || h
->u2
.vtable
== NULL
13878 || h
->u2
.vtable
->parent
== NULL
)
13881 /* Those vtables that do not have parents, we cannot merge. */
13882 if (h
->u2
.vtable
->parent
== (struct elf_link_hash_entry
*) -1)
13885 /* If we've already been done, exit. */
13886 if (h
->u2
.vtable
->used
&& h
->u2
.vtable
->used
[-1])
13889 /* Make sure the parent's table is up to date. */
13890 elf_gc_propagate_vtable_entries_used (h
->u2
.vtable
->parent
, okp
);
13892 if (h
->u2
.vtable
->used
== NULL
)
13894 /* None of this table's entries were referenced. Re-use the
13896 h
->u2
.vtable
->used
= h
->u2
.vtable
->parent
->u2
.vtable
->used
;
13897 h
->u2
.vtable
->size
= h
->u2
.vtable
->parent
->u2
.vtable
->size
;
13904 /* Or the parent's entries into ours. */
13905 cu
= h
->u2
.vtable
->used
;
13907 pu
= h
->u2
.vtable
->parent
->u2
.vtable
->used
;
13910 const struct elf_backend_data
*bed
;
13911 unsigned int log_file_align
;
13913 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
13914 log_file_align
= bed
->s
->log_file_align
;
13915 n
= h
->u2
.vtable
->parent
->u2
.vtable
->size
>> log_file_align
;
13929 struct link_info_ok
13931 struct bfd_link_info
*info
;
13936 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
,
13940 bfd_vma hstart
, hend
;
13941 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
13942 const struct elf_backend_data
*bed
;
13943 unsigned int log_file_align
;
13944 struct link_info_ok
*info
= (struct link_info_ok
*) ptr
;
13946 /* Take care of both those symbols that do not describe vtables as
13947 well as those that are not loaded. */
13949 || h
->u2
.vtable
== NULL
13950 || h
->u2
.vtable
->parent
== NULL
)
13953 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
13954 || h
->root
.type
== bfd_link_hash_defweak
);
13956 sec
= h
->root
.u
.def
.section
;
13957 hstart
= h
->root
.u
.def
.value
;
13958 hend
= hstart
+ h
->size
;
13960 relstart
= _bfd_elf_link_info_read_relocs (sec
->owner
, info
->info
,
13961 sec
, NULL
, NULL
, true);
13963 return info
->ok
= false;
13964 bed
= get_elf_backend_data (sec
->owner
);
13965 log_file_align
= bed
->s
->log_file_align
;
13967 relend
= relstart
+ sec
->reloc_count
;
13969 for (rel
= relstart
; rel
< relend
; ++rel
)
13970 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
13972 /* If the entry is in use, do nothing. */
13973 if (h
->u2
.vtable
->used
13974 && (rel
->r_offset
- hstart
) < h
->u2
.vtable
->size
)
13976 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
13977 if (h
->u2
.vtable
->used
[entry
])
13980 /* Otherwise, kill it. */
13981 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
13987 /* Mark sections containing dynamically referenced symbols. When
13988 building shared libraries, we must assume that any visible symbol is
13992 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry
*h
, void *inf
)
13994 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
13995 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
13997 if ((h
->root
.type
== bfd_link_hash_defined
13998 || h
->root
.type
== bfd_link_hash_defweak
)
14000 || h
->root
.ldscript_def
14001 || !info
->start_stop_gc
)
14002 && ((h
->ref_dynamic
&& !h
->forced_local
)
14003 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
14004 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
14005 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
14006 && (!bfd_link_executable (info
)
14007 || info
->gc_keep_exported
14008 || info
->export_dynamic
14011 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
14012 && (h
->versioned
>= versioned
14013 || !bfd_hide_sym_by_version (info
->version_info
,
14014 h
->root
.root
.string
)))))
14015 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
14020 /* Keep all sections containing symbols undefined on the command-line,
14021 and the section containing the entry symbol. */
14024 _bfd_elf_gc_keep (struct bfd_link_info
*info
)
14026 struct bfd_sym_chain
*sym
;
14028 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
14030 struct elf_link_hash_entry
*h
;
14032 h
= elf_link_hash_lookup (elf_hash_table (info
), sym
->name
,
14033 false, false, false);
14036 && (h
->root
.type
== bfd_link_hash_defined
14037 || h
->root
.type
== bfd_link_hash_defweak
)
14038 && !bfd_is_const_section (h
->root
.u
.def
.section
))
14039 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
14044 bfd_elf_parse_eh_frame_entries (bfd
*abfd ATTRIBUTE_UNUSED
,
14045 struct bfd_link_info
*info
)
14047 bfd
*ibfd
= info
->input_bfds
;
14049 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
14052 struct elf_reloc_cookie cookie
;
14054 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
14056 sec
= ibfd
->sections
;
14057 if (sec
== NULL
|| sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
14060 if (!init_reloc_cookie (&cookie
, info
, ibfd
))
14063 for (sec
= ibfd
->sections
; sec
; sec
= sec
->next
)
14065 if (startswith (bfd_section_name (sec
), ".eh_frame_entry")
14066 && init_reloc_cookie_rels (&cookie
, info
, ibfd
, sec
))
14068 _bfd_elf_parse_eh_frame_entry (info
, sec
, &cookie
);
14069 fini_reloc_cookie_rels (&cookie
, sec
);
14076 /* Do mark and sweep of unused sections. */
14079 bfd_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
14083 elf_gc_mark_hook_fn gc_mark_hook
;
14084 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14085 struct elf_link_hash_table
*htab
;
14086 struct link_info_ok info_ok
;
14088 if (!bed
->can_gc_sections
14089 || !is_elf_hash_table (info
->hash
))
14091 _bfd_error_handler(_("warning: gc-sections option ignored"));
14095 bed
->gc_keep (info
);
14096 htab
= elf_hash_table (info
);
14098 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
14099 at the .eh_frame section if we can mark the FDEs individually. */
14100 for (sub
= info
->input_bfds
;
14101 info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
&& sub
!= NULL
;
14102 sub
= sub
->link
.next
)
14105 struct elf_reloc_cookie cookie
;
14107 sec
= sub
->sections
;
14108 if (sec
== NULL
|| sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
14110 sec
= bfd_get_section_by_name (sub
, ".eh_frame");
14111 while (sec
&& init_reloc_cookie_for_section (&cookie
, info
, sec
))
14113 _bfd_elf_parse_eh_frame (sub
, info
, sec
, &cookie
);
14114 if (elf_section_data (sec
)->sec_info
14115 && (sec
->flags
& SEC_LINKER_CREATED
) == 0)
14116 elf_eh_frame_section (sub
) = sec
;
14117 fini_reloc_cookie_for_section (&cookie
, sec
);
14118 sec
= bfd_get_next_section_by_name (NULL
, sec
);
14122 /* Apply transitive closure to the vtable entry usage info. */
14123 elf_link_hash_traverse (htab
, elf_gc_propagate_vtable_entries_used
, &ok
);
14127 /* Kill the vtable relocations that were not used. */
14128 info_ok
.info
= info
;
14130 elf_link_hash_traverse (htab
, elf_gc_smash_unused_vtentry_relocs
, &info_ok
);
14134 /* Mark dynamically referenced symbols. */
14135 if (htab
->dynamic_sections_created
|| info
->gc_keep_exported
)
14136 elf_link_hash_traverse (htab
, bed
->gc_mark_dynamic_ref
, info
);
14138 /* Grovel through relocs to find out who stays ... */
14139 gc_mark_hook
= bed
->gc_mark_hook
;
14140 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
14144 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
14145 || elf_object_id (sub
) != elf_hash_table_id (htab
)
14146 || !(*bed
->relocs_compatible
) (sub
->xvec
, abfd
->xvec
))
14150 if (o
== NULL
|| o
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
14153 /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
14154 Also treat note sections as a root, if the section is not part
14155 of a group. We must keep all PREINIT_ARRAY, INIT_ARRAY as
14156 well as FINI_ARRAY sections for ld -r. */
14157 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
14159 && (o
->flags
& SEC_EXCLUDE
) == 0
14160 && ((o
->flags
& SEC_KEEP
) != 0
14161 || (bfd_link_relocatable (info
)
14162 && ((elf_section_data (o
)->this_hdr
.sh_type
14163 == SHT_PREINIT_ARRAY
)
14164 || (elf_section_data (o
)->this_hdr
.sh_type
14166 || (elf_section_data (o
)->this_hdr
.sh_type
14167 == SHT_FINI_ARRAY
)))
14168 || (elf_section_data (o
)->this_hdr
.sh_type
== SHT_NOTE
14169 && elf_next_in_group (o
) == NULL
14170 && elf_linked_to_section (o
) == NULL
)
14171 || ((elf_tdata (sub
)->has_gnu_osabi
& elf_gnu_osabi_retain
)
14172 && (elf_section_flags (o
) & SHF_GNU_RETAIN
))))
14174 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
14179 /* Allow the backend to mark additional target specific sections. */
14180 bed
->gc_mark_extra_sections (info
, gc_mark_hook
);
14182 /* ... and mark SEC_EXCLUDE for those that go. */
14183 return elf_gc_sweep (abfd
, info
);
14186 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
14189 bfd_elf_gc_record_vtinherit (bfd
*abfd
,
14191 struct elf_link_hash_entry
*h
,
14194 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
14195 struct elf_link_hash_entry
**search
, *child
;
14196 size_t extsymcount
;
14197 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14199 /* The sh_info field of the symtab header tells us where the
14200 external symbols start. We don't care about the local symbols at
14202 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/ bed
->s
->sizeof_sym
;
14203 if (!elf_bad_symtab (abfd
))
14204 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
14206 sym_hashes
= elf_sym_hashes (abfd
);
14207 sym_hashes_end
= PTR_ADD (sym_hashes
, extsymcount
);
14209 /* Hunt down the child symbol, which is in this section at the same
14210 offset as the relocation. */
14211 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
14213 if ((child
= *search
) != NULL
14214 && (child
->root
.type
== bfd_link_hash_defined
14215 || child
->root
.type
== bfd_link_hash_defweak
)
14216 && child
->root
.u
.def
.section
== sec
14217 && child
->root
.u
.def
.value
== offset
)
14221 /* xgettext:c-format */
14222 _bfd_error_handler (_("%pB: %pA+%#" PRIx64
": no symbol found for INHERIT"),
14223 abfd
, sec
, (uint64_t) offset
);
14224 bfd_set_error (bfd_error_invalid_operation
);
14228 if (!child
->u2
.vtable
)
14230 child
->u2
.vtable
= ((struct elf_link_virtual_table_entry
*)
14231 bfd_zalloc (abfd
, sizeof (*child
->u2
.vtable
)));
14232 if (!child
->u2
.vtable
)
14237 /* This *should* only be the absolute section. It could potentially
14238 be that someone has defined a non-global vtable though, which
14239 would be bad. It isn't worth paging in the local symbols to be
14240 sure though; that case should simply be handled by the assembler. */
14242 child
->u2
.vtable
->parent
= (struct elf_link_hash_entry
*) -1;
14245 child
->u2
.vtable
->parent
= h
;
14250 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
14253 bfd_elf_gc_record_vtentry (bfd
*abfd
, asection
*sec
,
14254 struct elf_link_hash_entry
*h
,
14257 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14258 unsigned int log_file_align
= bed
->s
->log_file_align
;
14262 /* xgettext:c-format */
14263 _bfd_error_handler (_("%pB: section '%pA': corrupt VTENTRY entry"),
14265 bfd_set_error (bfd_error_bad_value
);
14271 h
->u2
.vtable
= ((struct elf_link_virtual_table_entry
*)
14272 bfd_zalloc (abfd
, sizeof (*h
->u2
.vtable
)));
14277 if (addend
>= h
->u2
.vtable
->size
)
14279 size_t size
, bytes
, file_align
;
14280 bool *ptr
= h
->u2
.vtable
->used
;
14282 /* While the symbol is undefined, we have to be prepared to handle
14284 file_align
= 1 << log_file_align
;
14285 if (h
->root
.type
== bfd_link_hash_undefined
)
14286 size
= addend
+ file_align
;
14290 if (addend
>= size
)
14292 /* Oops! We've got a reference past the defined end of
14293 the table. This is probably a bug -- shall we warn? */
14294 size
= addend
+ file_align
;
14297 size
= (size
+ file_align
- 1) & -file_align
;
14299 /* Allocate one extra entry for use as a "done" flag for the
14300 consolidation pass. */
14301 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bool);
14305 ptr
= (bool *) bfd_realloc (ptr
- 1, bytes
);
14311 oldbytes
= (((h
->u2
.vtable
->size
>> log_file_align
) + 1)
14313 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
14317 ptr
= (bool *) bfd_zmalloc (bytes
);
14322 /* And arrange for that done flag to be at index -1. */
14323 h
->u2
.vtable
->used
= ptr
+ 1;
14324 h
->u2
.vtable
->size
= size
;
14327 h
->u2
.vtable
->used
[addend
>> log_file_align
] = true;
14332 /* Map an ELF section header flag to its corresponding string. */
14336 flagword flag_value
;
14337 } elf_flags_to_name_table
;
14339 static const elf_flags_to_name_table elf_flags_to_names
[] =
14341 { "SHF_WRITE", SHF_WRITE
},
14342 { "SHF_ALLOC", SHF_ALLOC
},
14343 { "SHF_EXECINSTR", SHF_EXECINSTR
},
14344 { "SHF_MERGE", SHF_MERGE
},
14345 { "SHF_STRINGS", SHF_STRINGS
},
14346 { "SHF_INFO_LINK", SHF_INFO_LINK
},
14347 { "SHF_LINK_ORDER", SHF_LINK_ORDER
},
14348 { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING
},
14349 { "SHF_GROUP", SHF_GROUP
},
14350 { "SHF_TLS", SHF_TLS
},
14351 { "SHF_MASKOS", SHF_MASKOS
},
14352 { "SHF_EXCLUDE", SHF_EXCLUDE
},
14355 /* Returns TRUE if the section is to be included, otherwise FALSE. */
14357 bfd_elf_lookup_section_flags (struct bfd_link_info
*info
,
14358 struct flag_info
*flaginfo
,
14361 const bfd_vma sh_flags
= elf_section_flags (section
);
14363 if (!flaginfo
->flags_initialized
)
14365 bfd
*obfd
= info
->output_bfd
;
14366 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
14367 struct flag_info_list
*tf
= flaginfo
->flag_list
;
14369 int without_hex
= 0;
14371 for (tf
= flaginfo
->flag_list
; tf
!= NULL
; tf
= tf
->next
)
14374 flagword (*lookup
) (char *);
14376 lookup
= bed
->elf_backend_lookup_section_flags_hook
;
14377 if (lookup
!= NULL
)
14379 flagword hexval
= (*lookup
) ((char *) tf
->name
);
14383 if (tf
->with
== with_flags
)
14384 with_hex
|= hexval
;
14385 else if (tf
->with
== without_flags
)
14386 without_hex
|= hexval
;
14391 for (i
= 0; i
< ARRAY_SIZE (elf_flags_to_names
); ++i
)
14393 if (strcmp (tf
->name
, elf_flags_to_names
[i
].flag_name
) == 0)
14395 if (tf
->with
== with_flags
)
14396 with_hex
|= elf_flags_to_names
[i
].flag_value
;
14397 else if (tf
->with
== without_flags
)
14398 without_hex
|= elf_flags_to_names
[i
].flag_value
;
14405 info
->callbacks
->einfo
14406 (_("unrecognized INPUT_SECTION_FLAG %s\n"), tf
->name
);
14410 flaginfo
->flags_initialized
= true;
14411 flaginfo
->only_with_flags
|= with_hex
;
14412 flaginfo
->not_with_flags
|= without_hex
;
14415 if ((flaginfo
->only_with_flags
& sh_flags
) != flaginfo
->only_with_flags
)
14418 if ((flaginfo
->not_with_flags
& sh_flags
) != 0)
14424 struct alloc_got_off_arg
{
14426 struct bfd_link_info
*info
;
14429 /* We need a special top-level link routine to convert got reference counts
14430 to real got offsets. */
14433 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *arg
)
14435 struct alloc_got_off_arg
*gofarg
= (struct alloc_got_off_arg
*) arg
;
14436 bfd
*obfd
= gofarg
->info
->output_bfd
;
14437 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
14439 if (h
->got
.refcount
> 0)
14441 h
->got
.offset
= gofarg
->gotoff
;
14442 gofarg
->gotoff
+= bed
->got_elt_size (obfd
, gofarg
->info
, h
, NULL
, 0);
14445 h
->got
.offset
= (bfd_vma
) -1;
14450 /* And an accompanying bit to work out final got entry offsets once
14451 we're done. Should be called from final_link. */
14454 bfd_elf_gc_common_finalize_got_offsets (bfd
*abfd
,
14455 struct bfd_link_info
*info
)
14458 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14460 struct alloc_got_off_arg gofarg
;
14462 BFD_ASSERT (abfd
== info
->output_bfd
);
14464 if (! is_elf_hash_table (info
->hash
))
14467 /* The GOT offset is relative to the .got section, but the GOT header is
14468 put into the .got.plt section, if the backend uses it. */
14469 if (bed
->want_got_plt
)
14472 gotoff
= bed
->got_header_size
;
14474 /* Do the local .got entries first. */
14475 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
14477 bfd_signed_vma
*local_got
;
14478 size_t j
, locsymcount
;
14479 Elf_Internal_Shdr
*symtab_hdr
;
14481 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
14484 local_got
= elf_local_got_refcounts (i
);
14488 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
14489 if (elf_bad_symtab (i
))
14490 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
14492 locsymcount
= symtab_hdr
->sh_info
;
14494 for (j
= 0; j
< locsymcount
; ++j
)
14496 if (local_got
[j
] > 0)
14498 local_got
[j
] = gotoff
;
14499 gotoff
+= bed
->got_elt_size (abfd
, info
, NULL
, i
, j
);
14502 local_got
[j
] = (bfd_vma
) -1;
14506 /* Then the global .got entries. .plt refcounts are handled by
14507 adjust_dynamic_symbol */
14508 gofarg
.gotoff
= gotoff
;
14509 gofarg
.info
= info
;
14510 elf_link_hash_traverse (elf_hash_table (info
),
14511 elf_gc_allocate_got_offsets
,
14516 /* Many folk need no more in the way of final link than this, once
14517 got entry reference counting is enabled. */
14520 bfd_elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
14522 if (!bfd_elf_gc_common_finalize_got_offsets (abfd
, info
))
14525 /* Invoke the regular ELF backend linker to do all the work. */
14526 return bfd_elf_final_link (abfd
, info
);
14530 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
14532 struct elf_reloc_cookie
*rcookie
= (struct elf_reloc_cookie
*) cookie
;
14534 if (rcookie
->bad_symtab
)
14535 rcookie
->rel
= rcookie
->rels
;
14537 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
14539 unsigned long r_symndx
;
14541 if (! rcookie
->bad_symtab
)
14542 if (rcookie
->rel
->r_offset
> offset
)
14544 if (rcookie
->rel
->r_offset
!= offset
)
14547 r_symndx
= rcookie
->rel
->r_info
>> rcookie
->r_sym_shift
;
14548 if (r_symndx
== STN_UNDEF
)
14551 if (r_symndx
>= rcookie
->locsymcount
14552 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
14554 struct elf_link_hash_entry
*h
;
14556 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
14558 while (h
->root
.type
== bfd_link_hash_indirect
14559 || h
->root
.type
== bfd_link_hash_warning
)
14560 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
14562 if ((h
->root
.type
== bfd_link_hash_defined
14563 || h
->root
.type
== bfd_link_hash_defweak
)
14564 && (h
->root
.u
.def
.section
->owner
!= rcookie
->abfd
14565 || h
->root
.u
.def
.section
->kept_section
!= NULL
14566 || discarded_section (h
->root
.u
.def
.section
)))
14571 /* It's not a relocation against a global symbol,
14572 but it could be a relocation against a local
14573 symbol for a discarded section. */
14575 Elf_Internal_Sym
*isym
;
14577 /* Need to: get the symbol; get the section. */
14578 isym
= &rcookie
->locsyms
[r_symndx
];
14579 isec
= bfd_section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
14581 && (isec
->kept_section
!= NULL
14582 || discarded_section (isec
)))
14590 /* Discard unneeded references to discarded sections.
14591 Returns -1 on error, 1 if any section's size was changed, 0 if
14592 nothing changed. This function assumes that the relocations are in
14593 sorted order, which is true for all known assemblers. */
14596 bfd_elf_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
14598 struct elf_reloc_cookie cookie
;
14603 if (info
->traditional_format
14604 || !is_elf_hash_table (info
->hash
))
14607 o
= bfd_get_section_by_name (output_bfd
, ".stab");
14612 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
14615 || i
->reloc_count
== 0
14616 || i
->sec_info_type
!= SEC_INFO_TYPE_STABS
)
14620 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
14623 if (!init_reloc_cookie_for_section (&cookie
, info
, i
))
14626 if (_bfd_discard_section_stabs (abfd
, i
,
14627 elf_section_data (i
)->sec_info
,
14628 bfd_elf_reloc_symbol_deleted_p
,
14632 fini_reloc_cookie_for_section (&cookie
, i
);
14637 if (info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
)
14638 o
= bfd_get_section_by_name (output_bfd
, ".eh_frame");
14642 int eh_changed
= 0;
14643 unsigned int eh_alignment
; /* Octets. */
14645 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
14651 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
14654 if (!init_reloc_cookie_for_section (&cookie
, info
, i
))
14657 _bfd_elf_parse_eh_frame (abfd
, info
, i
, &cookie
);
14658 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, i
,
14659 bfd_elf_reloc_symbol_deleted_p
,
14663 if (i
->size
!= i
->rawsize
)
14667 fini_reloc_cookie_for_section (&cookie
, i
);
14670 eh_alignment
= ((1 << o
->alignment_power
)
14671 * bfd_octets_per_byte (output_bfd
, o
));
14672 /* Skip over zero terminator, and prevent empty sections from
14673 adding alignment padding at the end. */
14674 for (i
= o
->map_tail
.s
; i
!= NULL
; i
= i
->map_tail
.s
)
14676 i
->flags
|= SEC_EXCLUDE
;
14677 else if (i
->size
> 4)
14679 /* The last non-empty eh_frame section doesn't need padding. */
14682 /* Any prior sections must pad the last FDE out to the output
14683 section alignment. Otherwise we might have zero padding
14684 between sections, which would be seen as a terminator. */
14685 for (; i
!= NULL
; i
= i
->map_tail
.s
)
14687 /* All but the last zero terminator should have been removed. */
14692 = (i
->size
+ eh_alignment
- 1) & -eh_alignment
;
14693 if (i
->size
!= size
)
14701 elf_link_hash_traverse (elf_hash_table (info
),
14702 _bfd_elf_adjust_eh_frame_global_symbol
, NULL
);
14705 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
14707 const struct elf_backend_data
*bed
;
14710 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
14712 s
= abfd
->sections
;
14713 if (s
== NULL
|| s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
14716 bed
= get_elf_backend_data (abfd
);
14718 if (bed
->elf_backend_discard_info
!= NULL
)
14720 if (!init_reloc_cookie (&cookie
, info
, abfd
))
14723 if ((*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
14726 fini_reloc_cookie (&cookie
, abfd
);
14730 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
14731 _bfd_elf_end_eh_frame_parsing (info
);
14733 if (info
->eh_frame_hdr_type
14734 && !bfd_link_relocatable (info
)
14735 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
14742 _bfd_elf_section_already_linked (bfd
*abfd
,
14744 struct bfd_link_info
*info
)
14747 const char *name
, *key
;
14748 struct bfd_section_already_linked
*l
;
14749 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
14751 if (sec
->output_section
== bfd_abs_section_ptr
)
14754 flags
= sec
->flags
;
14756 /* Return if it isn't a linkonce section. A comdat group section
14757 also has SEC_LINK_ONCE set. */
14758 if ((flags
& SEC_LINK_ONCE
) == 0)
14761 /* Don't put group member sections on our list of already linked
14762 sections. They are handled as a group via their group section. */
14763 if (elf_sec_group (sec
) != NULL
)
14766 /* For a SHT_GROUP section, use the group signature as the key. */
14768 if ((flags
& SEC_GROUP
) != 0
14769 && elf_next_in_group (sec
) != NULL
14770 && elf_group_name (elf_next_in_group (sec
)) != NULL
)
14771 key
= elf_group_name (elf_next_in_group (sec
));
14774 /* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */
14775 if (startswith (name
, ".gnu.linkonce.")
14776 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
14779 /* Must be a user linkonce section that doesn't follow gcc's
14780 naming convention. In this case we won't be matching
14781 single member groups. */
14785 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
14787 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
14789 /* We may have 2 different types of sections on the list: group
14790 sections with a signature of <key> (<key> is some string),
14791 and linkonce sections named .gnu.linkonce.<type>.<key>.
14792 Match like sections. LTO plugin sections are an exception.
14793 They are always named .gnu.linkonce.t.<key> and match either
14794 type of section. */
14795 if (((flags
& SEC_GROUP
) == (l
->sec
->flags
& SEC_GROUP
)
14796 && ((flags
& SEC_GROUP
) != 0
14797 || strcmp (name
, l
->sec
->name
) == 0))
14798 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0
14799 || (sec
->owner
->flags
& BFD_PLUGIN
) != 0)
14801 /* The section has already been linked. See if we should
14802 issue a warning. */
14803 if (!_bfd_handle_already_linked (sec
, l
, info
))
14806 if (flags
& SEC_GROUP
)
14808 asection
*first
= elf_next_in_group (sec
);
14809 asection
*s
= first
;
14813 s
->output_section
= bfd_abs_section_ptr
;
14814 /* Record which group discards it. */
14815 s
->kept_section
= l
->sec
;
14816 s
= elf_next_in_group (s
);
14817 /* These lists are circular. */
14827 /* A single member comdat group section may be discarded by a
14828 linkonce section and vice versa. */
14829 if ((flags
& SEC_GROUP
) != 0)
14831 asection
*first
= elf_next_in_group (sec
);
14833 if (first
!= NULL
&& elf_next_in_group (first
) == first
)
14834 /* Check this single member group against linkonce sections. */
14835 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
14836 if ((l
->sec
->flags
& SEC_GROUP
) == 0
14837 && bfd_elf_match_symbols_in_sections (l
->sec
, first
, info
))
14839 first
->output_section
= bfd_abs_section_ptr
;
14840 first
->kept_section
= l
->sec
;
14841 sec
->output_section
= bfd_abs_section_ptr
;
14846 /* Check this linkonce section against single member groups. */
14847 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
14848 if (l
->sec
->flags
& SEC_GROUP
)
14850 asection
*first
= elf_next_in_group (l
->sec
);
14853 && elf_next_in_group (first
) == first
14854 && bfd_elf_match_symbols_in_sections (first
, sec
, info
))
14856 sec
->output_section
= bfd_abs_section_ptr
;
14857 sec
->kept_section
= first
;
14862 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
14863 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
14864 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
14865 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
14866 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
14867 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
14868 `.gnu.linkonce.t.F' section from a different bfd not requiring any
14869 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
14870 The reverse order cannot happen as there is never a bfd with only the
14871 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
14872 matter as here were are looking only for cross-bfd sections. */
14874 if ((flags
& SEC_GROUP
) == 0 && startswith (name
, ".gnu.linkonce.r."))
14875 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
14876 if ((l
->sec
->flags
& SEC_GROUP
) == 0
14877 && startswith (l
->sec
->name
, ".gnu.linkonce.t."))
14879 if (abfd
!= l
->sec
->owner
)
14880 sec
->output_section
= bfd_abs_section_ptr
;
14884 /* This is the first section with this name. Record it. */
14885 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
14886 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
14887 return sec
->output_section
== bfd_abs_section_ptr
;
14891 _bfd_elf_common_definition (Elf_Internal_Sym
*sym
)
14893 return sym
->st_shndx
== SHN_COMMON
;
14897 _bfd_elf_common_section_index (asection
*sec ATTRIBUTE_UNUSED
)
14903 _bfd_elf_common_section (asection
*sec ATTRIBUTE_UNUSED
)
14905 return bfd_com_section_ptr
;
14909 _bfd_elf_default_got_elt_size (bfd
*abfd
,
14910 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
14911 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
14912 bfd
*ibfd ATTRIBUTE_UNUSED
,
14913 unsigned long symndx ATTRIBUTE_UNUSED
)
14915 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14916 return bed
->s
->arch_size
/ 8;
14919 /* Routines to support the creation of dynamic relocs. */
14921 /* Returns the name of the dynamic reloc section associated with SEC. */
14923 static const char *
14924 get_dynamic_reloc_section_name (bfd
* abfd
,
14929 const char *old_name
= bfd_section_name (sec
);
14930 const char *prefix
= is_rela
? ".rela" : ".rel";
14932 if (old_name
== NULL
)
14935 name
= bfd_alloc (abfd
, strlen (prefix
) + strlen (old_name
) + 1);
14936 sprintf (name
, "%s%s", prefix
, old_name
);
14941 /* Returns the dynamic reloc section associated with SEC.
14942 If necessary compute the name of the dynamic reloc section based
14943 on SEC's name (looked up in ABFD's string table) and the setting
14947 _bfd_elf_get_dynamic_reloc_section (bfd
*abfd
,
14951 asection
*reloc_sec
= elf_section_data (sec
)->sreloc
;
14953 if (reloc_sec
== NULL
)
14955 const char *name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
14959 reloc_sec
= bfd_get_linker_section (abfd
, name
);
14961 if (reloc_sec
!= NULL
)
14962 elf_section_data (sec
)->sreloc
= reloc_sec
;
14969 /* Returns the dynamic reloc section associated with SEC. If the
14970 section does not exist it is created and attached to the DYNOBJ
14971 bfd and stored in the SRELOC field of SEC's elf_section_data
14974 ALIGNMENT is the alignment for the newly created section and
14975 IS_RELA defines whether the name should be .rela.<SEC's name>
14976 or .rel.<SEC's name>. The section name is looked up in the
14977 string table associated with ABFD. */
14980 _bfd_elf_make_dynamic_reloc_section (asection
*sec
,
14982 unsigned int alignment
,
14986 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
14988 if (reloc_sec
== NULL
)
14990 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
14995 reloc_sec
= bfd_get_linker_section (dynobj
, name
);
14997 if (reloc_sec
== NULL
)
14999 flagword flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
15000 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
15001 if ((sec
->flags
& SEC_ALLOC
) != 0)
15002 flags
|= SEC_ALLOC
| SEC_LOAD
;
15004 reloc_sec
= bfd_make_section_anyway_with_flags (dynobj
, name
, flags
);
15005 if (reloc_sec
!= NULL
)
15007 /* _bfd_elf_get_sec_type_attr chooses a section type by
15008 name. Override as it may be wrong, eg. for a user
15009 section named "auto" we'll get ".relauto" which is
15010 seen to be a .rela section. */
15011 elf_section_type (reloc_sec
) = is_rela
? SHT_RELA
: SHT_REL
;
15012 if (!bfd_set_section_alignment (reloc_sec
, alignment
))
15017 elf_section_data (sec
)->sreloc
= reloc_sec
;
15023 /* Copy the ELF symbol type and other attributes for a linker script
15024 assignment from HSRC to HDEST. Generally this should be treated as
15025 if we found a strong non-dynamic definition for HDEST (except that
15026 ld ignores multiple definition errors). */
15028 _bfd_elf_copy_link_hash_symbol_type (bfd
*abfd
,
15029 struct bfd_link_hash_entry
*hdest
,
15030 struct bfd_link_hash_entry
*hsrc
)
15032 struct elf_link_hash_entry
*ehdest
= (struct elf_link_hash_entry
*) hdest
;
15033 struct elf_link_hash_entry
*ehsrc
= (struct elf_link_hash_entry
*) hsrc
;
15034 Elf_Internal_Sym isym
;
15036 ehdest
->type
= ehsrc
->type
;
15037 ehdest
->target_internal
= ehsrc
->target_internal
;
15039 isym
.st_other
= ehsrc
->other
;
15040 elf_merge_st_other (abfd
, ehdest
, isym
.st_other
, NULL
, true, false);
15043 /* Append a RELA relocation REL to section S in BFD. */
15046 elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
15048 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
15049 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
15050 BFD_ASSERT (loc
+ bed
->s
->sizeof_rela
<= s
->contents
+ s
->size
);
15051 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
15054 /* Append a REL relocation REL to section S in BFD. */
15057 elf_append_rel (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
15059 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
15060 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rel
);
15061 BFD_ASSERT (loc
+ bed
->s
->sizeof_rel
<= s
->contents
+ s
->size
);
15062 bed
->s
->swap_reloc_out (abfd
, rel
, loc
);
15065 /* Define __start, __stop, .startof. or .sizeof. symbol. */
15067 struct bfd_link_hash_entry
*
15068 bfd_elf_define_start_stop (struct bfd_link_info
*info
,
15069 const char *symbol
, asection
*sec
)
15071 struct elf_link_hash_entry
*h
;
15073 h
= elf_link_hash_lookup (elf_hash_table (info
), symbol
,
15074 false, false, true);
15075 /* NB: Common symbols will be turned into definition later. */
15077 && !h
->root
.ldscript_def
15078 && (h
->root
.type
== bfd_link_hash_undefined
15079 || h
->root
.type
== bfd_link_hash_undefweak
15080 || ((h
->ref_regular
|| h
->def_dynamic
)
15082 && h
->root
.type
!= bfd_link_hash_common
)))
15084 bool was_dynamic
= h
->ref_dynamic
|| h
->def_dynamic
;
15085 h
->verinfo
.verdef
= NULL
;
15086 h
->root
.type
= bfd_link_hash_defined
;
15087 h
->root
.u
.def
.section
= sec
;
15088 h
->root
.u
.def
.value
= 0;
15089 h
->def_regular
= 1;
15090 h
->def_dynamic
= 0;
15092 h
->u2
.start_stop_section
= sec
;
15093 if (symbol
[0] == '.')
15095 /* .startof. and .sizeof. symbols are local. */
15096 const struct elf_backend_data
*bed
;
15097 bed
= get_elf_backend_data (info
->output_bfd
);
15098 (*bed
->elf_backend_hide_symbol
) (info
, h
, true);
15102 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
15103 h
->other
= ((h
->other
& ~ELF_ST_VISIBILITY (-1))
15104 | info
->start_stop_visibility
);
15106 bfd_elf_link_record_dynamic_symbol (info
, h
);
15113 /* Find dynamic relocs for H that apply to read-only sections. */
15116 _bfd_elf_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
15118 struct elf_dyn_relocs
*p
;
15120 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
15122 asection
*s
= p
->sec
->output_section
;
15124 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
15130 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
15131 read-only sections. */
15134 _bfd_elf_maybe_set_textrel (struct elf_link_hash_entry
*h
, void *inf
)
15138 if (h
->root
.type
== bfd_link_hash_indirect
)
15141 sec
= _bfd_elf_readonly_dynrelocs (h
);
15144 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
15146 info
->flags
|= DF_TEXTREL
;
15147 /* xgettext:c-format */
15148 info
->callbacks
->minfo (_("%pB: dynamic relocation against `%pT' "
15149 "in read-only section `%pA'\n"),
15150 sec
->owner
, h
->root
.root
.string
, sec
);
15152 if (bfd_link_textrel_check (info
))
15153 /* xgettext:c-format */
15154 info
->callbacks
->einfo (_("%P: %pB: warning: relocation against `%s' "
15155 "in read-only section `%pA'\n"),
15156 sec
->owner
, h
->root
.root
.string
, sec
);
15158 /* Not an error, just cut short the traversal. */
15164 /* Add dynamic tags. */
15167 _bfd_elf_add_dynamic_tags (bfd
*output_bfd
, struct bfd_link_info
*info
,
15168 bool need_dynamic_reloc
)
15170 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
15172 if (htab
->dynamic_sections_created
)
15174 /* Add some entries to the .dynamic section. We fill in the
15175 values later, in finish_dynamic_sections, but we must add
15176 the entries now so that we get the correct size for the
15177 .dynamic section. The DT_DEBUG entry is filled in by the
15178 dynamic linker and used by the debugger. */
15179 #define add_dynamic_entry(TAG, VAL) \
15180 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
15182 const struct elf_backend_data
*bed
15183 = get_elf_backend_data (output_bfd
);
15185 if (bfd_link_executable (info
))
15187 if (!add_dynamic_entry (DT_DEBUG
, 0))
15191 if (htab
->dt_pltgot_required
|| htab
->splt
->size
!= 0)
15193 /* DT_PLTGOT is used by prelink even if there is no PLT
15195 if (!add_dynamic_entry (DT_PLTGOT
, 0))
15199 if (htab
->dt_jmprel_required
|| htab
->srelplt
->size
!= 0)
15201 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
15202 || !add_dynamic_entry (DT_PLTREL
,
15203 (bed
->rela_plts_and_copies_p
15204 ? DT_RELA
: DT_REL
))
15205 || !add_dynamic_entry (DT_JMPREL
, 0))
15209 if (htab
->tlsdesc_plt
15210 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
15211 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
15214 if (need_dynamic_reloc
)
15216 if (bed
->rela_plts_and_copies_p
)
15218 if (!add_dynamic_entry (DT_RELA
, 0)
15219 || !add_dynamic_entry (DT_RELASZ
, 0)
15220 || !add_dynamic_entry (DT_RELAENT
,
15221 bed
->s
->sizeof_rela
))
15226 if (!add_dynamic_entry (DT_REL
, 0)
15227 || !add_dynamic_entry (DT_RELSZ
, 0)
15228 || !add_dynamic_entry (DT_RELENT
,
15229 bed
->s
->sizeof_rel
))
15233 /* If any dynamic relocs apply to a read-only section,
15234 then we need a DT_TEXTREL entry. */
15235 if ((info
->flags
& DF_TEXTREL
) == 0)
15236 elf_link_hash_traverse (htab
, _bfd_elf_maybe_set_textrel
,
15239 if ((info
->flags
& DF_TEXTREL
) != 0)
15241 if (htab
->ifunc_resolvers
)
15242 info
->callbacks
->einfo
15243 (_("%P: warning: GNU indirect functions with DT_TEXTREL "
15244 "may result in a segfault at runtime; recompile with %s\n"),
15245 bfd_link_dll (info
) ? "-fPIC" : "-fPIE");
15247 if (!add_dynamic_entry (DT_TEXTREL
, 0))
15252 #undef add_dynamic_entry