1 /* ELF linking support for BFD.
2 Copyright (C) 1995-2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "bfd_stdint.h"
28 #include "safe-ctype.h"
29 #include "libiberty.h"
31 #if BFD_SUPPORTS_PLUGINS
32 #include "plugin-api.h"
36 /* This struct is used to pass information to routines called via
37 elf_link_hash_traverse which must return failure. */
39 struct elf_info_failed
41 struct bfd_link_info
*info
;
45 /* This structure is used to pass information to
46 _bfd_elf_link_find_version_dependencies. */
48 struct elf_find_verdep_info
50 /* General link information. */
51 struct bfd_link_info
*info
;
52 /* The number of dependencies. */
54 /* Whether we had a failure. */
58 static bfd_boolean _bfd_elf_fix_symbol_flags
59 (struct elf_link_hash_entry
*, struct elf_info_failed
*);
62 _bfd_elf_section_for_symbol (struct elf_reloc_cookie
*cookie
,
63 unsigned long r_symndx
,
66 if (r_symndx
>= cookie
->locsymcount
67 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
69 struct elf_link_hash_entry
*h
;
71 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
73 while (h
->root
.type
== bfd_link_hash_indirect
74 || h
->root
.type
== bfd_link_hash_warning
)
75 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
77 if ((h
->root
.type
== bfd_link_hash_defined
78 || h
->root
.type
== bfd_link_hash_defweak
)
79 && discarded_section (h
->root
.u
.def
.section
))
80 return h
->root
.u
.def
.section
;
86 /* It's not a relocation against a global symbol,
87 but it could be a relocation against a local
88 symbol for a discarded section. */
90 Elf_Internal_Sym
*isym
;
92 /* Need to: get the symbol; get the section. */
93 isym
= &cookie
->locsyms
[r_symndx
];
94 isec
= bfd_section_from_elf_index (cookie
->abfd
, isym
->st_shndx
);
96 && discard
? discarded_section (isec
) : 1)
102 /* Define a symbol in a dynamic linkage section. */
104 struct elf_link_hash_entry
*
105 _bfd_elf_define_linkage_sym (bfd
*abfd
,
106 struct bfd_link_info
*info
,
110 struct elf_link_hash_entry
*h
;
111 struct bfd_link_hash_entry
*bh
;
112 const struct elf_backend_data
*bed
;
114 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
117 /* Zap symbol defined in an as-needed lib that wasn't linked.
118 This is a symptom of a larger problem: Absolute symbols
119 defined in shared libraries can't be overridden, because we
120 lose the link to the bfd which is via the symbol section. */
121 h
->root
.type
= bfd_link_hash_new
;
127 bed
= get_elf_backend_data (abfd
);
128 if (!_bfd_generic_link_add_one_symbol (info
, abfd
, name
, BSF_GLOBAL
,
129 sec
, 0, NULL
, FALSE
, bed
->collect
,
132 h
= (struct elf_link_hash_entry
*) bh
;
133 BFD_ASSERT (h
!= NULL
);
136 h
->root
.linker_def
= 1;
137 h
->type
= STT_OBJECT
;
138 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
139 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
141 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
146 _bfd_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
150 struct elf_link_hash_entry
*h
;
151 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
152 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
154 /* This function may be called more than once. */
155 if (htab
->sgot
!= NULL
)
158 flags
= bed
->dynamic_sec_flags
;
160 s
= bfd_make_section_anyway_with_flags (abfd
,
161 (bed
->rela_plts_and_copies_p
162 ? ".rela.got" : ".rel.got"),
163 (bed
->dynamic_sec_flags
166 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
170 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
172 || !bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
176 if (bed
->want_got_plt
)
178 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
180 || !bfd_set_section_alignment (abfd
, s
,
181 bed
->s
->log_file_align
))
186 /* The first bit of the global offset table is the header. */
187 s
->size
+= bed
->got_header_size
;
189 if (bed
->want_got_sym
)
191 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
192 (or .got.plt) section. We don't do this in the linker script
193 because we don't want to define the symbol if we are not creating
194 a global offset table. */
195 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
196 "_GLOBAL_OFFSET_TABLE_");
197 elf_hash_table (info
)->hgot
= h
;
205 /* Create a strtab to hold the dynamic symbol names. */
207 _bfd_elf_link_create_dynstrtab (bfd
*abfd
, struct bfd_link_info
*info
)
209 struct elf_link_hash_table
*hash_table
;
211 hash_table
= elf_hash_table (info
);
212 if (hash_table
->dynobj
== NULL
)
214 /* We may not set dynobj, an input file holding linker created
215 dynamic sections to abfd, which may be a dynamic object with
216 its own dynamic sections. We need to find a normal input file
217 to hold linker created sections if possible. */
218 if ((abfd
->flags
& (DYNAMIC
| BFD_PLUGIN
)) != 0)
221 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
223 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
229 hash_table
->dynobj
= abfd
;
232 if (hash_table
->dynstr
== NULL
)
234 hash_table
->dynstr
= _bfd_elf_strtab_init ();
235 if (hash_table
->dynstr
== NULL
)
241 /* Create some sections which will be filled in with dynamic linking
242 information. ABFD is an input file which requires dynamic sections
243 to be created. The dynamic sections take up virtual memory space
244 when the final executable is run, so we need to create them before
245 addresses are assigned to the output sections. We work out the
246 actual contents and size of these sections later. */
249 _bfd_elf_link_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
253 const struct elf_backend_data
*bed
;
254 struct elf_link_hash_entry
*h
;
256 if (! is_elf_hash_table (info
->hash
))
259 if (elf_hash_table (info
)->dynamic_sections_created
)
262 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
265 abfd
= elf_hash_table (info
)->dynobj
;
266 bed
= get_elf_backend_data (abfd
);
268 flags
= bed
->dynamic_sec_flags
;
270 /* A dynamically linked executable has a .interp section, but a
271 shared library does not. */
272 if (bfd_link_executable (info
) && !info
->nointerp
)
274 s
= bfd_make_section_anyway_with_flags (abfd
, ".interp",
275 flags
| SEC_READONLY
);
280 /* Create sections to hold version informations. These are removed
281 if they are not needed. */
282 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_d",
283 flags
| SEC_READONLY
);
285 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
288 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version",
289 flags
| SEC_READONLY
);
291 || ! bfd_set_section_alignment (abfd
, s
, 1))
294 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_r",
295 flags
| SEC_READONLY
);
297 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
300 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynsym",
301 flags
| SEC_READONLY
);
303 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
305 elf_hash_table (info
)->dynsym
= s
;
307 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynstr",
308 flags
| SEC_READONLY
);
312 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic", flags
);
314 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
317 /* The special symbol _DYNAMIC is always set to the start of the
318 .dynamic section. We could set _DYNAMIC in a linker script, but we
319 only want to define it if we are, in fact, creating a .dynamic
320 section. We don't want to define it if there is no .dynamic
321 section, since on some ELF platforms the start up code examines it
322 to decide how to initialize the process. */
323 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_DYNAMIC");
324 elf_hash_table (info
)->hdynamic
= h
;
330 s
= bfd_make_section_anyway_with_flags (abfd
, ".hash",
331 flags
| SEC_READONLY
);
333 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
335 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
338 if (info
->emit_gnu_hash
)
340 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.hash",
341 flags
| SEC_READONLY
);
343 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
345 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
346 4 32-bit words followed by variable count of 64-bit words, then
347 variable count of 32-bit words. */
348 if (bed
->s
->arch_size
== 64)
349 elf_section_data (s
)->this_hdr
.sh_entsize
= 0;
351 elf_section_data (s
)->this_hdr
.sh_entsize
= 4;
354 /* Let the backend create the rest of the sections. This lets the
355 backend set the right flags. The backend will normally create
356 the .got and .plt sections. */
357 if (bed
->elf_backend_create_dynamic_sections
== NULL
358 || ! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
361 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
366 /* Create dynamic sections when linking against a dynamic object. */
369 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
371 flagword flags
, pltflags
;
372 struct elf_link_hash_entry
*h
;
374 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
375 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
377 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
378 .rel[a].bss sections. */
379 flags
= bed
->dynamic_sec_flags
;
382 if (bed
->plt_not_loaded
)
383 /* We do not clear SEC_ALLOC here because we still want the OS to
384 allocate space for the section; it's just that there's nothing
385 to read in from the object file. */
386 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
388 pltflags
|= SEC_ALLOC
| SEC_CODE
| SEC_LOAD
;
389 if (bed
->plt_readonly
)
390 pltflags
|= SEC_READONLY
;
392 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
394 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
398 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
400 if (bed
->want_plt_sym
)
402 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
403 "_PROCEDURE_LINKAGE_TABLE_");
404 elf_hash_table (info
)->hplt
= h
;
409 s
= bfd_make_section_anyway_with_flags (abfd
,
410 (bed
->rela_plts_and_copies_p
411 ? ".rela.plt" : ".rel.plt"),
412 flags
| SEC_READONLY
);
414 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
418 if (! _bfd_elf_create_got_section (abfd
, info
))
421 if (bed
->want_dynbss
)
423 /* The .dynbss section is a place to put symbols which are defined
424 by dynamic objects, are referenced by regular objects, and are
425 not functions. We must allocate space for them in the process
426 image and use a R_*_COPY reloc to tell the dynamic linker to
427 initialize them at run time. The linker script puts the .dynbss
428 section into the .bss section of the final image. */
429 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
430 SEC_ALLOC
| SEC_LINKER_CREATED
);
435 if (bed
->want_dynrelro
)
437 /* Similarly, but for symbols that were originally in read-only
438 sections. This section doesn't really need to have contents,
439 but make it like other .data.rel.ro sections. */
440 s
= bfd_make_section_anyway_with_flags (abfd
, ".data.rel.ro",
447 /* The .rel[a].bss section holds copy relocs. This section is not
448 normally needed. We need to create it here, though, so that the
449 linker will map it to an output section. We can't just create it
450 only if we need it, because we will not know whether we need it
451 until we have seen all the input files, and the first time the
452 main linker code calls BFD after examining all the input files
453 (size_dynamic_sections) the input sections have already been
454 mapped to the output sections. If the section turns out not to
455 be needed, we can discard it later. We will never need this
456 section when generating a shared object, since they do not use
458 if (bfd_link_executable (info
))
460 s
= bfd_make_section_anyway_with_flags (abfd
,
461 (bed
->rela_plts_and_copies_p
462 ? ".rela.bss" : ".rel.bss"),
463 flags
| SEC_READONLY
);
465 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
469 if (bed
->want_dynrelro
)
471 s
= (bfd_make_section_anyway_with_flags
472 (abfd
, (bed
->rela_plts_and_copies_p
473 ? ".rela.data.rel.ro" : ".rel.data.rel.ro"),
474 flags
| SEC_READONLY
));
476 || ! bfd_set_section_alignment (abfd
, s
,
477 bed
->s
->log_file_align
))
479 htab
->sreldynrelro
= s
;
487 /* Record a new dynamic symbol. We record the dynamic symbols as we
488 read the input files, since we need to have a list of all of them
489 before we can determine the final sizes of the output sections.
490 Note that we may actually call this function even though we are not
491 going to output any dynamic symbols; in some cases we know that a
492 symbol should be in the dynamic symbol table, but only if there is
496 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
497 struct elf_link_hash_entry
*h
)
499 if (h
->dynindx
== -1)
501 struct elf_strtab_hash
*dynstr
;
506 /* XXX: The ABI draft says the linker must turn hidden and
507 internal symbols into STB_LOCAL symbols when producing the
508 DSO. However, if ld.so honors st_other in the dynamic table,
509 this would not be necessary. */
510 switch (ELF_ST_VISIBILITY (h
->other
))
514 if (h
->root
.type
!= bfd_link_hash_undefined
515 && h
->root
.type
!= bfd_link_hash_undefweak
)
518 if (!elf_hash_table (info
)->is_relocatable_executable
)
526 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
527 ++elf_hash_table (info
)->dynsymcount
;
529 dynstr
= elf_hash_table (info
)->dynstr
;
532 /* Create a strtab to hold the dynamic symbol names. */
533 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
538 /* We don't put any version information in the dynamic string
540 name
= h
->root
.root
.string
;
541 p
= strchr (name
, ELF_VER_CHR
);
543 /* We know that the p points into writable memory. In fact,
544 there are only a few symbols that have read-only names, being
545 those like _GLOBAL_OFFSET_TABLE_ that are created specially
546 by the backends. Most symbols will have names pointing into
547 an ELF string table read from a file, or to objalloc memory. */
550 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
555 if (indx
== (size_t) -1)
557 h
->dynstr_index
= indx
;
563 /* Mark a symbol dynamic. */
566 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info
*info
,
567 struct elf_link_hash_entry
*h
,
568 Elf_Internal_Sym
*sym
)
570 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
572 /* It may be called more than once on the same H. */
573 if(h
->dynamic
|| bfd_link_relocatable (info
))
576 if ((info
->dynamic_data
577 && (h
->type
== STT_OBJECT
578 || h
->type
== STT_COMMON
580 && (ELF_ST_TYPE (sym
->st_info
) == STT_OBJECT
581 || ELF_ST_TYPE (sym
->st_info
) == STT_COMMON
))))
584 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
588 /* Record an assignment to a symbol made by a linker script. We need
589 this in case some dynamic object refers to this symbol. */
592 bfd_elf_record_link_assignment (bfd
*output_bfd
,
593 struct bfd_link_info
*info
,
598 struct elf_link_hash_entry
*h
, *hv
;
599 struct elf_link_hash_table
*htab
;
600 const struct elf_backend_data
*bed
;
602 if (!is_elf_hash_table (info
->hash
))
605 htab
= elf_hash_table (info
);
606 h
= elf_link_hash_lookup (htab
, name
, !provide
, TRUE
, FALSE
);
610 if (h
->root
.type
== bfd_link_hash_warning
)
611 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
613 if (h
->versioned
== unknown
)
615 /* Set versioned if symbol version is unknown. */
616 char *version
= strrchr (name
, ELF_VER_CHR
);
619 if (version
> name
&& version
[-1] != ELF_VER_CHR
)
620 h
->versioned
= versioned_hidden
;
622 h
->versioned
= versioned
;
626 /* Symbols defined in a linker script but not referenced anywhere
627 else will have non_elf set. */
630 bfd_elf_link_mark_dynamic_symbol (info
, h
, NULL
);
634 switch (h
->root
.type
)
636 case bfd_link_hash_defined
:
637 case bfd_link_hash_defweak
:
638 case bfd_link_hash_common
:
640 case bfd_link_hash_undefweak
:
641 case bfd_link_hash_undefined
:
642 /* Since we're defining the symbol, don't let it seem to have not
643 been defined. record_dynamic_symbol and size_dynamic_sections
644 may depend on this. */
645 h
->root
.type
= bfd_link_hash_new
;
646 if (h
->root
.u
.undef
.next
!= NULL
|| htab
->root
.undefs_tail
== &h
->root
)
647 bfd_link_repair_undef_list (&htab
->root
);
649 case bfd_link_hash_new
:
651 case bfd_link_hash_indirect
:
652 /* We had a versioned symbol in a dynamic library. We make the
653 the versioned symbol point to this one. */
654 bed
= get_elf_backend_data (output_bfd
);
656 while (hv
->root
.type
== bfd_link_hash_indirect
657 || hv
->root
.type
== bfd_link_hash_warning
)
658 hv
= (struct elf_link_hash_entry
*) hv
->root
.u
.i
.link
;
659 /* We don't need to update h->root.u since linker will set them
661 h
->root
.type
= bfd_link_hash_undefined
;
662 hv
->root
.type
= bfd_link_hash_indirect
;
663 hv
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
664 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hv
);
671 /* If this symbol is being provided by the linker script, and it is
672 currently defined by a dynamic object, but not by a regular
673 object, then mark it as undefined so that the generic linker will
674 force the correct value. */
678 h
->root
.type
= bfd_link_hash_undefined
;
680 /* If this symbol is not being provided by the linker script, and it is
681 currently defined by a dynamic object, but not by a regular object,
682 then clear out any version information because the symbol will not be
683 associated with the dynamic object any more. */
687 h
->verinfo
.verdef
= NULL
;
689 /* Make sure this symbol is not garbage collected. */
696 bed
= get_elf_backend_data (output_bfd
);
697 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
698 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
699 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
702 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
704 if (!bfd_link_relocatable (info
)
706 && (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
707 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
))
712 || bfd_link_dll (info
)
713 || elf_hash_table (info
)->is_relocatable_executable
)
716 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
719 /* If this is a weak defined symbol, and we know a corresponding
720 real symbol from the same dynamic object, make sure the real
721 symbol is also made into a dynamic symbol. */
722 if (h
->u
.weakdef
!= NULL
723 && h
->u
.weakdef
->dynindx
== -1)
725 if (! bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
733 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
734 success, and 2 on a failure caused by attempting to record a symbol
735 in a discarded section, eg. a discarded link-once section symbol. */
738 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
743 struct elf_link_local_dynamic_entry
*entry
;
744 struct elf_link_hash_table
*eht
;
745 struct elf_strtab_hash
*dynstr
;
748 Elf_External_Sym_Shndx eshndx
;
749 char esym
[sizeof (Elf64_External_Sym
)];
751 if (! is_elf_hash_table (info
->hash
))
754 /* See if the entry exists already. */
755 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
756 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
759 amt
= sizeof (*entry
);
760 entry
= (struct elf_link_local_dynamic_entry
*) bfd_alloc (input_bfd
, amt
);
764 /* Go find the symbol, so that we can find it's name. */
765 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
766 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
768 bfd_release (input_bfd
, entry
);
772 if (entry
->isym
.st_shndx
!= SHN_UNDEF
773 && entry
->isym
.st_shndx
< SHN_LORESERVE
)
777 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
778 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
780 /* We can still bfd_release here as nothing has done another
781 bfd_alloc. We can't do this later in this function. */
782 bfd_release (input_bfd
, entry
);
787 name
= (bfd_elf_string_from_elf_section
788 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
789 entry
->isym
.st_name
));
791 dynstr
= elf_hash_table (info
)->dynstr
;
794 /* Create a strtab to hold the dynamic symbol names. */
795 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
800 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, FALSE
);
801 if (dynstr_index
== (size_t) -1)
803 entry
->isym
.st_name
= dynstr_index
;
805 eht
= elf_hash_table (info
);
807 entry
->next
= eht
->dynlocal
;
808 eht
->dynlocal
= entry
;
809 entry
->input_bfd
= input_bfd
;
810 entry
->input_indx
= input_indx
;
813 /* Whatever binding the symbol had before, it's now local. */
815 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
817 /* The dynindx will be set at the end of size_dynamic_sections. */
822 /* Return the dynindex of a local dynamic symbol. */
825 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
829 struct elf_link_local_dynamic_entry
*e
;
831 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
832 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
837 /* This function is used to renumber the dynamic symbols, if some of
838 them are removed because they are marked as local. This is called
839 via elf_link_hash_traverse. */
842 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
845 size_t *count
= (size_t *) data
;
850 if (h
->dynindx
!= -1)
851 h
->dynindx
= ++(*count
);
857 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
858 STB_LOCAL binding. */
861 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
864 size_t *count
= (size_t *) data
;
866 if (!h
->forced_local
)
869 if (h
->dynindx
!= -1)
870 h
->dynindx
= ++(*count
);
875 /* Return true if the dynamic symbol for a given section should be
876 omitted when creating a shared library. */
878 _bfd_elf_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
879 struct bfd_link_info
*info
,
882 struct elf_link_hash_table
*htab
;
885 switch (elf_section_data (p
)->this_hdr
.sh_type
)
889 /* If sh_type is yet undecided, assume it could be
890 SHT_PROGBITS/SHT_NOBITS. */
892 htab
= elf_hash_table (info
);
893 if (p
== htab
->tls_sec
)
896 if (htab
->text_index_section
!= NULL
)
897 return p
!= htab
->text_index_section
&& p
!= htab
->data_index_section
;
899 return (htab
->dynobj
!= NULL
900 && (ip
= bfd_get_linker_section (htab
->dynobj
, p
->name
)) != NULL
901 && ip
->output_section
== p
);
903 /* There shouldn't be section relative relocations
904 against any other section. */
910 /* Assign dynsym indices. In a shared library we generate a section
911 symbol for each output section, which come first. Next come symbols
912 which have been forced to local binding. Then all of the back-end
913 allocated local dynamic syms, followed by the rest of the global
917 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
,
918 struct bfd_link_info
*info
,
919 unsigned long *section_sym_count
)
921 unsigned long dynsymcount
= 0;
923 if (bfd_link_pic (info
)
924 || elf_hash_table (info
)->is_relocatable_executable
)
926 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
928 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
929 if ((p
->flags
& SEC_EXCLUDE
) == 0
930 && (p
->flags
& SEC_ALLOC
) != 0
931 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
932 elf_section_data (p
)->dynindx
= ++dynsymcount
;
934 elf_section_data (p
)->dynindx
= 0;
936 *section_sym_count
= dynsymcount
;
938 elf_link_hash_traverse (elf_hash_table (info
),
939 elf_link_renumber_local_hash_table_dynsyms
,
942 if (elf_hash_table (info
)->dynlocal
)
944 struct elf_link_local_dynamic_entry
*p
;
945 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
946 p
->dynindx
= ++dynsymcount
;
948 elf_hash_table (info
)->local_dynsymcount
= dynsymcount
;
950 elf_link_hash_traverse (elf_hash_table (info
),
951 elf_link_renumber_hash_table_dynsyms
,
954 /* There is an unused NULL entry at the head of the table which we
955 must account for in our count even if the table is empty since it
956 is intended for the mandatory DT_SYMTAB tag (.dynsym section) in
960 elf_hash_table (info
)->dynsymcount
= dynsymcount
;
964 /* Merge st_other field. */
967 elf_merge_st_other (bfd
*abfd
, struct elf_link_hash_entry
*h
,
968 const Elf_Internal_Sym
*isym
, asection
*sec
,
969 bfd_boolean definition
, bfd_boolean dynamic
)
971 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
973 /* If st_other has a processor-specific meaning, specific
974 code might be needed here. */
975 if (bed
->elf_backend_merge_symbol_attribute
)
976 (*bed
->elf_backend_merge_symbol_attribute
) (h
, isym
, definition
,
981 unsigned symvis
= ELF_ST_VISIBILITY (isym
->st_other
);
982 unsigned hvis
= ELF_ST_VISIBILITY (h
->other
);
984 /* Keep the most constraining visibility. Leave the remainder
985 of the st_other field to elf_backend_merge_symbol_attribute. */
986 if (symvis
- 1 < hvis
- 1)
987 h
->other
= symvis
| (h
->other
& ~ELF_ST_VISIBILITY (-1));
990 && ELF_ST_VISIBILITY (isym
->st_other
) != STV_DEFAULT
991 && (sec
->flags
& SEC_READONLY
) == 0)
992 h
->protected_def
= 1;
995 /* This function is called when we want to merge a new symbol with an
996 existing symbol. It handles the various cases which arise when we
997 find a definition in a dynamic object, or when there is already a
998 definition in a dynamic object. The new symbol is described by
999 NAME, SYM, PSEC, and PVALUE. We set SYM_HASH to the hash table
1000 entry. We set POLDBFD to the old symbol's BFD. We set POLD_WEAK
1001 if the old symbol was weak. We set POLD_ALIGNMENT to the alignment
1002 of an old common symbol. We set OVERRIDE if the old symbol is
1003 overriding a new definition. We set TYPE_CHANGE_OK if it is OK for
1004 the type to change. We set SIZE_CHANGE_OK if it is OK for the size
1005 to change. By OK to change, we mean that we shouldn't warn if the
1006 type or size does change. */
1009 _bfd_elf_merge_symbol (bfd
*abfd
,
1010 struct bfd_link_info
*info
,
1012 Elf_Internal_Sym
*sym
,
1015 struct elf_link_hash_entry
**sym_hash
,
1017 bfd_boolean
*pold_weak
,
1018 unsigned int *pold_alignment
,
1020 bfd_boolean
*override
,
1021 bfd_boolean
*type_change_ok
,
1022 bfd_boolean
*size_change_ok
,
1023 bfd_boolean
*matched
)
1025 asection
*sec
, *oldsec
;
1026 struct elf_link_hash_entry
*h
;
1027 struct elf_link_hash_entry
*hi
;
1028 struct elf_link_hash_entry
*flip
;
1031 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
1032 bfd_boolean newweak
, oldweak
, newfunc
, oldfunc
;
1033 const struct elf_backend_data
*bed
;
1040 bind
= ELF_ST_BIND (sym
->st_info
);
1042 if (! bfd_is_und_section (sec
))
1043 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
1045 h
= ((struct elf_link_hash_entry
*)
1046 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
1051 bed
= get_elf_backend_data (abfd
);
1053 /* NEW_VERSION is the symbol version of the new symbol. */
1054 if (h
->versioned
!= unversioned
)
1056 /* Symbol version is unknown or versioned. */
1057 new_version
= strrchr (name
, ELF_VER_CHR
);
1060 if (h
->versioned
== unknown
)
1062 if (new_version
> name
&& new_version
[-1] != ELF_VER_CHR
)
1063 h
->versioned
= versioned_hidden
;
1065 h
->versioned
= versioned
;
1068 if (new_version
[0] == '\0')
1072 h
->versioned
= unversioned
;
1077 /* For merging, we only care about real symbols. But we need to make
1078 sure that indirect symbol dynamic flags are updated. */
1080 while (h
->root
.type
== bfd_link_hash_indirect
1081 || h
->root
.type
== bfd_link_hash_warning
)
1082 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1086 if (hi
== h
|| h
->root
.type
== bfd_link_hash_new
)
1090 /* OLD_HIDDEN is true if the existing symbol is only visible
1091 to the symbol with the same symbol version. NEW_HIDDEN is
1092 true if the new symbol is only visible to the symbol with
1093 the same symbol version. */
1094 bfd_boolean old_hidden
= h
->versioned
== versioned_hidden
;
1095 bfd_boolean new_hidden
= hi
->versioned
== versioned_hidden
;
1096 if (!old_hidden
&& !new_hidden
)
1097 /* The new symbol matches the existing symbol if both
1102 /* OLD_VERSION is the symbol version of the existing
1106 if (h
->versioned
>= versioned
)
1107 old_version
= strrchr (h
->root
.root
.string
,
1112 /* The new symbol matches the existing symbol if they
1113 have the same symbol version. */
1114 *matched
= (old_version
== new_version
1115 || (old_version
!= NULL
1116 && new_version
!= NULL
1117 && strcmp (old_version
, new_version
) == 0));
1122 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
1127 switch (h
->root
.type
)
1132 case bfd_link_hash_undefined
:
1133 case bfd_link_hash_undefweak
:
1134 oldbfd
= h
->root
.u
.undef
.abfd
;
1137 case bfd_link_hash_defined
:
1138 case bfd_link_hash_defweak
:
1139 oldbfd
= h
->root
.u
.def
.section
->owner
;
1140 oldsec
= h
->root
.u
.def
.section
;
1143 case bfd_link_hash_common
:
1144 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
1145 oldsec
= h
->root
.u
.c
.p
->section
;
1147 *pold_alignment
= h
->root
.u
.c
.p
->alignment_power
;
1150 if (poldbfd
&& *poldbfd
== NULL
)
1153 /* Differentiate strong and weak symbols. */
1154 newweak
= bind
== STB_WEAK
;
1155 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
1156 || h
->root
.type
== bfd_link_hash_undefweak
);
1158 *pold_weak
= oldweak
;
1160 /* This code is for coping with dynamic objects, and is only useful
1161 if we are doing an ELF link. */
1162 if (!(*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
1165 /* We have to check it for every instance since the first few may be
1166 references and not all compilers emit symbol type for undefined
1168 bfd_elf_link_mark_dynamic_symbol (info
, h
, sym
);
1170 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1171 respectively, is from a dynamic object. */
1173 newdyn
= (abfd
->flags
& DYNAMIC
) != 0;
1175 /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
1176 syms and defined syms in dynamic libraries respectively.
1177 ref_dynamic on the other hand can be set for a symbol defined in
1178 a dynamic library, and def_dynamic may not be set; When the
1179 definition in a dynamic lib is overridden by a definition in the
1180 executable use of the symbol in the dynamic lib becomes a
1181 reference to the executable symbol. */
1184 if (bfd_is_und_section (sec
))
1186 if (bind
!= STB_WEAK
)
1188 h
->ref_dynamic_nonweak
= 1;
1189 hi
->ref_dynamic_nonweak
= 1;
1194 /* Update the existing symbol only if they match. */
1197 hi
->dynamic_def
= 1;
1201 /* If we just created the symbol, mark it as being an ELF symbol.
1202 Other than that, there is nothing to do--there is no merge issue
1203 with a newly defined symbol--so we just return. */
1205 if (h
->root
.type
== bfd_link_hash_new
)
1211 /* In cases involving weak versioned symbols, we may wind up trying
1212 to merge a symbol with itself. Catch that here, to avoid the
1213 confusion that results if we try to override a symbol with
1214 itself. The additional tests catch cases like
1215 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1216 dynamic object, which we do want to handle here. */
1218 && (newweak
|| oldweak
)
1219 && ((abfd
->flags
& DYNAMIC
) == 0
1220 || !h
->def_regular
))
1225 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
1226 else if (oldsec
!= NULL
)
1228 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1229 indices used by MIPS ELF. */
1230 olddyn
= (oldsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
1233 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1234 respectively, appear to be a definition rather than reference. */
1236 newdef
= !bfd_is_und_section (sec
) && !bfd_is_com_section (sec
);
1238 olddef
= (h
->root
.type
!= bfd_link_hash_undefined
1239 && h
->root
.type
!= bfd_link_hash_undefweak
1240 && h
->root
.type
!= bfd_link_hash_common
);
1242 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1243 respectively, appear to be a function. */
1245 newfunc
= (ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1246 && bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)));
1248 oldfunc
= (h
->type
!= STT_NOTYPE
1249 && bed
->is_function_type (h
->type
));
1251 if (!(newfunc
&& oldfunc
)
1252 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1253 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1254 && h
->type
!= STT_NOTYPE
1255 && (newdef
|| bfd_is_com_section (sec
))
1256 && (olddef
|| h
->root
.type
== bfd_link_hash_common
))
1258 /* If creating a default indirect symbol ("foo" or "foo@") from
1259 a dynamic versioned definition ("foo@@") skip doing so if
1260 there is an existing regular definition with a different
1261 type. We don't want, for example, a "time" variable in the
1262 executable overriding a "time" function in a shared library. */
1270 /* When adding a symbol from a regular object file after we have
1271 created indirect symbols, undo the indirection and any
1278 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1279 h
->forced_local
= 0;
1283 if (h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1285 h
->root
.type
= bfd_link_hash_undefined
;
1286 h
->root
.u
.undef
.abfd
= abfd
;
1290 h
->root
.type
= bfd_link_hash_new
;
1291 h
->root
.u
.undef
.abfd
= NULL
;
1297 /* Check TLS symbols. We don't check undefined symbols introduced
1298 by "ld -u" which have no type (and oldbfd NULL), and we don't
1299 check symbols from plugins because they also have no type. */
1301 && (oldbfd
->flags
& BFD_PLUGIN
) == 0
1302 && (abfd
->flags
& BFD_PLUGIN
) == 0
1303 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1304 && (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
|| h
->type
== STT_TLS
))
1307 bfd_boolean ntdef
, tdef
;
1308 asection
*ntsec
, *tsec
;
1310 if (h
->type
== STT_TLS
)
1331 /* xgettext:c-format */
1332 (_("%s: TLS definition in %B section %A "
1333 "mismatches non-TLS definition in %B section %A"),
1334 h
->root
.root
.string
, tbfd
, tsec
, ntbfd
, ntsec
);
1335 else if (!tdef
&& !ntdef
)
1337 /* xgettext:c-format */
1338 (_("%s: TLS reference in %B "
1339 "mismatches non-TLS reference in %B"),
1340 h
->root
.root
.string
, tbfd
, ntbfd
);
1343 /* xgettext:c-format */
1344 (_("%s: TLS definition in %B section %A "
1345 "mismatches non-TLS reference in %B"),
1346 h
->root
.root
.string
, tbfd
, tsec
, ntbfd
);
1349 /* xgettext:c-format */
1350 (_("%s: TLS reference in %B "
1351 "mismatches non-TLS definition in %B section %A"),
1352 h
->root
.root
.string
, tbfd
, ntbfd
, ntsec
);
1354 bfd_set_error (bfd_error_bad_value
);
1358 /* If the old symbol has non-default visibility, we ignore the new
1359 definition from a dynamic object. */
1361 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1362 && !bfd_is_und_section (sec
))
1365 /* Make sure this symbol is dynamic. */
1367 hi
->ref_dynamic
= 1;
1368 /* A protected symbol has external availability. Make sure it is
1369 recorded as dynamic.
1371 FIXME: Should we check type and size for protected symbol? */
1372 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1373 return bfd_elf_link_record_dynamic_symbol (info
, h
);
1378 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
1381 /* If the new symbol with non-default visibility comes from a
1382 relocatable file and the old definition comes from a dynamic
1383 object, we remove the old definition. */
1384 if (hi
->root
.type
== bfd_link_hash_indirect
)
1386 /* Handle the case where the old dynamic definition is
1387 default versioned. We need to copy the symbol info from
1388 the symbol with default version to the normal one if it
1389 was referenced before. */
1392 hi
->root
.type
= h
->root
.type
;
1393 h
->root
.type
= bfd_link_hash_indirect
;
1394 (*bed
->elf_backend_copy_indirect_symbol
) (info
, hi
, h
);
1396 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1397 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1399 /* If the new symbol is hidden or internal, completely undo
1400 any dynamic link state. */
1401 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1402 h
->forced_local
= 0;
1409 /* FIXME: Should we check type and size for protected symbol? */
1419 /* If the old symbol was undefined before, then it will still be
1420 on the undefs list. If the new symbol is undefined or
1421 common, we can't make it bfd_link_hash_new here, because new
1422 undefined or common symbols will be added to the undefs list
1423 by _bfd_generic_link_add_one_symbol. Symbols may not be
1424 added twice to the undefs list. Also, if the new symbol is
1425 undefweak then we don't want to lose the strong undef. */
1426 if (h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1428 h
->root
.type
= bfd_link_hash_undefined
;
1429 h
->root
.u
.undef
.abfd
= abfd
;
1433 h
->root
.type
= bfd_link_hash_new
;
1434 h
->root
.u
.undef
.abfd
= NULL
;
1437 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1439 /* If the new symbol is hidden or internal, completely undo
1440 any dynamic link state. */
1441 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1442 h
->forced_local
= 0;
1448 /* FIXME: Should we check type and size for protected symbol? */
1454 /* If a new weak symbol definition comes from a regular file and the
1455 old symbol comes from a dynamic library, we treat the new one as
1456 strong. Similarly, an old weak symbol definition from a regular
1457 file is treated as strong when the new symbol comes from a dynamic
1458 library. Further, an old weak symbol from a dynamic library is
1459 treated as strong if the new symbol is from a dynamic library.
1460 This reflects the way glibc's ld.so works.
1462 Do this before setting *type_change_ok or *size_change_ok so that
1463 we warn properly when dynamic library symbols are overridden. */
1465 if (newdef
&& !newdyn
&& olddyn
)
1467 if (olddef
&& newdyn
)
1470 /* Allow changes between different types of function symbol. */
1471 if (newfunc
&& oldfunc
)
1472 *type_change_ok
= TRUE
;
1474 /* It's OK to change the type if either the existing symbol or the
1475 new symbol is weak. A type change is also OK if the old symbol
1476 is undefined and the new symbol is defined. */
1481 && h
->root
.type
== bfd_link_hash_undefined
))
1482 *type_change_ok
= TRUE
;
1484 /* It's OK to change the size if either the existing symbol or the
1485 new symbol is weak, or if the old symbol is undefined. */
1488 || h
->root
.type
== bfd_link_hash_undefined
)
1489 *size_change_ok
= TRUE
;
1491 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1492 symbol, respectively, appears to be a common symbol in a dynamic
1493 object. If a symbol appears in an uninitialized section, and is
1494 not weak, and is not a function, then it may be a common symbol
1495 which was resolved when the dynamic object was created. We want
1496 to treat such symbols specially, because they raise special
1497 considerations when setting the symbol size: if the symbol
1498 appears as a common symbol in a regular object, and the size in
1499 the regular object is larger, we must make sure that we use the
1500 larger size. This problematic case can always be avoided in C,
1501 but it must be handled correctly when using Fortran shared
1504 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1505 likewise for OLDDYNCOMMON and OLDDEF.
1507 Note that this test is just a heuristic, and that it is quite
1508 possible to have an uninitialized symbol in a shared object which
1509 is really a definition, rather than a common symbol. This could
1510 lead to some minor confusion when the symbol really is a common
1511 symbol in some regular object. However, I think it will be
1517 && (sec
->flags
& SEC_ALLOC
) != 0
1518 && (sec
->flags
& SEC_LOAD
) == 0
1521 newdyncommon
= TRUE
;
1523 newdyncommon
= FALSE
;
1527 && h
->root
.type
== bfd_link_hash_defined
1529 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1530 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
1533 olddyncommon
= TRUE
;
1535 olddyncommon
= FALSE
;
1537 /* We now know everything about the old and new symbols. We ask the
1538 backend to check if we can merge them. */
1539 if (bed
->merge_symbol
!= NULL
)
1541 if (!bed
->merge_symbol (h
, sym
, psec
, newdef
, olddef
, oldbfd
, oldsec
))
1546 /* If both the old and the new symbols look like common symbols in a
1547 dynamic object, set the size of the symbol to the larger of the
1552 && sym
->st_size
!= h
->size
)
1554 /* Since we think we have two common symbols, issue a multiple
1555 common warning if desired. Note that we only warn if the
1556 size is different. If the size is the same, we simply let
1557 the old symbol override the new one as normally happens with
1558 symbols defined in dynamic objects. */
1560 (*info
->callbacks
->multiple_common
) (info
, &h
->root
, abfd
,
1561 bfd_link_hash_common
, sym
->st_size
);
1562 if (sym
->st_size
> h
->size
)
1563 h
->size
= sym
->st_size
;
1565 *size_change_ok
= TRUE
;
1568 /* If we are looking at a dynamic object, and we have found a
1569 definition, we need to see if the symbol was already defined by
1570 some other object. If so, we want to use the existing
1571 definition, and we do not want to report a multiple symbol
1572 definition error; we do this by clobbering *PSEC to be
1573 bfd_und_section_ptr.
1575 We treat a common symbol as a definition if the symbol in the
1576 shared library is a function, since common symbols always
1577 represent variables; this can cause confusion in principle, but
1578 any such confusion would seem to indicate an erroneous program or
1579 shared library. We also permit a common symbol in a regular
1580 object to override a weak symbol in a shared object. */
1585 || (h
->root
.type
== bfd_link_hash_common
1586 && (newweak
|| newfunc
))))
1590 newdyncommon
= FALSE
;
1592 *psec
= sec
= bfd_und_section_ptr
;
1593 *size_change_ok
= TRUE
;
1595 /* If we get here when the old symbol is a common symbol, then
1596 we are explicitly letting it override a weak symbol or
1597 function in a dynamic object, and we don't want to warn about
1598 a type change. If the old symbol is a defined symbol, a type
1599 change warning may still be appropriate. */
1601 if (h
->root
.type
== bfd_link_hash_common
)
1602 *type_change_ok
= TRUE
;
1605 /* Handle the special case of an old common symbol merging with a
1606 new symbol which looks like a common symbol in a shared object.
1607 We change *PSEC and *PVALUE to make the new symbol look like a
1608 common symbol, and let _bfd_generic_link_add_one_symbol do the
1612 && h
->root
.type
== bfd_link_hash_common
)
1616 newdyncommon
= FALSE
;
1617 *pvalue
= sym
->st_size
;
1618 *psec
= sec
= bed
->common_section (oldsec
);
1619 *size_change_ok
= TRUE
;
1622 /* Skip weak definitions of symbols that are already defined. */
1623 if (newdef
&& olddef
&& newweak
)
1625 /* Don't skip new non-IR weak syms. */
1626 if (!(oldbfd
!= NULL
1627 && (oldbfd
->flags
& BFD_PLUGIN
) != 0
1628 && (abfd
->flags
& BFD_PLUGIN
) == 0))
1634 /* Merge st_other. If the symbol already has a dynamic index,
1635 but visibility says it should not be visible, turn it into a
1637 elf_merge_st_other (abfd
, h
, sym
, sec
, newdef
, newdyn
);
1638 if (h
->dynindx
!= -1)
1639 switch (ELF_ST_VISIBILITY (h
->other
))
1643 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1648 /* If the old symbol is from a dynamic object, and the new symbol is
1649 a definition which is not from a dynamic object, then the new
1650 symbol overrides the old symbol. Symbols from regular files
1651 always take precedence over symbols from dynamic objects, even if
1652 they are defined after the dynamic object in the link.
1654 As above, we again permit a common symbol in a regular object to
1655 override a definition in a shared object if the shared object
1656 symbol is a function or is weak. */
1661 || (bfd_is_com_section (sec
)
1662 && (oldweak
|| oldfunc
)))
1667 /* Change the hash table entry to undefined, and let
1668 _bfd_generic_link_add_one_symbol do the right thing with the
1671 h
->root
.type
= bfd_link_hash_undefined
;
1672 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1673 *size_change_ok
= TRUE
;
1676 olddyncommon
= FALSE
;
1678 /* We again permit a type change when a common symbol may be
1679 overriding a function. */
1681 if (bfd_is_com_section (sec
))
1685 /* If a common symbol overrides a function, make sure
1686 that it isn't defined dynamically nor has type
1689 h
->type
= STT_NOTYPE
;
1691 *type_change_ok
= TRUE
;
1694 if (hi
->root
.type
== bfd_link_hash_indirect
)
1697 /* This union may have been set to be non-NULL when this symbol
1698 was seen in a dynamic object. We must force the union to be
1699 NULL, so that it is correct for a regular symbol. */
1700 h
->verinfo
.vertree
= NULL
;
1703 /* Handle the special case of a new common symbol merging with an
1704 old symbol that looks like it might be a common symbol defined in
1705 a shared object. Note that we have already handled the case in
1706 which a new common symbol should simply override the definition
1707 in the shared library. */
1710 && bfd_is_com_section (sec
)
1713 /* It would be best if we could set the hash table entry to a
1714 common symbol, but we don't know what to use for the section
1715 or the alignment. */
1716 (*info
->callbacks
->multiple_common
) (info
, &h
->root
, abfd
,
1717 bfd_link_hash_common
, sym
->st_size
);
1719 /* If the presumed common symbol in the dynamic object is
1720 larger, pretend that the new symbol has its size. */
1722 if (h
->size
> *pvalue
)
1725 /* We need to remember the alignment required by the symbol
1726 in the dynamic object. */
1727 BFD_ASSERT (pold_alignment
);
1728 *pold_alignment
= h
->root
.u
.def
.section
->alignment_power
;
1731 olddyncommon
= FALSE
;
1733 h
->root
.type
= bfd_link_hash_undefined
;
1734 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1736 *size_change_ok
= TRUE
;
1737 *type_change_ok
= TRUE
;
1739 if (hi
->root
.type
== bfd_link_hash_indirect
)
1742 h
->verinfo
.vertree
= NULL
;
1747 /* Handle the case where we had a versioned symbol in a dynamic
1748 library and now find a definition in a normal object. In this
1749 case, we make the versioned symbol point to the normal one. */
1750 flip
->root
.type
= h
->root
.type
;
1751 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1752 h
->root
.type
= bfd_link_hash_indirect
;
1753 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1754 (*bed
->elf_backend_copy_indirect_symbol
) (info
, flip
, h
);
1758 flip
->ref_dynamic
= 1;
1765 /* This function is called to create an indirect symbol from the
1766 default for the symbol with the default version if needed. The
1767 symbol is described by H, NAME, SYM, SEC, and VALUE. We
1768 set DYNSYM if the new indirect symbol is dynamic. */
1771 _bfd_elf_add_default_symbol (bfd
*abfd
,
1772 struct bfd_link_info
*info
,
1773 struct elf_link_hash_entry
*h
,
1775 Elf_Internal_Sym
*sym
,
1779 bfd_boolean
*dynsym
)
1781 bfd_boolean type_change_ok
;
1782 bfd_boolean size_change_ok
;
1785 struct elf_link_hash_entry
*hi
;
1786 struct bfd_link_hash_entry
*bh
;
1787 const struct elf_backend_data
*bed
;
1788 bfd_boolean collect
;
1789 bfd_boolean dynamic
;
1790 bfd_boolean override
;
1792 size_t len
, shortlen
;
1794 bfd_boolean matched
;
1796 if (h
->versioned
== unversioned
|| h
->versioned
== versioned_hidden
)
1799 /* If this symbol has a version, and it is the default version, we
1800 create an indirect symbol from the default name to the fully
1801 decorated name. This will cause external references which do not
1802 specify a version to be bound to this version of the symbol. */
1803 p
= strchr (name
, ELF_VER_CHR
);
1804 if (h
->versioned
== unknown
)
1808 h
->versioned
= unversioned
;
1813 if (p
[1] != ELF_VER_CHR
)
1815 h
->versioned
= versioned_hidden
;
1819 h
->versioned
= versioned
;
1824 /* PR ld/19073: We may see an unversioned definition after the
1830 bed
= get_elf_backend_data (abfd
);
1831 collect
= bed
->collect
;
1832 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1834 shortlen
= p
- name
;
1835 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1836 if (shortname
== NULL
)
1838 memcpy (shortname
, name
, shortlen
);
1839 shortname
[shortlen
] = '\0';
1841 /* We are going to create a new symbol. Merge it with any existing
1842 symbol with this name. For the purposes of the merge, act as
1843 though we were defining the symbol we just defined, although we
1844 actually going to define an indirect symbol. */
1845 type_change_ok
= FALSE
;
1846 size_change_ok
= FALSE
;
1849 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &tmp_sec
, &value
,
1850 &hi
, poldbfd
, NULL
, NULL
, &skip
, &override
,
1851 &type_change_ok
, &size_change_ok
, &matched
))
1857 if (hi
->def_regular
)
1859 /* If the undecorated symbol will have a version added by a
1860 script different to H, then don't indirect to/from the
1861 undecorated symbol. This isn't ideal because we may not yet
1862 have seen symbol versions, if given by a script on the
1863 command line rather than via --version-script. */
1864 if (hi
->verinfo
.vertree
== NULL
&& info
->version_info
!= NULL
)
1869 = bfd_find_version_for_sym (info
->version_info
,
1870 hi
->root
.root
.string
, &hide
);
1871 if (hi
->verinfo
.vertree
!= NULL
&& hide
)
1873 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
1877 if (hi
->verinfo
.vertree
!= NULL
1878 && strcmp (p
+ 1 + (p
[1] == '@'), hi
->verinfo
.vertree
->name
) != 0)
1884 /* Add the default symbol if not performing a relocatable link. */
1885 if (! bfd_link_relocatable (info
))
1888 if (! (_bfd_generic_link_add_one_symbol
1889 (info
, abfd
, shortname
, BSF_INDIRECT
,
1890 bfd_ind_section_ptr
,
1891 0, name
, FALSE
, collect
, &bh
)))
1893 hi
= (struct elf_link_hash_entry
*) bh
;
1898 /* In this case the symbol named SHORTNAME is overriding the
1899 indirect symbol we want to add. We were planning on making
1900 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1901 is the name without a version. NAME is the fully versioned
1902 name, and it is the default version.
1904 Overriding means that we already saw a definition for the
1905 symbol SHORTNAME in a regular object, and it is overriding
1906 the symbol defined in the dynamic object.
1908 When this happens, we actually want to change NAME, the
1909 symbol we just added, to refer to SHORTNAME. This will cause
1910 references to NAME in the shared object to become references
1911 to SHORTNAME in the regular object. This is what we expect
1912 when we override a function in a shared object: that the
1913 references in the shared object will be mapped to the
1914 definition in the regular object. */
1916 while (hi
->root
.type
== bfd_link_hash_indirect
1917 || hi
->root
.type
== bfd_link_hash_warning
)
1918 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1920 h
->root
.type
= bfd_link_hash_indirect
;
1921 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1925 hi
->ref_dynamic
= 1;
1929 if (! bfd_elf_link_record_dynamic_symbol (info
, hi
))
1934 /* Now set HI to H, so that the following code will set the
1935 other fields correctly. */
1939 /* Check if HI is a warning symbol. */
1940 if (hi
->root
.type
== bfd_link_hash_warning
)
1941 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1943 /* If there is a duplicate definition somewhere, then HI may not
1944 point to an indirect symbol. We will have reported an error to
1945 the user in that case. */
1947 if (hi
->root
.type
== bfd_link_hash_indirect
)
1949 struct elf_link_hash_entry
*ht
;
1951 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1952 (*bed
->elf_backend_copy_indirect_symbol
) (info
, ht
, hi
);
1954 /* A reference to the SHORTNAME symbol from a dynamic library
1955 will be satisfied by the versioned symbol at runtime. In
1956 effect, we have a reference to the versioned symbol. */
1957 ht
->ref_dynamic_nonweak
|= hi
->ref_dynamic_nonweak
;
1958 hi
->dynamic_def
|= ht
->dynamic_def
;
1960 /* See if the new flags lead us to realize that the symbol must
1966 if (! bfd_link_executable (info
)
1973 if (hi
->ref_regular
)
1979 /* We also need to define an indirection from the nondefault version
1983 len
= strlen (name
);
1984 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, len
);
1985 if (shortname
== NULL
)
1987 memcpy (shortname
, name
, shortlen
);
1988 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1990 /* Once again, merge with any existing symbol. */
1991 type_change_ok
= FALSE
;
1992 size_change_ok
= FALSE
;
1994 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &tmp_sec
, &value
,
1995 &hi
, poldbfd
, NULL
, NULL
, &skip
, &override
,
1996 &type_change_ok
, &size_change_ok
, &matched
))
2004 /* Here SHORTNAME is a versioned name, so we don't expect to see
2005 the type of override we do in the case above unless it is
2006 overridden by a versioned definition. */
2007 if (hi
->root
.type
!= bfd_link_hash_defined
2008 && hi
->root
.type
!= bfd_link_hash_defweak
)
2010 /* xgettext:c-format */
2011 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
2017 if (! (_bfd_generic_link_add_one_symbol
2018 (info
, abfd
, shortname
, BSF_INDIRECT
,
2019 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
2021 hi
= (struct elf_link_hash_entry
*) bh
;
2023 /* If there is a duplicate definition somewhere, then HI may not
2024 point to an indirect symbol. We will have reported an error
2025 to the user in that case. */
2027 if (hi
->root
.type
== bfd_link_hash_indirect
)
2029 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
2030 h
->ref_dynamic_nonweak
|= hi
->ref_dynamic_nonweak
;
2031 hi
->dynamic_def
|= h
->dynamic_def
;
2033 /* See if the new flags lead us to realize that the symbol
2039 if (! bfd_link_executable (info
)
2045 if (hi
->ref_regular
)
2055 /* This routine is used to export all defined symbols into the dynamic
2056 symbol table. It is called via elf_link_hash_traverse. */
2059 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
2061 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2063 /* Ignore indirect symbols. These are added by the versioning code. */
2064 if (h
->root
.type
== bfd_link_hash_indirect
)
2067 /* Ignore this if we won't export it. */
2068 if (!eif
->info
->export_dynamic
&& !h
->dynamic
)
2071 if (h
->dynindx
== -1
2072 && (h
->def_regular
|| h
->ref_regular
)
2073 && ! bfd_hide_sym_by_version (eif
->info
->version_info
,
2074 h
->root
.root
.string
))
2076 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2086 /* Look through the symbols which are defined in other shared
2087 libraries and referenced here. Update the list of version
2088 dependencies. This will be put into the .gnu.version_r section.
2089 This function is called via elf_link_hash_traverse. */
2092 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
2095 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
2096 Elf_Internal_Verneed
*t
;
2097 Elf_Internal_Vernaux
*a
;
2100 /* We only care about symbols defined in shared objects with version
2105 || h
->verinfo
.verdef
== NULL
2106 || (elf_dyn_lib_class (h
->verinfo
.verdef
->vd_bfd
)
2107 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
| DYN_NO_NEEDED
)))
2110 /* See if we already know about this version. */
2111 for (t
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
2115 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
2118 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2119 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
2125 /* This is a new version. Add it to tree we are building. */
2130 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
2133 rinfo
->failed
= TRUE
;
2137 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
2138 t
->vn_nextref
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
2139 elf_tdata (rinfo
->info
->output_bfd
)->verref
= t
;
2143 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
2146 rinfo
->failed
= TRUE
;
2150 /* Note that we are copying a string pointer here, and testing it
2151 above. If bfd_elf_string_from_elf_section is ever changed to
2152 discard the string data when low in memory, this will have to be
2154 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
2156 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
2157 a
->vna_nextptr
= t
->vn_auxptr
;
2159 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
2162 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
2169 /* Figure out appropriate versions for all the symbols. We may not
2170 have the version number script until we have read all of the input
2171 files, so until that point we don't know which symbols should be
2172 local. This function is called via elf_link_hash_traverse. */
2175 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
2177 struct elf_info_failed
*sinfo
;
2178 struct bfd_link_info
*info
;
2179 const struct elf_backend_data
*bed
;
2180 struct elf_info_failed eif
;
2183 sinfo
= (struct elf_info_failed
*) data
;
2186 /* Fix the symbol flags. */
2189 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
2192 sinfo
->failed
= TRUE
;
2196 /* We only need version numbers for symbols defined in regular
2198 if (!h
->def_regular
)
2201 bed
= get_elf_backend_data (info
->output_bfd
);
2202 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
2203 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
2205 struct bfd_elf_version_tree
*t
;
2208 if (*p
== ELF_VER_CHR
)
2211 /* If there is no version string, we can just return out. */
2215 /* Look for the version. If we find it, it is no longer weak. */
2216 for (t
= sinfo
->info
->version_info
; t
!= NULL
; t
= t
->next
)
2218 if (strcmp (t
->name
, p
) == 0)
2222 struct bfd_elf_version_expr
*d
;
2224 len
= p
- h
->root
.root
.string
;
2225 alc
= (char *) bfd_malloc (len
);
2228 sinfo
->failed
= TRUE
;
2231 memcpy (alc
, h
->root
.root
.string
, len
- 1);
2232 alc
[len
- 1] = '\0';
2233 if (alc
[len
- 2] == ELF_VER_CHR
)
2234 alc
[len
- 2] = '\0';
2236 h
->verinfo
.vertree
= t
;
2240 if (t
->globals
.list
!= NULL
)
2241 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
2243 /* See if there is anything to force this symbol to
2245 if (d
== NULL
&& t
->locals
.list
!= NULL
)
2247 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
2250 && ! info
->export_dynamic
)
2251 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2259 /* If we are building an application, we need to create a
2260 version node for this version. */
2261 if (t
== NULL
&& bfd_link_executable (info
))
2263 struct bfd_elf_version_tree
**pp
;
2266 /* If we aren't going to export this symbol, we don't need
2267 to worry about it. */
2268 if (h
->dynindx
== -1)
2271 t
= (struct bfd_elf_version_tree
*) bfd_zalloc (info
->output_bfd
,
2275 sinfo
->failed
= TRUE
;
2280 t
->name_indx
= (unsigned int) -1;
2284 /* Don't count anonymous version tag. */
2285 if (sinfo
->info
->version_info
!= NULL
2286 && sinfo
->info
->version_info
->vernum
== 0)
2288 for (pp
= &sinfo
->info
->version_info
;
2292 t
->vernum
= version_index
;
2296 h
->verinfo
.vertree
= t
;
2300 /* We could not find the version for a symbol when
2301 generating a shared archive. Return an error. */
2303 /* xgettext:c-format */
2304 (_("%B: version node not found for symbol %s"),
2305 info
->output_bfd
, h
->root
.root
.string
);
2306 bfd_set_error (bfd_error_bad_value
);
2307 sinfo
->failed
= TRUE
;
2312 /* If we don't have a version for this symbol, see if we can find
2314 if (h
->verinfo
.vertree
== NULL
&& sinfo
->info
->version_info
!= NULL
)
2319 = bfd_find_version_for_sym (sinfo
->info
->version_info
,
2320 h
->root
.root
.string
, &hide
);
2321 if (h
->verinfo
.vertree
!= NULL
&& hide
)
2322 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2328 /* Read and swap the relocs from the section indicated by SHDR. This
2329 may be either a REL or a RELA section. The relocations are
2330 translated into RELA relocations and stored in INTERNAL_RELOCS,
2331 which should have already been allocated to contain enough space.
2332 The EXTERNAL_RELOCS are a buffer where the external form of the
2333 relocations should be stored.
2335 Returns FALSE if something goes wrong. */
2338 elf_link_read_relocs_from_section (bfd
*abfd
,
2340 Elf_Internal_Shdr
*shdr
,
2341 void *external_relocs
,
2342 Elf_Internal_Rela
*internal_relocs
)
2344 const struct elf_backend_data
*bed
;
2345 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2346 const bfd_byte
*erela
;
2347 const bfd_byte
*erelaend
;
2348 Elf_Internal_Rela
*irela
;
2349 Elf_Internal_Shdr
*symtab_hdr
;
2352 /* Position ourselves at the start of the section. */
2353 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2356 /* Read the relocations. */
2357 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
2360 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2361 nsyms
= NUM_SHDR_ENTRIES (symtab_hdr
);
2363 bed
= get_elf_backend_data (abfd
);
2365 /* Convert the external relocations to the internal format. */
2366 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2367 swap_in
= bed
->s
->swap_reloc_in
;
2368 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2369 swap_in
= bed
->s
->swap_reloca_in
;
2372 bfd_set_error (bfd_error_wrong_format
);
2376 erela
= (const bfd_byte
*) external_relocs
;
2377 erelaend
= erela
+ shdr
->sh_size
;
2378 irela
= internal_relocs
;
2379 while (erela
< erelaend
)
2383 (*swap_in
) (abfd
, erela
, irela
);
2384 r_symndx
= ELF32_R_SYM (irela
->r_info
);
2385 if (bed
->s
->arch_size
== 64)
2389 if ((size_t) r_symndx
>= nsyms
)
2392 /* xgettext:c-format */
2393 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2394 " for offset 0x%lx in section `%A'"),
2395 abfd
, (unsigned long) r_symndx
, (unsigned long) nsyms
,
2396 irela
->r_offset
, sec
);
2397 bfd_set_error (bfd_error_bad_value
);
2401 else if (r_symndx
!= STN_UNDEF
)
2404 /* xgettext:c-format */
2405 (_("%B: non-zero symbol index (0x%lx)"
2406 " for offset 0x%lx in section `%A'"
2407 " when the object file has no symbol table"),
2408 abfd
, (unsigned long) r_symndx
, (unsigned long) nsyms
,
2409 irela
->r_offset
, sec
);
2410 bfd_set_error (bfd_error_bad_value
);
2413 irela
+= bed
->s
->int_rels_per_ext_rel
;
2414 erela
+= shdr
->sh_entsize
;
2420 /* Read and swap the relocs for a section O. They may have been
2421 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2422 not NULL, they are used as buffers to read into. They are known to
2423 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2424 the return value is allocated using either malloc or bfd_alloc,
2425 according to the KEEP_MEMORY argument. If O has two relocation
2426 sections (both REL and RELA relocations), then the REL_HDR
2427 relocations will appear first in INTERNAL_RELOCS, followed by the
2428 RELA_HDR relocations. */
2431 _bfd_elf_link_read_relocs (bfd
*abfd
,
2433 void *external_relocs
,
2434 Elf_Internal_Rela
*internal_relocs
,
2435 bfd_boolean keep_memory
)
2437 void *alloc1
= NULL
;
2438 Elf_Internal_Rela
*alloc2
= NULL
;
2439 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2440 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
2441 Elf_Internal_Rela
*internal_rela_relocs
;
2443 if (esdo
->relocs
!= NULL
)
2444 return esdo
->relocs
;
2446 if (o
->reloc_count
== 0)
2449 if (internal_relocs
== NULL
)
2453 size
= (bfd_size_type
) o
->reloc_count
* sizeof (Elf_Internal_Rela
);
2455 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2457 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2458 if (internal_relocs
== NULL
)
2462 if (external_relocs
== NULL
)
2464 bfd_size_type size
= 0;
2467 size
+= esdo
->rel
.hdr
->sh_size
;
2469 size
+= esdo
->rela
.hdr
->sh_size
;
2471 alloc1
= bfd_malloc (size
);
2474 external_relocs
= alloc1
;
2477 internal_rela_relocs
= internal_relocs
;
2480 if (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rel
.hdr
,
2484 external_relocs
= (((bfd_byte
*) external_relocs
)
2485 + esdo
->rel
.hdr
->sh_size
);
2486 internal_rela_relocs
+= (NUM_SHDR_ENTRIES (esdo
->rel
.hdr
)
2487 * bed
->s
->int_rels_per_ext_rel
);
2491 && (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rela
.hdr
,
2493 internal_rela_relocs
)))
2496 /* Cache the results for next time, if we can. */
2498 esdo
->relocs
= internal_relocs
;
2503 /* Don't free alloc2, since if it was allocated we are passing it
2504 back (under the name of internal_relocs). */
2506 return internal_relocs
;
2514 bfd_release (abfd
, alloc2
);
2521 /* Compute the size of, and allocate space for, REL_HDR which is the
2522 section header for a section containing relocations for O. */
2525 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2526 struct bfd_elf_section_reloc_data
*reldata
)
2528 Elf_Internal_Shdr
*rel_hdr
= reldata
->hdr
;
2530 /* That allows us to calculate the size of the section. */
2531 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reldata
->count
;
2533 /* The contents field must last into write_object_contents, so we
2534 allocate it with bfd_alloc rather than malloc. Also since we
2535 cannot be sure that the contents will actually be filled in,
2536 we zero the allocated space. */
2537 rel_hdr
->contents
= (unsigned char *) bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2538 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2541 if (reldata
->hashes
== NULL
&& reldata
->count
)
2543 struct elf_link_hash_entry
**p
;
2545 p
= ((struct elf_link_hash_entry
**)
2546 bfd_zmalloc (reldata
->count
* sizeof (*p
)));
2550 reldata
->hashes
= p
;
2556 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2557 originated from the section given by INPUT_REL_HDR) to the
2561 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2562 asection
*input_section
,
2563 Elf_Internal_Shdr
*input_rel_hdr
,
2564 Elf_Internal_Rela
*internal_relocs
,
2565 struct elf_link_hash_entry
**rel_hash
2568 Elf_Internal_Rela
*irela
;
2569 Elf_Internal_Rela
*irelaend
;
2571 struct bfd_elf_section_reloc_data
*output_reldata
;
2572 asection
*output_section
;
2573 const struct elf_backend_data
*bed
;
2574 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2575 struct bfd_elf_section_data
*esdo
;
2577 output_section
= input_section
->output_section
;
2579 bed
= get_elf_backend_data (output_bfd
);
2580 esdo
= elf_section_data (output_section
);
2581 if (esdo
->rel
.hdr
&& esdo
->rel
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2583 output_reldata
= &esdo
->rel
;
2584 swap_out
= bed
->s
->swap_reloc_out
;
2586 else if (esdo
->rela
.hdr
2587 && esdo
->rela
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2589 output_reldata
= &esdo
->rela
;
2590 swap_out
= bed
->s
->swap_reloca_out
;
2595 /* xgettext:c-format */
2596 (_("%B: relocation size mismatch in %B section %A"),
2597 output_bfd
, input_section
->owner
, input_section
);
2598 bfd_set_error (bfd_error_wrong_format
);
2602 erel
= output_reldata
->hdr
->contents
;
2603 erel
+= output_reldata
->count
* input_rel_hdr
->sh_entsize
;
2604 irela
= internal_relocs
;
2605 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2606 * bed
->s
->int_rels_per_ext_rel
);
2607 while (irela
< irelaend
)
2609 (*swap_out
) (output_bfd
, irela
, erel
);
2610 irela
+= bed
->s
->int_rels_per_ext_rel
;
2611 erel
+= input_rel_hdr
->sh_entsize
;
2614 /* Bump the counter, so that we know where to add the next set of
2616 output_reldata
->count
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2621 /* Make weak undefined symbols in PIE dynamic. */
2624 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info
*info
,
2625 struct elf_link_hash_entry
*h
)
2627 if (bfd_link_pie (info
)
2629 && h
->root
.type
== bfd_link_hash_undefweak
)
2630 return bfd_elf_link_record_dynamic_symbol (info
, h
);
2635 /* Fix up the flags for a symbol. This handles various cases which
2636 can only be fixed after all the input files are seen. This is
2637 currently called by both adjust_dynamic_symbol and
2638 assign_sym_version, which is unnecessary but perhaps more robust in
2639 the face of future changes. */
2642 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2643 struct elf_info_failed
*eif
)
2645 const struct elf_backend_data
*bed
;
2647 /* If this symbol was mentioned in a non-ELF file, try to set
2648 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2649 permit a non-ELF file to correctly refer to a symbol defined in
2650 an ELF dynamic object. */
2653 while (h
->root
.type
== bfd_link_hash_indirect
)
2654 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2656 if (h
->root
.type
!= bfd_link_hash_defined
2657 && h
->root
.type
!= bfd_link_hash_defweak
)
2660 h
->ref_regular_nonweak
= 1;
2664 if (h
->root
.u
.def
.section
->owner
!= NULL
2665 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2666 == bfd_target_elf_flavour
))
2669 h
->ref_regular_nonweak
= 1;
2675 if (h
->dynindx
== -1
2679 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2688 /* Unfortunately, NON_ELF is only correct if the symbol
2689 was first seen in a non-ELF file. Fortunately, if the symbol
2690 was first seen in an ELF file, we're probably OK unless the
2691 symbol was defined in a non-ELF file. Catch that case here.
2692 FIXME: We're still in trouble if the symbol was first seen in
2693 a dynamic object, and then later in a non-ELF regular object. */
2694 if ((h
->root
.type
== bfd_link_hash_defined
2695 || h
->root
.type
== bfd_link_hash_defweak
)
2697 && (h
->root
.u
.def
.section
->owner
!= NULL
2698 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2699 != bfd_target_elf_flavour
)
2700 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2701 && !h
->def_dynamic
)))
2705 /* Backend specific symbol fixup. */
2706 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2707 if (bed
->elf_backend_fixup_symbol
2708 && !(*bed
->elf_backend_fixup_symbol
) (eif
->info
, h
))
2711 /* If this is a final link, and the symbol was defined as a common
2712 symbol in a regular object file, and there was no definition in
2713 any dynamic object, then the linker will have allocated space for
2714 the symbol in a common section but the DEF_REGULAR
2715 flag will not have been set. */
2716 if (h
->root
.type
== bfd_link_hash_defined
2720 && (h
->root
.u
.def
.section
->owner
->flags
& (DYNAMIC
| BFD_PLUGIN
)) == 0)
2723 /* If a weak undefined symbol has non-default visibility, we also
2724 hide it from the dynamic linker. */
2725 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2726 && h
->root
.type
== bfd_link_hash_undefweak
)
2727 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2729 /* A hidden versioned symbol in executable should be forced local if
2730 it is is locally defined, not referenced by shared library and not
2732 else if (bfd_link_executable (eif
->info
)
2733 && h
->versioned
== versioned_hidden
2734 && !eif
->info
->export_dynamic
2738 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2740 /* If -Bsymbolic was used (which means to bind references to global
2741 symbols to the definition within the shared object), and this
2742 symbol was defined in a regular object, then it actually doesn't
2743 need a PLT entry. Likewise, if the symbol has non-default
2744 visibility. If the symbol has hidden or internal visibility, we
2745 will force it local. */
2746 else if (h
->needs_plt
2747 && bfd_link_pic (eif
->info
)
2748 && is_elf_hash_table (eif
->info
->hash
)
2749 && (SYMBOLIC_BIND (eif
->info
, h
)
2750 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2753 bfd_boolean force_local
;
2755 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2756 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2757 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2760 /* If this is a weak defined symbol in a dynamic object, and we know
2761 the real definition in the dynamic object, copy interesting flags
2762 over to the real definition. */
2763 if (h
->u
.weakdef
!= NULL
)
2765 /* If the real definition is defined by a regular object file,
2766 don't do anything special. See the longer description in
2767 _bfd_elf_adjust_dynamic_symbol, below. */
2768 if (h
->u
.weakdef
->def_regular
)
2769 h
->u
.weakdef
= NULL
;
2772 struct elf_link_hash_entry
*weakdef
= h
->u
.weakdef
;
2774 while (h
->root
.type
== bfd_link_hash_indirect
)
2775 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2777 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2778 || h
->root
.type
== bfd_link_hash_defweak
);
2779 BFD_ASSERT (weakdef
->def_dynamic
);
2780 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2781 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2782 (*bed
->elf_backend_copy_indirect_symbol
) (eif
->info
, weakdef
, h
);
2789 /* Make the backend pick a good value for a dynamic symbol. This is
2790 called via elf_link_hash_traverse, and also calls itself
2794 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2796 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2798 const struct elf_backend_data
*bed
;
2800 if (! is_elf_hash_table (eif
->info
->hash
))
2803 /* Ignore indirect symbols. These are added by the versioning code. */
2804 if (h
->root
.type
== bfd_link_hash_indirect
)
2807 /* Fix the symbol flags. */
2808 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2811 if (h
->root
.type
== bfd_link_hash_undefweak
)
2813 if (eif
->info
->dynamic_undefined_weak
== 0)
2814 _bfd_elf_link_hash_hide_symbol (eif
->info
, h
, TRUE
);
2815 else if (eif
->info
->dynamic_undefined_weak
> 0
2817 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2818 && !bfd_hide_sym_by_version (eif
->info
->version_info
,
2819 h
->root
.root
.string
))
2821 if (!bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2829 /* If this symbol does not require a PLT entry, and it is not
2830 defined by a dynamic object, or is not referenced by a regular
2831 object, ignore it. We do have to handle a weak defined symbol,
2832 even if no regular object refers to it, if we decided to add it
2833 to the dynamic symbol table. FIXME: Do we normally need to worry
2834 about symbols which are defined by one dynamic object and
2835 referenced by another one? */
2837 && h
->type
!= STT_GNU_IFUNC
2841 && (h
->u
.weakdef
== NULL
|| h
->u
.weakdef
->dynindx
== -1))))
2843 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
2847 /* If we've already adjusted this symbol, don't do it again. This
2848 can happen via a recursive call. */
2849 if (h
->dynamic_adjusted
)
2852 /* Don't look at this symbol again. Note that we must set this
2853 after checking the above conditions, because we may look at a
2854 symbol once, decide not to do anything, and then get called
2855 recursively later after REF_REGULAR is set below. */
2856 h
->dynamic_adjusted
= 1;
2858 /* If this is a weak definition, and we know a real definition, and
2859 the real symbol is not itself defined by a regular object file,
2860 then get a good value for the real definition. We handle the
2861 real symbol first, for the convenience of the backend routine.
2863 Note that there is a confusing case here. If the real definition
2864 is defined by a regular object file, we don't get the real symbol
2865 from the dynamic object, but we do get the weak symbol. If the
2866 processor backend uses a COPY reloc, then if some routine in the
2867 dynamic object changes the real symbol, we will not see that
2868 change in the corresponding weak symbol. This is the way other
2869 ELF linkers work as well, and seems to be a result of the shared
2872 I will clarify this issue. Most SVR4 shared libraries define the
2873 variable _timezone and define timezone as a weak synonym. The
2874 tzset call changes _timezone. If you write
2875 extern int timezone;
2877 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2878 you might expect that, since timezone is a synonym for _timezone,
2879 the same number will print both times. However, if the processor
2880 backend uses a COPY reloc, then actually timezone will be copied
2881 into your process image, and, since you define _timezone
2882 yourself, _timezone will not. Thus timezone and _timezone will
2883 wind up at different memory locations. The tzset call will set
2884 _timezone, leaving timezone unchanged. */
2886 if (h
->u
.weakdef
!= NULL
)
2888 /* If we get to this point, there is an implicit reference to
2889 H->U.WEAKDEF by a regular object file via the weak symbol H. */
2890 h
->u
.weakdef
->ref_regular
= 1;
2892 /* Ensure that the backend adjust_dynamic_symbol function sees
2893 H->U.WEAKDEF before H by recursively calling ourselves. */
2894 if (! _bfd_elf_adjust_dynamic_symbol (h
->u
.weakdef
, eif
))
2898 /* If a symbol has no type and no size and does not require a PLT
2899 entry, then we are probably about to do the wrong thing here: we
2900 are probably going to create a COPY reloc for an empty object.
2901 This case can arise when a shared object is built with assembly
2902 code, and the assembly code fails to set the symbol type. */
2904 && h
->type
== STT_NOTYPE
2907 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2908 h
->root
.root
.string
);
2910 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2911 bed
= get_elf_backend_data (dynobj
);
2913 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2922 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2926 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info
*info
,
2927 struct elf_link_hash_entry
*h
,
2930 unsigned int power_of_two
;
2932 asection
*sec
= h
->root
.u
.def
.section
;
2934 /* The section aligment of definition is the maximum alignment
2935 requirement of symbols defined in the section. Since we don't
2936 know the symbol alignment requirement, we start with the
2937 maximum alignment and check low bits of the symbol address
2938 for the minimum alignment. */
2939 power_of_two
= bfd_get_section_alignment (sec
->owner
, sec
);
2940 mask
= ((bfd_vma
) 1 << power_of_two
) - 1;
2941 while ((h
->root
.u
.def
.value
& mask
) != 0)
2947 if (power_of_two
> bfd_get_section_alignment (dynbss
->owner
,
2950 /* Adjust the section alignment if needed. */
2951 if (! bfd_set_section_alignment (dynbss
->owner
, dynbss
,
2956 /* We make sure that the symbol will be aligned properly. */
2957 dynbss
->size
= BFD_ALIGN (dynbss
->size
, mask
+ 1);
2959 /* Define the symbol as being at this point in DYNBSS. */
2960 h
->root
.u
.def
.section
= dynbss
;
2961 h
->root
.u
.def
.value
= dynbss
->size
;
2963 /* Increment the size of DYNBSS to make room for the symbol. */
2964 dynbss
->size
+= h
->size
;
2966 /* No error if extern_protected_data is true. */
2967 if (h
->protected_def
2968 && (!info
->extern_protected_data
2969 || (info
->extern_protected_data
< 0
2970 && !get_elf_backend_data (dynbss
->owner
)->extern_protected_data
)))
2971 info
->callbacks
->einfo
2972 (_("%P: copy reloc against protected `%T' is dangerous\n"),
2973 h
->root
.root
.string
);
2978 /* Adjust all external symbols pointing into SEC_MERGE sections
2979 to reflect the object merging within the sections. */
2982 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2986 if ((h
->root
.type
== bfd_link_hash_defined
2987 || h
->root
.type
== bfd_link_hash_defweak
)
2988 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2989 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
2991 bfd
*output_bfd
= (bfd
*) data
;
2993 h
->root
.u
.def
.value
=
2994 _bfd_merged_section_offset (output_bfd
,
2995 &h
->root
.u
.def
.section
,
2996 elf_section_data (sec
)->sec_info
,
2997 h
->root
.u
.def
.value
);
3003 /* Returns false if the symbol referred to by H should be considered
3004 to resolve local to the current module, and true if it should be
3005 considered to bind dynamically. */
3008 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
3009 struct bfd_link_info
*info
,
3010 bfd_boolean not_local_protected
)
3012 bfd_boolean binding_stays_local_p
;
3013 const struct elf_backend_data
*bed
;
3014 struct elf_link_hash_table
*hash_table
;
3019 while (h
->root
.type
== bfd_link_hash_indirect
3020 || h
->root
.type
== bfd_link_hash_warning
)
3021 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3023 /* If it was forced local, then clearly it's not dynamic. */
3024 if (h
->dynindx
== -1)
3026 if (h
->forced_local
)
3029 /* Identify the cases where name binding rules say that a
3030 visible symbol resolves locally. */
3031 binding_stays_local_p
= (bfd_link_executable (info
)
3032 || SYMBOLIC_BIND (info
, h
));
3034 switch (ELF_ST_VISIBILITY (h
->other
))
3041 hash_table
= elf_hash_table (info
);
3042 if (!is_elf_hash_table (hash_table
))
3045 bed
= get_elf_backend_data (hash_table
->dynobj
);
3047 /* Proper resolution for function pointer equality may require
3048 that these symbols perhaps be resolved dynamically, even though
3049 we should be resolving them to the current module. */
3050 if (!not_local_protected
|| !bed
->is_function_type (h
->type
))
3051 binding_stays_local_p
= TRUE
;
3058 /* If it isn't defined locally, then clearly it's dynamic. */
3059 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
3062 /* Otherwise, the symbol is dynamic if binding rules don't tell
3063 us that it remains local. */
3064 return !binding_stays_local_p
;
3067 /* Return true if the symbol referred to by H should be considered
3068 to resolve local to the current module, and false otherwise. Differs
3069 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
3070 undefined symbols. The two functions are virtually identical except
3071 for the place where dynindx == -1 is tested. If that test is true,
3072 _bfd_elf_dynamic_symbol_p will say the symbol is local, while
3073 _bfd_elf_symbol_refs_local_p will say the symbol is local only for
3075 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
3076 !_bfd_elf_symbol_refs_local_p, except that targets differ in their
3077 treatment of undefined weak symbols. For those that do not make
3078 undefined weak symbols dynamic, both functions may return false. */
3081 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
3082 struct bfd_link_info
*info
,
3083 bfd_boolean local_protected
)
3085 const struct elf_backend_data
*bed
;
3086 struct elf_link_hash_table
*hash_table
;
3088 /* If it's a local sym, of course we resolve locally. */
3092 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
3093 if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
3094 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
3097 /* Forced local symbols resolve locally. */
3098 if (h
->forced_local
)
3101 /* Common symbols that become definitions don't get the DEF_REGULAR
3102 flag set, so test it first, and don't bail out. */
3103 if (ELF_COMMON_DEF_P (h
))
3105 /* If we don't have a definition in a regular file, then we can't
3106 resolve locally. The sym is either undefined or dynamic. */
3107 else if (!h
->def_regular
)
3110 /* Non-dynamic symbols resolve locally. */
3111 if (h
->dynindx
== -1)
3114 /* At this point, we know the symbol is defined and dynamic. In an
3115 executable it must resolve locally, likewise when building symbolic
3116 shared libraries. */
3117 if (bfd_link_executable (info
) || SYMBOLIC_BIND (info
, h
))
3120 /* Now deal with defined dynamic symbols in shared libraries. Ones
3121 with default visibility might not resolve locally. */
3122 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3125 hash_table
= elf_hash_table (info
);
3126 if (!is_elf_hash_table (hash_table
))
3129 bed
= get_elf_backend_data (hash_table
->dynobj
);
3131 /* If extern_protected_data is false, STV_PROTECTED non-function
3132 symbols are local. */
3133 if ((!info
->extern_protected_data
3134 || (info
->extern_protected_data
< 0
3135 && !bed
->extern_protected_data
))
3136 && !bed
->is_function_type (h
->type
))
3139 /* Function pointer equality tests may require that STV_PROTECTED
3140 symbols be treated as dynamic symbols. If the address of a
3141 function not defined in an executable is set to that function's
3142 plt entry in the executable, then the address of the function in
3143 a shared library must also be the plt entry in the executable. */
3144 return local_protected
;
3147 /* Caches some TLS segment info, and ensures that the TLS segment vma is
3148 aligned. Returns the first TLS output section. */
3150 struct bfd_section
*
3151 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
3153 struct bfd_section
*sec
, *tls
;
3154 unsigned int align
= 0;
3156 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3157 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
3161 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
3162 if (sec
->alignment_power
> align
)
3163 align
= sec
->alignment_power
;
3165 elf_hash_table (info
)->tls_sec
= tls
;
3167 /* Ensure the alignment of the first section is the largest alignment,
3168 so that the tls segment starts aligned. */
3170 tls
->alignment_power
= align
;
3175 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
3177 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
3178 Elf_Internal_Sym
*sym
)
3180 const struct elf_backend_data
*bed
;
3182 /* Local symbols do not count, but target specific ones might. */
3183 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
3184 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
3187 bed
= get_elf_backend_data (abfd
);
3188 /* Function symbols do not count. */
3189 if (bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)))
3192 /* If the section is undefined, then so is the symbol. */
3193 if (sym
->st_shndx
== SHN_UNDEF
)
3196 /* If the symbol is defined in the common section, then
3197 it is a common definition and so does not count. */
3198 if (bed
->common_definition (sym
))
3201 /* If the symbol is in a target specific section then we
3202 must rely upon the backend to tell us what it is. */
3203 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
3204 /* FIXME - this function is not coded yet:
3206 return _bfd_is_global_symbol_definition (abfd, sym);
3208 Instead for now assume that the definition is not global,
3209 Even if this is wrong, at least the linker will behave
3210 in the same way that it used to do. */
3216 /* Search the symbol table of the archive element of the archive ABFD
3217 whose archive map contains a mention of SYMDEF, and determine if
3218 the symbol is defined in this element. */
3220 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
3222 Elf_Internal_Shdr
* hdr
;
3226 Elf_Internal_Sym
*isymbuf
;
3227 Elf_Internal_Sym
*isym
;
3228 Elf_Internal_Sym
*isymend
;
3231 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
3235 if (! bfd_check_format (abfd
, bfd_object
))
3238 /* Select the appropriate symbol table. If we don't know if the
3239 object file is an IR object, give linker LTO plugin a chance to
3240 get the correct symbol table. */
3241 if (abfd
->plugin_format
== bfd_plugin_yes
3242 #if BFD_SUPPORTS_PLUGINS
3243 || (abfd
->plugin_format
== bfd_plugin_unknown
3244 && bfd_link_plugin_object_p (abfd
))
3248 /* Use the IR symbol table if the object has been claimed by
3250 abfd
= abfd
->plugin_dummy_bfd
;
3251 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3253 else if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
3254 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3256 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3258 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3260 /* The sh_info field of the symtab header tells us where the
3261 external symbols start. We don't care about the local symbols. */
3262 if (elf_bad_symtab (abfd
))
3264 extsymcount
= symcount
;
3269 extsymcount
= symcount
- hdr
->sh_info
;
3270 extsymoff
= hdr
->sh_info
;
3273 if (extsymcount
== 0)
3276 /* Read in the symbol table. */
3277 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3279 if (isymbuf
== NULL
)
3282 /* Scan the symbol table looking for SYMDEF. */
3284 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
3288 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3293 if (strcmp (name
, symdef
->name
) == 0)
3295 result
= is_global_data_symbol_definition (abfd
, isym
);
3305 /* Add an entry to the .dynamic table. */
3308 _bfd_elf_add_dynamic_entry (struct bfd_link_info
*info
,
3312 struct elf_link_hash_table
*hash_table
;
3313 const struct elf_backend_data
*bed
;
3315 bfd_size_type newsize
;
3316 bfd_byte
*newcontents
;
3317 Elf_Internal_Dyn dyn
;
3319 hash_table
= elf_hash_table (info
);
3320 if (! is_elf_hash_table (hash_table
))
3323 bed
= get_elf_backend_data (hash_table
->dynobj
);
3324 s
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3325 BFD_ASSERT (s
!= NULL
);
3327 newsize
= s
->size
+ bed
->s
->sizeof_dyn
;
3328 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
3329 if (newcontents
== NULL
)
3333 dyn
.d_un
.d_val
= val
;
3334 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
, newcontents
+ s
->size
);
3337 s
->contents
= newcontents
;
3342 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3343 otherwise just check whether one already exists. Returns -1 on error,
3344 1 if a DT_NEEDED tag already exists, and 0 on success. */
3347 elf_add_dt_needed_tag (bfd
*abfd
,
3348 struct bfd_link_info
*info
,
3352 struct elf_link_hash_table
*hash_table
;
3355 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
3358 hash_table
= elf_hash_table (info
);
3359 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, soname
, FALSE
);
3360 if (strindex
== (size_t) -1)
3363 if (_bfd_elf_strtab_refcount (hash_table
->dynstr
, strindex
) != 1)
3366 const struct elf_backend_data
*bed
;
3369 bed
= get_elf_backend_data (hash_table
->dynobj
);
3370 sdyn
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3372 for (extdyn
= sdyn
->contents
;
3373 extdyn
< sdyn
->contents
+ sdyn
->size
;
3374 extdyn
+= bed
->s
->sizeof_dyn
)
3376 Elf_Internal_Dyn dyn
;
3378 bed
->s
->swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
3379 if (dyn
.d_tag
== DT_NEEDED
3380 && dyn
.d_un
.d_val
== strindex
)
3382 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3390 if (!_bfd_elf_link_create_dynamic_sections (hash_table
->dynobj
, info
))
3393 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
3397 /* We were just checking for existence of the tag. */
3398 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3403 /* Return true if SONAME is on the needed list between NEEDED and STOP
3404 (or the end of list if STOP is NULL), and needed by a library that
3408 on_needed_list (const char *soname
,
3409 struct bfd_link_needed_list
*needed
,
3410 struct bfd_link_needed_list
*stop
)
3412 struct bfd_link_needed_list
*look
;
3413 for (look
= needed
; look
!= stop
; look
= look
->next
)
3414 if (strcmp (soname
, look
->name
) == 0
3415 && ((elf_dyn_lib_class (look
->by
) & DYN_AS_NEEDED
) == 0
3416 /* If needed by a library that itself is not directly
3417 needed, recursively check whether that library is
3418 indirectly needed. Since we add DT_NEEDED entries to
3419 the end of the list, library dependencies appear after
3420 the library. Therefore search prior to the current
3421 LOOK, preventing possible infinite recursion. */
3422 || on_needed_list (elf_dt_name (look
->by
), needed
, look
)))
3428 /* Sort symbol by value, section, and size. */
3430 elf_sort_symbol (const void *arg1
, const void *arg2
)
3432 const struct elf_link_hash_entry
*h1
;
3433 const struct elf_link_hash_entry
*h2
;
3434 bfd_signed_vma vdiff
;
3436 h1
= *(const struct elf_link_hash_entry
**) arg1
;
3437 h2
= *(const struct elf_link_hash_entry
**) arg2
;
3438 vdiff
= h1
->root
.u
.def
.value
- h2
->root
.u
.def
.value
;
3440 return vdiff
> 0 ? 1 : -1;
3443 int sdiff
= h1
->root
.u
.def
.section
->id
- h2
->root
.u
.def
.section
->id
;
3445 return sdiff
> 0 ? 1 : -1;
3447 vdiff
= h1
->size
- h2
->size
;
3448 return vdiff
== 0 ? 0 : vdiff
> 0 ? 1 : -1;
3451 /* This function is used to adjust offsets into .dynstr for
3452 dynamic symbols. This is called via elf_link_hash_traverse. */
3455 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
3457 struct elf_strtab_hash
*dynstr
= (struct elf_strtab_hash
*) data
;
3459 if (h
->dynindx
!= -1)
3460 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
3464 /* Assign string offsets in .dynstr, update all structures referencing
3468 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
3470 struct elf_link_hash_table
*hash_table
= elf_hash_table (info
);
3471 struct elf_link_local_dynamic_entry
*entry
;
3472 struct elf_strtab_hash
*dynstr
= hash_table
->dynstr
;
3473 bfd
*dynobj
= hash_table
->dynobj
;
3476 const struct elf_backend_data
*bed
;
3479 _bfd_elf_strtab_finalize (dynstr
);
3480 size
= _bfd_elf_strtab_size (dynstr
);
3482 bed
= get_elf_backend_data (dynobj
);
3483 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3484 BFD_ASSERT (sdyn
!= NULL
);
3486 /* Update all .dynamic entries referencing .dynstr strings. */
3487 for (extdyn
= sdyn
->contents
;
3488 extdyn
< sdyn
->contents
+ sdyn
->size
;
3489 extdyn
+= bed
->s
->sizeof_dyn
)
3491 Elf_Internal_Dyn dyn
;
3493 bed
->s
->swap_dyn_in (dynobj
, extdyn
, &dyn
);
3497 dyn
.d_un
.d_val
= size
;
3507 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
3512 bed
->s
->swap_dyn_out (dynobj
, &dyn
, extdyn
);
3515 /* Now update local dynamic symbols. */
3516 for (entry
= hash_table
->dynlocal
; entry
; entry
= entry
->next
)
3517 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
3518 entry
->isym
.st_name
);
3520 /* And the rest of dynamic symbols. */
3521 elf_link_hash_traverse (hash_table
, elf_adjust_dynstr_offsets
, dynstr
);
3523 /* Adjust version definitions. */
3524 if (elf_tdata (output_bfd
)->cverdefs
)
3529 Elf_Internal_Verdef def
;
3530 Elf_Internal_Verdaux defaux
;
3532 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
3536 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
3538 p
+= sizeof (Elf_External_Verdef
);
3539 if (def
.vd_aux
!= sizeof (Elf_External_Verdef
))
3541 for (i
= 0; i
< def
.vd_cnt
; ++i
)
3543 _bfd_elf_swap_verdaux_in (output_bfd
,
3544 (Elf_External_Verdaux
*) p
, &defaux
);
3545 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
3547 _bfd_elf_swap_verdaux_out (output_bfd
,
3548 &defaux
, (Elf_External_Verdaux
*) p
);
3549 p
+= sizeof (Elf_External_Verdaux
);
3552 while (def
.vd_next
);
3555 /* Adjust version references. */
3556 if (elf_tdata (output_bfd
)->verref
)
3561 Elf_Internal_Verneed need
;
3562 Elf_Internal_Vernaux needaux
;
3564 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
3568 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
3570 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
3571 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
3572 (Elf_External_Verneed
*) p
);
3573 p
+= sizeof (Elf_External_Verneed
);
3574 for (i
= 0; i
< need
.vn_cnt
; ++i
)
3576 _bfd_elf_swap_vernaux_in (output_bfd
,
3577 (Elf_External_Vernaux
*) p
, &needaux
);
3578 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
3580 _bfd_elf_swap_vernaux_out (output_bfd
,
3582 (Elf_External_Vernaux
*) p
);
3583 p
+= sizeof (Elf_External_Vernaux
);
3586 while (need
.vn_next
);
3592 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3593 The default is to only match when the INPUT and OUTPUT are exactly
3597 _bfd_elf_default_relocs_compatible (const bfd_target
*input
,
3598 const bfd_target
*output
)
3600 return input
== output
;
3603 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3604 This version is used when different targets for the same architecture
3605 are virtually identical. */
3608 _bfd_elf_relocs_compatible (const bfd_target
*input
,
3609 const bfd_target
*output
)
3611 const struct elf_backend_data
*obed
, *ibed
;
3613 if (input
== output
)
3616 ibed
= xvec_get_elf_backend_data (input
);
3617 obed
= xvec_get_elf_backend_data (output
);
3619 if (ibed
->arch
!= obed
->arch
)
3622 /* If both backends are using this function, deem them compatible. */
3623 return ibed
->relocs_compatible
== obed
->relocs_compatible
;
3626 /* Make a special call to the linker "notice" function to tell it that
3627 we are about to handle an as-needed lib, or have finished
3628 processing the lib. */
3631 _bfd_elf_notice_as_needed (bfd
*ibfd
,
3632 struct bfd_link_info
*info
,
3633 enum notice_asneeded_action act
)
3635 return (*info
->callbacks
->notice
) (info
, NULL
, NULL
, ibfd
, NULL
, act
, 0);
3638 /* Check relocations an ELF object file. */
3641 _bfd_elf_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
3643 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3644 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3646 /* If this object is the same format as the output object, and it is
3647 not a shared library, then let the backend look through the
3650 This is required to build global offset table entries and to
3651 arrange for dynamic relocs. It is not required for the
3652 particular common case of linking non PIC code, even when linking
3653 against shared libraries, but unfortunately there is no way of
3654 knowing whether an object file has been compiled PIC or not.
3655 Looking through the relocs is not particularly time consuming.
3656 The problem is that we must either (1) keep the relocs in memory,
3657 which causes the linker to require additional runtime memory or
3658 (2) read the relocs twice from the input file, which wastes time.
3659 This would be a good case for using mmap.
3661 I have no idea how to handle linking PIC code into a file of a
3662 different format. It probably can't be done. */
3663 if ((abfd
->flags
& DYNAMIC
) == 0
3664 && is_elf_hash_table (htab
)
3665 && bed
->check_relocs
!= NULL
3666 && elf_object_id (abfd
) == elf_hash_table_id (htab
)
3667 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
3671 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3673 Elf_Internal_Rela
*internal_relocs
;
3676 /* Don't check relocations in excluded sections. */
3677 if ((o
->flags
& SEC_RELOC
) == 0
3678 || (o
->flags
& SEC_EXCLUDE
) != 0
3679 || o
->reloc_count
== 0
3680 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
3681 && (o
->flags
& SEC_DEBUGGING
) != 0)
3682 || bfd_is_abs_section (o
->output_section
))
3685 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
3687 if (internal_relocs
== NULL
)
3690 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
3692 if (elf_section_data (o
)->relocs
!= internal_relocs
)
3693 free (internal_relocs
);
3703 /* Add symbols from an ELF object file to the linker hash table. */
3706 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3708 Elf_Internal_Ehdr
*ehdr
;
3709 Elf_Internal_Shdr
*hdr
;
3713 struct elf_link_hash_entry
**sym_hash
;
3714 bfd_boolean dynamic
;
3715 Elf_External_Versym
*extversym
= NULL
;
3716 Elf_External_Versym
*ever
;
3717 struct elf_link_hash_entry
*weaks
;
3718 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
3719 size_t nondeflt_vers_cnt
= 0;
3720 Elf_Internal_Sym
*isymbuf
= NULL
;
3721 Elf_Internal_Sym
*isym
;
3722 Elf_Internal_Sym
*isymend
;
3723 const struct elf_backend_data
*bed
;
3724 bfd_boolean add_needed
;
3725 struct elf_link_hash_table
*htab
;
3727 void *alloc_mark
= NULL
;
3728 struct bfd_hash_entry
**old_table
= NULL
;
3729 unsigned int old_size
= 0;
3730 unsigned int old_count
= 0;
3731 void *old_tab
= NULL
;
3733 struct bfd_link_hash_entry
*old_undefs
= NULL
;
3734 struct bfd_link_hash_entry
*old_undefs_tail
= NULL
;
3735 void *old_strtab
= NULL
;
3738 bfd_boolean just_syms
;
3740 htab
= elf_hash_table (info
);
3741 bed
= get_elf_backend_data (abfd
);
3743 if ((abfd
->flags
& DYNAMIC
) == 0)
3749 /* You can't use -r against a dynamic object. Also, there's no
3750 hope of using a dynamic object which does not exactly match
3751 the format of the output file. */
3752 if (bfd_link_relocatable (info
)
3753 || !is_elf_hash_table (htab
)
3754 || info
->output_bfd
->xvec
!= abfd
->xvec
)
3756 if (bfd_link_relocatable (info
))
3757 bfd_set_error (bfd_error_invalid_operation
);
3759 bfd_set_error (bfd_error_wrong_format
);
3764 ehdr
= elf_elfheader (abfd
);
3765 if (info
->warn_alternate_em
3766 && bed
->elf_machine_code
!= ehdr
->e_machine
3767 && ((bed
->elf_machine_alt1
!= 0
3768 && ehdr
->e_machine
== bed
->elf_machine_alt1
)
3769 || (bed
->elf_machine_alt2
!= 0
3770 && ehdr
->e_machine
== bed
->elf_machine_alt2
)))
3771 info
->callbacks
->einfo
3772 /* xgettext:c-format */
3773 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3774 ehdr
->e_machine
, abfd
, bed
->elf_machine_code
);
3776 /* As a GNU extension, any input sections which are named
3777 .gnu.warning.SYMBOL are treated as warning symbols for the given
3778 symbol. This differs from .gnu.warning sections, which generate
3779 warnings when they are included in an output file. */
3780 /* PR 12761: Also generate this warning when building shared libraries. */
3781 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3785 name
= bfd_get_section_name (abfd
, s
);
3786 if (CONST_STRNEQ (name
, ".gnu.warning."))
3791 name
+= sizeof ".gnu.warning." - 1;
3793 /* If this is a shared object, then look up the symbol
3794 in the hash table. If it is there, and it is already
3795 been defined, then we will not be using the entry
3796 from this shared object, so we don't need to warn.
3797 FIXME: If we see the definition in a regular object
3798 later on, we will warn, but we shouldn't. The only
3799 fix is to keep track of what warnings we are supposed
3800 to emit, and then handle them all at the end of the
3804 struct elf_link_hash_entry
*h
;
3806 h
= elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
3808 /* FIXME: What about bfd_link_hash_common? */
3810 && (h
->root
.type
== bfd_link_hash_defined
3811 || h
->root
.type
== bfd_link_hash_defweak
))
3816 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
3820 if (! bfd_get_section_contents (abfd
, s
, msg
, 0, sz
))
3825 if (! (_bfd_generic_link_add_one_symbol
3826 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
3827 FALSE
, bed
->collect
, NULL
)))
3830 if (bfd_link_executable (info
))
3832 /* Clobber the section size so that the warning does
3833 not get copied into the output file. */
3836 /* Also set SEC_EXCLUDE, so that symbols defined in
3837 the warning section don't get copied to the output. */
3838 s
->flags
|= SEC_EXCLUDE
;
3843 just_syms
= ((s
= abfd
->sections
) != NULL
3844 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
);
3849 /* If we are creating a shared library, create all the dynamic
3850 sections immediately. We need to attach them to something,
3851 so we attach them to this BFD, provided it is the right
3852 format and is not from ld --just-symbols. Always create the
3853 dynamic sections for -E/--dynamic-list. FIXME: If there
3854 are no input BFD's of the same format as the output, we can't
3855 make a shared library. */
3857 && (bfd_link_pic (info
)
3858 || (!bfd_link_relocatable (info
)
3860 && (info
->export_dynamic
|| info
->dynamic
)))
3861 && is_elf_hash_table (htab
)
3862 && info
->output_bfd
->xvec
== abfd
->xvec
3863 && !htab
->dynamic_sections_created
)
3865 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
3869 else if (!is_elf_hash_table (htab
))
3873 const char *soname
= NULL
;
3875 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
3876 const Elf_Internal_Phdr
*phdr
;
3879 /* ld --just-symbols and dynamic objects don't mix very well.
3880 ld shouldn't allow it. */
3884 /* If this dynamic lib was specified on the command line with
3885 --as-needed in effect, then we don't want to add a DT_NEEDED
3886 tag unless the lib is actually used. Similary for libs brought
3887 in by another lib's DT_NEEDED. When --no-add-needed is used
3888 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3889 any dynamic library in DT_NEEDED tags in the dynamic lib at
3891 add_needed
= (elf_dyn_lib_class (abfd
)
3892 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
3893 | DYN_NO_NEEDED
)) == 0;
3895 s
= bfd_get_section_by_name (abfd
, ".dynamic");
3900 unsigned int elfsec
;
3901 unsigned long shlink
;
3903 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
3910 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
3911 if (elfsec
== SHN_BAD
)
3912 goto error_free_dyn
;
3913 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
3915 for (extdyn
= dynbuf
;
3916 extdyn
< dynbuf
+ s
->size
;
3917 extdyn
+= bed
->s
->sizeof_dyn
)
3919 Elf_Internal_Dyn dyn
;
3921 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
3922 if (dyn
.d_tag
== DT_SONAME
)
3924 unsigned int tagv
= dyn
.d_un
.d_val
;
3925 soname
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3927 goto error_free_dyn
;
3929 if (dyn
.d_tag
== DT_NEEDED
)
3931 struct bfd_link_needed_list
*n
, **pn
;
3933 unsigned int tagv
= dyn
.d_un
.d_val
;
3935 amt
= sizeof (struct bfd_link_needed_list
);
3936 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3937 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3938 if (n
== NULL
|| fnm
== NULL
)
3939 goto error_free_dyn
;
3940 amt
= strlen (fnm
) + 1;
3941 anm
= (char *) bfd_alloc (abfd
, amt
);
3943 goto error_free_dyn
;
3944 memcpy (anm
, fnm
, amt
);
3948 for (pn
= &htab
->needed
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3952 if (dyn
.d_tag
== DT_RUNPATH
)
3954 struct bfd_link_needed_list
*n
, **pn
;
3956 unsigned int tagv
= dyn
.d_un
.d_val
;
3958 amt
= sizeof (struct bfd_link_needed_list
);
3959 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3960 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3961 if (n
== NULL
|| fnm
== NULL
)
3962 goto error_free_dyn
;
3963 amt
= strlen (fnm
) + 1;
3964 anm
= (char *) bfd_alloc (abfd
, amt
);
3966 goto error_free_dyn
;
3967 memcpy (anm
, fnm
, amt
);
3971 for (pn
= & runpath
;
3977 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3978 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
3980 struct bfd_link_needed_list
*n
, **pn
;
3982 unsigned int tagv
= dyn
.d_un
.d_val
;
3984 amt
= sizeof (struct bfd_link_needed_list
);
3985 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3986 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3987 if (n
== NULL
|| fnm
== NULL
)
3988 goto error_free_dyn
;
3989 amt
= strlen (fnm
) + 1;
3990 anm
= (char *) bfd_alloc (abfd
, amt
);
3992 goto error_free_dyn
;
3993 memcpy (anm
, fnm
, amt
);
4003 if (dyn
.d_tag
== DT_AUDIT
)
4005 unsigned int tagv
= dyn
.d_un
.d_val
;
4006 audit
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
4013 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
4014 frees all more recently bfd_alloc'd blocks as well. */
4020 struct bfd_link_needed_list
**pn
;
4021 for (pn
= &htab
->runpath
; *pn
!= NULL
; pn
= &(*pn
)->next
)
4026 /* If we have a PT_GNU_RELRO program header, mark as read-only
4027 all sections contained fully therein. This makes relro
4028 shared library sections appear as they will at run-time. */
4029 phdr
= elf_tdata (abfd
)->phdr
+ elf_elfheader (abfd
)->e_phnum
;
4030 while (--phdr
>= elf_tdata (abfd
)->phdr
)
4031 if (phdr
->p_type
== PT_GNU_RELRO
)
4033 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4034 if ((s
->flags
& SEC_ALLOC
) != 0
4035 && s
->vma
>= phdr
->p_vaddr
4036 && s
->vma
+ s
->size
<= phdr
->p_vaddr
+ phdr
->p_memsz
)
4037 s
->flags
|= SEC_READONLY
;
4041 /* We do not want to include any of the sections in a dynamic
4042 object in the output file. We hack by simply clobbering the
4043 list of sections in the BFD. This could be handled more
4044 cleanly by, say, a new section flag; the existing
4045 SEC_NEVER_LOAD flag is not the one we want, because that one
4046 still implies that the section takes up space in the output
4048 bfd_section_list_clear (abfd
);
4050 /* Find the name to use in a DT_NEEDED entry that refers to this
4051 object. If the object has a DT_SONAME entry, we use it.
4052 Otherwise, if the generic linker stuck something in
4053 elf_dt_name, we use that. Otherwise, we just use the file
4055 if (soname
== NULL
|| *soname
== '\0')
4057 soname
= elf_dt_name (abfd
);
4058 if (soname
== NULL
|| *soname
== '\0')
4059 soname
= bfd_get_filename (abfd
);
4062 /* Save the SONAME because sometimes the linker emulation code
4063 will need to know it. */
4064 elf_dt_name (abfd
) = soname
;
4066 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
4070 /* If we have already included this dynamic object in the
4071 link, just ignore it. There is no reason to include a
4072 particular dynamic object more than once. */
4076 /* Save the DT_AUDIT entry for the linker emulation code. */
4077 elf_dt_audit (abfd
) = audit
;
4080 /* If this is a dynamic object, we always link against the .dynsym
4081 symbol table, not the .symtab symbol table. The dynamic linker
4082 will only see the .dynsym symbol table, so there is no reason to
4083 look at .symtab for a dynamic object. */
4085 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
4086 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4088 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
4090 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
4092 /* The sh_info field of the symtab header tells us where the
4093 external symbols start. We don't care about the local symbols at
4095 if (elf_bad_symtab (abfd
))
4097 extsymcount
= symcount
;
4102 extsymcount
= symcount
- hdr
->sh_info
;
4103 extsymoff
= hdr
->sh_info
;
4106 sym_hash
= elf_sym_hashes (abfd
);
4107 if (extsymcount
!= 0)
4109 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
4111 if (isymbuf
== NULL
)
4114 if (sym_hash
== NULL
)
4116 /* We store a pointer to the hash table entry for each
4119 amt
*= sizeof (struct elf_link_hash_entry
*);
4120 sym_hash
= (struct elf_link_hash_entry
**) bfd_zalloc (abfd
, amt
);
4121 if (sym_hash
== NULL
)
4122 goto error_free_sym
;
4123 elf_sym_hashes (abfd
) = sym_hash
;
4129 /* Read in any version definitions. */
4130 if (!_bfd_elf_slurp_version_tables (abfd
,
4131 info
->default_imported_symver
))
4132 goto error_free_sym
;
4134 /* Read in the symbol versions, but don't bother to convert them
4135 to internal format. */
4136 if (elf_dynversym (abfd
) != 0)
4138 Elf_Internal_Shdr
*versymhdr
;
4140 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
4141 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
4142 if (extversym
== NULL
)
4143 goto error_free_sym
;
4144 amt
= versymhdr
->sh_size
;
4145 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
4146 || bfd_bread (extversym
, amt
, abfd
) != amt
)
4147 goto error_free_vers
;
4151 /* If we are loading an as-needed shared lib, save the symbol table
4152 state before we start adding symbols. If the lib turns out
4153 to be unneeded, restore the state. */
4154 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4159 for (entsize
= 0, i
= 0; i
< htab
->root
.table
.size
; i
++)
4161 struct bfd_hash_entry
*p
;
4162 struct elf_link_hash_entry
*h
;
4164 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4166 h
= (struct elf_link_hash_entry
*) p
;
4167 entsize
+= htab
->root
.table
.entsize
;
4168 if (h
->root
.type
== bfd_link_hash_warning
)
4169 entsize
+= htab
->root
.table
.entsize
;
4173 tabsize
= htab
->root
.table
.size
* sizeof (struct bfd_hash_entry
*);
4174 old_tab
= bfd_malloc (tabsize
+ entsize
);
4175 if (old_tab
== NULL
)
4176 goto error_free_vers
;
4178 /* Remember the current objalloc pointer, so that all mem for
4179 symbols added can later be reclaimed. */
4180 alloc_mark
= bfd_hash_allocate (&htab
->root
.table
, 1);
4181 if (alloc_mark
== NULL
)
4182 goto error_free_vers
;
4184 /* Make a special call to the linker "notice" function to
4185 tell it that we are about to handle an as-needed lib. */
4186 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_as_needed
))
4187 goto error_free_vers
;
4189 /* Clone the symbol table. Remember some pointers into the
4190 symbol table, and dynamic symbol count. */
4191 old_ent
= (char *) old_tab
+ tabsize
;
4192 memcpy (old_tab
, htab
->root
.table
.table
, tabsize
);
4193 old_undefs
= htab
->root
.undefs
;
4194 old_undefs_tail
= htab
->root
.undefs_tail
;
4195 old_table
= htab
->root
.table
.table
;
4196 old_size
= htab
->root
.table
.size
;
4197 old_count
= htab
->root
.table
.count
;
4198 old_strtab
= _bfd_elf_strtab_save (htab
->dynstr
);
4199 if (old_strtab
== NULL
)
4200 goto error_free_vers
;
4202 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4204 struct bfd_hash_entry
*p
;
4205 struct elf_link_hash_entry
*h
;
4207 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4209 memcpy (old_ent
, p
, htab
->root
.table
.entsize
);
4210 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4211 h
= (struct elf_link_hash_entry
*) p
;
4212 if (h
->root
.type
== bfd_link_hash_warning
)
4214 memcpy (old_ent
, h
->root
.u
.i
.link
, htab
->root
.table
.entsize
);
4215 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4222 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
4223 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
4225 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
4229 asection
*sec
, *new_sec
;
4232 struct elf_link_hash_entry
*h
;
4233 struct elf_link_hash_entry
*hi
;
4234 bfd_boolean definition
;
4235 bfd_boolean size_change_ok
;
4236 bfd_boolean type_change_ok
;
4237 bfd_boolean new_weakdef
;
4238 bfd_boolean new_weak
;
4239 bfd_boolean old_weak
;
4240 bfd_boolean override
;
4242 bfd_boolean discarded
;
4243 unsigned int old_alignment
;
4245 bfd_boolean matched
;
4249 flags
= BSF_NO_FLAGS
;
4251 value
= isym
->st_value
;
4252 common
= bed
->common_definition (isym
);
4255 bind
= ELF_ST_BIND (isym
->st_info
);
4259 /* This should be impossible, since ELF requires that all
4260 global symbols follow all local symbols, and that sh_info
4261 point to the first global symbol. Unfortunately, Irix 5
4266 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
4274 case STB_GNU_UNIQUE
:
4275 flags
= BSF_GNU_UNIQUE
;
4279 /* Leave it up to the processor backend. */
4283 if (isym
->st_shndx
== SHN_UNDEF
)
4284 sec
= bfd_und_section_ptr
;
4285 else if (isym
->st_shndx
== SHN_ABS
)
4286 sec
= bfd_abs_section_ptr
;
4287 else if (isym
->st_shndx
== SHN_COMMON
)
4289 sec
= bfd_com_section_ptr
;
4290 /* What ELF calls the size we call the value. What ELF
4291 calls the value we call the alignment. */
4292 value
= isym
->st_size
;
4296 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4298 sec
= bfd_abs_section_ptr
;
4299 else if (discarded_section (sec
))
4301 /* Symbols from discarded section are undefined. We keep
4303 sec
= bfd_und_section_ptr
;
4305 isym
->st_shndx
= SHN_UNDEF
;
4307 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
4311 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4314 goto error_free_vers
;
4316 if (isym
->st_shndx
== SHN_COMMON
4317 && (abfd
->flags
& BFD_PLUGIN
) != 0)
4319 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
4323 flagword sflags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
4325 xc
= bfd_make_section_with_flags (abfd
, "COMMON", sflags
);
4327 goto error_free_vers
;
4331 else if (isym
->st_shndx
== SHN_COMMON
4332 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
4333 && !bfd_link_relocatable (info
))
4335 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
4339 flagword sflags
= (SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_IS_COMMON
4340 | SEC_LINKER_CREATED
);
4341 tcomm
= bfd_make_section_with_flags (abfd
, ".tcommon", sflags
);
4343 goto error_free_vers
;
4347 else if (bed
->elf_add_symbol_hook
)
4349 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
4351 goto error_free_vers
;
4353 /* The hook function sets the name to NULL if this symbol
4354 should be skipped for some reason. */
4359 /* Sanity check that all possibilities were handled. */
4362 bfd_set_error (bfd_error_bad_value
);
4363 goto error_free_vers
;
4366 /* Silently discard TLS symbols from --just-syms. There's
4367 no way to combine a static TLS block with a new TLS block
4368 for this executable. */
4369 if (ELF_ST_TYPE (isym
->st_info
) == STT_TLS
4370 && sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4373 if (bfd_is_und_section (sec
)
4374 || bfd_is_com_section (sec
))
4379 size_change_ok
= FALSE
;
4380 type_change_ok
= bed
->type_change_ok
;
4387 if (is_elf_hash_table (htab
))
4389 Elf_Internal_Versym iver
;
4390 unsigned int vernum
= 0;
4395 if (info
->default_imported_symver
)
4396 /* Use the default symbol version created earlier. */
4397 iver
.vs_vers
= elf_tdata (abfd
)->cverdefs
;
4402 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
4404 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
4406 /* If this is a hidden symbol, or if it is not version
4407 1, we append the version name to the symbol name.
4408 However, we do not modify a non-hidden absolute symbol
4409 if it is not a function, because it might be the version
4410 symbol itself. FIXME: What if it isn't? */
4411 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
4413 && (!bfd_is_abs_section (sec
)
4414 || bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
)))))
4417 size_t namelen
, verlen
, newlen
;
4420 if (isym
->st_shndx
!= SHN_UNDEF
)
4422 if (vernum
> elf_tdata (abfd
)->cverdefs
)
4424 else if (vernum
> 1)
4426 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
4433 /* xgettext:c-format */
4434 (_("%B: %s: invalid version %u (max %d)"),
4436 elf_tdata (abfd
)->cverdefs
);
4437 bfd_set_error (bfd_error_bad_value
);
4438 goto error_free_vers
;
4443 /* We cannot simply test for the number of
4444 entries in the VERNEED section since the
4445 numbers for the needed versions do not start
4447 Elf_Internal_Verneed
*t
;
4450 for (t
= elf_tdata (abfd
)->verref
;
4454 Elf_Internal_Vernaux
*a
;
4456 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
4458 if (a
->vna_other
== vernum
)
4460 verstr
= a
->vna_nodename
;
4470 /* xgettext:c-format */
4471 (_("%B: %s: invalid needed version %d"),
4472 abfd
, name
, vernum
);
4473 bfd_set_error (bfd_error_bad_value
);
4474 goto error_free_vers
;
4478 namelen
= strlen (name
);
4479 verlen
= strlen (verstr
);
4480 newlen
= namelen
+ verlen
+ 2;
4481 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4482 && isym
->st_shndx
!= SHN_UNDEF
)
4485 newname
= (char *) bfd_hash_allocate (&htab
->root
.table
, newlen
);
4486 if (newname
== NULL
)
4487 goto error_free_vers
;
4488 memcpy (newname
, name
, namelen
);
4489 p
= newname
+ namelen
;
4491 /* If this is a defined non-hidden version symbol,
4492 we add another @ to the name. This indicates the
4493 default version of the symbol. */
4494 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4495 && isym
->st_shndx
!= SHN_UNDEF
)
4497 memcpy (p
, verstr
, verlen
+ 1);
4502 /* If this symbol has default visibility and the user has
4503 requested we not re-export it, then mark it as hidden. */
4504 if (!bfd_is_und_section (sec
)
4507 && ELF_ST_VISIBILITY (isym
->st_other
) != STV_INTERNAL
)
4508 isym
->st_other
= (STV_HIDDEN
4509 | (isym
->st_other
& ~ELF_ST_VISIBILITY (-1)));
4511 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
, &value
,
4512 sym_hash
, &old_bfd
, &old_weak
,
4513 &old_alignment
, &skip
, &override
,
4514 &type_change_ok
, &size_change_ok
,
4516 goto error_free_vers
;
4521 /* Override a definition only if the new symbol matches the
4523 if (override
&& matched
)
4527 while (h
->root
.type
== bfd_link_hash_indirect
4528 || h
->root
.type
== bfd_link_hash_warning
)
4529 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4531 if (elf_tdata (abfd
)->verdef
!= NULL
4534 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
4537 if (! (_bfd_generic_link_add_one_symbol
4538 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
4539 (struct bfd_link_hash_entry
**) sym_hash
)))
4540 goto error_free_vers
;
4542 if ((flags
& BSF_GNU_UNIQUE
)
4543 && (abfd
->flags
& DYNAMIC
) == 0
4544 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
4545 elf_tdata (info
->output_bfd
)->has_gnu_symbols
|= elf_gnu_symbol_unique
;
4548 /* We need to make sure that indirect symbol dynamic flags are
4551 while (h
->root
.type
== bfd_link_hash_indirect
4552 || h
->root
.type
== bfd_link_hash_warning
)
4553 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4555 /* Setting the index to -3 tells elf_link_output_extsym that
4556 this symbol is defined in a discarded section. */
4562 new_weak
= (flags
& BSF_WEAK
) != 0;
4563 new_weakdef
= FALSE
;
4567 && !bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
))
4568 && is_elf_hash_table (htab
)
4569 && h
->u
.weakdef
== NULL
)
4571 /* Keep a list of all weak defined non function symbols from
4572 a dynamic object, using the weakdef field. Later in this
4573 function we will set the weakdef field to the correct
4574 value. We only put non-function symbols from dynamic
4575 objects on this list, because that happens to be the only
4576 time we need to know the normal symbol corresponding to a
4577 weak symbol, and the information is time consuming to
4578 figure out. If the weakdef field is not already NULL,
4579 then this symbol was already defined by some previous
4580 dynamic object, and we will be using that previous
4581 definition anyhow. */
4583 h
->u
.weakdef
= weaks
;
4588 /* Set the alignment of a common symbol. */
4589 if ((common
|| bfd_is_com_section (sec
))
4590 && h
->root
.type
== bfd_link_hash_common
)
4595 align
= bfd_log2 (isym
->st_value
);
4598 /* The new symbol is a common symbol in a shared object.
4599 We need to get the alignment from the section. */
4600 align
= new_sec
->alignment_power
;
4602 if (align
> old_alignment
)
4603 h
->root
.u
.c
.p
->alignment_power
= align
;
4605 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
4608 if (is_elf_hash_table (htab
))
4610 /* Set a flag in the hash table entry indicating the type of
4611 reference or definition we just found. A dynamic symbol
4612 is one which is referenced or defined by both a regular
4613 object and a shared object. */
4614 bfd_boolean dynsym
= FALSE
;
4616 /* Plugin symbols aren't normal. Don't set def_regular or
4617 ref_regular for them, or make them dynamic. */
4618 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
4625 if (bind
!= STB_WEAK
)
4626 h
->ref_regular_nonweak
= 1;
4638 /* If the indirect symbol has been forced local, don't
4639 make the real symbol dynamic. */
4640 if ((h
== hi
|| !hi
->forced_local
)
4641 && (bfd_link_dll (info
)
4651 hi
->ref_dynamic
= 1;
4656 hi
->def_dynamic
= 1;
4659 /* If the indirect symbol has been forced local, don't
4660 make the real symbol dynamic. */
4661 if ((h
== hi
|| !hi
->forced_local
)
4664 || (h
->u
.weakdef
!= NULL
4666 && h
->u
.weakdef
->dynindx
!= -1)))
4670 /* Check to see if we need to add an indirect symbol for
4671 the default name. */
4673 || (!override
&& h
->root
.type
== bfd_link_hash_common
))
4674 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
4675 sec
, value
, &old_bfd
, &dynsym
))
4676 goto error_free_vers
;
4678 /* Check the alignment when a common symbol is involved. This
4679 can change when a common symbol is overridden by a normal
4680 definition or a common symbol is ignored due to the old
4681 normal definition. We need to make sure the maximum
4682 alignment is maintained. */
4683 if ((old_alignment
|| common
)
4684 && h
->root
.type
!= bfd_link_hash_common
)
4686 unsigned int common_align
;
4687 unsigned int normal_align
;
4688 unsigned int symbol_align
;
4692 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
4693 || h
->root
.type
== bfd_link_hash_defweak
);
4695 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
4696 if (h
->root
.u
.def
.section
->owner
!= NULL
4697 && (h
->root
.u
.def
.section
->owner
->flags
4698 & (DYNAMIC
| BFD_PLUGIN
)) == 0)
4700 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
4701 if (normal_align
> symbol_align
)
4702 normal_align
= symbol_align
;
4705 normal_align
= symbol_align
;
4709 common_align
= old_alignment
;
4710 common_bfd
= old_bfd
;
4715 common_align
= bfd_log2 (isym
->st_value
);
4717 normal_bfd
= old_bfd
;
4720 if (normal_align
< common_align
)
4722 /* PR binutils/2735 */
4723 if (normal_bfd
== NULL
)
4725 /* xgettext:c-format */
4726 (_("Warning: alignment %u of common symbol `%s' in %B is"
4727 " greater than the alignment (%u) of its section %A"),
4728 1 << common_align
, name
, common_bfd
,
4729 1 << normal_align
, h
->root
.u
.def
.section
);
4732 /* xgettext:c-format */
4733 (_("Warning: alignment %u of symbol `%s' in %B"
4734 " is smaller than %u in %B"),
4735 1 << normal_align
, name
, normal_bfd
,
4736 1 << common_align
, common_bfd
);
4740 /* Remember the symbol size if it isn't undefined. */
4741 if (isym
->st_size
!= 0
4742 && isym
->st_shndx
!= SHN_UNDEF
4743 && (definition
|| h
->size
== 0))
4746 && h
->size
!= isym
->st_size
4747 && ! size_change_ok
)
4749 /* xgettext:c-format */
4750 (_("Warning: size of symbol `%s' changed"
4751 " from %lu in %B to %lu in %B"),
4752 name
, (unsigned long) h
->size
, old_bfd
,
4753 (unsigned long) isym
->st_size
, abfd
);
4755 h
->size
= isym
->st_size
;
4758 /* If this is a common symbol, then we always want H->SIZE
4759 to be the size of the common symbol. The code just above
4760 won't fix the size if a common symbol becomes larger. We
4761 don't warn about a size change here, because that is
4762 covered by --warn-common. Allow changes between different
4764 if (h
->root
.type
== bfd_link_hash_common
)
4765 h
->size
= h
->root
.u
.c
.size
;
4767 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
4768 && ((definition
&& !new_weak
)
4769 || (old_weak
&& h
->root
.type
== bfd_link_hash_common
)
4770 || h
->type
== STT_NOTYPE
))
4772 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
4774 /* Turn an IFUNC symbol from a DSO into a normal FUNC
4776 if (type
== STT_GNU_IFUNC
4777 && (abfd
->flags
& DYNAMIC
) != 0)
4780 if (h
->type
!= type
)
4782 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
4783 /* xgettext:c-format */
4785 (_("Warning: type of symbol `%s' changed"
4786 " from %d to %d in %B"),
4787 name
, h
->type
, type
, abfd
);
4793 /* Merge st_other field. */
4794 elf_merge_st_other (abfd
, h
, isym
, sec
, definition
, dynamic
);
4796 /* We don't want to make debug symbol dynamic. */
4798 && (sec
->flags
& SEC_DEBUGGING
)
4799 && !bfd_link_relocatable (info
))
4802 /* Nor should we make plugin symbols dynamic. */
4803 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
4808 h
->target_internal
= isym
->st_target_internal
;
4809 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
4812 if (definition
&& !dynamic
)
4814 char *p
= strchr (name
, ELF_VER_CHR
);
4815 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
4817 /* Queue non-default versions so that .symver x, x@FOO
4818 aliases can be checked. */
4821 amt
= ((isymend
- isym
+ 1)
4822 * sizeof (struct elf_link_hash_entry
*));
4824 = (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4826 goto error_free_vers
;
4828 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
4832 if (dynsym
&& h
->dynindx
== -1)
4834 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4835 goto error_free_vers
;
4836 if (h
->u
.weakdef
!= NULL
4838 && h
->u
.weakdef
->dynindx
== -1)
4840 if (!bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
4841 goto error_free_vers
;
4844 else if (h
->dynindx
!= -1)
4845 /* If the symbol already has a dynamic index, but
4846 visibility says it should not be visible, turn it into
4848 switch (ELF_ST_VISIBILITY (h
->other
))
4852 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
4857 /* Don't add DT_NEEDED for references from the dummy bfd nor
4858 for unmatched symbol. */
4863 && h
->ref_regular_nonweak
4865 || (old_bfd
->flags
& BFD_PLUGIN
) == 0))
4866 || (h
->ref_dynamic_nonweak
4867 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0
4868 && !on_needed_list (elf_dt_name (abfd
),
4869 htab
->needed
, NULL
))))
4872 const char *soname
= elf_dt_name (abfd
);
4874 info
->callbacks
->minfo ("%!", soname
, old_bfd
,
4875 h
->root
.root
.string
);
4877 /* A symbol from a library loaded via DT_NEEDED of some
4878 other library is referenced by a regular object.
4879 Add a DT_NEEDED entry for it. Issue an error if
4880 --no-add-needed is used and the reference was not
4883 && (elf_dyn_lib_class (abfd
) & DYN_NO_NEEDED
) != 0)
4886 /* xgettext:c-format */
4887 (_("%B: undefined reference to symbol '%s'"),
4889 bfd_set_error (bfd_error_missing_dso
);
4890 goto error_free_vers
;
4893 elf_dyn_lib_class (abfd
) = (enum dynamic_lib_link_class
)
4894 (elf_dyn_lib_class (abfd
) & ~DYN_AS_NEEDED
);
4897 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
4899 goto error_free_vers
;
4901 BFD_ASSERT (ret
== 0);
4906 if (extversym
!= NULL
)
4912 if (isymbuf
!= NULL
)
4918 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4922 /* Restore the symbol table. */
4923 old_ent
= (char *) old_tab
+ tabsize
;
4924 memset (elf_sym_hashes (abfd
), 0,
4925 extsymcount
* sizeof (struct elf_link_hash_entry
*));
4926 htab
->root
.table
.table
= old_table
;
4927 htab
->root
.table
.size
= old_size
;
4928 htab
->root
.table
.count
= old_count
;
4929 memcpy (htab
->root
.table
.table
, old_tab
, tabsize
);
4930 htab
->root
.undefs
= old_undefs
;
4931 htab
->root
.undefs_tail
= old_undefs_tail
;
4932 _bfd_elf_strtab_restore (htab
->dynstr
, old_strtab
);
4935 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4937 struct bfd_hash_entry
*p
;
4938 struct elf_link_hash_entry
*h
;
4940 unsigned int alignment_power
;
4941 unsigned int non_ir_ref_dynamic
;
4943 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4945 h
= (struct elf_link_hash_entry
*) p
;
4946 if (h
->root
.type
== bfd_link_hash_warning
)
4947 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4949 /* Preserve the maximum alignment and size for common
4950 symbols even if this dynamic lib isn't on DT_NEEDED
4951 since it can still be loaded at run time by another
4953 if (h
->root
.type
== bfd_link_hash_common
)
4955 size
= h
->root
.u
.c
.size
;
4956 alignment_power
= h
->root
.u
.c
.p
->alignment_power
;
4961 alignment_power
= 0;
4963 /* Preserve non_ir_ref_dynamic so that this symbol
4964 will be exported when the dynamic lib becomes needed
4965 in the second pass. */
4966 non_ir_ref_dynamic
= h
->root
.non_ir_ref_dynamic
;
4967 memcpy (p
, old_ent
, htab
->root
.table
.entsize
);
4968 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4969 h
= (struct elf_link_hash_entry
*) p
;
4970 if (h
->root
.type
== bfd_link_hash_warning
)
4972 memcpy (h
->root
.u
.i
.link
, old_ent
, htab
->root
.table
.entsize
);
4973 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4974 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4976 if (h
->root
.type
== bfd_link_hash_common
)
4978 if (size
> h
->root
.u
.c
.size
)
4979 h
->root
.u
.c
.size
= size
;
4980 if (alignment_power
> h
->root
.u
.c
.p
->alignment_power
)
4981 h
->root
.u
.c
.p
->alignment_power
= alignment_power
;
4983 h
->root
.non_ir_ref_dynamic
= non_ir_ref_dynamic
;
4987 /* Make a special call to the linker "notice" function to
4988 tell it that symbols added for crefs may need to be removed. */
4989 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_not_needed
))
4990 goto error_free_vers
;
4993 objalloc_free_block ((struct objalloc
*) htab
->root
.table
.memory
,
4995 if (nondeflt_vers
!= NULL
)
4996 free (nondeflt_vers
);
5000 if (old_tab
!= NULL
)
5002 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_needed
))
5003 goto error_free_vers
;
5008 /* Now that all the symbols from this input file are created, if
5009 not performing a relocatable link, handle .symver foo, foo@BAR
5010 such that any relocs against foo become foo@BAR. */
5011 if (!bfd_link_relocatable (info
) && nondeflt_vers
!= NULL
)
5015 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
5017 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
5018 char *shortname
, *p
;
5020 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
5022 || (h
->root
.type
!= bfd_link_hash_defined
5023 && h
->root
.type
!= bfd_link_hash_defweak
))
5026 amt
= p
- h
->root
.root
.string
;
5027 shortname
= (char *) bfd_malloc (amt
+ 1);
5029 goto error_free_vers
;
5030 memcpy (shortname
, h
->root
.root
.string
, amt
);
5031 shortname
[amt
] = '\0';
5033 hi
= (struct elf_link_hash_entry
*)
5034 bfd_link_hash_lookup (&htab
->root
, shortname
,
5035 FALSE
, FALSE
, FALSE
);
5037 && hi
->root
.type
== h
->root
.type
5038 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
5039 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
5041 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
5042 hi
->root
.type
= bfd_link_hash_indirect
;
5043 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
5044 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
5045 sym_hash
= elf_sym_hashes (abfd
);
5047 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
5048 if (sym_hash
[symidx
] == hi
)
5050 sym_hash
[symidx
] = h
;
5056 free (nondeflt_vers
);
5057 nondeflt_vers
= NULL
;
5060 /* Now set the weakdefs field correctly for all the weak defined
5061 symbols we found. The only way to do this is to search all the
5062 symbols. Since we only need the information for non functions in
5063 dynamic objects, that's the only time we actually put anything on
5064 the list WEAKS. We need this information so that if a regular
5065 object refers to a symbol defined weakly in a dynamic object, the
5066 real symbol in the dynamic object is also put in the dynamic
5067 symbols; we also must arrange for both symbols to point to the
5068 same memory location. We could handle the general case of symbol
5069 aliasing, but a general symbol alias can only be generated in
5070 assembler code, handling it correctly would be very time
5071 consuming, and other ELF linkers don't handle general aliasing
5075 struct elf_link_hash_entry
**hpp
;
5076 struct elf_link_hash_entry
**hppend
;
5077 struct elf_link_hash_entry
**sorted_sym_hash
;
5078 struct elf_link_hash_entry
*h
;
5081 /* Since we have to search the whole symbol list for each weak
5082 defined symbol, search time for N weak defined symbols will be
5083 O(N^2). Binary search will cut it down to O(NlogN). */
5085 amt
*= sizeof (struct elf_link_hash_entry
*);
5086 sorted_sym_hash
= (struct elf_link_hash_entry
**) bfd_malloc (amt
);
5087 if (sorted_sym_hash
== NULL
)
5089 sym_hash
= sorted_sym_hash
;
5090 hpp
= elf_sym_hashes (abfd
);
5091 hppend
= hpp
+ extsymcount
;
5093 for (; hpp
< hppend
; hpp
++)
5097 && h
->root
.type
== bfd_link_hash_defined
5098 && !bed
->is_function_type (h
->type
))
5106 qsort (sorted_sym_hash
, sym_count
,
5107 sizeof (struct elf_link_hash_entry
*),
5110 while (weaks
!= NULL
)
5112 struct elf_link_hash_entry
*hlook
;
5115 size_t i
, j
, idx
= 0;
5118 weaks
= hlook
->u
.weakdef
;
5119 hlook
->u
.weakdef
= NULL
;
5121 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
5122 || hlook
->root
.type
== bfd_link_hash_defweak
5123 || hlook
->root
.type
== bfd_link_hash_common
5124 || hlook
->root
.type
== bfd_link_hash_indirect
);
5125 slook
= hlook
->root
.u
.def
.section
;
5126 vlook
= hlook
->root
.u
.def
.value
;
5132 bfd_signed_vma vdiff
;
5134 h
= sorted_sym_hash
[idx
];
5135 vdiff
= vlook
- h
->root
.u
.def
.value
;
5142 int sdiff
= slook
->id
- h
->root
.u
.def
.section
->id
;
5152 /* We didn't find a value/section match. */
5156 /* With multiple aliases, or when the weak symbol is already
5157 strongly defined, we have multiple matching symbols and
5158 the binary search above may land on any of them. Step
5159 one past the matching symbol(s). */
5162 h
= sorted_sym_hash
[idx
];
5163 if (h
->root
.u
.def
.section
!= slook
5164 || h
->root
.u
.def
.value
!= vlook
)
5168 /* Now look back over the aliases. Since we sorted by size
5169 as well as value and section, we'll choose the one with
5170 the largest size. */
5173 h
= sorted_sym_hash
[idx
];
5175 /* Stop if value or section doesn't match. */
5176 if (h
->root
.u
.def
.section
!= slook
5177 || h
->root
.u
.def
.value
!= vlook
)
5179 else if (h
!= hlook
)
5181 hlook
->u
.weakdef
= h
;
5183 /* If the weak definition is in the list of dynamic
5184 symbols, make sure the real definition is put
5186 if (hlook
->dynindx
!= -1 && h
->dynindx
== -1)
5188 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5191 free (sorted_sym_hash
);
5196 /* If the real definition is in the list of dynamic
5197 symbols, make sure the weak definition is put
5198 there as well. If we don't do this, then the
5199 dynamic loader might not merge the entries for the
5200 real definition and the weak definition. */
5201 if (h
->dynindx
!= -1 && hlook
->dynindx
== -1)
5203 if (! bfd_elf_link_record_dynamic_symbol (info
, hlook
))
5204 goto err_free_sym_hash
;
5211 free (sorted_sym_hash
);
5214 if (bed
->check_directives
5215 && !(*bed
->check_directives
) (abfd
, info
))
5218 if (!info
->check_relocs_after_open_input
5219 && !_bfd_elf_link_check_relocs (abfd
, info
))
5222 /* If this is a non-traditional link, try to optimize the handling
5223 of the .stab/.stabstr sections. */
5225 && ! info
->traditional_format
5226 && is_elf_hash_table (htab
)
5227 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
5231 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
5232 if (stabstr
!= NULL
)
5234 bfd_size_type string_offset
= 0;
5237 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
5238 if (CONST_STRNEQ (stab
->name
, ".stab")
5239 && (!stab
->name
[5] ||
5240 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
5241 && (stab
->flags
& SEC_MERGE
) == 0
5242 && !bfd_is_abs_section (stab
->output_section
))
5244 struct bfd_elf_section_data
*secdata
;
5246 secdata
= elf_section_data (stab
);
5247 if (! _bfd_link_section_stabs (abfd
, &htab
->stab_info
, stab
,
5248 stabstr
, &secdata
->sec_info
,
5251 if (secdata
->sec_info
)
5252 stab
->sec_info_type
= SEC_INFO_TYPE_STABS
;
5257 if (is_elf_hash_table (htab
) && add_needed
)
5259 /* Add this bfd to the loaded list. */
5260 struct elf_link_loaded_list
*n
;
5262 n
= (struct elf_link_loaded_list
*) bfd_alloc (abfd
, sizeof (*n
));
5266 n
->next
= htab
->loaded
;
5273 if (old_tab
!= NULL
)
5275 if (old_strtab
!= NULL
)
5277 if (nondeflt_vers
!= NULL
)
5278 free (nondeflt_vers
);
5279 if (extversym
!= NULL
)
5282 if (isymbuf
!= NULL
)
5288 /* Return the linker hash table entry of a symbol that might be
5289 satisfied by an archive symbol. Return -1 on error. */
5291 struct elf_link_hash_entry
*
5292 _bfd_elf_archive_symbol_lookup (bfd
*abfd
,
5293 struct bfd_link_info
*info
,
5296 struct elf_link_hash_entry
*h
;
5300 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, TRUE
);
5304 /* If this is a default version (the name contains @@), look up the
5305 symbol again with only one `@' as well as without the version.
5306 The effect is that references to the symbol with and without the
5307 version will be matched by the default symbol in the archive. */
5309 p
= strchr (name
, ELF_VER_CHR
);
5310 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
5313 /* First check with only one `@'. */
5314 len
= strlen (name
);
5315 copy
= (char *) bfd_alloc (abfd
, len
);
5317 return (struct elf_link_hash_entry
*) 0 - 1;
5319 first
= p
- name
+ 1;
5320 memcpy (copy
, name
, first
);
5321 memcpy (copy
+ first
, name
+ first
+ 1, len
- first
);
5323 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
, FALSE
, FALSE
, TRUE
);
5326 /* We also need to check references to the symbol without the
5328 copy
[first
- 1] = '\0';
5329 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
5330 FALSE
, FALSE
, TRUE
);
5333 bfd_release (abfd
, copy
);
5337 /* Add symbols from an ELF archive file to the linker hash table. We
5338 don't use _bfd_generic_link_add_archive_symbols because we need to
5339 handle versioned symbols.
5341 Fortunately, ELF archive handling is simpler than that done by
5342 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
5343 oddities. In ELF, if we find a symbol in the archive map, and the
5344 symbol is currently undefined, we know that we must pull in that
5347 Unfortunately, we do have to make multiple passes over the symbol
5348 table until nothing further is resolved. */
5351 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5354 unsigned char *included
= NULL
;
5358 const struct elf_backend_data
*bed
;
5359 struct elf_link_hash_entry
* (*archive_symbol_lookup
)
5360 (bfd
*, struct bfd_link_info
*, const char *);
5362 if (! bfd_has_map (abfd
))
5364 /* An empty archive is a special case. */
5365 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
5367 bfd_set_error (bfd_error_no_armap
);
5371 /* Keep track of all symbols we know to be already defined, and all
5372 files we know to be already included. This is to speed up the
5373 second and subsequent passes. */
5374 c
= bfd_ardata (abfd
)->symdef_count
;
5378 amt
*= sizeof (*included
);
5379 included
= (unsigned char *) bfd_zmalloc (amt
);
5380 if (included
== NULL
)
5383 symdefs
= bfd_ardata (abfd
)->symdefs
;
5384 bed
= get_elf_backend_data (abfd
);
5385 archive_symbol_lookup
= bed
->elf_backend_archive_symbol_lookup
;
5398 symdefend
= symdef
+ c
;
5399 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
5401 struct elf_link_hash_entry
*h
;
5403 struct bfd_link_hash_entry
*undefs_tail
;
5408 if (symdef
->file_offset
== last
)
5414 h
= archive_symbol_lookup (abfd
, info
, symdef
->name
);
5415 if (h
== (struct elf_link_hash_entry
*) 0 - 1)
5421 if (h
->root
.type
== bfd_link_hash_common
)
5423 /* We currently have a common symbol. The archive map contains
5424 a reference to this symbol, so we may want to include it. We
5425 only want to include it however, if this archive element
5426 contains a definition of the symbol, not just another common
5429 Unfortunately some archivers (including GNU ar) will put
5430 declarations of common symbols into their archive maps, as
5431 well as real definitions, so we cannot just go by the archive
5432 map alone. Instead we must read in the element's symbol
5433 table and check that to see what kind of symbol definition
5435 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
5438 else if (h
->root
.type
!= bfd_link_hash_undefined
)
5440 if (h
->root
.type
!= bfd_link_hash_undefweak
)
5441 /* Symbol must be defined. Don't check it again. */
5446 /* We need to include this archive member. */
5447 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
5448 if (element
== NULL
)
5451 if (! bfd_check_format (element
, bfd_object
))
5454 undefs_tail
= info
->hash
->undefs_tail
;
5456 if (!(*info
->callbacks
5457 ->add_archive_element
) (info
, element
, symdef
->name
, &element
))
5459 if (!bfd_link_add_symbols (element
, info
))
5462 /* If there are any new undefined symbols, we need to make
5463 another pass through the archive in order to see whether
5464 they can be defined. FIXME: This isn't perfect, because
5465 common symbols wind up on undefs_tail and because an
5466 undefined symbol which is defined later on in this pass
5467 does not require another pass. This isn't a bug, but it
5468 does make the code less efficient than it could be. */
5469 if (undefs_tail
!= info
->hash
->undefs_tail
)
5472 /* Look backward to mark all symbols from this object file
5473 which we have already seen in this pass. */
5477 included
[mark
] = TRUE
;
5482 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
5484 /* We mark subsequent symbols from this object file as we go
5485 on through the loop. */
5486 last
= symdef
->file_offset
;
5496 if (included
!= NULL
)
5501 /* Given an ELF BFD, add symbols to the global hash table as
5505 bfd_elf_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5507 switch (bfd_get_format (abfd
))
5510 return elf_link_add_object_symbols (abfd
, info
);
5512 return elf_link_add_archive_symbols (abfd
, info
);
5514 bfd_set_error (bfd_error_wrong_format
);
5519 struct hash_codes_info
5521 unsigned long *hashcodes
;
5525 /* This function will be called though elf_link_hash_traverse to store
5526 all hash value of the exported symbols in an array. */
5529 elf_collect_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5531 struct hash_codes_info
*inf
= (struct hash_codes_info
*) data
;
5536 /* Ignore indirect symbols. These are added by the versioning code. */
5537 if (h
->dynindx
== -1)
5540 name
= h
->root
.root
.string
;
5541 if (h
->versioned
>= versioned
)
5543 char *p
= strchr (name
, ELF_VER_CHR
);
5546 alc
= (char *) bfd_malloc (p
- name
+ 1);
5552 memcpy (alc
, name
, p
- name
);
5553 alc
[p
- name
] = '\0';
5558 /* Compute the hash value. */
5559 ha
= bfd_elf_hash (name
);
5561 /* Store the found hash value in the array given as the argument. */
5562 *(inf
->hashcodes
)++ = ha
;
5564 /* And store it in the struct so that we can put it in the hash table
5566 h
->u
.elf_hash_value
= ha
;
5574 struct collect_gnu_hash_codes
5577 const struct elf_backend_data
*bed
;
5578 unsigned long int nsyms
;
5579 unsigned long int maskbits
;
5580 unsigned long int *hashcodes
;
5581 unsigned long int *hashval
;
5582 unsigned long int *indx
;
5583 unsigned long int *counts
;
5586 long int min_dynindx
;
5587 unsigned long int bucketcount
;
5588 unsigned long int symindx
;
5589 long int local_indx
;
5590 long int shift1
, shift2
;
5591 unsigned long int mask
;
5595 /* This function will be called though elf_link_hash_traverse to store
5596 all hash value of the exported symbols in an array. */
5599 elf_collect_gnu_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5601 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5606 /* Ignore indirect symbols. These are added by the versioning code. */
5607 if (h
->dynindx
== -1)
5610 /* Ignore also local symbols and undefined symbols. */
5611 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5614 name
= h
->root
.root
.string
;
5615 if (h
->versioned
>= versioned
)
5617 char *p
= strchr (name
, ELF_VER_CHR
);
5620 alc
= (char *) bfd_malloc (p
- name
+ 1);
5626 memcpy (alc
, name
, p
- name
);
5627 alc
[p
- name
] = '\0';
5632 /* Compute the hash value. */
5633 ha
= bfd_elf_gnu_hash (name
);
5635 /* Store the found hash value in the array for compute_bucket_count,
5636 and also for .dynsym reordering purposes. */
5637 s
->hashcodes
[s
->nsyms
] = ha
;
5638 s
->hashval
[h
->dynindx
] = ha
;
5640 if (s
->min_dynindx
< 0 || s
->min_dynindx
> h
->dynindx
)
5641 s
->min_dynindx
= h
->dynindx
;
5649 /* This function will be called though elf_link_hash_traverse to do
5650 final dynaminc symbol renumbering. */
5653 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry
*h
, void *data
)
5655 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5656 unsigned long int bucket
;
5657 unsigned long int val
;
5659 /* Ignore indirect symbols. */
5660 if (h
->dynindx
== -1)
5663 /* Ignore also local symbols and undefined symbols. */
5664 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5666 if (h
->dynindx
>= s
->min_dynindx
)
5667 h
->dynindx
= s
->local_indx
++;
5671 bucket
= s
->hashval
[h
->dynindx
] % s
->bucketcount
;
5672 val
= (s
->hashval
[h
->dynindx
] >> s
->shift1
)
5673 & ((s
->maskbits
>> s
->shift1
) - 1);
5674 s
->bitmask
[val
] |= ((bfd_vma
) 1) << (s
->hashval
[h
->dynindx
] & s
->mask
);
5676 |= ((bfd_vma
) 1) << ((s
->hashval
[h
->dynindx
] >> s
->shift2
) & s
->mask
);
5677 val
= s
->hashval
[h
->dynindx
] & ~(unsigned long int) 1;
5678 if (s
->counts
[bucket
] == 1)
5679 /* Last element terminates the chain. */
5681 bfd_put_32 (s
->output_bfd
, val
,
5682 s
->contents
+ (s
->indx
[bucket
] - s
->symindx
) * 4);
5683 --s
->counts
[bucket
];
5684 h
->dynindx
= s
->indx
[bucket
]++;
5688 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5691 _bfd_elf_hash_symbol (struct elf_link_hash_entry
*h
)
5693 return !(h
->forced_local
5694 || h
->root
.type
== bfd_link_hash_undefined
5695 || h
->root
.type
== bfd_link_hash_undefweak
5696 || ((h
->root
.type
== bfd_link_hash_defined
5697 || h
->root
.type
== bfd_link_hash_defweak
)
5698 && h
->root
.u
.def
.section
->output_section
== NULL
));
5701 /* Array used to determine the number of hash table buckets to use
5702 based on the number of symbols there are. If there are fewer than
5703 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5704 fewer than 37 we use 17 buckets, and so forth. We never use more
5705 than 32771 buckets. */
5707 static const size_t elf_buckets
[] =
5709 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5713 /* Compute bucket count for hashing table. We do not use a static set
5714 of possible tables sizes anymore. Instead we determine for all
5715 possible reasonable sizes of the table the outcome (i.e., the
5716 number of collisions etc) and choose the best solution. The
5717 weighting functions are not too simple to allow the table to grow
5718 without bounds. Instead one of the weighting factors is the size.
5719 Therefore the result is always a good payoff between few collisions
5720 (= short chain lengths) and table size. */
5722 compute_bucket_count (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5723 unsigned long int *hashcodes ATTRIBUTE_UNUSED
,
5724 unsigned long int nsyms
,
5727 size_t best_size
= 0;
5728 unsigned long int i
;
5730 /* We have a problem here. The following code to optimize the table
5731 size requires an integer type with more the 32 bits. If
5732 BFD_HOST_U_64_BIT is set we know about such a type. */
5733 #ifdef BFD_HOST_U_64_BIT
5738 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
5739 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
5740 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5741 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
5742 unsigned long int *counts
;
5744 unsigned int no_improvement_count
= 0;
5746 /* Possible optimization parameters: if we have NSYMS symbols we say
5747 that the hashing table must at least have NSYMS/4 and at most
5749 minsize
= nsyms
/ 4;
5752 best_size
= maxsize
= nsyms
* 2;
5757 if ((best_size
& 31) == 0)
5761 /* Create array where we count the collisions in. We must use bfd_malloc
5762 since the size could be large. */
5764 amt
*= sizeof (unsigned long int);
5765 counts
= (unsigned long int *) bfd_malloc (amt
);
5769 /* Compute the "optimal" size for the hash table. The criteria is a
5770 minimal chain length. The minor criteria is (of course) the size
5772 for (i
= minsize
; i
< maxsize
; ++i
)
5774 /* Walk through the array of hashcodes and count the collisions. */
5775 BFD_HOST_U_64_BIT max
;
5776 unsigned long int j
;
5777 unsigned long int fact
;
5779 if (gnu_hash
&& (i
& 31) == 0)
5782 memset (counts
, '\0', i
* sizeof (unsigned long int));
5784 /* Determine how often each hash bucket is used. */
5785 for (j
= 0; j
< nsyms
; ++j
)
5786 ++counts
[hashcodes
[j
] % i
];
5788 /* For the weight function we need some information about the
5789 pagesize on the target. This is information need not be 100%
5790 accurate. Since this information is not available (so far) we
5791 define it here to a reasonable default value. If it is crucial
5792 to have a better value some day simply define this value. */
5793 # ifndef BFD_TARGET_PAGESIZE
5794 # define BFD_TARGET_PAGESIZE (4096)
5797 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5799 max
= (2 + dynsymcount
) * bed
->s
->sizeof_hash_entry
;
5802 /* Variant 1: optimize for short chains. We add the squares
5803 of all the chain lengths (which favors many small chain
5804 over a few long chains). */
5805 for (j
= 0; j
< i
; ++j
)
5806 max
+= counts
[j
] * counts
[j
];
5808 /* This adds penalties for the overall size of the table. */
5809 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5812 /* Variant 2: Optimize a lot more for small table. Here we
5813 also add squares of the size but we also add penalties for
5814 empty slots (the +1 term). */
5815 for (j
= 0; j
< i
; ++j
)
5816 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
5818 /* The overall size of the table is considered, but not as
5819 strong as in variant 1, where it is squared. */
5820 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5824 /* Compare with current best results. */
5825 if (max
< best_chlen
)
5829 no_improvement_count
= 0;
5831 /* PR 11843: Avoid futile long searches for the best bucket size
5832 when there are a large number of symbols. */
5833 else if (++no_improvement_count
== 100)
5840 #endif /* defined (BFD_HOST_U_64_BIT) */
5842 /* This is the fallback solution if no 64bit type is available or if we
5843 are not supposed to spend much time on optimizations. We select the
5844 bucket count using a fixed set of numbers. */
5845 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5847 best_size
= elf_buckets
[i
];
5848 if (nsyms
< elf_buckets
[i
+ 1])
5851 if (gnu_hash
&& best_size
< 2)
5858 /* Size any SHT_GROUP section for ld -r. */
5861 _bfd_elf_size_group_sections (struct bfd_link_info
*info
)
5865 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
5866 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
5867 && !_bfd_elf_fixup_group_sections (ibfd
, bfd_abs_section_ptr
))
5872 /* Set a default stack segment size. The value in INFO wins. If it
5873 is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5874 undefined it is initialized. */
5877 bfd_elf_stack_segment_size (bfd
*output_bfd
,
5878 struct bfd_link_info
*info
,
5879 const char *legacy_symbol
,
5880 bfd_vma default_size
)
5882 struct elf_link_hash_entry
*h
= NULL
;
5884 /* Look for legacy symbol. */
5886 h
= elf_link_hash_lookup (elf_hash_table (info
), legacy_symbol
,
5887 FALSE
, FALSE
, FALSE
);
5888 if (h
&& (h
->root
.type
== bfd_link_hash_defined
5889 || h
->root
.type
== bfd_link_hash_defweak
)
5891 && (h
->type
== STT_NOTYPE
|| h
->type
== STT_OBJECT
))
5893 /* The symbol has no type if specified on the command line. */
5894 h
->type
= STT_OBJECT
;
5895 if (info
->stacksize
)
5896 /* xgettext:c-format */
5897 _bfd_error_handler (_("%B: stack size specified and %s set"),
5898 output_bfd
, legacy_symbol
);
5899 else if (h
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
5900 /* xgettext:c-format */
5901 _bfd_error_handler (_("%B: %s not absolute"),
5902 output_bfd
, legacy_symbol
);
5904 info
->stacksize
= h
->root
.u
.def
.value
;
5907 if (!info
->stacksize
)
5908 /* If the user didn't set a size, or explicitly inhibit the
5909 size, set it now. */
5910 info
->stacksize
= default_size
;
5912 /* Provide the legacy symbol, if it is referenced. */
5913 if (h
&& (h
->root
.type
== bfd_link_hash_undefined
5914 || h
->root
.type
== bfd_link_hash_undefweak
))
5916 struct bfd_link_hash_entry
*bh
= NULL
;
5918 if (!(_bfd_generic_link_add_one_symbol
5919 (info
, output_bfd
, legacy_symbol
,
5920 BSF_GLOBAL
, bfd_abs_section_ptr
,
5921 info
->stacksize
>= 0 ? info
->stacksize
: 0,
5922 NULL
, FALSE
, get_elf_backend_data (output_bfd
)->collect
, &bh
)))
5925 h
= (struct elf_link_hash_entry
*) bh
;
5927 h
->type
= STT_OBJECT
;
5933 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
5935 struct elf_gc_sweep_symbol_info
5937 struct bfd_link_info
*info
;
5938 void (*hide_symbol
) (struct bfd_link_info
*, struct elf_link_hash_entry
*,
5943 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *data
)
5946 && (((h
->root
.type
== bfd_link_hash_defined
5947 || h
->root
.type
== bfd_link_hash_defweak
)
5948 && !((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
5949 && h
->root
.u
.def
.section
->gc_mark
))
5950 || h
->root
.type
== bfd_link_hash_undefined
5951 || h
->root
.type
== bfd_link_hash_undefweak
))
5953 struct elf_gc_sweep_symbol_info
*inf
;
5955 inf
= (struct elf_gc_sweep_symbol_info
*) data
;
5956 (*inf
->hide_symbol
) (inf
->info
, h
, TRUE
);
5959 h
->ref_regular_nonweak
= 0;
5965 /* Set up the sizes and contents of the ELF dynamic sections. This is
5966 called by the ELF linker emulation before_allocation routine. We
5967 must set the sizes of the sections before the linker sets the
5968 addresses of the various sections. */
5971 bfd_elf_size_dynamic_sections (bfd
*output_bfd
,
5974 const char *filter_shlib
,
5976 const char *depaudit
,
5977 const char * const *auxiliary_filters
,
5978 struct bfd_link_info
*info
,
5979 asection
**sinterpptr
)
5982 const struct elf_backend_data
*bed
;
5986 if (!is_elf_hash_table (info
->hash
))
5989 dynobj
= elf_hash_table (info
)->dynobj
;
5991 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
5993 struct bfd_elf_version_tree
*verdefs
;
5994 struct elf_info_failed asvinfo
;
5995 struct bfd_elf_version_tree
*t
;
5996 struct bfd_elf_version_expr
*d
;
5997 struct elf_info_failed eif
;
5998 bfd_boolean all_defined
;
6005 /* If we are supposed to export all symbols into the dynamic symbol
6006 table (this is not the normal case), then do so. */
6007 if (info
->export_dynamic
6008 || (bfd_link_executable (info
) && info
->dynamic
))
6010 elf_link_hash_traverse (elf_hash_table (info
),
6011 _bfd_elf_export_symbol
,
6019 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6021 if (soname_indx
== (size_t) -1
6022 || !_bfd_elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
6026 soname_indx
= (size_t) -1;
6028 /* Make all global versions with definition. */
6029 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
6030 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
6031 if (!d
->symver
&& d
->literal
)
6033 const char *verstr
, *name
;
6034 size_t namelen
, verlen
, newlen
;
6035 char *newname
, *p
, leading_char
;
6036 struct elf_link_hash_entry
*newh
;
6038 leading_char
= bfd_get_symbol_leading_char (output_bfd
);
6040 namelen
= strlen (name
) + (leading_char
!= '\0');
6042 verlen
= strlen (verstr
);
6043 newlen
= namelen
+ verlen
+ 3;
6045 newname
= (char *) bfd_malloc (newlen
);
6046 if (newname
== NULL
)
6048 newname
[0] = leading_char
;
6049 memcpy (newname
+ (leading_char
!= '\0'), name
, namelen
);
6051 /* Check the hidden versioned definition. */
6052 p
= newname
+ namelen
;
6054 memcpy (p
, verstr
, verlen
+ 1);
6055 newh
= elf_link_hash_lookup (elf_hash_table (info
),
6056 newname
, FALSE
, FALSE
,
6059 || (newh
->root
.type
!= bfd_link_hash_defined
6060 && newh
->root
.type
!= bfd_link_hash_defweak
))
6062 /* Check the default versioned definition. */
6064 memcpy (p
, verstr
, verlen
+ 1);
6065 newh
= elf_link_hash_lookup (elf_hash_table (info
),
6066 newname
, FALSE
, FALSE
,
6071 /* Mark this version if there is a definition and it is
6072 not defined in a shared object. */
6074 && !newh
->def_dynamic
6075 && (newh
->root
.type
== bfd_link_hash_defined
6076 || newh
->root
.type
== bfd_link_hash_defweak
))
6080 /* Attach all the symbols to their version information. */
6081 asvinfo
.info
= info
;
6082 asvinfo
.failed
= FALSE
;
6084 elf_link_hash_traverse (elf_hash_table (info
),
6085 _bfd_elf_link_assign_sym_version
,
6090 if (!info
->allow_undefined_version
)
6092 /* Check if all global versions have a definition. */
6094 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
6095 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
6096 if (d
->literal
&& !d
->symver
&& !d
->script
)
6099 (_("%s: undefined version: %s"),
6100 d
->pattern
, t
->name
);
6101 all_defined
= FALSE
;
6106 bfd_set_error (bfd_error_bad_value
);
6111 /* Set up the version definition section. */
6112 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
6113 BFD_ASSERT (s
!= NULL
);
6115 /* We may have created additional version definitions if we are
6116 just linking a regular application. */
6117 verdefs
= info
->version_info
;
6119 /* Skip anonymous version tag. */
6120 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
6121 verdefs
= verdefs
->next
;
6123 if (verdefs
== NULL
&& !info
->create_default_symver
)
6124 s
->flags
|= SEC_EXCLUDE
;
6130 Elf_Internal_Verdef def
;
6131 Elf_Internal_Verdaux defaux
;
6132 struct bfd_link_hash_entry
*bh
;
6133 struct elf_link_hash_entry
*h
;
6139 /* Make space for the base version. */
6140 size
+= sizeof (Elf_External_Verdef
);
6141 size
+= sizeof (Elf_External_Verdaux
);
6144 /* Make space for the default version. */
6145 if (info
->create_default_symver
)
6147 size
+= sizeof (Elf_External_Verdef
);
6151 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6153 struct bfd_elf_version_deps
*n
;
6155 /* Don't emit base version twice. */
6159 size
+= sizeof (Elf_External_Verdef
);
6160 size
+= sizeof (Elf_External_Verdaux
);
6163 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6164 size
+= sizeof (Elf_External_Verdaux
);
6168 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6169 if (s
->contents
== NULL
&& s
->size
!= 0)
6172 /* Fill in the version definition section. */
6176 def
.vd_version
= VER_DEF_CURRENT
;
6177 def
.vd_flags
= VER_FLG_BASE
;
6180 if (info
->create_default_symver
)
6182 def
.vd_aux
= 2 * sizeof (Elf_External_Verdef
);
6183 def
.vd_next
= sizeof (Elf_External_Verdef
);
6187 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6188 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6189 + sizeof (Elf_External_Verdaux
));
6192 if (soname_indx
!= (size_t) -1)
6194 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6196 def
.vd_hash
= bfd_elf_hash (soname
);
6197 defaux
.vda_name
= soname_indx
;
6204 name
= lbasename (output_bfd
->filename
);
6205 def
.vd_hash
= bfd_elf_hash (name
);
6206 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6208 if (indx
== (size_t) -1)
6210 defaux
.vda_name
= indx
;
6212 defaux
.vda_next
= 0;
6214 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6215 (Elf_External_Verdef
*) p
);
6216 p
+= sizeof (Elf_External_Verdef
);
6217 if (info
->create_default_symver
)
6219 /* Add a symbol representing this version. */
6221 if (! (_bfd_generic_link_add_one_symbol
6222 (info
, dynobj
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6224 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6226 h
= (struct elf_link_hash_entry
*) bh
;
6229 h
->type
= STT_OBJECT
;
6230 h
->verinfo
.vertree
= NULL
;
6232 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6235 /* Create a duplicate of the base version with the same
6236 aux block, but different flags. */
6239 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6241 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6242 + sizeof (Elf_External_Verdaux
));
6245 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6246 (Elf_External_Verdef
*) p
);
6247 p
+= sizeof (Elf_External_Verdef
);
6249 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6250 (Elf_External_Verdaux
*) p
);
6251 p
+= sizeof (Elf_External_Verdaux
);
6253 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6256 struct bfd_elf_version_deps
*n
;
6258 /* Don't emit the base version twice. */
6263 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6266 /* Add a symbol representing this version. */
6268 if (! (_bfd_generic_link_add_one_symbol
6269 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6271 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6273 h
= (struct elf_link_hash_entry
*) bh
;
6276 h
->type
= STT_OBJECT
;
6277 h
->verinfo
.vertree
= t
;
6279 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6282 def
.vd_version
= VER_DEF_CURRENT
;
6284 if (t
->globals
.list
== NULL
6285 && t
->locals
.list
== NULL
6287 def
.vd_flags
|= VER_FLG_WEAK
;
6288 def
.vd_ndx
= t
->vernum
+ (info
->create_default_symver
? 2 : 1);
6289 def
.vd_cnt
= cdeps
+ 1;
6290 def
.vd_hash
= bfd_elf_hash (t
->name
);
6291 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6294 /* If a basever node is next, it *must* be the last node in
6295 the chain, otherwise Verdef construction breaks. */
6296 if (t
->next
!= NULL
&& t
->next
->vernum
== 0)
6297 BFD_ASSERT (t
->next
->next
== NULL
);
6299 if (t
->next
!= NULL
&& t
->next
->vernum
!= 0)
6300 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6301 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
6303 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6304 (Elf_External_Verdef
*) p
);
6305 p
+= sizeof (Elf_External_Verdef
);
6307 defaux
.vda_name
= h
->dynstr_index
;
6308 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6310 defaux
.vda_next
= 0;
6311 if (t
->deps
!= NULL
)
6312 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6313 t
->name_indx
= defaux
.vda_name
;
6315 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6316 (Elf_External_Verdaux
*) p
);
6317 p
+= sizeof (Elf_External_Verdaux
);
6319 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6321 if (n
->version_needed
== NULL
)
6323 /* This can happen if there was an error in the
6325 defaux
.vda_name
= 0;
6329 defaux
.vda_name
= n
->version_needed
->name_indx
;
6330 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6333 if (n
->next
== NULL
)
6334 defaux
.vda_next
= 0;
6336 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6338 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6339 (Elf_External_Verdaux
*) p
);
6340 p
+= sizeof (Elf_External_Verdaux
);
6344 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
6347 /* Work out the size of the version reference section. */
6349 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
6350 BFD_ASSERT (s
!= NULL
);
6352 struct elf_find_verdep_info sinfo
;
6355 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
6356 if (sinfo
.vers
== 0)
6358 sinfo
.failed
= FALSE
;
6360 elf_link_hash_traverse (elf_hash_table (info
),
6361 _bfd_elf_link_find_version_dependencies
,
6366 if (elf_tdata (output_bfd
)->verref
== NULL
)
6367 s
->flags
|= SEC_EXCLUDE
;
6370 Elf_Internal_Verneed
*vn
;
6375 /* Build the version dependency section. */
6378 for (vn
= elf_tdata (output_bfd
)->verref
;
6380 vn
= vn
->vn_nextref
)
6382 Elf_Internal_Vernaux
*a
;
6384 size
+= sizeof (Elf_External_Verneed
);
6386 for (a
= vn
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6387 size
+= sizeof (Elf_External_Vernaux
);
6391 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6392 if (s
->contents
== NULL
)
6396 for (vn
= elf_tdata (output_bfd
)->verref
;
6398 vn
= vn
->vn_nextref
)
6401 Elf_Internal_Vernaux
*a
;
6405 for (a
= vn
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6408 vn
->vn_version
= VER_NEED_CURRENT
;
6410 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6411 elf_dt_name (vn
->vn_bfd
) != NULL
6412 ? elf_dt_name (vn
->vn_bfd
)
6413 : lbasename (vn
->vn_bfd
->filename
),
6415 if (indx
== (size_t) -1)
6418 vn
->vn_aux
= sizeof (Elf_External_Verneed
);
6419 if (vn
->vn_nextref
== NULL
)
6422 vn
->vn_next
= (sizeof (Elf_External_Verneed
)
6423 + caux
* sizeof (Elf_External_Vernaux
));
6425 _bfd_elf_swap_verneed_out (output_bfd
, vn
,
6426 (Elf_External_Verneed
*) p
);
6427 p
+= sizeof (Elf_External_Verneed
);
6429 for (a
= vn
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6431 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
6432 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6433 a
->vna_nodename
, FALSE
);
6434 if (indx
== (size_t) -1)
6437 if (a
->vna_nextptr
== NULL
)
6440 a
->vna_next
= sizeof (Elf_External_Vernaux
);
6442 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
6443 (Elf_External_Vernaux
*) p
);
6444 p
+= sizeof (Elf_External_Vernaux
);
6448 elf_tdata (output_bfd
)->cverrefs
= crefs
;
6453 bed
= get_elf_backend_data (output_bfd
);
6455 if (info
->gc_sections
&& bed
->can_gc_sections
)
6457 struct elf_gc_sweep_symbol_info sweep_info
;
6458 unsigned long section_sym_count
;
6460 /* Remove the symbols that were in the swept sections from the
6461 dynamic symbol table. GCFIXME: Anyone know how to get them
6462 out of the static symbol table as well? */
6463 sweep_info
.info
= info
;
6464 sweep_info
.hide_symbol
= bed
->elf_backend_hide_symbol
;
6465 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
,
6468 /* We need to reassign dynsym indices now that symbols may have
6469 been removed. See the call in `bfd_elf_size_dynsym_hash_dynstr'
6470 for the details of the conditions used here. */
6471 if (elf_hash_table (info
)->dynamic_sections_created
6472 || bed
->always_renumber_dynsyms
)
6473 _bfd_elf_link_renumber_dynsyms (output_bfd
, info
, §ion_sym_count
);
6476 /* Any syms created from now on start with -1 in
6477 got.refcount/offset and plt.refcount/offset. */
6478 elf_hash_table (info
)->init_got_refcount
6479 = elf_hash_table (info
)->init_got_offset
;
6480 elf_hash_table (info
)->init_plt_refcount
6481 = elf_hash_table (info
)->init_plt_offset
;
6483 if (bfd_link_relocatable (info
)
6484 && !_bfd_elf_size_group_sections (info
))
6487 /* The backend may have to create some sections regardless of whether
6488 we're dynamic or not. */
6489 if (bed
->elf_backend_always_size_sections
6490 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
6493 /* Determine any GNU_STACK segment requirements, after the backend
6494 has had a chance to set a default segment size. */
6495 if (info
->execstack
)
6496 elf_stack_flags (output_bfd
) = PF_R
| PF_W
| PF_X
;
6497 else if (info
->noexecstack
)
6498 elf_stack_flags (output_bfd
) = PF_R
| PF_W
;
6502 asection
*notesec
= NULL
;
6505 for (inputobj
= info
->input_bfds
;
6507 inputobj
= inputobj
->link
.next
)
6512 & (DYNAMIC
| EXEC_P
| BFD_PLUGIN
| BFD_LINKER_CREATED
))
6514 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
6517 if (s
->flags
& SEC_CODE
)
6521 else if (bed
->default_execstack
)
6524 if (notesec
|| info
->stacksize
> 0)
6525 elf_stack_flags (output_bfd
) = PF_R
| PF_W
| exec
;
6526 if (notesec
&& exec
&& bfd_link_relocatable (info
)
6527 && notesec
->output_section
!= bfd_abs_section_ptr
)
6528 notesec
->output_section
->flags
|= SEC_CODE
;
6531 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
6533 struct elf_info_failed eif
;
6534 struct elf_link_hash_entry
*h
;
6538 *sinterpptr
= bfd_get_linker_section (dynobj
, ".interp");
6539 BFD_ASSERT (*sinterpptr
!= NULL
|| !bfd_link_executable (info
) || info
->nointerp
);
6543 if (!_bfd_elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
6545 info
->flags
|= DF_SYMBOLIC
;
6553 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
6555 if (indx
== (size_t) -1)
6558 tag
= info
->new_dtags
? DT_RUNPATH
: DT_RPATH
;
6559 if (!_bfd_elf_add_dynamic_entry (info
, tag
, indx
))
6563 if (filter_shlib
!= NULL
)
6567 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6568 filter_shlib
, TRUE
);
6569 if (indx
== (size_t) -1
6570 || !_bfd_elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
6574 if (auxiliary_filters
!= NULL
)
6576 const char * const *p
;
6578 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
6582 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6584 if (indx
== (size_t) -1
6585 || !_bfd_elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
6594 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, audit
,
6596 if (indx
== (size_t) -1
6597 || !_bfd_elf_add_dynamic_entry (info
, DT_AUDIT
, indx
))
6601 if (depaudit
!= NULL
)
6605 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, depaudit
,
6607 if (indx
== (size_t) -1
6608 || !_bfd_elf_add_dynamic_entry (info
, DT_DEPAUDIT
, indx
))
6615 /* Find all symbols which were defined in a dynamic object and make
6616 the backend pick a reasonable value for them. */
6617 elf_link_hash_traverse (elf_hash_table (info
),
6618 _bfd_elf_adjust_dynamic_symbol
,
6623 /* Add some entries to the .dynamic section. We fill in some of the
6624 values later, in bfd_elf_final_link, but we must add the entries
6625 now so that we know the final size of the .dynamic section. */
6627 /* If there are initialization and/or finalization functions to
6628 call then add the corresponding DT_INIT/DT_FINI entries. */
6629 h
= (info
->init_function
6630 ? elf_link_hash_lookup (elf_hash_table (info
),
6631 info
->init_function
, FALSE
,
6638 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT
, 0))
6641 h
= (info
->fini_function
6642 ? elf_link_hash_lookup (elf_hash_table (info
),
6643 info
->fini_function
, FALSE
,
6650 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI
, 0))
6654 s
= bfd_get_section_by_name (output_bfd
, ".preinit_array");
6655 if (s
!= NULL
&& s
->linker_has_input
)
6657 /* DT_PREINIT_ARRAY is not allowed in shared library. */
6658 if (! bfd_link_executable (info
))
6663 for (sub
= info
->input_bfds
; sub
!= NULL
;
6664 sub
= sub
->link
.next
)
6665 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
)
6666 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
6667 if (elf_section_data (o
)->this_hdr
.sh_type
6668 == SHT_PREINIT_ARRAY
)
6671 (_("%B: .preinit_array section is not allowed in DSO"),
6676 bfd_set_error (bfd_error_nonrepresentable_section
);
6680 if (!_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
6681 || !_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
6684 s
= bfd_get_section_by_name (output_bfd
, ".init_array");
6685 if (s
!= NULL
&& s
->linker_has_input
)
6687 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
6688 || !_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
6691 s
= bfd_get_section_by_name (output_bfd
, ".fini_array");
6692 if (s
!= NULL
&& s
->linker_has_input
)
6694 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
6695 || !_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
6699 dynstr
= bfd_get_linker_section (dynobj
, ".dynstr");
6700 /* If .dynstr is excluded from the link, we don't want any of
6701 these tags. Strictly, we should be checking each section
6702 individually; This quick check covers for the case where
6703 someone does a /DISCARD/ : { *(*) }. */
6704 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
6706 bfd_size_type strsize
;
6708 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6709 if ((info
->emit_hash
6710 && !_bfd_elf_add_dynamic_entry (info
, DT_HASH
, 0))
6711 || (info
->emit_gnu_hash
6712 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_HASH
, 0))
6713 || !_bfd_elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
6714 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
6715 || !_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
6716 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMENT
,
6717 bed
->s
->sizeof_sym
))
6722 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
6725 /* The backend must work out the sizes of all the other dynamic
6728 && bed
->elf_backend_size_dynamic_sections
!= NULL
6729 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
6732 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
6734 unsigned long section_sym_count
;
6736 if (elf_tdata (output_bfd
)->cverdefs
)
6738 unsigned int crefs
= elf_tdata (output_bfd
)->cverdefs
;
6740 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
6741 || !_bfd_elf_add_dynamic_entry (info
, DT_VERDEFNUM
, crefs
))
6745 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
6747 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
6750 else if (info
->flags
& DF_BIND_NOW
)
6752 if (!_bfd_elf_add_dynamic_entry (info
, DT_BIND_NOW
, 0))
6758 if (bfd_link_executable (info
))
6759 info
->flags_1
&= ~ (DF_1_INITFIRST
6762 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
6766 if (elf_tdata (output_bfd
)->cverrefs
)
6768 unsigned int crefs
= elf_tdata (output_bfd
)->cverrefs
;
6770 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
6771 || !_bfd_elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
6775 if ((elf_tdata (output_bfd
)->cverrefs
== 0
6776 && elf_tdata (output_bfd
)->cverdefs
== 0)
6777 || _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6778 §ion_sym_count
) == 0)
6782 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6783 s
->flags
|= SEC_EXCLUDE
;
6789 /* Find the first non-excluded output section. We'll use its
6790 section symbol for some emitted relocs. */
6792 _bfd_elf_init_1_index_section (bfd
*output_bfd
, struct bfd_link_info
*info
)
6796 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6797 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
6798 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6800 elf_hash_table (info
)->text_index_section
= s
;
6805 /* Find two non-excluded output sections, one for code, one for data.
6806 We'll use their section symbols for some emitted relocs. */
6808 _bfd_elf_init_2_index_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6812 /* Data first, since setting text_index_section changes
6813 _bfd_elf_link_omit_section_dynsym. */
6814 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6815 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
)) == SEC_ALLOC
)
6816 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6818 elf_hash_table (info
)->data_index_section
= s
;
6822 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6823 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
))
6824 == (SEC_ALLOC
| SEC_READONLY
))
6825 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6827 elf_hash_table (info
)->text_index_section
= s
;
6831 if (elf_hash_table (info
)->text_index_section
== NULL
)
6832 elf_hash_table (info
)->text_index_section
6833 = elf_hash_table (info
)->data_index_section
;
6837 bfd_elf_size_dynsym_hash_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
6839 const struct elf_backend_data
*bed
;
6840 unsigned long section_sym_count
;
6841 bfd_size_type dynsymcount
;
6843 if (!is_elf_hash_table (info
->hash
))
6846 bed
= get_elf_backend_data (output_bfd
);
6847 (*bed
->elf_backend_init_index_section
) (output_bfd
, info
);
6849 /* Assign dynsym indices. In a shared library we generate a section
6850 symbol for each output section, which come first. Next come all
6851 of the back-end allocated local dynamic syms, followed by the rest
6852 of the global symbols.
6854 This is usually not needed for static binaries, however backends
6855 can request to always do it, e.g. the MIPS backend uses dynamic
6856 symbol counts to lay out GOT, which will be produced in the
6857 presence of GOT relocations even in static binaries (holding fixed
6858 data in that case, to satisfy those relocations). */
6860 if (elf_hash_table (info
)->dynamic_sections_created
6861 || bed
->always_renumber_dynsyms
)
6862 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6863 §ion_sym_count
);
6865 if (elf_hash_table (info
)->dynamic_sections_created
)
6869 unsigned int dtagcount
;
6871 dynobj
= elf_hash_table (info
)->dynobj
;
6873 /* Work out the size of the symbol version section. */
6874 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6875 BFD_ASSERT (s
!= NULL
);
6876 if ((s
->flags
& SEC_EXCLUDE
) == 0)
6878 s
->size
= dynsymcount
* sizeof (Elf_External_Versym
);
6879 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6880 if (s
->contents
== NULL
)
6883 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
6887 /* Set the size of the .dynsym and .hash sections. We counted
6888 the number of dynamic symbols in elf_link_add_object_symbols.
6889 We will build the contents of .dynsym and .hash when we build
6890 the final symbol table, because until then we do not know the
6891 correct value to give the symbols. We built the .dynstr
6892 section as we went along in elf_link_add_object_symbols. */
6893 s
= elf_hash_table (info
)->dynsym
;
6894 BFD_ASSERT (s
!= NULL
);
6895 s
->size
= dynsymcount
* bed
->s
->sizeof_sym
;
6897 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6898 if (s
->contents
== NULL
)
6901 /* The first entry in .dynsym is a dummy symbol. Clear all the
6902 section syms, in case we don't output them all. */
6903 ++section_sym_count
;
6904 memset (s
->contents
, 0, section_sym_count
* bed
->s
->sizeof_sym
);
6906 elf_hash_table (info
)->bucketcount
= 0;
6908 /* Compute the size of the hashing table. As a side effect this
6909 computes the hash values for all the names we export. */
6910 if (info
->emit_hash
)
6912 unsigned long int *hashcodes
;
6913 struct hash_codes_info hashinf
;
6915 unsigned long int nsyms
;
6917 size_t hash_entry_size
;
6919 /* Compute the hash values for all exported symbols. At the same
6920 time store the values in an array so that we could use them for
6922 amt
= dynsymcount
* sizeof (unsigned long int);
6923 hashcodes
= (unsigned long int *) bfd_malloc (amt
);
6924 if (hashcodes
== NULL
)
6926 hashinf
.hashcodes
= hashcodes
;
6927 hashinf
.error
= FALSE
;
6929 /* Put all hash values in HASHCODES. */
6930 elf_link_hash_traverse (elf_hash_table (info
),
6931 elf_collect_hash_codes
, &hashinf
);
6938 nsyms
= hashinf
.hashcodes
- hashcodes
;
6940 = compute_bucket_count (info
, hashcodes
, nsyms
, 0);
6943 if (bucketcount
== 0 && nsyms
> 0)
6946 elf_hash_table (info
)->bucketcount
= bucketcount
;
6948 s
= bfd_get_linker_section (dynobj
, ".hash");
6949 BFD_ASSERT (s
!= NULL
);
6950 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
6951 s
->size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
6952 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6953 if (s
->contents
== NULL
)
6956 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
6957 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
6958 s
->contents
+ hash_entry_size
);
6961 if (info
->emit_gnu_hash
)
6964 unsigned char *contents
;
6965 struct collect_gnu_hash_codes cinfo
;
6969 memset (&cinfo
, 0, sizeof (cinfo
));
6971 /* Compute the hash values for all exported symbols. At the same
6972 time store the values in an array so that we could use them for
6974 amt
= dynsymcount
* 2 * sizeof (unsigned long int);
6975 cinfo
.hashcodes
= (long unsigned int *) bfd_malloc (amt
);
6976 if (cinfo
.hashcodes
== NULL
)
6979 cinfo
.hashval
= cinfo
.hashcodes
+ dynsymcount
;
6980 cinfo
.min_dynindx
= -1;
6981 cinfo
.output_bfd
= output_bfd
;
6984 /* Put all hash values in HASHCODES. */
6985 elf_link_hash_traverse (elf_hash_table (info
),
6986 elf_collect_gnu_hash_codes
, &cinfo
);
6989 free (cinfo
.hashcodes
);
6994 = compute_bucket_count (info
, cinfo
.hashcodes
, cinfo
.nsyms
, 1);
6996 if (bucketcount
== 0)
6998 free (cinfo
.hashcodes
);
7002 s
= bfd_get_linker_section (dynobj
, ".gnu.hash");
7003 BFD_ASSERT (s
!= NULL
);
7005 if (cinfo
.nsyms
== 0)
7007 /* Empty .gnu.hash section is special. */
7008 BFD_ASSERT (cinfo
.min_dynindx
== -1);
7009 free (cinfo
.hashcodes
);
7010 s
->size
= 5 * 4 + bed
->s
->arch_size
/ 8;
7011 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
7012 if (contents
== NULL
)
7014 s
->contents
= contents
;
7015 /* 1 empty bucket. */
7016 bfd_put_32 (output_bfd
, 1, contents
);
7017 /* SYMIDX above the special symbol 0. */
7018 bfd_put_32 (output_bfd
, 1, contents
+ 4);
7019 /* Just one word for bitmask. */
7020 bfd_put_32 (output_bfd
, 1, contents
+ 8);
7021 /* Only hash fn bloom filter. */
7022 bfd_put_32 (output_bfd
, 0, contents
+ 12);
7023 /* No hashes are valid - empty bitmask. */
7024 bfd_put (bed
->s
->arch_size
, output_bfd
, 0, contents
+ 16);
7025 /* No hashes in the only bucket. */
7026 bfd_put_32 (output_bfd
, 0,
7027 contents
+ 16 + bed
->s
->arch_size
/ 8);
7031 unsigned long int maskwords
, maskbitslog2
, x
;
7032 BFD_ASSERT (cinfo
.min_dynindx
!= -1);
7036 while ((x
>>= 1) != 0)
7038 if (maskbitslog2
< 3)
7040 else if ((1 << (maskbitslog2
- 2)) & cinfo
.nsyms
)
7041 maskbitslog2
= maskbitslog2
+ 3;
7043 maskbitslog2
= maskbitslog2
+ 2;
7044 if (bed
->s
->arch_size
== 64)
7046 if (maskbitslog2
== 5)
7052 cinfo
.mask
= (1 << cinfo
.shift1
) - 1;
7053 cinfo
.shift2
= maskbitslog2
;
7054 cinfo
.maskbits
= 1 << maskbitslog2
;
7055 maskwords
= 1 << (maskbitslog2
- cinfo
.shift1
);
7056 amt
= bucketcount
* sizeof (unsigned long int) * 2;
7057 amt
+= maskwords
* sizeof (bfd_vma
);
7058 cinfo
.bitmask
= (bfd_vma
*) bfd_malloc (amt
);
7059 if (cinfo
.bitmask
== NULL
)
7061 free (cinfo
.hashcodes
);
7065 cinfo
.counts
= (long unsigned int *) (cinfo
.bitmask
+ maskwords
);
7066 cinfo
.indx
= cinfo
.counts
+ bucketcount
;
7067 cinfo
.symindx
= dynsymcount
- cinfo
.nsyms
;
7068 memset (cinfo
.bitmask
, 0, maskwords
* sizeof (bfd_vma
));
7070 /* Determine how often each hash bucket is used. */
7071 memset (cinfo
.counts
, 0, bucketcount
* sizeof (cinfo
.counts
[0]));
7072 for (i
= 0; i
< cinfo
.nsyms
; ++i
)
7073 ++cinfo
.counts
[cinfo
.hashcodes
[i
] % bucketcount
];
7075 for (i
= 0, cnt
= cinfo
.symindx
; i
< bucketcount
; ++i
)
7076 if (cinfo
.counts
[i
] != 0)
7078 cinfo
.indx
[i
] = cnt
;
7079 cnt
+= cinfo
.counts
[i
];
7081 BFD_ASSERT (cnt
== dynsymcount
);
7082 cinfo
.bucketcount
= bucketcount
;
7083 cinfo
.local_indx
= cinfo
.min_dynindx
;
7085 s
->size
= (4 + bucketcount
+ cinfo
.nsyms
) * 4;
7086 s
->size
+= cinfo
.maskbits
/ 8;
7087 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
7088 if (contents
== NULL
)
7090 free (cinfo
.bitmask
);
7091 free (cinfo
.hashcodes
);
7095 s
->contents
= contents
;
7096 bfd_put_32 (output_bfd
, bucketcount
, contents
);
7097 bfd_put_32 (output_bfd
, cinfo
.symindx
, contents
+ 4);
7098 bfd_put_32 (output_bfd
, maskwords
, contents
+ 8);
7099 bfd_put_32 (output_bfd
, cinfo
.shift2
, contents
+ 12);
7100 contents
+= 16 + cinfo
.maskbits
/ 8;
7102 for (i
= 0; i
< bucketcount
; ++i
)
7104 if (cinfo
.counts
[i
] == 0)
7105 bfd_put_32 (output_bfd
, 0, contents
);
7107 bfd_put_32 (output_bfd
, cinfo
.indx
[i
], contents
);
7111 cinfo
.contents
= contents
;
7113 /* Renumber dynamic symbols, populate .gnu.hash section. */
7114 elf_link_hash_traverse (elf_hash_table (info
),
7115 elf_renumber_gnu_hash_syms
, &cinfo
);
7117 contents
= s
->contents
+ 16;
7118 for (i
= 0; i
< maskwords
; ++i
)
7120 bfd_put (bed
->s
->arch_size
, output_bfd
, cinfo
.bitmask
[i
],
7122 contents
+= bed
->s
->arch_size
/ 8;
7125 free (cinfo
.bitmask
);
7126 free (cinfo
.hashcodes
);
7130 s
= bfd_get_linker_section (dynobj
, ".dynstr");
7131 BFD_ASSERT (s
!= NULL
);
7133 elf_finalize_dynstr (output_bfd
, info
);
7135 s
->size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
7137 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
7138 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0))
7145 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
7148 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7151 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
);
7152 sec
->sec_info_type
= SEC_INFO_TYPE_NONE
;
7155 /* Finish SHF_MERGE section merging. */
7158 _bfd_elf_merge_sections (bfd
*obfd
, struct bfd_link_info
*info
)
7163 if (!is_elf_hash_table (info
->hash
))
7166 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7167 if ((ibfd
->flags
& DYNAMIC
) == 0
7168 && bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
7169 && (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
7170 == get_elf_backend_data (obfd
)->s
->elfclass
))
7171 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7172 if ((sec
->flags
& SEC_MERGE
) != 0
7173 && !bfd_is_abs_section (sec
->output_section
))
7175 struct bfd_elf_section_data
*secdata
;
7177 secdata
= elf_section_data (sec
);
7178 if (! _bfd_add_merge_section (obfd
,
7179 &elf_hash_table (info
)->merge_info
,
7180 sec
, &secdata
->sec_info
))
7182 else if (secdata
->sec_info
)
7183 sec
->sec_info_type
= SEC_INFO_TYPE_MERGE
;
7186 if (elf_hash_table (info
)->merge_info
!= NULL
)
7187 _bfd_merge_sections (obfd
, info
, elf_hash_table (info
)->merge_info
,
7188 merge_sections_remove_hook
);
7192 /* Create an entry in an ELF linker hash table. */
7194 struct bfd_hash_entry
*
7195 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
7196 struct bfd_hash_table
*table
,
7199 /* Allocate the structure if it has not already been allocated by a
7203 entry
= (struct bfd_hash_entry
*)
7204 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
7209 /* Call the allocation method of the superclass. */
7210 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
7213 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
7214 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
7216 /* Set local fields. */
7219 ret
->got
= htab
->init_got_refcount
;
7220 ret
->plt
= htab
->init_plt_refcount
;
7221 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
7222 - offsetof (struct elf_link_hash_entry
, size
)));
7223 /* Assume that we have been called by a non-ELF symbol reader.
7224 This flag is then reset by the code which reads an ELF input
7225 file. This ensures that a symbol created by a non-ELF symbol
7226 reader will have the flag set correctly. */
7233 /* Copy data from an indirect symbol to its direct symbol, hiding the
7234 old indirect symbol. Also used for copying flags to a weakdef. */
7237 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info
*info
,
7238 struct elf_link_hash_entry
*dir
,
7239 struct elf_link_hash_entry
*ind
)
7241 struct elf_link_hash_table
*htab
;
7243 /* Copy down any references that we may have already seen to the
7244 symbol which just became indirect. */
7246 if (dir
->versioned
!= versioned_hidden
)
7247 dir
->ref_dynamic
|= ind
->ref_dynamic
;
7248 dir
->ref_regular
|= ind
->ref_regular
;
7249 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
7250 dir
->non_got_ref
|= ind
->non_got_ref
;
7251 dir
->needs_plt
|= ind
->needs_plt
;
7252 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
7254 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7257 /* Copy over the global and procedure linkage table refcount entries.
7258 These may have been already set up by a check_relocs routine. */
7259 htab
= elf_hash_table (info
);
7260 if (ind
->got
.refcount
> htab
->init_got_refcount
.refcount
)
7262 if (dir
->got
.refcount
< 0)
7263 dir
->got
.refcount
= 0;
7264 dir
->got
.refcount
+= ind
->got
.refcount
;
7265 ind
->got
.refcount
= htab
->init_got_refcount
.refcount
;
7268 if (ind
->plt
.refcount
> htab
->init_plt_refcount
.refcount
)
7270 if (dir
->plt
.refcount
< 0)
7271 dir
->plt
.refcount
= 0;
7272 dir
->plt
.refcount
+= ind
->plt
.refcount
;
7273 ind
->plt
.refcount
= htab
->init_plt_refcount
.refcount
;
7276 if (ind
->dynindx
!= -1)
7278 if (dir
->dynindx
!= -1)
7279 _bfd_elf_strtab_delref (htab
->dynstr
, dir
->dynstr_index
);
7280 dir
->dynindx
= ind
->dynindx
;
7281 dir
->dynstr_index
= ind
->dynstr_index
;
7283 ind
->dynstr_index
= 0;
7288 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
7289 struct elf_link_hash_entry
*h
,
7290 bfd_boolean force_local
)
7292 /* STT_GNU_IFUNC symbol must go through PLT. */
7293 if (h
->type
!= STT_GNU_IFUNC
)
7295 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
7300 h
->forced_local
= 1;
7301 if (h
->dynindx
!= -1)
7303 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7306 h
->dynstr_index
= 0;
7311 /* Initialize an ELF linker hash table. *TABLE has been zeroed by our
7315 _bfd_elf_link_hash_table_init
7316 (struct elf_link_hash_table
*table
,
7318 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
7319 struct bfd_hash_table
*,
7321 unsigned int entsize
,
7322 enum elf_target_id target_id
)
7325 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
7327 table
->init_got_refcount
.refcount
= can_refcount
- 1;
7328 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
7329 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
7330 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
7331 /* The first dynamic symbol is a dummy. */
7332 table
->dynsymcount
= 1;
7334 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
7336 table
->root
.type
= bfd_link_elf_hash_table
;
7337 table
->hash_table_id
= target_id
;
7342 /* Create an ELF linker hash table. */
7344 struct bfd_link_hash_table
*
7345 _bfd_elf_link_hash_table_create (bfd
*abfd
)
7347 struct elf_link_hash_table
*ret
;
7348 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
7350 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
7354 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
,
7355 sizeof (struct elf_link_hash_entry
),
7361 ret
->root
.hash_table_free
= _bfd_elf_link_hash_table_free
;
7366 /* Destroy an ELF linker hash table. */
7369 _bfd_elf_link_hash_table_free (bfd
*obfd
)
7371 struct elf_link_hash_table
*htab
;
7373 htab
= (struct elf_link_hash_table
*) obfd
->link
.hash
;
7374 if (htab
->dynstr
!= NULL
)
7375 _bfd_elf_strtab_free (htab
->dynstr
);
7376 _bfd_merge_sections_free (htab
->merge_info
);
7377 _bfd_generic_link_hash_table_free (obfd
);
7380 /* This is a hook for the ELF emulation code in the generic linker to
7381 tell the backend linker what file name to use for the DT_NEEDED
7382 entry for a dynamic object. */
7385 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
7387 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7388 && bfd_get_format (abfd
) == bfd_object
)
7389 elf_dt_name (abfd
) = name
;
7393 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
7396 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7397 && bfd_get_format (abfd
) == bfd_object
)
7398 lib_class
= elf_dyn_lib_class (abfd
);
7405 bfd_elf_set_dyn_lib_class (bfd
*abfd
, enum dynamic_lib_link_class lib_class
)
7407 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7408 && bfd_get_format (abfd
) == bfd_object
)
7409 elf_dyn_lib_class (abfd
) = lib_class
;
7412 /* Get the list of DT_NEEDED entries for a link. This is a hook for
7413 the linker ELF emulation code. */
7415 struct bfd_link_needed_list
*
7416 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
7417 struct bfd_link_info
*info
)
7419 if (! is_elf_hash_table (info
->hash
))
7421 return elf_hash_table (info
)->needed
;
7424 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
7425 hook for the linker ELF emulation code. */
7427 struct bfd_link_needed_list
*
7428 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
7429 struct bfd_link_info
*info
)
7431 if (! is_elf_hash_table (info
->hash
))
7433 return elf_hash_table (info
)->runpath
;
7436 /* Get the name actually used for a dynamic object for a link. This
7437 is the SONAME entry if there is one. Otherwise, it is the string
7438 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
7441 bfd_elf_get_dt_soname (bfd
*abfd
)
7443 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7444 && bfd_get_format (abfd
) == bfd_object
)
7445 return elf_dt_name (abfd
);
7449 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
7450 the ELF linker emulation code. */
7453 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
7454 struct bfd_link_needed_list
**pneeded
)
7457 bfd_byte
*dynbuf
= NULL
;
7458 unsigned int elfsec
;
7459 unsigned long shlink
;
7460 bfd_byte
*extdyn
, *extdynend
;
7462 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
7466 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
7467 || bfd_get_format (abfd
) != bfd_object
)
7470 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7471 if (s
== NULL
|| s
->size
== 0)
7474 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
7477 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
7478 if (elfsec
== SHN_BAD
)
7481 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
7483 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
7484 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
7487 extdynend
= extdyn
+ s
->size
;
7488 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
7490 Elf_Internal_Dyn dyn
;
7492 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
7494 if (dyn
.d_tag
== DT_NULL
)
7497 if (dyn
.d_tag
== DT_NEEDED
)
7500 struct bfd_link_needed_list
*l
;
7501 unsigned int tagv
= dyn
.d_un
.d_val
;
7504 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
7509 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
7530 struct elf_symbuf_symbol
7532 unsigned long st_name
; /* Symbol name, index in string tbl */
7533 unsigned char st_info
; /* Type and binding attributes */
7534 unsigned char st_other
; /* Visibilty, and target specific */
7537 struct elf_symbuf_head
7539 struct elf_symbuf_symbol
*ssym
;
7541 unsigned int st_shndx
;
7548 Elf_Internal_Sym
*isym
;
7549 struct elf_symbuf_symbol
*ssym
;
7554 /* Sort references to symbols by ascending section number. */
7557 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
7559 const Elf_Internal_Sym
*s1
= *(const Elf_Internal_Sym
**) arg1
;
7560 const Elf_Internal_Sym
*s2
= *(const Elf_Internal_Sym
**) arg2
;
7562 return s1
->st_shndx
- s2
->st_shndx
;
7566 elf_sym_name_compare (const void *arg1
, const void *arg2
)
7568 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
7569 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
7570 return strcmp (s1
->name
, s2
->name
);
7573 static struct elf_symbuf_head
*
7574 elf_create_symbuf (size_t symcount
, Elf_Internal_Sym
*isymbuf
)
7576 Elf_Internal_Sym
**ind
, **indbufend
, **indbuf
;
7577 struct elf_symbuf_symbol
*ssym
;
7578 struct elf_symbuf_head
*ssymbuf
, *ssymhead
;
7579 size_t i
, shndx_count
, total_size
;
7581 indbuf
= (Elf_Internal_Sym
**) bfd_malloc2 (symcount
, sizeof (*indbuf
));
7585 for (ind
= indbuf
, i
= 0; i
< symcount
; i
++)
7586 if (isymbuf
[i
].st_shndx
!= SHN_UNDEF
)
7587 *ind
++ = &isymbuf
[i
];
7590 qsort (indbuf
, indbufend
- indbuf
, sizeof (Elf_Internal_Sym
*),
7591 elf_sort_elf_symbol
);
7594 if (indbufend
> indbuf
)
7595 for (ind
= indbuf
, shndx_count
++; ind
< indbufend
- 1; ind
++)
7596 if (ind
[0]->st_shndx
!= ind
[1]->st_shndx
)
7599 total_size
= ((shndx_count
+ 1) * sizeof (*ssymbuf
)
7600 + (indbufend
- indbuf
) * sizeof (*ssym
));
7601 ssymbuf
= (struct elf_symbuf_head
*) bfd_malloc (total_size
);
7602 if (ssymbuf
== NULL
)
7608 ssym
= (struct elf_symbuf_symbol
*) (ssymbuf
+ shndx_count
+ 1);
7609 ssymbuf
->ssym
= NULL
;
7610 ssymbuf
->count
= shndx_count
;
7611 ssymbuf
->st_shndx
= 0;
7612 for (ssymhead
= ssymbuf
, ind
= indbuf
; ind
< indbufend
; ssym
++, ind
++)
7614 if (ind
== indbuf
|| ssymhead
->st_shndx
!= (*ind
)->st_shndx
)
7617 ssymhead
->ssym
= ssym
;
7618 ssymhead
->count
= 0;
7619 ssymhead
->st_shndx
= (*ind
)->st_shndx
;
7621 ssym
->st_name
= (*ind
)->st_name
;
7622 ssym
->st_info
= (*ind
)->st_info
;
7623 ssym
->st_other
= (*ind
)->st_other
;
7626 BFD_ASSERT ((size_t) (ssymhead
- ssymbuf
) == shndx_count
7627 && (((bfd_hostptr_t
) ssym
- (bfd_hostptr_t
) ssymbuf
)
7634 /* Check if 2 sections define the same set of local and global
7638 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
,
7639 struct bfd_link_info
*info
)
7642 const struct elf_backend_data
*bed1
, *bed2
;
7643 Elf_Internal_Shdr
*hdr1
, *hdr2
;
7644 size_t symcount1
, symcount2
;
7645 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
7646 struct elf_symbuf_head
*ssymbuf1
, *ssymbuf2
;
7647 Elf_Internal_Sym
*isym
, *isymend
;
7648 struct elf_symbol
*symtable1
= NULL
, *symtable2
= NULL
;
7649 size_t count1
, count2
, i
;
7650 unsigned int shndx1
, shndx2
;
7656 /* Both sections have to be in ELF. */
7657 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
7658 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
7661 if (elf_section_type (sec1
) != elf_section_type (sec2
))
7664 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
7665 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
7666 if (shndx1
== SHN_BAD
|| shndx2
== SHN_BAD
)
7669 bed1
= get_elf_backend_data (bfd1
);
7670 bed2
= get_elf_backend_data (bfd2
);
7671 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
7672 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
7673 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
7674 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
7676 if (symcount1
== 0 || symcount2
== 0)
7682 ssymbuf1
= (struct elf_symbuf_head
*) elf_tdata (bfd1
)->symbuf
;
7683 ssymbuf2
= (struct elf_symbuf_head
*) elf_tdata (bfd2
)->symbuf
;
7685 if (ssymbuf1
== NULL
)
7687 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
7689 if (isymbuf1
== NULL
)
7692 if (!info
->reduce_memory_overheads
)
7693 elf_tdata (bfd1
)->symbuf
= ssymbuf1
7694 = elf_create_symbuf (symcount1
, isymbuf1
);
7697 if (ssymbuf1
== NULL
|| ssymbuf2
== NULL
)
7699 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
7701 if (isymbuf2
== NULL
)
7704 if (ssymbuf1
!= NULL
&& !info
->reduce_memory_overheads
)
7705 elf_tdata (bfd2
)->symbuf
= ssymbuf2
7706 = elf_create_symbuf (symcount2
, isymbuf2
);
7709 if (ssymbuf1
!= NULL
&& ssymbuf2
!= NULL
)
7711 /* Optimized faster version. */
7713 struct elf_symbol
*symp
;
7714 struct elf_symbuf_symbol
*ssym
, *ssymend
;
7717 hi
= ssymbuf1
->count
;
7722 mid
= (lo
+ hi
) / 2;
7723 if (shndx1
< ssymbuf1
[mid
].st_shndx
)
7725 else if (shndx1
> ssymbuf1
[mid
].st_shndx
)
7729 count1
= ssymbuf1
[mid
].count
;
7736 hi
= ssymbuf2
->count
;
7741 mid
= (lo
+ hi
) / 2;
7742 if (shndx2
< ssymbuf2
[mid
].st_shndx
)
7744 else if (shndx2
> ssymbuf2
[mid
].st_shndx
)
7748 count2
= ssymbuf2
[mid
].count
;
7754 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7758 = (struct elf_symbol
*) bfd_malloc (count1
* sizeof (*symtable1
));
7760 = (struct elf_symbol
*) bfd_malloc (count2
* sizeof (*symtable2
));
7761 if (symtable1
== NULL
|| symtable2
== NULL
)
7765 for (ssym
= ssymbuf1
->ssym
, ssymend
= ssym
+ count1
;
7766 ssym
< ssymend
; ssym
++, symp
++)
7768 symp
->u
.ssym
= ssym
;
7769 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
7775 for (ssym
= ssymbuf2
->ssym
, ssymend
= ssym
+ count2
;
7776 ssym
< ssymend
; ssym
++, symp
++)
7778 symp
->u
.ssym
= ssym
;
7779 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
7784 /* Sort symbol by name. */
7785 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7786 elf_sym_name_compare
);
7787 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7788 elf_sym_name_compare
);
7790 for (i
= 0; i
< count1
; i
++)
7791 /* Two symbols must have the same binding, type and name. */
7792 if (symtable1
[i
].u
.ssym
->st_info
!= symtable2
[i
].u
.ssym
->st_info
7793 || symtable1
[i
].u
.ssym
->st_other
!= symtable2
[i
].u
.ssym
->st_other
7794 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7801 symtable1
= (struct elf_symbol
*)
7802 bfd_malloc (symcount1
* sizeof (struct elf_symbol
));
7803 symtable2
= (struct elf_symbol
*)
7804 bfd_malloc (symcount2
* sizeof (struct elf_symbol
));
7805 if (symtable1
== NULL
|| symtable2
== NULL
)
7808 /* Count definitions in the section. */
7810 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
; isym
< isymend
; isym
++)
7811 if (isym
->st_shndx
== shndx1
)
7812 symtable1
[count1
++].u
.isym
= isym
;
7815 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
; isym
< isymend
; isym
++)
7816 if (isym
->st_shndx
== shndx2
)
7817 symtable2
[count2
++].u
.isym
= isym
;
7819 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7822 for (i
= 0; i
< count1
; i
++)
7824 = bfd_elf_string_from_elf_section (bfd1
, hdr1
->sh_link
,
7825 symtable1
[i
].u
.isym
->st_name
);
7827 for (i
= 0; i
< count2
; i
++)
7829 = bfd_elf_string_from_elf_section (bfd2
, hdr2
->sh_link
,
7830 symtable2
[i
].u
.isym
->st_name
);
7832 /* Sort symbol by name. */
7833 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7834 elf_sym_name_compare
);
7835 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7836 elf_sym_name_compare
);
7838 for (i
= 0; i
< count1
; i
++)
7839 /* Two symbols must have the same binding, type and name. */
7840 if (symtable1
[i
].u
.isym
->st_info
!= symtable2
[i
].u
.isym
->st_info
7841 || symtable1
[i
].u
.isym
->st_other
!= symtable2
[i
].u
.isym
->st_other
7842 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7860 /* Return TRUE if 2 section types are compatible. */
7863 _bfd_elf_match_sections_by_type (bfd
*abfd
, const asection
*asec
,
7864 bfd
*bbfd
, const asection
*bsec
)
7868 || abfd
->xvec
->flavour
!= bfd_target_elf_flavour
7869 || bbfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7872 return elf_section_type (asec
) == elf_section_type (bsec
);
7875 /* Final phase of ELF linker. */
7877 /* A structure we use to avoid passing large numbers of arguments. */
7879 struct elf_final_link_info
7881 /* General link information. */
7882 struct bfd_link_info
*info
;
7885 /* Symbol string table. */
7886 struct elf_strtab_hash
*symstrtab
;
7887 /* .hash section. */
7889 /* symbol version section (.gnu.version). */
7890 asection
*symver_sec
;
7891 /* Buffer large enough to hold contents of any section. */
7893 /* Buffer large enough to hold external relocs of any section. */
7894 void *external_relocs
;
7895 /* Buffer large enough to hold internal relocs of any section. */
7896 Elf_Internal_Rela
*internal_relocs
;
7897 /* Buffer large enough to hold external local symbols of any input
7899 bfd_byte
*external_syms
;
7900 /* And a buffer for symbol section indices. */
7901 Elf_External_Sym_Shndx
*locsym_shndx
;
7902 /* Buffer large enough to hold internal local symbols of any input
7904 Elf_Internal_Sym
*internal_syms
;
7905 /* Array large enough to hold a symbol index for each local symbol
7906 of any input BFD. */
7908 /* Array large enough to hold a section pointer for each local
7909 symbol of any input BFD. */
7910 asection
**sections
;
7911 /* Buffer for SHT_SYMTAB_SHNDX section. */
7912 Elf_External_Sym_Shndx
*symshndxbuf
;
7913 /* Number of STT_FILE syms seen. */
7914 size_t filesym_count
;
7917 /* This struct is used to pass information to elf_link_output_extsym. */
7919 struct elf_outext_info
7922 bfd_boolean localsyms
;
7923 bfd_boolean file_sym_done
;
7924 struct elf_final_link_info
*flinfo
;
7928 /* Support for evaluating a complex relocation.
7930 Complex relocations are generalized, self-describing relocations. The
7931 implementation of them consists of two parts: complex symbols, and the
7932 relocations themselves.
7934 The relocations are use a reserved elf-wide relocation type code (R_RELC
7935 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7936 information (start bit, end bit, word width, etc) into the addend. This
7937 information is extracted from CGEN-generated operand tables within gas.
7939 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7940 internal) representing prefix-notation expressions, including but not
7941 limited to those sorts of expressions normally encoded as addends in the
7942 addend field. The symbol mangling format is:
7945 | <unary-operator> ':' <node>
7946 | <binary-operator> ':' <node> ':' <node>
7949 <literal> := 's' <digits=N> ':' <N character symbol name>
7950 | 'S' <digits=N> ':' <N character section name>
7954 <binary-operator> := as in C
7955 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7958 set_symbol_value (bfd
*bfd_with_globals
,
7959 Elf_Internal_Sym
*isymbuf
,
7964 struct elf_link_hash_entry
**sym_hashes
;
7965 struct elf_link_hash_entry
*h
;
7966 size_t extsymoff
= locsymcount
;
7968 if (symidx
< locsymcount
)
7970 Elf_Internal_Sym
*sym
;
7972 sym
= isymbuf
+ symidx
;
7973 if (ELF_ST_BIND (sym
->st_info
) == STB_LOCAL
)
7975 /* It is a local symbol: move it to the
7976 "absolute" section and give it a value. */
7977 sym
->st_shndx
= SHN_ABS
;
7978 sym
->st_value
= val
;
7981 BFD_ASSERT (elf_bad_symtab (bfd_with_globals
));
7985 /* It is a global symbol: set its link type
7986 to "defined" and give it a value. */
7988 sym_hashes
= elf_sym_hashes (bfd_with_globals
);
7989 h
= sym_hashes
[symidx
- extsymoff
];
7990 while (h
->root
.type
== bfd_link_hash_indirect
7991 || h
->root
.type
== bfd_link_hash_warning
)
7992 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7993 h
->root
.type
= bfd_link_hash_defined
;
7994 h
->root
.u
.def
.value
= val
;
7995 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
7999 resolve_symbol (const char *name
,
8001 struct elf_final_link_info
*flinfo
,
8003 Elf_Internal_Sym
*isymbuf
,
8006 Elf_Internal_Sym
*sym
;
8007 struct bfd_link_hash_entry
*global_entry
;
8008 const char *candidate
= NULL
;
8009 Elf_Internal_Shdr
*symtab_hdr
;
8012 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
8014 for (i
= 0; i
< locsymcount
; ++ i
)
8018 if (ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
8021 candidate
= bfd_elf_string_from_elf_section (input_bfd
,
8022 symtab_hdr
->sh_link
,
8025 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
8026 name
, candidate
, (unsigned long) sym
->st_value
);
8028 if (candidate
&& strcmp (candidate
, name
) == 0)
8030 asection
*sec
= flinfo
->sections
[i
];
8032 *result
= _bfd_elf_rel_local_sym (input_bfd
, sym
, &sec
, 0);
8033 *result
+= sec
->output_offset
+ sec
->output_section
->vma
;
8035 printf ("Found symbol with value %8.8lx\n",
8036 (unsigned long) *result
);
8042 /* Hmm, haven't found it yet. perhaps it is a global. */
8043 global_entry
= bfd_link_hash_lookup (flinfo
->info
->hash
, name
,
8044 FALSE
, FALSE
, TRUE
);
8048 if (global_entry
->type
== bfd_link_hash_defined
8049 || global_entry
->type
== bfd_link_hash_defweak
)
8051 *result
= (global_entry
->u
.def
.value
8052 + global_entry
->u
.def
.section
->output_section
->vma
8053 + global_entry
->u
.def
.section
->output_offset
);
8055 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
8056 global_entry
->root
.string
, (unsigned long) *result
);
8064 /* Looks up NAME in SECTIONS. If found sets RESULT to NAME's address (in
8065 bytes) and returns TRUE, otherwise returns FALSE. Accepts pseudo-section
8066 names like "foo.end" which is the end address of section "foo". */
8069 resolve_section (const char *name
,
8077 for (curr
= sections
; curr
; curr
= curr
->next
)
8078 if (strcmp (curr
->name
, name
) == 0)
8080 *result
= curr
->vma
;
8084 /* Hmm. still haven't found it. try pseudo-section names. */
8085 /* FIXME: This could be coded more efficiently... */
8086 for (curr
= sections
; curr
; curr
= curr
->next
)
8088 len
= strlen (curr
->name
);
8089 if (len
> strlen (name
))
8092 if (strncmp (curr
->name
, name
, len
) == 0)
8094 if (strncmp (".end", name
+ len
, 4) == 0)
8096 *result
= curr
->vma
+ curr
->size
/ bfd_octets_per_byte (abfd
);
8100 /* Insert more pseudo-section names here, if you like. */
8108 undefined_reference (const char *reftype
, const char *name
)
8110 /* xgettext:c-format */
8111 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
8116 eval_symbol (bfd_vma
*result
,
8119 struct elf_final_link_info
*flinfo
,
8121 Elf_Internal_Sym
*isymbuf
,
8130 const char *sym
= *symp
;
8132 bfd_boolean symbol_is_section
= FALSE
;
8137 if (len
< 1 || len
> sizeof (symbuf
))
8139 bfd_set_error (bfd_error_invalid_operation
);
8152 *result
= strtoul (sym
, (char **) symp
, 16);
8156 symbol_is_section
= TRUE
;
8160 symlen
= strtol (sym
, (char **) symp
, 10);
8161 sym
= *symp
+ 1; /* Skip the trailing ':'. */
8163 if (symend
< sym
|| symlen
+ 1 > sizeof (symbuf
))
8165 bfd_set_error (bfd_error_invalid_operation
);
8169 memcpy (symbuf
, sym
, symlen
);
8170 symbuf
[symlen
] = '\0';
8171 *symp
= sym
+ symlen
;
8173 /* Is it always possible, with complex symbols, that gas "mis-guessed"
8174 the symbol as a section, or vice-versa. so we're pretty liberal in our
8175 interpretation here; section means "try section first", not "must be a
8176 section", and likewise with symbol. */
8178 if (symbol_is_section
)
8180 if (!resolve_section (symbuf
, flinfo
->output_bfd
->sections
, result
, input_bfd
)
8181 && !resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
8182 isymbuf
, locsymcount
))
8184 undefined_reference ("section", symbuf
);
8190 if (!resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
8191 isymbuf
, locsymcount
)
8192 && !resolve_section (symbuf
, flinfo
->output_bfd
->sections
,
8195 undefined_reference ("symbol", symbuf
);
8202 /* All that remains are operators. */
8204 #define UNARY_OP(op) \
8205 if (strncmp (sym, #op, strlen (#op)) == 0) \
8207 sym += strlen (#op); \
8211 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
8212 isymbuf, locsymcount, signed_p)) \
8215 *result = op ((bfd_signed_vma) a); \
8221 #define BINARY_OP(op) \
8222 if (strncmp (sym, #op, strlen (#op)) == 0) \
8224 sym += strlen (#op); \
8228 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
8229 isymbuf, locsymcount, signed_p)) \
8232 if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
8233 isymbuf, locsymcount, signed_p)) \
8236 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
8266 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym
);
8267 bfd_set_error (bfd_error_invalid_operation
);
8273 put_value (bfd_vma size
,
8274 unsigned long chunksz
,
8279 location
+= (size
- chunksz
);
8281 for (; size
; size
-= chunksz
, location
-= chunksz
)
8286 bfd_put_8 (input_bfd
, x
, location
);
8290 bfd_put_16 (input_bfd
, x
, location
);
8294 bfd_put_32 (input_bfd
, x
, location
);
8295 /* Computed this way because x >>= 32 is undefined if x is a 32-bit value. */
8301 bfd_put_64 (input_bfd
, x
, location
);
8302 /* Computed this way because x >>= 64 is undefined if x is a 64-bit value. */
8315 get_value (bfd_vma size
,
8316 unsigned long chunksz
,
8323 /* Sanity checks. */
8324 BFD_ASSERT (chunksz
<= sizeof (x
)
8327 && (size
% chunksz
) == 0
8328 && input_bfd
!= NULL
8329 && location
!= NULL
);
8331 if (chunksz
== sizeof (x
))
8333 BFD_ASSERT (size
== chunksz
);
8335 /* Make sure that we do not perform an undefined shift operation.
8336 We know that size == chunksz so there will only be one iteration
8337 of the loop below. */
8341 shift
= 8 * chunksz
;
8343 for (; size
; size
-= chunksz
, location
+= chunksz
)
8348 x
= (x
<< shift
) | bfd_get_8 (input_bfd
, location
);
8351 x
= (x
<< shift
) | bfd_get_16 (input_bfd
, location
);
8354 x
= (x
<< shift
) | bfd_get_32 (input_bfd
, location
);
8358 x
= (x
<< shift
) | bfd_get_64 (input_bfd
, location
);
8369 decode_complex_addend (unsigned long *start
, /* in bits */
8370 unsigned long *oplen
, /* in bits */
8371 unsigned long *len
, /* in bits */
8372 unsigned long *wordsz
, /* in bytes */
8373 unsigned long *chunksz
, /* in bytes */
8374 unsigned long *lsb0_p
,
8375 unsigned long *signed_p
,
8376 unsigned long *trunc_p
,
8377 unsigned long encoded
)
8379 * start
= encoded
& 0x3F;
8380 * len
= (encoded
>> 6) & 0x3F;
8381 * oplen
= (encoded
>> 12) & 0x3F;
8382 * wordsz
= (encoded
>> 18) & 0xF;
8383 * chunksz
= (encoded
>> 22) & 0xF;
8384 * lsb0_p
= (encoded
>> 27) & 1;
8385 * signed_p
= (encoded
>> 28) & 1;
8386 * trunc_p
= (encoded
>> 29) & 1;
8389 bfd_reloc_status_type
8390 bfd_elf_perform_complex_relocation (bfd
*input_bfd
,
8391 asection
*input_section ATTRIBUTE_UNUSED
,
8393 Elf_Internal_Rela
*rel
,
8396 bfd_vma shift
, x
, mask
;
8397 unsigned long start
, oplen
, len
, wordsz
, chunksz
, lsb0_p
, signed_p
, trunc_p
;
8398 bfd_reloc_status_type r
;
8400 /* Perform this reloc, since it is complex.
8401 (this is not to say that it necessarily refers to a complex
8402 symbol; merely that it is a self-describing CGEN based reloc.
8403 i.e. the addend has the complete reloc information (bit start, end,
8404 word size, etc) encoded within it.). */
8406 decode_complex_addend (&start
, &oplen
, &len
, &wordsz
,
8407 &chunksz
, &lsb0_p
, &signed_p
,
8408 &trunc_p
, rel
->r_addend
);
8410 mask
= (((1L << (len
- 1)) - 1) << 1) | 1;
8413 shift
= (start
+ 1) - len
;
8415 shift
= (8 * wordsz
) - (start
+ len
);
8417 x
= get_value (wordsz
, chunksz
, input_bfd
,
8418 contents
+ rel
->r_offset
* bfd_octets_per_byte (input_bfd
));
8421 printf ("Doing complex reloc: "
8422 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
8423 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
8424 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
8425 lsb0_p
, signed_p
, trunc_p
, wordsz
, chunksz
, start
, len
,
8426 oplen
, (unsigned long) x
, (unsigned long) mask
,
8427 (unsigned long) relocation
);
8432 /* Now do an overflow check. */
8433 r
= bfd_check_overflow ((signed_p
8434 ? complain_overflow_signed
8435 : complain_overflow_unsigned
),
8436 len
, 0, (8 * wordsz
),
8440 x
= (x
& ~(mask
<< shift
)) | ((relocation
& mask
) << shift
);
8443 printf (" relocation: %8.8lx\n"
8444 " shifted mask: %8.8lx\n"
8445 " shifted/masked reloc: %8.8lx\n"
8446 " result: %8.8lx\n",
8447 (unsigned long) relocation
, (unsigned long) (mask
<< shift
),
8448 (unsigned long) ((relocation
& mask
) << shift
), (unsigned long) x
);
8450 put_value (wordsz
, chunksz
, input_bfd
, x
,
8451 contents
+ rel
->r_offset
* bfd_octets_per_byte (input_bfd
));
8455 /* Functions to read r_offset from external (target order) reloc
8456 entry. Faster than bfd_getl32 et al, because we let the compiler
8457 know the value is aligned. */
8460 ext32l_r_offset (const void *p
)
8467 const union aligned32
*a
8468 = (const union aligned32
*) &((const Elf32_External_Rel
*) p
)->r_offset
;
8470 uint32_t aval
= ( (uint32_t) a
->c
[0]
8471 | (uint32_t) a
->c
[1] << 8
8472 | (uint32_t) a
->c
[2] << 16
8473 | (uint32_t) a
->c
[3] << 24);
8478 ext32b_r_offset (const void *p
)
8485 const union aligned32
*a
8486 = (const union aligned32
*) &((const Elf32_External_Rel
*) p
)->r_offset
;
8488 uint32_t aval
= ( (uint32_t) a
->c
[0] << 24
8489 | (uint32_t) a
->c
[1] << 16
8490 | (uint32_t) a
->c
[2] << 8
8491 | (uint32_t) a
->c
[3]);
8495 #ifdef BFD_HOST_64_BIT
8497 ext64l_r_offset (const void *p
)
8504 const union aligned64
*a
8505 = (const union aligned64
*) &((const Elf64_External_Rel
*) p
)->r_offset
;
8507 uint64_t aval
= ( (uint64_t) a
->c
[0]
8508 | (uint64_t) a
->c
[1] << 8
8509 | (uint64_t) a
->c
[2] << 16
8510 | (uint64_t) a
->c
[3] << 24
8511 | (uint64_t) a
->c
[4] << 32
8512 | (uint64_t) a
->c
[5] << 40
8513 | (uint64_t) a
->c
[6] << 48
8514 | (uint64_t) a
->c
[7] << 56);
8519 ext64b_r_offset (const void *p
)
8526 const union aligned64
*a
8527 = (const union aligned64
*) &((const Elf64_External_Rel
*) p
)->r_offset
;
8529 uint64_t aval
= ( (uint64_t) a
->c
[0] << 56
8530 | (uint64_t) a
->c
[1] << 48
8531 | (uint64_t) a
->c
[2] << 40
8532 | (uint64_t) a
->c
[3] << 32
8533 | (uint64_t) a
->c
[4] << 24
8534 | (uint64_t) a
->c
[5] << 16
8535 | (uint64_t) a
->c
[6] << 8
8536 | (uint64_t) a
->c
[7]);
8541 /* When performing a relocatable link, the input relocations are
8542 preserved. But, if they reference global symbols, the indices
8543 referenced must be updated. Update all the relocations found in
8547 elf_link_adjust_relocs (bfd
*abfd
,
8549 struct bfd_elf_section_reloc_data
*reldata
,
8551 struct bfd_link_info
*info
)
8554 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8556 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8557 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8558 bfd_vma r_type_mask
;
8560 unsigned int count
= reldata
->count
;
8561 struct elf_link_hash_entry
**rel_hash
= reldata
->hashes
;
8563 if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
8565 swap_in
= bed
->s
->swap_reloc_in
;
8566 swap_out
= bed
->s
->swap_reloc_out
;
8568 else if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
8570 swap_in
= bed
->s
->swap_reloca_in
;
8571 swap_out
= bed
->s
->swap_reloca_out
;
8576 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
8579 if (bed
->s
->arch_size
== 32)
8586 r_type_mask
= 0xffffffff;
8590 erela
= reldata
->hdr
->contents
;
8591 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= reldata
->hdr
->sh_entsize
)
8593 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
8596 if (*rel_hash
== NULL
)
8599 if ((*rel_hash
)->indx
== -2
8600 && info
->gc_sections
8601 && ! info
->gc_keep_exported
)
8603 /* PR 21524: Let the user know if a symbol was removed by garbage collection. */
8604 _bfd_error_handler (_("%B:%A: error: relocation references symbol %s which was removed by garbage collection."),
8606 (*rel_hash
)->root
.root
.string
);
8607 _bfd_error_handler (_("%B:%A: error: try relinking with --gc-keep-exported enabled."),
8609 (*rel_hash
)->root
.root
.string
);
8610 bfd_set_error (bfd_error_invalid_operation
);
8613 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
8615 (*swap_in
) (abfd
, erela
, irela
);
8616 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
8617 irela
[j
].r_info
= ((bfd_vma
) (*rel_hash
)->indx
<< r_sym_shift
8618 | (irela
[j
].r_info
& r_type_mask
));
8619 (*swap_out
) (abfd
, irela
, erela
);
8622 if (bed
->elf_backend_update_relocs
)
8623 (*bed
->elf_backend_update_relocs
) (sec
, reldata
);
8625 if (sort
&& count
!= 0)
8627 bfd_vma (*ext_r_off
) (const void *);
8630 bfd_byte
*base
, *end
, *p
, *loc
;
8631 bfd_byte
*buf
= NULL
;
8633 if (bed
->s
->arch_size
== 32)
8635 if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)
8636 ext_r_off
= ext32l_r_offset
;
8637 else if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
8638 ext_r_off
= ext32b_r_offset
;
8644 #ifdef BFD_HOST_64_BIT
8645 if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)
8646 ext_r_off
= ext64l_r_offset
;
8647 else if (abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
8648 ext_r_off
= ext64b_r_offset
;
8654 /* Must use a stable sort here. A modified insertion sort,
8655 since the relocs are mostly sorted already. */
8656 elt_size
= reldata
->hdr
->sh_entsize
;
8657 base
= reldata
->hdr
->contents
;
8658 end
= base
+ count
* elt_size
;
8659 if (elt_size
> sizeof (Elf64_External_Rela
))
8662 /* Ensure the first element is lowest. This acts as a sentinel,
8663 speeding the main loop below. */
8664 r_off
= (*ext_r_off
) (base
);
8665 for (p
= loc
= base
; (p
+= elt_size
) < end
; )
8667 bfd_vma r_off2
= (*ext_r_off
) (p
);
8676 /* Don't just swap *base and *loc as that changes the order
8677 of the original base[0] and base[1] if they happen to
8678 have the same r_offset. */
8679 bfd_byte onebuf
[sizeof (Elf64_External_Rela
)];
8680 memcpy (onebuf
, loc
, elt_size
);
8681 memmove (base
+ elt_size
, base
, loc
- base
);
8682 memcpy (base
, onebuf
, elt_size
);
8685 for (p
= base
+ elt_size
; (p
+= elt_size
) < end
; )
8687 /* base to p is sorted, *p is next to insert. */
8688 r_off
= (*ext_r_off
) (p
);
8689 /* Search the sorted region for location to insert. */
8691 while (r_off
< (*ext_r_off
) (loc
))
8696 /* Chances are there is a run of relocs to insert here,
8697 from one of more input files. Files are not always
8698 linked in order due to the way elf_link_input_bfd is
8699 called. See pr17666. */
8700 size_t sortlen
= p
- loc
;
8701 bfd_vma r_off2
= (*ext_r_off
) (loc
);
8702 size_t runlen
= elt_size
;
8703 size_t buf_size
= 96 * 1024;
8704 while (p
+ runlen
< end
8705 && (sortlen
<= buf_size
8706 || runlen
+ elt_size
<= buf_size
)
8707 && r_off2
> (*ext_r_off
) (p
+ runlen
))
8711 buf
= bfd_malloc (buf_size
);
8715 if (runlen
< sortlen
)
8717 memcpy (buf
, p
, runlen
);
8718 memmove (loc
+ runlen
, loc
, sortlen
);
8719 memcpy (loc
, buf
, runlen
);
8723 memcpy (buf
, loc
, sortlen
);
8724 memmove (loc
, p
, runlen
);
8725 memcpy (loc
+ runlen
, buf
, sortlen
);
8727 p
+= runlen
- elt_size
;
8730 /* Hashes are no longer valid. */
8731 free (reldata
->hashes
);
8732 reldata
->hashes
= NULL
;
8738 struct elf_link_sort_rela
8744 enum elf_reloc_type_class type
;
8745 /* We use this as an array of size int_rels_per_ext_rel. */
8746 Elf_Internal_Rela rela
[1];
8750 elf_link_sort_cmp1 (const void *A
, const void *B
)
8752 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8753 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8754 int relativea
, relativeb
;
8756 relativea
= a
->type
== reloc_class_relative
;
8757 relativeb
= b
->type
== reloc_class_relative
;
8759 if (relativea
< relativeb
)
8761 if (relativea
> relativeb
)
8763 if ((a
->rela
->r_info
& a
->u
.sym_mask
) < (b
->rela
->r_info
& b
->u
.sym_mask
))
8765 if ((a
->rela
->r_info
& a
->u
.sym_mask
) > (b
->rela
->r_info
& b
->u
.sym_mask
))
8767 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8769 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8775 elf_link_sort_cmp2 (const void *A
, const void *B
)
8777 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8778 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8780 if (a
->type
< b
->type
)
8782 if (a
->type
> b
->type
)
8784 if (a
->u
.offset
< b
->u
.offset
)
8786 if (a
->u
.offset
> b
->u
.offset
)
8788 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8790 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8796 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
8798 asection
*dynamic_relocs
;
8801 bfd_size_type count
, size
;
8802 size_t i
, ret
, sort_elt
, ext_size
;
8803 bfd_byte
*sort
, *s_non_relative
, *p
;
8804 struct elf_link_sort_rela
*sq
;
8805 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8806 int i2e
= bed
->s
->int_rels_per_ext_rel
;
8807 unsigned int opb
= bfd_octets_per_byte (abfd
);
8808 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8809 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8810 struct bfd_link_order
*lo
;
8812 bfd_boolean use_rela
;
8814 /* Find a dynamic reloc section. */
8815 rela_dyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
8816 rel_dyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
8817 if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0
8818 && rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8820 bfd_boolean use_rela_initialised
= FALSE
;
8822 /* This is just here to stop gcc from complaining.
8823 Its initialization checking code is not perfect. */
8826 /* Both sections are present. Examine the sizes
8827 of the indirect sections to help us choose. */
8828 for (lo
= rela_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8829 if (lo
->type
== bfd_indirect_link_order
)
8831 asection
*o
= lo
->u
.indirect
.section
;
8833 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8835 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8836 /* Section size is divisible by both rel and rela sizes.
8837 It is of no help to us. */
8841 /* Section size is only divisible by rela. */
8842 if (use_rela_initialised
&& !use_rela
)
8844 _bfd_error_handler (_("%B: Unable to sort relocs - "
8845 "they are in more than one size"),
8847 bfd_set_error (bfd_error_invalid_operation
);
8853 use_rela_initialised
= TRUE
;
8857 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8859 /* Section size is only divisible by rel. */
8860 if (use_rela_initialised
&& use_rela
)
8862 _bfd_error_handler (_("%B: Unable to sort relocs - "
8863 "they are in more than one size"),
8865 bfd_set_error (bfd_error_invalid_operation
);
8871 use_rela_initialised
= TRUE
;
8876 /* The section size is not divisible by either -
8877 something is wrong. */
8878 _bfd_error_handler (_("%B: Unable to sort relocs - "
8879 "they are of an unknown size"), abfd
);
8880 bfd_set_error (bfd_error_invalid_operation
);
8885 for (lo
= rel_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8886 if (lo
->type
== bfd_indirect_link_order
)
8888 asection
*o
= lo
->u
.indirect
.section
;
8890 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8892 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8893 /* Section size is divisible by both rel and rela sizes.
8894 It is of no help to us. */
8898 /* Section size is only divisible by rela. */
8899 if (use_rela_initialised
&& !use_rela
)
8901 _bfd_error_handler (_("%B: Unable to sort relocs - "
8902 "they are in more than one size"),
8904 bfd_set_error (bfd_error_invalid_operation
);
8910 use_rela_initialised
= TRUE
;
8914 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8916 /* Section size is only divisible by rel. */
8917 if (use_rela_initialised
&& use_rela
)
8919 _bfd_error_handler (_("%B: Unable to sort relocs - "
8920 "they are in more than one size"),
8922 bfd_set_error (bfd_error_invalid_operation
);
8928 use_rela_initialised
= TRUE
;
8933 /* The section size is not divisible by either -
8934 something is wrong. */
8935 _bfd_error_handler (_("%B: Unable to sort relocs - "
8936 "they are of an unknown size"), abfd
);
8937 bfd_set_error (bfd_error_invalid_operation
);
8942 if (! use_rela_initialised
)
8946 else if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0)
8948 else if (rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8955 dynamic_relocs
= rela_dyn
;
8956 ext_size
= bed
->s
->sizeof_rela
;
8957 swap_in
= bed
->s
->swap_reloca_in
;
8958 swap_out
= bed
->s
->swap_reloca_out
;
8962 dynamic_relocs
= rel_dyn
;
8963 ext_size
= bed
->s
->sizeof_rel
;
8964 swap_in
= bed
->s
->swap_reloc_in
;
8965 swap_out
= bed
->s
->swap_reloc_out
;
8969 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8970 if (lo
->type
== bfd_indirect_link_order
)
8971 size
+= lo
->u
.indirect
.section
->size
;
8973 if (size
!= dynamic_relocs
->size
)
8976 sort_elt
= (sizeof (struct elf_link_sort_rela
)
8977 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
8979 count
= dynamic_relocs
->size
/ ext_size
;
8982 sort
= (bfd_byte
*) bfd_zmalloc (sort_elt
* count
);
8986 (*info
->callbacks
->warning
)
8987 (info
, _("Not enough memory to sort relocations"), 0, abfd
, 0, 0);
8991 if (bed
->s
->arch_size
== 32)
8992 r_sym_mask
= ~(bfd_vma
) 0xff;
8994 r_sym_mask
= ~(bfd_vma
) 0xffffffff;
8996 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8997 if (lo
->type
== bfd_indirect_link_order
)
8999 bfd_byte
*erel
, *erelend
;
9000 asection
*o
= lo
->u
.indirect
.section
;
9002 if (o
->contents
== NULL
&& o
->size
!= 0)
9004 /* This is a reloc section that is being handled as a normal
9005 section. See bfd_section_from_shdr. We can't combine
9006 relocs in this case. */
9011 erelend
= o
->contents
+ o
->size
;
9012 p
= sort
+ o
->output_offset
* opb
/ ext_size
* sort_elt
;
9014 while (erel
< erelend
)
9016 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
9018 (*swap_in
) (abfd
, erel
, s
->rela
);
9019 s
->type
= (*bed
->elf_backend_reloc_type_class
) (info
, o
, s
->rela
);
9020 s
->u
.sym_mask
= r_sym_mask
;
9026 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
9028 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
9030 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
9031 if (s
->type
!= reloc_class_relative
)
9037 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
9038 for (; i
< count
; i
++, p
+= sort_elt
)
9040 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
9041 if (((sp
->rela
->r_info
^ sq
->rela
->r_info
) & r_sym_mask
) != 0)
9043 sp
->u
.offset
= sq
->rela
->r_offset
;
9046 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
9048 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9049 if (htab
->srelplt
&& htab
->srelplt
->output_section
== dynamic_relocs
)
9051 /* We have plt relocs in .rela.dyn. */
9052 sq
= (struct elf_link_sort_rela
*) sort
;
9053 for (i
= 0; i
< count
; i
++)
9054 if (sq
[count
- i
- 1].type
!= reloc_class_plt
)
9056 if (i
!= 0 && htab
->srelplt
->size
== i
* ext_size
)
9058 struct bfd_link_order
**plo
;
9059 /* Put srelplt link_order last. This is so the output_offset
9060 set in the next loop is correct for DT_JMPREL. */
9061 for (plo
= &dynamic_relocs
->map_head
.link_order
; *plo
!= NULL
; )
9062 if ((*plo
)->type
== bfd_indirect_link_order
9063 && (*plo
)->u
.indirect
.section
== htab
->srelplt
)
9069 plo
= &(*plo
)->next
;
9072 dynamic_relocs
->map_tail
.link_order
= lo
;
9077 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
9078 if (lo
->type
== bfd_indirect_link_order
)
9080 bfd_byte
*erel
, *erelend
;
9081 asection
*o
= lo
->u
.indirect
.section
;
9084 erelend
= o
->contents
+ o
->size
;
9085 o
->output_offset
= (p
- sort
) / sort_elt
* ext_size
/ opb
;
9086 while (erel
< erelend
)
9088 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
9089 (*swap_out
) (abfd
, s
->rela
, erel
);
9096 *psec
= dynamic_relocs
;
9100 /* Add a symbol to the output symbol string table. */
9103 elf_link_output_symstrtab (struct elf_final_link_info
*flinfo
,
9105 Elf_Internal_Sym
*elfsym
,
9106 asection
*input_sec
,
9107 struct elf_link_hash_entry
*h
)
9109 int (*output_symbol_hook
)
9110 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*, asection
*,
9111 struct elf_link_hash_entry
*);
9112 struct elf_link_hash_table
*hash_table
;
9113 const struct elf_backend_data
*bed
;
9114 bfd_size_type strtabsize
;
9116 BFD_ASSERT (elf_onesymtab (flinfo
->output_bfd
));
9118 bed
= get_elf_backend_data (flinfo
->output_bfd
);
9119 output_symbol_hook
= bed
->elf_backend_link_output_symbol_hook
;
9120 if (output_symbol_hook
!= NULL
)
9122 int ret
= (*output_symbol_hook
) (flinfo
->info
, name
, elfsym
, input_sec
, h
);
9129 || (input_sec
->flags
& SEC_EXCLUDE
))
9130 elfsym
->st_name
= (unsigned long) -1;
9133 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
9134 to get the final offset for st_name. */
9136 = (unsigned long) _bfd_elf_strtab_add (flinfo
->symstrtab
,
9138 if (elfsym
->st_name
== (unsigned long) -1)
9142 hash_table
= elf_hash_table (flinfo
->info
);
9143 strtabsize
= hash_table
->strtabsize
;
9144 if (strtabsize
<= hash_table
->strtabcount
)
9146 strtabsize
+= strtabsize
;
9147 hash_table
->strtabsize
= strtabsize
;
9148 strtabsize
*= sizeof (*hash_table
->strtab
);
9150 = (struct elf_sym_strtab
*) bfd_realloc (hash_table
->strtab
,
9152 if (hash_table
->strtab
== NULL
)
9155 hash_table
->strtab
[hash_table
->strtabcount
].sym
= *elfsym
;
9156 hash_table
->strtab
[hash_table
->strtabcount
].dest_index
9157 = hash_table
->strtabcount
;
9158 hash_table
->strtab
[hash_table
->strtabcount
].destshndx_index
9159 = flinfo
->symshndxbuf
? bfd_get_symcount (flinfo
->output_bfd
) : 0;
9161 bfd_get_symcount (flinfo
->output_bfd
) += 1;
9162 hash_table
->strtabcount
+= 1;
9167 /* Swap symbols out to the symbol table and flush the output symbols to
9171 elf_link_swap_symbols_out (struct elf_final_link_info
*flinfo
)
9173 struct elf_link_hash_table
*hash_table
= elf_hash_table (flinfo
->info
);
9176 const struct elf_backend_data
*bed
;
9178 Elf_Internal_Shdr
*hdr
;
9182 if (!hash_table
->strtabcount
)
9185 BFD_ASSERT (elf_onesymtab (flinfo
->output_bfd
));
9187 bed
= get_elf_backend_data (flinfo
->output_bfd
);
9189 amt
= bed
->s
->sizeof_sym
* hash_table
->strtabcount
;
9190 symbuf
= (bfd_byte
*) bfd_malloc (amt
);
9194 if (flinfo
->symshndxbuf
)
9196 amt
= sizeof (Elf_External_Sym_Shndx
);
9197 amt
*= bfd_get_symcount (flinfo
->output_bfd
);
9198 flinfo
->symshndxbuf
= (Elf_External_Sym_Shndx
*) bfd_zmalloc (amt
);
9199 if (flinfo
->symshndxbuf
== NULL
)
9206 for (i
= 0; i
< hash_table
->strtabcount
; i
++)
9208 struct elf_sym_strtab
*elfsym
= &hash_table
->strtab
[i
];
9209 if (elfsym
->sym
.st_name
== (unsigned long) -1)
9210 elfsym
->sym
.st_name
= 0;
9213 = (unsigned long) _bfd_elf_strtab_offset (flinfo
->symstrtab
,
9214 elfsym
->sym
.st_name
);
9215 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, &elfsym
->sym
,
9216 ((bfd_byte
*) symbuf
9217 + (elfsym
->dest_index
9218 * bed
->s
->sizeof_sym
)),
9219 (flinfo
->symshndxbuf
9220 + elfsym
->destshndx_index
));
9223 hdr
= &elf_tdata (flinfo
->output_bfd
)->symtab_hdr
;
9224 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
9225 amt
= hash_table
->strtabcount
* bed
->s
->sizeof_sym
;
9226 if (bfd_seek (flinfo
->output_bfd
, pos
, SEEK_SET
) == 0
9227 && bfd_bwrite (symbuf
, amt
, flinfo
->output_bfd
) == amt
)
9229 hdr
->sh_size
+= amt
;
9237 free (hash_table
->strtab
);
9238 hash_table
->strtab
= NULL
;
9243 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
9246 check_dynsym (bfd
*abfd
, Elf_Internal_Sym
*sym
)
9248 if (sym
->st_shndx
>= (SHN_LORESERVE
& 0xffff)
9249 && sym
->st_shndx
< SHN_LORESERVE
)
9251 /* The gABI doesn't support dynamic symbols in output sections
9254 /* xgettext:c-format */
9255 (_("%B: Too many sections: %d (>= %d)"),
9256 abfd
, bfd_count_sections (abfd
), SHN_LORESERVE
& 0xffff);
9257 bfd_set_error (bfd_error_nonrepresentable_section
);
9263 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
9264 allowing an unsatisfied unversioned symbol in the DSO to match a
9265 versioned symbol that would normally require an explicit version.
9266 We also handle the case that a DSO references a hidden symbol
9267 which may be satisfied by a versioned symbol in another DSO. */
9270 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
9271 const struct elf_backend_data
*bed
,
9272 struct elf_link_hash_entry
*h
)
9275 struct elf_link_loaded_list
*loaded
;
9277 if (!is_elf_hash_table (info
->hash
))
9280 /* Check indirect symbol. */
9281 while (h
->root
.type
== bfd_link_hash_indirect
)
9282 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9284 switch (h
->root
.type
)
9290 case bfd_link_hash_undefined
:
9291 case bfd_link_hash_undefweak
:
9292 abfd
= h
->root
.u
.undef
.abfd
;
9294 || (abfd
->flags
& DYNAMIC
) == 0
9295 || (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) == 0)
9299 case bfd_link_hash_defined
:
9300 case bfd_link_hash_defweak
:
9301 abfd
= h
->root
.u
.def
.section
->owner
;
9304 case bfd_link_hash_common
:
9305 abfd
= h
->root
.u
.c
.p
->section
->owner
;
9308 BFD_ASSERT (abfd
!= NULL
);
9310 for (loaded
= elf_hash_table (info
)->loaded
;
9312 loaded
= loaded
->next
)
9315 Elf_Internal_Shdr
*hdr
;
9319 Elf_Internal_Shdr
*versymhdr
;
9320 Elf_Internal_Sym
*isym
;
9321 Elf_Internal_Sym
*isymend
;
9322 Elf_Internal_Sym
*isymbuf
;
9323 Elf_External_Versym
*ever
;
9324 Elf_External_Versym
*extversym
;
9326 input
= loaded
->abfd
;
9328 /* We check each DSO for a possible hidden versioned definition. */
9330 || (input
->flags
& DYNAMIC
) == 0
9331 || elf_dynversym (input
) == 0)
9334 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
9336 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
9337 if (elf_bad_symtab (input
))
9339 extsymcount
= symcount
;
9344 extsymcount
= symcount
- hdr
->sh_info
;
9345 extsymoff
= hdr
->sh_info
;
9348 if (extsymcount
== 0)
9351 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
9353 if (isymbuf
== NULL
)
9356 /* Read in any version definitions. */
9357 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
9358 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
9359 if (extversym
== NULL
)
9362 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
9363 || (bfd_bread (extversym
, versymhdr
->sh_size
, input
)
9364 != versymhdr
->sh_size
))
9372 ever
= extversym
+ extsymoff
;
9373 isymend
= isymbuf
+ extsymcount
;
9374 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
9377 Elf_Internal_Versym iver
;
9378 unsigned short version_index
;
9380 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
9381 || isym
->st_shndx
== SHN_UNDEF
)
9384 name
= bfd_elf_string_from_elf_section (input
,
9387 if (strcmp (name
, h
->root
.root
.string
) != 0)
9390 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
9392 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
9394 && h
->forced_local
))
9396 /* If we have a non-hidden versioned sym, then it should
9397 have provided a definition for the undefined sym unless
9398 it is defined in a non-shared object and forced local.
9403 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
9404 if (version_index
== 1 || version_index
== 2)
9406 /* This is the base or first version. We can use it. */
9420 /* Convert ELF common symbol TYPE. */
9423 elf_link_convert_common_type (struct bfd_link_info
*info
, int type
)
9425 /* Commom symbol can only appear in relocatable link. */
9426 if (!bfd_link_relocatable (info
))
9428 switch (info
->elf_stt_common
)
9432 case elf_stt_common
:
9435 case no_elf_stt_common
:
9442 /* Add an external symbol to the symbol table. This is called from
9443 the hash table traversal routine. When generating a shared object,
9444 we go through the symbol table twice. The first time we output
9445 anything that might have been forced to local scope in a version
9446 script. The second time we output the symbols that are still
9450 elf_link_output_extsym (struct bfd_hash_entry
*bh
, void *data
)
9452 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
9453 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
9454 struct elf_final_link_info
*flinfo
= eoinfo
->flinfo
;
9456 Elf_Internal_Sym sym
;
9457 asection
*input_sec
;
9458 const struct elf_backend_data
*bed
;
9463 if (h
->root
.type
== bfd_link_hash_warning
)
9465 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9466 if (h
->root
.type
== bfd_link_hash_new
)
9470 /* Decide whether to output this symbol in this pass. */
9471 if (eoinfo
->localsyms
)
9473 if (!h
->forced_local
)
9478 if (h
->forced_local
)
9482 bed
= get_elf_backend_data (flinfo
->output_bfd
);
9484 if (h
->root
.type
== bfd_link_hash_undefined
)
9486 /* If we have an undefined symbol reference here then it must have
9487 come from a shared library that is being linked in. (Undefined
9488 references in regular files have already been handled unless
9489 they are in unreferenced sections which are removed by garbage
9491 bfd_boolean ignore_undef
= FALSE
;
9493 /* Some symbols may be special in that the fact that they're
9494 undefined can be safely ignored - let backend determine that. */
9495 if (bed
->elf_backend_ignore_undef_symbol
)
9496 ignore_undef
= bed
->elf_backend_ignore_undef_symbol (h
);
9498 /* If we are reporting errors for this situation then do so now. */
9501 && (!h
->ref_regular
|| flinfo
->info
->gc_sections
)
9502 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
)
9503 && flinfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
9504 (*flinfo
->info
->callbacks
->undefined_symbol
)
9505 (flinfo
->info
, h
->root
.root
.string
,
9506 h
->ref_regular
? NULL
: h
->root
.u
.undef
.abfd
,
9508 flinfo
->info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
);
9510 /* Strip a global symbol defined in a discarded section. */
9515 /* We should also warn if a forced local symbol is referenced from
9516 shared libraries. */
9517 if (bfd_link_executable (flinfo
->info
)
9522 && h
->ref_dynamic_nonweak
9523 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
))
9527 struct elf_link_hash_entry
*hi
= h
;
9529 /* Check indirect symbol. */
9530 while (hi
->root
.type
== bfd_link_hash_indirect
)
9531 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
9533 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
9534 /* xgettext:c-format */
9535 msg
= _("%B: internal symbol `%s' in %B is referenced by DSO");
9536 else if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
9537 /* xgettext:c-format */
9538 msg
= _("%B: hidden symbol `%s' in %B is referenced by DSO");
9540 /* xgettext:c-format */
9541 msg
= _("%B: local symbol `%s' in %B is referenced by DSO");
9542 def_bfd
= flinfo
->output_bfd
;
9543 if (hi
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
9544 def_bfd
= hi
->root
.u
.def
.section
->owner
;
9545 _bfd_error_handler (msg
, flinfo
->output_bfd
,
9546 h
->root
.root
.string
, def_bfd
);
9547 bfd_set_error (bfd_error_bad_value
);
9548 eoinfo
->failed
= TRUE
;
9552 /* We don't want to output symbols that have never been mentioned by
9553 a regular file, or that we have been told to strip. However, if
9554 h->indx is set to -2, the symbol is used by a reloc and we must
9559 else if ((h
->def_dynamic
9561 || h
->root
.type
== bfd_link_hash_new
)
9565 else if (flinfo
->info
->strip
== strip_all
)
9567 else if (flinfo
->info
->strip
== strip_some
9568 && bfd_hash_lookup (flinfo
->info
->keep_hash
,
9569 h
->root
.root
.string
, FALSE
, FALSE
) == NULL
)
9571 else if ((h
->root
.type
== bfd_link_hash_defined
9572 || h
->root
.type
== bfd_link_hash_defweak
)
9573 && ((flinfo
->info
->strip_discarded
9574 && discarded_section (h
->root
.u
.def
.section
))
9575 || ((h
->root
.u
.def
.section
->flags
& SEC_LINKER_CREATED
) == 0
9576 && h
->root
.u
.def
.section
->owner
!= NULL
9577 && (h
->root
.u
.def
.section
->owner
->flags
& BFD_PLUGIN
) != 0)))
9579 else if ((h
->root
.type
== bfd_link_hash_undefined
9580 || h
->root
.type
== bfd_link_hash_undefweak
)
9581 && h
->root
.u
.undef
.abfd
!= NULL
9582 && (h
->root
.u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0)
9587 /* If we're stripping it, and it's not a dynamic symbol, there's
9588 nothing else to do. However, if it is a forced local symbol or
9589 an ifunc symbol we need to give the backend finish_dynamic_symbol
9590 function a chance to make it dynamic. */
9593 && type
!= STT_GNU_IFUNC
9594 && !h
->forced_local
)
9598 sym
.st_size
= h
->size
;
9599 sym
.st_other
= h
->other
;
9600 switch (h
->root
.type
)
9603 case bfd_link_hash_new
:
9604 case bfd_link_hash_warning
:
9608 case bfd_link_hash_undefined
:
9609 case bfd_link_hash_undefweak
:
9610 input_sec
= bfd_und_section_ptr
;
9611 sym
.st_shndx
= SHN_UNDEF
;
9614 case bfd_link_hash_defined
:
9615 case bfd_link_hash_defweak
:
9617 input_sec
= h
->root
.u
.def
.section
;
9618 if (input_sec
->output_section
!= NULL
)
9621 _bfd_elf_section_from_bfd_section (flinfo
->output_bfd
,
9622 input_sec
->output_section
);
9623 if (sym
.st_shndx
== SHN_BAD
)
9626 /* xgettext:c-format */
9627 (_("%B: could not find output section %A for input section %A"),
9628 flinfo
->output_bfd
, input_sec
->output_section
, input_sec
);
9629 bfd_set_error (bfd_error_nonrepresentable_section
);
9630 eoinfo
->failed
= TRUE
;
9634 /* ELF symbols in relocatable files are section relative,
9635 but in nonrelocatable files they are virtual
9637 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
9638 if (!bfd_link_relocatable (flinfo
->info
))
9640 sym
.st_value
+= input_sec
->output_section
->vma
;
9641 if (h
->type
== STT_TLS
)
9643 asection
*tls_sec
= elf_hash_table (flinfo
->info
)->tls_sec
;
9644 if (tls_sec
!= NULL
)
9645 sym
.st_value
-= tls_sec
->vma
;
9651 BFD_ASSERT (input_sec
->owner
== NULL
9652 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
9653 sym
.st_shndx
= SHN_UNDEF
;
9654 input_sec
= bfd_und_section_ptr
;
9659 case bfd_link_hash_common
:
9660 input_sec
= h
->root
.u
.c
.p
->section
;
9661 sym
.st_shndx
= bed
->common_section_index (input_sec
);
9662 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
9665 case bfd_link_hash_indirect
:
9666 /* These symbols are created by symbol versioning. They point
9667 to the decorated version of the name. For example, if the
9668 symbol foo@@GNU_1.2 is the default, which should be used when
9669 foo is used with no version, then we add an indirect symbol
9670 foo which points to foo@@GNU_1.2. We ignore these symbols,
9671 since the indirected symbol is already in the hash table. */
9675 if (type
== STT_COMMON
|| type
== STT_OBJECT
)
9676 switch (h
->root
.type
)
9678 case bfd_link_hash_common
:
9679 type
= elf_link_convert_common_type (flinfo
->info
, type
);
9681 case bfd_link_hash_defined
:
9682 case bfd_link_hash_defweak
:
9683 if (bed
->common_definition (&sym
))
9684 type
= elf_link_convert_common_type (flinfo
->info
, type
);
9688 case bfd_link_hash_undefined
:
9689 case bfd_link_hash_undefweak
:
9695 if (h
->forced_local
)
9697 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, type
);
9698 /* Turn off visibility on local symbol. */
9699 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
9701 /* Set STB_GNU_UNIQUE only if symbol is defined in regular object. */
9702 else if (h
->unique_global
&& h
->def_regular
)
9703 sym
.st_info
= ELF_ST_INFO (STB_GNU_UNIQUE
, type
);
9704 else if (h
->root
.type
== bfd_link_hash_undefweak
9705 || h
->root
.type
== bfd_link_hash_defweak
)
9706 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, type
);
9708 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
9709 sym
.st_target_internal
= h
->target_internal
;
9711 /* Give the processor backend a chance to tweak the symbol value,
9712 and also to finish up anything that needs to be done for this
9713 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
9714 forced local syms when non-shared is due to a historical quirk.
9715 STT_GNU_IFUNC symbol must go through PLT. */
9716 if ((h
->type
== STT_GNU_IFUNC
9718 && !bfd_link_relocatable (flinfo
->info
))
9719 || ((h
->dynindx
!= -1
9721 && ((bfd_link_pic (flinfo
->info
)
9722 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
9723 || h
->root
.type
!= bfd_link_hash_undefweak
))
9724 || !h
->forced_local
)
9725 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
))
9727 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
9728 (flinfo
->output_bfd
, flinfo
->info
, h
, &sym
)))
9730 eoinfo
->failed
= TRUE
;
9735 /* If we are marking the symbol as undefined, and there are no
9736 non-weak references to this symbol from a regular object, then
9737 mark the symbol as weak undefined; if there are non-weak
9738 references, mark the symbol as strong. We can't do this earlier,
9739 because it might not be marked as undefined until the
9740 finish_dynamic_symbol routine gets through with it. */
9741 if (sym
.st_shndx
== SHN_UNDEF
9743 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
9744 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
9747 type
= ELF_ST_TYPE (sym
.st_info
);
9749 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
9750 if (type
== STT_GNU_IFUNC
)
9753 if (h
->ref_regular_nonweak
)
9754 bindtype
= STB_GLOBAL
;
9756 bindtype
= STB_WEAK
;
9757 sym
.st_info
= ELF_ST_INFO (bindtype
, type
);
9760 /* If this is a symbol defined in a dynamic library, don't use the
9761 symbol size from the dynamic library. Relinking an executable
9762 against a new library may introduce gratuitous changes in the
9763 executable's symbols if we keep the size. */
9764 if (sym
.st_shndx
== SHN_UNDEF
9769 /* If a non-weak symbol with non-default visibility is not defined
9770 locally, it is a fatal error. */
9771 if (!bfd_link_relocatable (flinfo
->info
)
9772 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
9773 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
9774 && h
->root
.type
== bfd_link_hash_undefined
9779 if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
)
9780 /* xgettext:c-format */
9781 msg
= _("%B: protected symbol `%s' isn't defined");
9782 else if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
)
9783 /* xgettext:c-format */
9784 msg
= _("%B: internal symbol `%s' isn't defined");
9786 /* xgettext:c-format */
9787 msg
= _("%B: hidden symbol `%s' isn't defined");
9788 _bfd_error_handler (msg
, flinfo
->output_bfd
, h
->root
.root
.string
);
9789 bfd_set_error (bfd_error_bad_value
);
9790 eoinfo
->failed
= TRUE
;
9794 /* If this symbol should be put in the .dynsym section, then put it
9795 there now. We already know the symbol index. We also fill in
9796 the entry in the .hash section. */
9797 if (elf_hash_table (flinfo
->info
)->dynsym
!= NULL
9799 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
)
9803 /* Since there is no version information in the dynamic string,
9804 if there is no version info in symbol version section, we will
9805 have a run-time problem if not linking executable, referenced
9806 by shared library, or not bound locally. */
9807 if (h
->verinfo
.verdef
== NULL
9808 && (!bfd_link_executable (flinfo
->info
)
9810 || !h
->def_regular
))
9812 char *p
= strrchr (h
->root
.root
.string
, ELF_VER_CHR
);
9814 if (p
&& p
[1] != '\0')
9817 /* xgettext:c-format */
9818 (_("%B: No symbol version section for versioned symbol `%s'"),
9819 flinfo
->output_bfd
, h
->root
.root
.string
);
9820 eoinfo
->failed
= TRUE
;
9825 sym
.st_name
= h
->dynstr_index
;
9826 esym
= (elf_hash_table (flinfo
->info
)->dynsym
->contents
9827 + h
->dynindx
* bed
->s
->sizeof_sym
);
9828 if (!check_dynsym (flinfo
->output_bfd
, &sym
))
9830 eoinfo
->failed
= TRUE
;
9833 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, &sym
, esym
, 0);
9835 if (flinfo
->hash_sec
!= NULL
)
9837 size_t hash_entry_size
;
9838 bfd_byte
*bucketpos
;
9843 bucketcount
= elf_hash_table (flinfo
->info
)->bucketcount
;
9844 bucket
= h
->u
.elf_hash_value
% bucketcount
;
9847 = elf_section_data (flinfo
->hash_sec
)->this_hdr
.sh_entsize
;
9848 bucketpos
= ((bfd_byte
*) flinfo
->hash_sec
->contents
9849 + (bucket
+ 2) * hash_entry_size
);
9850 chain
= bfd_get (8 * hash_entry_size
, flinfo
->output_bfd
, bucketpos
);
9851 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, h
->dynindx
,
9853 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, chain
,
9854 ((bfd_byte
*) flinfo
->hash_sec
->contents
9855 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
9858 if (flinfo
->symver_sec
!= NULL
&& flinfo
->symver_sec
->contents
!= NULL
)
9860 Elf_Internal_Versym iversym
;
9861 Elf_External_Versym
*eversym
;
9863 if (!h
->def_regular
)
9865 if (h
->verinfo
.verdef
== NULL
9866 || (elf_dyn_lib_class (h
->verinfo
.verdef
->vd_bfd
)
9867 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
| DYN_NO_NEEDED
)))
9868 iversym
.vs_vers
= 0;
9870 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
9874 if (h
->verinfo
.vertree
== NULL
)
9875 iversym
.vs_vers
= 1;
9877 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
9878 if (flinfo
->info
->create_default_symver
)
9882 /* Turn on VERSYM_HIDDEN only if the hidden versioned symbol is
9884 if (h
->versioned
== versioned_hidden
&& h
->def_regular
)
9885 iversym
.vs_vers
|= VERSYM_HIDDEN
;
9887 eversym
= (Elf_External_Versym
*) flinfo
->symver_sec
->contents
;
9888 eversym
+= h
->dynindx
;
9889 _bfd_elf_swap_versym_out (flinfo
->output_bfd
, &iversym
, eversym
);
9893 /* If the symbol is undefined, and we didn't output it to .dynsym,
9894 strip it from .symtab too. Obviously we can't do this for
9895 relocatable output or when needed for --emit-relocs. */
9896 else if (input_sec
== bfd_und_section_ptr
9898 && !bfd_link_relocatable (flinfo
->info
))
9900 /* Also strip others that we couldn't earlier due to dynamic symbol
9904 if ((input_sec
->flags
& SEC_EXCLUDE
) != 0)
9907 /* Output a FILE symbol so that following locals are not associated
9908 with the wrong input file. We need one for forced local symbols
9909 if we've seen more than one FILE symbol or when we have exactly
9910 one FILE symbol but global symbols are present in a file other
9911 than the one with the FILE symbol. We also need one if linker
9912 defined symbols are present. In practice these conditions are
9913 always met, so just emit the FILE symbol unconditionally. */
9914 if (eoinfo
->localsyms
9915 && !eoinfo
->file_sym_done
9916 && eoinfo
->flinfo
->filesym_count
!= 0)
9918 Elf_Internal_Sym fsym
;
9920 memset (&fsym
, 0, sizeof (fsym
));
9921 fsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
9922 fsym
.st_shndx
= SHN_ABS
;
9923 if (!elf_link_output_symstrtab (eoinfo
->flinfo
, NULL
, &fsym
,
9924 bfd_und_section_ptr
, NULL
))
9927 eoinfo
->file_sym_done
= TRUE
;
9930 indx
= bfd_get_symcount (flinfo
->output_bfd
);
9931 ret
= elf_link_output_symstrtab (flinfo
, h
->root
.root
.string
, &sym
,
9935 eoinfo
->failed
= TRUE
;
9940 else if (h
->indx
== -2)
9946 /* Return TRUE if special handling is done for relocs in SEC against
9947 symbols defined in discarded sections. */
9950 elf_section_ignore_discarded_relocs (asection
*sec
)
9952 const struct elf_backend_data
*bed
;
9954 switch (sec
->sec_info_type
)
9956 case SEC_INFO_TYPE_STABS
:
9957 case SEC_INFO_TYPE_EH_FRAME
:
9958 case SEC_INFO_TYPE_EH_FRAME_ENTRY
:
9964 bed
= get_elf_backend_data (sec
->owner
);
9965 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
9966 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))
9972 /* Return a mask saying how ld should treat relocations in SEC against
9973 symbols defined in discarded sections. If this function returns
9974 COMPLAIN set, ld will issue a warning message. If this function
9975 returns PRETEND set, and the discarded section was link-once and the
9976 same size as the kept link-once section, ld will pretend that the
9977 symbol was actually defined in the kept section. Otherwise ld will
9978 zero the reloc (at least that is the intent, but some cooperation by
9979 the target dependent code is needed, particularly for REL targets). */
9982 _bfd_elf_default_action_discarded (asection
*sec
)
9984 if (sec
->flags
& SEC_DEBUGGING
)
9987 if (strcmp (".eh_frame", sec
->name
) == 0)
9990 if (strcmp (".gcc_except_table", sec
->name
) == 0)
9993 return COMPLAIN
| PRETEND
;
9996 /* Find a match between a section and a member of a section group. */
9999 match_group_member (asection
*sec
, asection
*group
,
10000 struct bfd_link_info
*info
)
10002 asection
*first
= elf_next_in_group (group
);
10003 asection
*s
= first
;
10007 if (bfd_elf_match_symbols_in_sections (s
, sec
, info
))
10010 s
= elf_next_in_group (s
);
10018 /* Check if the kept section of a discarded section SEC can be used
10019 to replace it. Return the replacement if it is OK. Otherwise return
10023 _bfd_elf_check_kept_section (asection
*sec
, struct bfd_link_info
*info
)
10027 kept
= sec
->kept_section
;
10030 if ((kept
->flags
& SEC_GROUP
) != 0)
10031 kept
= match_group_member (sec
, kept
, info
);
10033 && ((sec
->rawsize
!= 0 ? sec
->rawsize
: sec
->size
)
10034 != (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
10036 sec
->kept_section
= kept
;
10041 /* Link an input file into the linker output file. This function
10042 handles all the sections and relocations of the input file at once.
10043 This is so that we only have to read the local symbols once, and
10044 don't have to keep them in memory. */
10047 elf_link_input_bfd (struct elf_final_link_info
*flinfo
, bfd
*input_bfd
)
10049 int (*relocate_section
)
10050 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
10051 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
10053 Elf_Internal_Shdr
*symtab_hdr
;
10054 size_t locsymcount
;
10056 Elf_Internal_Sym
*isymbuf
;
10057 Elf_Internal_Sym
*isym
;
10058 Elf_Internal_Sym
*isymend
;
10060 asection
**ppsection
;
10062 const struct elf_backend_data
*bed
;
10063 struct elf_link_hash_entry
**sym_hashes
;
10064 bfd_size_type address_size
;
10065 bfd_vma r_type_mask
;
10067 bfd_boolean have_file_sym
= FALSE
;
10069 output_bfd
= flinfo
->output_bfd
;
10070 bed
= get_elf_backend_data (output_bfd
);
10071 relocate_section
= bed
->elf_backend_relocate_section
;
10073 /* If this is a dynamic object, we don't want to do anything here:
10074 we don't want the local symbols, and we don't want the section
10076 if ((input_bfd
->flags
& DYNAMIC
) != 0)
10079 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
10080 if (elf_bad_symtab (input_bfd
))
10082 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
10087 locsymcount
= symtab_hdr
->sh_info
;
10088 extsymoff
= symtab_hdr
->sh_info
;
10091 /* Read the local symbols. */
10092 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
10093 if (isymbuf
== NULL
&& locsymcount
!= 0)
10095 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
10096 flinfo
->internal_syms
,
10097 flinfo
->external_syms
,
10098 flinfo
->locsym_shndx
);
10099 if (isymbuf
== NULL
)
10103 /* Find local symbol sections and adjust values of symbols in
10104 SEC_MERGE sections. Write out those local symbols we know are
10105 going into the output file. */
10106 isymend
= isymbuf
+ locsymcount
;
10107 for (isym
= isymbuf
, pindex
= flinfo
->indices
, ppsection
= flinfo
->sections
;
10109 isym
++, pindex
++, ppsection
++)
10113 Elf_Internal_Sym osym
;
10119 if (elf_bad_symtab (input_bfd
))
10121 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
10128 if (isym
->st_shndx
== SHN_UNDEF
)
10129 isec
= bfd_und_section_ptr
;
10130 else if (isym
->st_shndx
== SHN_ABS
)
10131 isec
= bfd_abs_section_ptr
;
10132 else if (isym
->st_shndx
== SHN_COMMON
)
10133 isec
= bfd_com_section_ptr
;
10136 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
10139 /* Don't attempt to output symbols with st_shnx in the
10140 reserved range other than SHN_ABS and SHN_COMMON. */
10144 else if (isec
->sec_info_type
== SEC_INFO_TYPE_MERGE
10145 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
10147 _bfd_merged_section_offset (output_bfd
, &isec
,
10148 elf_section_data (isec
)->sec_info
,
10154 /* Don't output the first, undefined, symbol. In fact, don't
10155 output any undefined local symbol. */
10156 if (isec
== bfd_und_section_ptr
)
10159 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
10161 /* We never output section symbols. Instead, we use the
10162 section symbol of the corresponding section in the output
10167 /* If we are stripping all symbols, we don't want to output this
10169 if (flinfo
->info
->strip
== strip_all
)
10172 /* If we are discarding all local symbols, we don't want to
10173 output this one. If we are generating a relocatable output
10174 file, then some of the local symbols may be required by
10175 relocs; we output them below as we discover that they are
10177 if (flinfo
->info
->discard
== discard_all
)
10180 /* If this symbol is defined in a section which we are
10181 discarding, we don't need to keep it. */
10182 if (isym
->st_shndx
!= SHN_UNDEF
10183 && isym
->st_shndx
< SHN_LORESERVE
10184 && bfd_section_removed_from_list (output_bfd
,
10185 isec
->output_section
))
10188 /* Get the name of the symbol. */
10189 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
10194 /* See if we are discarding symbols with this name. */
10195 if ((flinfo
->info
->strip
== strip_some
10196 && (bfd_hash_lookup (flinfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
10198 || (((flinfo
->info
->discard
== discard_sec_merge
10199 && (isec
->flags
& SEC_MERGE
)
10200 && !bfd_link_relocatable (flinfo
->info
))
10201 || flinfo
->info
->discard
== discard_l
)
10202 && bfd_is_local_label_name (input_bfd
, name
)))
10205 if (ELF_ST_TYPE (isym
->st_info
) == STT_FILE
)
10207 if (input_bfd
->lto_output
)
10208 /* -flto puts a temp file name here. This means builds
10209 are not reproducible. Discard the symbol. */
10211 have_file_sym
= TRUE
;
10212 flinfo
->filesym_count
+= 1;
10214 if (!have_file_sym
)
10216 /* In the absence of debug info, bfd_find_nearest_line uses
10217 FILE symbols to determine the source file for local
10218 function symbols. Provide a FILE symbol here if input
10219 files lack such, so that their symbols won't be
10220 associated with a previous input file. It's not the
10221 source file, but the best we can do. */
10222 have_file_sym
= TRUE
;
10223 flinfo
->filesym_count
+= 1;
10224 memset (&osym
, 0, sizeof (osym
));
10225 osym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
10226 osym
.st_shndx
= SHN_ABS
;
10227 if (!elf_link_output_symstrtab (flinfo
,
10228 (input_bfd
->lto_output
? NULL
10229 : input_bfd
->filename
),
10230 &osym
, bfd_abs_section_ptr
,
10237 /* Adjust the section index for the output file. */
10238 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
10239 isec
->output_section
);
10240 if (osym
.st_shndx
== SHN_BAD
)
10243 /* ELF symbols in relocatable files are section relative, but
10244 in executable files they are virtual addresses. Note that
10245 this code assumes that all ELF sections have an associated
10246 BFD section with a reasonable value for output_offset; below
10247 we assume that they also have a reasonable value for
10248 output_section. Any special sections must be set up to meet
10249 these requirements. */
10250 osym
.st_value
+= isec
->output_offset
;
10251 if (!bfd_link_relocatable (flinfo
->info
))
10253 osym
.st_value
+= isec
->output_section
->vma
;
10254 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
10256 /* STT_TLS symbols are relative to PT_TLS segment base. */
10257 BFD_ASSERT (elf_hash_table (flinfo
->info
)->tls_sec
!= NULL
);
10258 osym
.st_value
-= elf_hash_table (flinfo
->info
)->tls_sec
->vma
;
10262 indx
= bfd_get_symcount (output_bfd
);
10263 ret
= elf_link_output_symstrtab (flinfo
, name
, &osym
, isec
, NULL
);
10270 if (bed
->s
->arch_size
== 32)
10272 r_type_mask
= 0xff;
10278 r_type_mask
= 0xffffffff;
10283 /* Relocate the contents of each section. */
10284 sym_hashes
= elf_sym_hashes (input_bfd
);
10285 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
10287 bfd_byte
*contents
;
10289 if (! o
->linker_mark
)
10291 /* This section was omitted from the link. */
10295 if (!flinfo
->info
->resolve_section_groups
10296 && (o
->flags
& (SEC_LINKER_CREATED
| SEC_GROUP
)) == SEC_GROUP
)
10298 /* Deal with the group signature symbol. */
10299 struct bfd_elf_section_data
*sec_data
= elf_section_data (o
);
10300 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
10301 asection
*osec
= o
->output_section
;
10303 BFD_ASSERT (bfd_link_relocatable (flinfo
->info
));
10304 if (symndx
>= locsymcount
10305 || (elf_bad_symtab (input_bfd
)
10306 && flinfo
->sections
[symndx
] == NULL
))
10308 struct elf_link_hash_entry
*h
= sym_hashes
[symndx
- extsymoff
];
10309 while (h
->root
.type
== bfd_link_hash_indirect
10310 || h
->root
.type
== bfd_link_hash_warning
)
10311 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10312 /* Arrange for symbol to be output. */
10314 elf_section_data (osec
)->this_hdr
.sh_info
= -2;
10316 else if (ELF_ST_TYPE (isymbuf
[symndx
].st_info
) == STT_SECTION
)
10318 /* We'll use the output section target_index. */
10319 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
10320 elf_section_data (osec
)->this_hdr
.sh_info
= sec
->target_index
;
10324 if (flinfo
->indices
[symndx
] == -1)
10326 /* Otherwise output the local symbol now. */
10327 Elf_Internal_Sym sym
= isymbuf
[symndx
];
10328 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
10333 name
= bfd_elf_string_from_elf_section (input_bfd
,
10334 symtab_hdr
->sh_link
,
10339 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
10341 if (sym
.st_shndx
== SHN_BAD
)
10344 sym
.st_value
+= o
->output_offset
;
10346 indx
= bfd_get_symcount (output_bfd
);
10347 ret
= elf_link_output_symstrtab (flinfo
, name
, &sym
, o
,
10352 flinfo
->indices
[symndx
] = indx
;
10356 elf_section_data (osec
)->this_hdr
.sh_info
10357 = flinfo
->indices
[symndx
];
10361 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
10362 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
10365 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
10367 /* Section was created by _bfd_elf_link_create_dynamic_sections
10372 /* Get the contents of the section. They have been cached by a
10373 relaxation routine. Note that o is a section in an input
10374 file, so the contents field will not have been set by any of
10375 the routines which work on output files. */
10376 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
10378 contents
= elf_section_data (o
)->this_hdr
.contents
;
10379 if (bed
->caches_rawsize
10381 && o
->rawsize
< o
->size
)
10383 memcpy (flinfo
->contents
, contents
, o
->rawsize
);
10384 contents
= flinfo
->contents
;
10389 contents
= flinfo
->contents
;
10390 if (! bfd_get_full_section_contents (input_bfd
, o
, &contents
))
10394 if ((o
->flags
& SEC_RELOC
) != 0)
10396 Elf_Internal_Rela
*internal_relocs
;
10397 Elf_Internal_Rela
*rel
, *relend
;
10398 int action_discarded
;
10401 /* Get the swapped relocs. */
10403 = _bfd_elf_link_read_relocs (input_bfd
, o
, flinfo
->external_relocs
,
10404 flinfo
->internal_relocs
, FALSE
);
10405 if (internal_relocs
== NULL
10406 && o
->reloc_count
> 0)
10409 /* We need to reverse-copy input .ctors/.dtors sections if
10410 they are placed in .init_array/.finit_array for output. */
10411 if (o
->size
> address_size
10412 && ((strncmp (o
->name
, ".ctors", 6) == 0
10413 && strcmp (o
->output_section
->name
,
10414 ".init_array") == 0)
10415 || (strncmp (o
->name
, ".dtors", 6) == 0
10416 && strcmp (o
->output_section
->name
,
10417 ".fini_array") == 0))
10418 && (o
->name
[6] == 0 || o
->name
[6] == '.'))
10420 if (o
->size
* bed
->s
->int_rels_per_ext_rel
10421 != o
->reloc_count
* address_size
)
10424 /* xgettext:c-format */
10425 (_("error: %B: size of section %A is not "
10426 "multiple of address size"),
10428 bfd_set_error (bfd_error_on_input
);
10431 o
->flags
|= SEC_ELF_REVERSE_COPY
;
10434 action_discarded
= -1;
10435 if (!elf_section_ignore_discarded_relocs (o
))
10436 action_discarded
= (*bed
->action_discarded
) (o
);
10438 /* Run through the relocs evaluating complex reloc symbols and
10439 looking for relocs against symbols from discarded sections
10440 or section symbols from removed link-once sections.
10441 Complain about relocs against discarded sections. Zero
10442 relocs against removed link-once sections. */
10444 rel
= internal_relocs
;
10445 relend
= rel
+ o
->reloc_count
;
10446 for ( ; rel
< relend
; rel
++)
10448 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
10449 unsigned int s_type
;
10450 asection
**ps
, *sec
;
10451 struct elf_link_hash_entry
*h
= NULL
;
10452 const char *sym_name
;
10454 if (r_symndx
== STN_UNDEF
)
10457 if (r_symndx
>= locsymcount
10458 || (elf_bad_symtab (input_bfd
)
10459 && flinfo
->sections
[r_symndx
] == NULL
))
10461 h
= sym_hashes
[r_symndx
- extsymoff
];
10463 /* Badly formatted input files can contain relocs that
10464 reference non-existant symbols. Check here so that
10465 we do not seg fault. */
10470 sprintf_vma (buffer
, rel
->r_info
);
10472 /* xgettext:c-format */
10473 (_("error: %B contains a reloc (0x%s) for section %A "
10474 "that references a non-existent global symbol"),
10475 input_bfd
, buffer
, o
);
10476 bfd_set_error (bfd_error_bad_value
);
10480 while (h
->root
.type
== bfd_link_hash_indirect
10481 || h
->root
.type
== bfd_link_hash_warning
)
10482 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10486 /* If a plugin symbol is referenced from a non-IR file,
10487 mark the symbol as undefined. Note that the
10488 linker may attach linker created dynamic sections
10489 to the plugin bfd. Symbols defined in linker
10490 created sections are not plugin symbols. */
10491 if ((h
->root
.non_ir_ref_regular
10492 || h
->root
.non_ir_ref_dynamic
)
10493 && (h
->root
.type
== bfd_link_hash_defined
10494 || h
->root
.type
== bfd_link_hash_defweak
)
10495 && (h
->root
.u
.def
.section
->flags
10496 & SEC_LINKER_CREATED
) == 0
10497 && h
->root
.u
.def
.section
->owner
!= NULL
10498 && (h
->root
.u
.def
.section
->owner
->flags
10499 & BFD_PLUGIN
) != 0)
10501 h
->root
.type
= bfd_link_hash_undefined
;
10502 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
10506 if (h
->root
.type
== bfd_link_hash_defined
10507 || h
->root
.type
== bfd_link_hash_defweak
)
10508 ps
= &h
->root
.u
.def
.section
;
10510 sym_name
= h
->root
.root
.string
;
10514 Elf_Internal_Sym
*sym
= isymbuf
+ r_symndx
;
10516 s_type
= ELF_ST_TYPE (sym
->st_info
);
10517 ps
= &flinfo
->sections
[r_symndx
];
10518 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
10522 if ((s_type
== STT_RELC
|| s_type
== STT_SRELC
)
10523 && !bfd_link_relocatable (flinfo
->info
))
10526 bfd_vma dot
= (rel
->r_offset
10527 + o
->output_offset
+ o
->output_section
->vma
);
10529 printf ("Encountered a complex symbol!");
10530 printf (" (input_bfd %s, section %s, reloc %ld\n",
10531 input_bfd
->filename
, o
->name
,
10532 (long) (rel
- internal_relocs
));
10533 printf (" symbol: idx %8.8lx, name %s\n",
10534 r_symndx
, sym_name
);
10535 printf (" reloc : info %8.8lx, addr %8.8lx\n",
10536 (unsigned long) rel
->r_info
,
10537 (unsigned long) rel
->r_offset
);
10539 if (!eval_symbol (&val
, &sym_name
, input_bfd
, flinfo
, dot
,
10540 isymbuf
, locsymcount
, s_type
== STT_SRELC
))
10543 /* Symbol evaluated OK. Update to absolute value. */
10544 set_symbol_value (input_bfd
, isymbuf
, locsymcount
,
10549 if (action_discarded
!= -1 && ps
!= NULL
)
10551 /* Complain if the definition comes from a
10552 discarded section. */
10553 if ((sec
= *ps
) != NULL
&& discarded_section (sec
))
10555 BFD_ASSERT (r_symndx
!= STN_UNDEF
);
10556 if (action_discarded
& COMPLAIN
)
10557 (*flinfo
->info
->callbacks
->einfo
)
10558 /* xgettext:c-format */
10559 (_("%X`%s' referenced in section `%A' of %B: "
10560 "defined in discarded section `%A' of %B\n"),
10561 sym_name
, o
, input_bfd
, sec
, sec
->owner
);
10563 /* Try to do the best we can to support buggy old
10564 versions of gcc. Pretend that the symbol is
10565 really defined in the kept linkonce section.
10566 FIXME: This is quite broken. Modifying the
10567 symbol here means we will be changing all later
10568 uses of the symbol, not just in this section. */
10569 if (action_discarded
& PRETEND
)
10573 kept
= _bfd_elf_check_kept_section (sec
,
10585 /* Relocate the section by invoking a back end routine.
10587 The back end routine is responsible for adjusting the
10588 section contents as necessary, and (if using Rela relocs
10589 and generating a relocatable output file) adjusting the
10590 reloc addend as necessary.
10592 The back end routine does not have to worry about setting
10593 the reloc address or the reloc symbol index.
10595 The back end routine is given a pointer to the swapped in
10596 internal symbols, and can access the hash table entries
10597 for the external symbols via elf_sym_hashes (input_bfd).
10599 When generating relocatable output, the back end routine
10600 must handle STB_LOCAL/STT_SECTION symbols specially. The
10601 output symbol is going to be a section symbol
10602 corresponding to the output section, which will require
10603 the addend to be adjusted. */
10605 ret
= (*relocate_section
) (output_bfd
, flinfo
->info
,
10606 input_bfd
, o
, contents
,
10614 || bfd_link_relocatable (flinfo
->info
)
10615 || flinfo
->info
->emitrelocations
)
10617 Elf_Internal_Rela
*irela
;
10618 Elf_Internal_Rela
*irelaend
, *irelamid
;
10619 bfd_vma last_offset
;
10620 struct elf_link_hash_entry
**rel_hash
;
10621 struct elf_link_hash_entry
**rel_hash_list
, **rela_hash_list
;
10622 Elf_Internal_Shdr
*input_rel_hdr
, *input_rela_hdr
;
10623 unsigned int next_erel
;
10624 bfd_boolean rela_normal
;
10625 struct bfd_elf_section_data
*esdi
, *esdo
;
10627 esdi
= elf_section_data (o
);
10628 esdo
= elf_section_data (o
->output_section
);
10629 rela_normal
= FALSE
;
10631 /* Adjust the reloc addresses and symbol indices. */
10633 irela
= internal_relocs
;
10634 irelaend
= irela
+ o
->reloc_count
;
10635 rel_hash
= esdo
->rel
.hashes
+ esdo
->rel
.count
;
10636 /* We start processing the REL relocs, if any. When we reach
10637 IRELAMID in the loop, we switch to the RELA relocs. */
10639 if (esdi
->rel
.hdr
!= NULL
)
10640 irelamid
+= (NUM_SHDR_ENTRIES (esdi
->rel
.hdr
)
10641 * bed
->s
->int_rels_per_ext_rel
);
10642 rel_hash_list
= rel_hash
;
10643 rela_hash_list
= NULL
;
10644 last_offset
= o
->output_offset
;
10645 if (!bfd_link_relocatable (flinfo
->info
))
10646 last_offset
+= o
->output_section
->vma
;
10647 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
10649 unsigned long r_symndx
;
10651 Elf_Internal_Sym sym
;
10653 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
10659 if (irela
== irelamid
)
10661 rel_hash
= esdo
->rela
.hashes
+ esdo
->rela
.count
;
10662 rela_hash_list
= rel_hash
;
10663 rela_normal
= bed
->rela_normal
;
10666 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
10669 if (irela
->r_offset
>= (bfd_vma
) -2)
10671 /* This is a reloc for a deleted entry or somesuch.
10672 Turn it into an R_*_NONE reloc, at the same
10673 offset as the last reloc. elf_eh_frame.c and
10674 bfd_elf_discard_info rely on reloc offsets
10676 irela
->r_offset
= last_offset
;
10678 irela
->r_addend
= 0;
10682 irela
->r_offset
+= o
->output_offset
;
10684 /* Relocs in an executable have to be virtual addresses. */
10685 if (!bfd_link_relocatable (flinfo
->info
))
10686 irela
->r_offset
+= o
->output_section
->vma
;
10688 last_offset
= irela
->r_offset
;
10690 r_symndx
= irela
->r_info
>> r_sym_shift
;
10691 if (r_symndx
== STN_UNDEF
)
10694 if (r_symndx
>= locsymcount
10695 || (elf_bad_symtab (input_bfd
)
10696 && flinfo
->sections
[r_symndx
] == NULL
))
10698 struct elf_link_hash_entry
*rh
;
10699 unsigned long indx
;
10701 /* This is a reloc against a global symbol. We
10702 have not yet output all the local symbols, so
10703 we do not know the symbol index of any global
10704 symbol. We set the rel_hash entry for this
10705 reloc to point to the global hash table entry
10706 for this symbol. The symbol index is then
10707 set at the end of bfd_elf_final_link. */
10708 indx
= r_symndx
- extsymoff
;
10709 rh
= elf_sym_hashes (input_bfd
)[indx
];
10710 while (rh
->root
.type
== bfd_link_hash_indirect
10711 || rh
->root
.type
== bfd_link_hash_warning
)
10712 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
10714 /* Setting the index to -2 tells
10715 elf_link_output_extsym that this symbol is
10716 used by a reloc. */
10717 BFD_ASSERT (rh
->indx
< 0);
10724 /* This is a reloc against a local symbol. */
10727 sym
= isymbuf
[r_symndx
];
10728 sec
= flinfo
->sections
[r_symndx
];
10729 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
10731 /* I suppose the backend ought to fill in the
10732 section of any STT_SECTION symbol against a
10733 processor specific section. */
10734 r_symndx
= STN_UNDEF
;
10735 if (bfd_is_abs_section (sec
))
10737 else if (sec
== NULL
|| sec
->owner
== NULL
)
10739 bfd_set_error (bfd_error_bad_value
);
10744 asection
*osec
= sec
->output_section
;
10746 /* If we have discarded a section, the output
10747 section will be the absolute section. In
10748 case of discarded SEC_MERGE sections, use
10749 the kept section. relocate_section should
10750 have already handled discarded linkonce
10752 if (bfd_is_abs_section (osec
)
10753 && sec
->kept_section
!= NULL
10754 && sec
->kept_section
->output_section
!= NULL
)
10756 osec
= sec
->kept_section
->output_section
;
10757 irela
->r_addend
-= osec
->vma
;
10760 if (!bfd_is_abs_section (osec
))
10762 r_symndx
= osec
->target_index
;
10763 if (r_symndx
== STN_UNDEF
)
10765 irela
->r_addend
+= osec
->vma
;
10766 osec
= _bfd_nearby_section (output_bfd
, osec
,
10768 irela
->r_addend
-= osec
->vma
;
10769 r_symndx
= osec
->target_index
;
10774 /* Adjust the addend according to where the
10775 section winds up in the output section. */
10777 irela
->r_addend
+= sec
->output_offset
;
10781 if (flinfo
->indices
[r_symndx
] == -1)
10783 unsigned long shlink
;
10788 if (flinfo
->info
->strip
== strip_all
)
10790 /* You can't do ld -r -s. */
10791 bfd_set_error (bfd_error_invalid_operation
);
10795 /* This symbol was skipped earlier, but
10796 since it is needed by a reloc, we
10797 must output it now. */
10798 shlink
= symtab_hdr
->sh_link
;
10799 name
= (bfd_elf_string_from_elf_section
10800 (input_bfd
, shlink
, sym
.st_name
));
10804 osec
= sec
->output_section
;
10806 _bfd_elf_section_from_bfd_section (output_bfd
,
10808 if (sym
.st_shndx
== SHN_BAD
)
10811 sym
.st_value
+= sec
->output_offset
;
10812 if (!bfd_link_relocatable (flinfo
->info
))
10814 sym
.st_value
+= osec
->vma
;
10815 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
10817 /* STT_TLS symbols are relative to PT_TLS
10819 BFD_ASSERT (elf_hash_table (flinfo
->info
)
10820 ->tls_sec
!= NULL
);
10821 sym
.st_value
-= (elf_hash_table (flinfo
->info
)
10826 indx
= bfd_get_symcount (output_bfd
);
10827 ret
= elf_link_output_symstrtab (flinfo
, name
,
10833 flinfo
->indices
[r_symndx
] = indx
;
10838 r_symndx
= flinfo
->indices
[r_symndx
];
10841 irela
->r_info
= ((bfd_vma
) r_symndx
<< r_sym_shift
10842 | (irela
->r_info
& r_type_mask
));
10845 /* Swap out the relocs. */
10846 input_rel_hdr
= esdi
->rel
.hdr
;
10847 if (input_rel_hdr
&& input_rel_hdr
->sh_size
!= 0)
10849 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
10854 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
10855 * bed
->s
->int_rels_per_ext_rel
);
10856 rel_hash_list
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
10859 input_rela_hdr
= esdi
->rela
.hdr
;
10860 if (input_rela_hdr
&& input_rela_hdr
->sh_size
!= 0)
10862 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
10871 /* Write out the modified section contents. */
10872 if (bed
->elf_backend_write_section
10873 && (*bed
->elf_backend_write_section
) (output_bfd
, flinfo
->info
, o
,
10876 /* Section written out. */
10878 else switch (o
->sec_info_type
)
10880 case SEC_INFO_TYPE_STABS
:
10881 if (! (_bfd_write_section_stabs
10883 &elf_hash_table (flinfo
->info
)->stab_info
,
10884 o
, &elf_section_data (o
)->sec_info
, contents
)))
10887 case SEC_INFO_TYPE_MERGE
:
10888 if (! _bfd_write_merged_section (output_bfd
, o
,
10889 elf_section_data (o
)->sec_info
))
10892 case SEC_INFO_TYPE_EH_FRAME
:
10894 if (! _bfd_elf_write_section_eh_frame (output_bfd
, flinfo
->info
,
10899 case SEC_INFO_TYPE_EH_FRAME_ENTRY
:
10901 if (! _bfd_elf_write_section_eh_frame_entry (output_bfd
,
10909 if (! (o
->flags
& SEC_EXCLUDE
))
10911 file_ptr offset
= (file_ptr
) o
->output_offset
;
10912 bfd_size_type todo
= o
->size
;
10914 offset
*= bfd_octets_per_byte (output_bfd
);
10916 if ((o
->flags
& SEC_ELF_REVERSE_COPY
))
10918 /* Reverse-copy input section to output. */
10921 todo
-= address_size
;
10922 if (! bfd_set_section_contents (output_bfd
,
10930 offset
+= address_size
;
10934 else if (! bfd_set_section_contents (output_bfd
,
10948 /* Generate a reloc when linking an ELF file. This is a reloc
10949 requested by the linker, and does not come from any input file. This
10950 is used to build constructor and destructor tables when linking
10954 elf_reloc_link_order (bfd
*output_bfd
,
10955 struct bfd_link_info
*info
,
10956 asection
*output_section
,
10957 struct bfd_link_order
*link_order
)
10959 reloc_howto_type
*howto
;
10963 struct bfd_elf_section_reloc_data
*reldata
;
10964 struct elf_link_hash_entry
**rel_hash_ptr
;
10965 Elf_Internal_Shdr
*rel_hdr
;
10966 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
10967 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
10970 struct bfd_elf_section_data
*esdo
= elf_section_data (output_section
);
10972 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
10975 bfd_set_error (bfd_error_bad_value
);
10979 addend
= link_order
->u
.reloc
.p
->addend
;
10982 reldata
= &esdo
->rel
;
10983 else if (esdo
->rela
.hdr
)
10984 reldata
= &esdo
->rela
;
10991 /* Figure out the symbol index. */
10992 rel_hash_ptr
= reldata
->hashes
+ reldata
->count
;
10993 if (link_order
->type
== bfd_section_reloc_link_order
)
10995 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
10996 BFD_ASSERT (indx
!= 0);
10997 *rel_hash_ptr
= NULL
;
11001 struct elf_link_hash_entry
*h
;
11003 /* Treat a reloc against a defined symbol as though it were
11004 actually against the section. */
11005 h
= ((struct elf_link_hash_entry
*)
11006 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
11007 link_order
->u
.reloc
.p
->u
.name
,
11008 FALSE
, FALSE
, TRUE
));
11010 && (h
->root
.type
== bfd_link_hash_defined
11011 || h
->root
.type
== bfd_link_hash_defweak
))
11015 section
= h
->root
.u
.def
.section
;
11016 indx
= section
->output_section
->target_index
;
11017 *rel_hash_ptr
= NULL
;
11018 /* It seems that we ought to add the symbol value to the
11019 addend here, but in practice it has already been added
11020 because it was passed to constructor_callback. */
11021 addend
+= section
->output_section
->vma
+ section
->output_offset
;
11023 else if (h
!= NULL
)
11025 /* Setting the index to -2 tells elf_link_output_extsym that
11026 this symbol is used by a reloc. */
11033 (*info
->callbacks
->unattached_reloc
)
11034 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0);
11039 /* If this is an inplace reloc, we must write the addend into the
11041 if (howto
->partial_inplace
&& addend
!= 0)
11043 bfd_size_type size
;
11044 bfd_reloc_status_type rstat
;
11047 const char *sym_name
;
11049 size
= (bfd_size_type
) bfd_get_reloc_size (howto
);
11050 buf
= (bfd_byte
*) bfd_zmalloc (size
);
11051 if (buf
== NULL
&& size
!= 0)
11053 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
11060 case bfd_reloc_outofrange
:
11063 case bfd_reloc_overflow
:
11064 if (link_order
->type
== bfd_section_reloc_link_order
)
11065 sym_name
= bfd_section_name (output_bfd
,
11066 link_order
->u
.reloc
.p
->u
.section
);
11068 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
11069 (*info
->callbacks
->reloc_overflow
) (info
, NULL
, sym_name
,
11070 howto
->name
, addend
, NULL
, NULL
,
11075 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
11077 * bfd_octets_per_byte (output_bfd
),
11084 /* The address of a reloc is relative to the section in a
11085 relocatable file, and is a virtual address in an executable
11087 offset
= link_order
->offset
;
11088 if (! bfd_link_relocatable (info
))
11089 offset
+= output_section
->vma
;
11091 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
11093 irel
[i
].r_offset
= offset
;
11094 irel
[i
].r_info
= 0;
11095 irel
[i
].r_addend
= 0;
11097 if (bed
->s
->arch_size
== 32)
11098 irel
[0].r_info
= ELF32_R_INFO (indx
, howto
->type
);
11100 irel
[0].r_info
= ELF64_R_INFO (indx
, howto
->type
);
11102 rel_hdr
= reldata
->hdr
;
11103 erel
= rel_hdr
->contents
;
11104 if (rel_hdr
->sh_type
== SHT_REL
)
11106 erel
+= reldata
->count
* bed
->s
->sizeof_rel
;
11107 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
11111 irel
[0].r_addend
= addend
;
11112 erel
+= reldata
->count
* bed
->s
->sizeof_rela
;
11113 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
11122 /* Get the output vma of the section pointed to by the sh_link field. */
11125 elf_get_linked_section_vma (struct bfd_link_order
*p
)
11127 Elf_Internal_Shdr
**elf_shdrp
;
11131 s
= p
->u
.indirect
.section
;
11132 elf_shdrp
= elf_elfsections (s
->owner
);
11133 elfsec
= _bfd_elf_section_from_bfd_section (s
->owner
, s
);
11134 elfsec
= elf_shdrp
[elfsec
]->sh_link
;
11136 The Intel C compiler generates SHT_IA_64_UNWIND with
11137 SHF_LINK_ORDER. But it doesn't set the sh_link or
11138 sh_info fields. Hence we could get the situation
11139 where elfsec is 0. */
11142 const struct elf_backend_data
*bed
11143 = get_elf_backend_data (s
->owner
);
11144 if (bed
->link_order_error_handler
)
11145 bed
->link_order_error_handler
11146 /* xgettext:c-format */
11147 (_("%B: warning: sh_link not set for section `%A'"), s
->owner
, s
);
11152 s
= elf_shdrp
[elfsec
]->bfd_section
;
11153 return s
->output_section
->vma
+ s
->output_offset
;
11158 /* Compare two sections based on the locations of the sections they are
11159 linked to. Used by elf_fixup_link_order. */
11162 compare_link_order (const void * a
, const void * b
)
11167 apos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)a
);
11168 bpos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)b
);
11171 return apos
> bpos
;
11175 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
11176 order as their linked sections. Returns false if this could not be done
11177 because an output section includes both ordered and unordered
11178 sections. Ideally we'd do this in the linker proper. */
11181 elf_fixup_link_order (bfd
*abfd
, asection
*o
)
11183 int seen_linkorder
;
11186 struct bfd_link_order
*p
;
11188 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11190 struct bfd_link_order
**sections
;
11191 asection
*s
, *other_sec
, *linkorder_sec
;
11195 linkorder_sec
= NULL
;
11197 seen_linkorder
= 0;
11198 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11200 if (p
->type
== bfd_indirect_link_order
)
11202 s
= p
->u
.indirect
.section
;
11204 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
11205 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
11206 && (elfsec
= _bfd_elf_section_from_bfd_section (sub
, s
))
11207 && elfsec
< elf_numsections (sub
)
11208 && elf_elfsections (sub
)[elfsec
]->sh_flags
& SHF_LINK_ORDER
11209 && elf_elfsections (sub
)[elfsec
]->sh_link
< elf_numsections (sub
))
11223 if (seen_other
&& seen_linkorder
)
11225 if (other_sec
&& linkorder_sec
)
11227 /* xgettext:c-format */
11228 (_("%A has both ordered [`%A' in %B] "
11229 "and unordered [`%A' in %B] sections"),
11230 o
, linkorder_sec
, linkorder_sec
->owner
,
11231 other_sec
, other_sec
->owner
);
11234 (_("%A has both ordered and unordered sections"), o
);
11235 bfd_set_error (bfd_error_bad_value
);
11240 if (!seen_linkorder
)
11243 sections
= (struct bfd_link_order
**)
11244 bfd_malloc (seen_linkorder
* sizeof (struct bfd_link_order
*));
11245 if (sections
== NULL
)
11247 seen_linkorder
= 0;
11249 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11251 sections
[seen_linkorder
++] = p
;
11253 /* Sort the input sections in the order of their linked section. */
11254 qsort (sections
, seen_linkorder
, sizeof (struct bfd_link_order
*),
11255 compare_link_order
);
11257 /* Change the offsets of the sections. */
11259 for (n
= 0; n
< seen_linkorder
; n
++)
11261 s
= sections
[n
]->u
.indirect
.section
;
11262 offset
&= ~(bfd_vma
) 0 << s
->alignment_power
;
11263 s
->output_offset
= offset
/ bfd_octets_per_byte (abfd
);
11264 sections
[n
]->offset
= offset
;
11265 offset
+= sections
[n
]->size
;
11272 /* Generate an import library in INFO->implib_bfd from symbols in ABFD.
11273 Returns TRUE upon success, FALSE otherwise. */
11276 elf_output_implib (bfd
*abfd
, struct bfd_link_info
*info
)
11278 bfd_boolean ret
= FALSE
;
11280 const struct elf_backend_data
*bed
;
11282 enum bfd_architecture arch
;
11284 asymbol
**sympp
= NULL
;
11288 elf_symbol_type
*osymbuf
;
11290 implib_bfd
= info
->out_implib_bfd
;
11291 bed
= get_elf_backend_data (abfd
);
11293 if (!bfd_set_format (implib_bfd
, bfd_object
))
11296 /* Use flag from executable but make it a relocatable object. */
11297 flags
= bfd_get_file_flags (abfd
);
11298 flags
&= ~HAS_RELOC
;
11299 if (!bfd_set_start_address (implib_bfd
, 0)
11300 || !bfd_set_file_flags (implib_bfd
, flags
& ~EXEC_P
))
11303 /* Copy architecture of output file to import library file. */
11304 arch
= bfd_get_arch (abfd
);
11305 mach
= bfd_get_mach (abfd
);
11306 if (!bfd_set_arch_mach (implib_bfd
, arch
, mach
)
11307 && (abfd
->target_defaulted
11308 || bfd_get_arch (abfd
) != bfd_get_arch (implib_bfd
)))
11311 /* Get symbol table size. */
11312 symsize
= bfd_get_symtab_upper_bound (abfd
);
11316 /* Read in the symbol table. */
11317 sympp
= (asymbol
**) xmalloc (symsize
);
11318 symcount
= bfd_canonicalize_symtab (abfd
, sympp
);
11322 /* Allow the BFD backend to copy any private header data it
11323 understands from the output BFD to the import library BFD. */
11324 if (! bfd_copy_private_header_data (abfd
, implib_bfd
))
11327 /* Filter symbols to appear in the import library. */
11328 if (bed
->elf_backend_filter_implib_symbols
)
11329 symcount
= bed
->elf_backend_filter_implib_symbols (abfd
, info
, sympp
,
11332 symcount
= _bfd_elf_filter_global_symbols (abfd
, info
, sympp
, symcount
);
11335 bfd_set_error (bfd_error_no_symbols
);
11336 _bfd_error_handler (_("%B: no symbol found for import library"),
11342 /* Make symbols absolute. */
11343 osymbuf
= (elf_symbol_type
*) bfd_alloc2 (implib_bfd
, symcount
,
11344 sizeof (*osymbuf
));
11345 for (src_count
= 0; src_count
< symcount
; src_count
++)
11347 memcpy (&osymbuf
[src_count
], (elf_symbol_type
*) sympp
[src_count
],
11348 sizeof (*osymbuf
));
11349 osymbuf
[src_count
].symbol
.section
= bfd_abs_section_ptr
;
11350 osymbuf
[src_count
].internal_elf_sym
.st_shndx
= SHN_ABS
;
11351 osymbuf
[src_count
].symbol
.value
+= sympp
[src_count
]->section
->vma
;
11352 osymbuf
[src_count
].internal_elf_sym
.st_value
=
11353 osymbuf
[src_count
].symbol
.value
;
11354 sympp
[src_count
] = &osymbuf
[src_count
].symbol
;
11357 bfd_set_symtab (implib_bfd
, sympp
, symcount
);
11359 /* Allow the BFD backend to copy any private data it understands
11360 from the output BFD to the import library BFD. This is done last
11361 to permit the routine to look at the filtered symbol table. */
11362 if (! bfd_copy_private_bfd_data (abfd
, implib_bfd
))
11365 if (!bfd_close (implib_bfd
))
11376 elf_final_link_free (bfd
*obfd
, struct elf_final_link_info
*flinfo
)
11380 if (flinfo
->symstrtab
!= NULL
)
11381 _bfd_elf_strtab_free (flinfo
->symstrtab
);
11382 if (flinfo
->contents
!= NULL
)
11383 free (flinfo
->contents
);
11384 if (flinfo
->external_relocs
!= NULL
)
11385 free (flinfo
->external_relocs
);
11386 if (flinfo
->internal_relocs
!= NULL
)
11387 free (flinfo
->internal_relocs
);
11388 if (flinfo
->external_syms
!= NULL
)
11389 free (flinfo
->external_syms
);
11390 if (flinfo
->locsym_shndx
!= NULL
)
11391 free (flinfo
->locsym_shndx
);
11392 if (flinfo
->internal_syms
!= NULL
)
11393 free (flinfo
->internal_syms
);
11394 if (flinfo
->indices
!= NULL
)
11395 free (flinfo
->indices
);
11396 if (flinfo
->sections
!= NULL
)
11397 free (flinfo
->sections
);
11398 if (flinfo
->symshndxbuf
!= NULL
)
11399 free (flinfo
->symshndxbuf
);
11400 for (o
= obfd
->sections
; o
!= NULL
; o
= o
->next
)
11402 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11403 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
11404 free (esdo
->rel
.hashes
);
11405 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
11406 free (esdo
->rela
.hashes
);
11410 /* Do the final step of an ELF link. */
11413 bfd_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
11415 bfd_boolean dynamic
;
11416 bfd_boolean emit_relocs
;
11418 struct elf_final_link_info flinfo
;
11420 struct bfd_link_order
*p
;
11422 bfd_size_type max_contents_size
;
11423 bfd_size_type max_external_reloc_size
;
11424 bfd_size_type max_internal_reloc_count
;
11425 bfd_size_type max_sym_count
;
11426 bfd_size_type max_sym_shndx_count
;
11427 Elf_Internal_Sym elfsym
;
11429 Elf_Internal_Shdr
*symtab_hdr
;
11430 Elf_Internal_Shdr
*symtab_shndx_hdr
;
11431 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11432 struct elf_outext_info eoinfo
;
11433 bfd_boolean merged
;
11434 size_t relativecount
= 0;
11435 asection
*reldyn
= 0;
11437 asection
*attr_section
= NULL
;
11438 bfd_vma attr_size
= 0;
11439 const char *std_attrs_section
;
11440 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
11442 if (!is_elf_hash_table (htab
))
11445 if (bfd_link_pic (info
))
11446 abfd
->flags
|= DYNAMIC
;
11448 dynamic
= htab
->dynamic_sections_created
;
11449 dynobj
= htab
->dynobj
;
11451 emit_relocs
= (bfd_link_relocatable (info
)
11452 || info
->emitrelocations
);
11454 flinfo
.info
= info
;
11455 flinfo
.output_bfd
= abfd
;
11456 flinfo
.symstrtab
= _bfd_elf_strtab_init ();
11457 if (flinfo
.symstrtab
== NULL
)
11462 flinfo
.hash_sec
= NULL
;
11463 flinfo
.symver_sec
= NULL
;
11467 flinfo
.hash_sec
= bfd_get_linker_section (dynobj
, ".hash");
11468 /* Note that dynsym_sec can be NULL (on VMS). */
11469 flinfo
.symver_sec
= bfd_get_linker_section (dynobj
, ".gnu.version");
11470 /* Note that it is OK if symver_sec is NULL. */
11473 flinfo
.contents
= NULL
;
11474 flinfo
.external_relocs
= NULL
;
11475 flinfo
.internal_relocs
= NULL
;
11476 flinfo
.external_syms
= NULL
;
11477 flinfo
.locsym_shndx
= NULL
;
11478 flinfo
.internal_syms
= NULL
;
11479 flinfo
.indices
= NULL
;
11480 flinfo
.sections
= NULL
;
11481 flinfo
.symshndxbuf
= NULL
;
11482 flinfo
.filesym_count
= 0;
11484 /* The object attributes have been merged. Remove the input
11485 sections from the link, and set the contents of the output
11487 std_attrs_section
= get_elf_backend_data (abfd
)->obj_attrs_section
;
11488 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11490 if ((std_attrs_section
&& strcmp (o
->name
, std_attrs_section
) == 0)
11491 || strcmp (o
->name
, ".gnu.attributes") == 0)
11493 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11495 asection
*input_section
;
11497 if (p
->type
!= bfd_indirect_link_order
)
11499 input_section
= p
->u
.indirect
.section
;
11500 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11501 elf_link_input_bfd ignores this section. */
11502 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11505 attr_size
= bfd_elf_obj_attr_size (abfd
);
11508 bfd_set_section_size (abfd
, o
, attr_size
);
11510 /* Skip this section later on. */
11511 o
->map_head
.link_order
= NULL
;
11514 o
->flags
|= SEC_EXCLUDE
;
11518 /* Count up the number of relocations we will output for each output
11519 section, so that we know the sizes of the reloc sections. We
11520 also figure out some maximum sizes. */
11521 max_contents_size
= 0;
11522 max_external_reloc_size
= 0;
11523 max_internal_reloc_count
= 0;
11525 max_sym_shndx_count
= 0;
11527 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11529 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11530 o
->reloc_count
= 0;
11532 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11534 unsigned int reloc_count
= 0;
11535 unsigned int additional_reloc_count
= 0;
11536 struct bfd_elf_section_data
*esdi
= NULL
;
11538 if (p
->type
== bfd_section_reloc_link_order
11539 || p
->type
== bfd_symbol_reloc_link_order
)
11541 else if (p
->type
== bfd_indirect_link_order
)
11545 sec
= p
->u
.indirect
.section
;
11547 /* Mark all sections which are to be included in the
11548 link. This will normally be every section. We need
11549 to do this so that we can identify any sections which
11550 the linker has decided to not include. */
11551 sec
->linker_mark
= TRUE
;
11553 if (sec
->flags
& SEC_MERGE
)
11556 if (sec
->rawsize
> max_contents_size
)
11557 max_contents_size
= sec
->rawsize
;
11558 if (sec
->size
> max_contents_size
)
11559 max_contents_size
= sec
->size
;
11561 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
11562 && (sec
->owner
->flags
& DYNAMIC
) == 0)
11566 /* We are interested in just local symbols, not all
11568 if (elf_bad_symtab (sec
->owner
))
11569 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
11570 / bed
->s
->sizeof_sym
);
11572 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
11574 if (sym_count
> max_sym_count
)
11575 max_sym_count
= sym_count
;
11577 if (sym_count
> max_sym_shndx_count
11578 && elf_symtab_shndx_list (sec
->owner
) != NULL
)
11579 max_sym_shndx_count
= sym_count
;
11581 if (esdo
->this_hdr
.sh_type
== SHT_REL
11582 || esdo
->this_hdr
.sh_type
== SHT_RELA
)
11583 /* Some backends use reloc_count in relocation sections
11584 to count particular types of relocs. Of course,
11585 reloc sections themselves can't have relocations. */
11587 else if (emit_relocs
)
11589 reloc_count
= sec
->reloc_count
;
11590 if (bed
->elf_backend_count_additional_relocs
)
11593 c
= (*bed
->elf_backend_count_additional_relocs
) (sec
);
11594 additional_reloc_count
+= c
;
11597 else if (bed
->elf_backend_count_relocs
)
11598 reloc_count
= (*bed
->elf_backend_count_relocs
) (info
, sec
);
11600 esdi
= elf_section_data (sec
);
11602 if ((sec
->flags
& SEC_RELOC
) != 0)
11604 size_t ext_size
= 0;
11606 if (esdi
->rel
.hdr
!= NULL
)
11607 ext_size
= esdi
->rel
.hdr
->sh_size
;
11608 if (esdi
->rela
.hdr
!= NULL
)
11609 ext_size
+= esdi
->rela
.hdr
->sh_size
;
11611 if (ext_size
> max_external_reloc_size
)
11612 max_external_reloc_size
= ext_size
;
11613 if (sec
->reloc_count
> max_internal_reloc_count
)
11614 max_internal_reloc_count
= sec
->reloc_count
;
11619 if (reloc_count
== 0)
11622 reloc_count
+= additional_reloc_count
;
11623 o
->reloc_count
+= reloc_count
;
11625 if (p
->type
== bfd_indirect_link_order
&& emit_relocs
)
11629 esdo
->rel
.count
+= NUM_SHDR_ENTRIES (esdi
->rel
.hdr
);
11630 esdo
->rel
.count
+= additional_reloc_count
;
11632 if (esdi
->rela
.hdr
)
11634 esdo
->rela
.count
+= NUM_SHDR_ENTRIES (esdi
->rela
.hdr
);
11635 esdo
->rela
.count
+= additional_reloc_count
;
11641 esdo
->rela
.count
+= reloc_count
;
11643 esdo
->rel
.count
+= reloc_count
;
11647 if (o
->reloc_count
> 0)
11648 o
->flags
|= SEC_RELOC
;
11651 /* Explicitly clear the SEC_RELOC flag. The linker tends to
11652 set it (this is probably a bug) and if it is set
11653 assign_section_numbers will create a reloc section. */
11654 o
->flags
&=~ SEC_RELOC
;
11657 /* If the SEC_ALLOC flag is not set, force the section VMA to
11658 zero. This is done in elf_fake_sections as well, but forcing
11659 the VMA to 0 here will ensure that relocs against these
11660 sections are handled correctly. */
11661 if ((o
->flags
& SEC_ALLOC
) == 0
11662 && ! o
->user_set_vma
)
11666 if (! bfd_link_relocatable (info
) && merged
)
11667 elf_link_hash_traverse (htab
, _bfd_elf_link_sec_merge_syms
, abfd
);
11669 /* Figure out the file positions for everything but the symbol table
11670 and the relocs. We set symcount to force assign_section_numbers
11671 to create a symbol table. */
11672 bfd_get_symcount (abfd
) = info
->strip
!= strip_all
|| emit_relocs
;
11673 BFD_ASSERT (! abfd
->output_has_begun
);
11674 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
11677 /* Set sizes, and assign file positions for reloc sections. */
11678 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11680 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11681 if ((o
->flags
& SEC_RELOC
) != 0)
11684 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rel
)))
11688 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rela
)))
11692 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
11693 to count upwards while actually outputting the relocations. */
11694 esdo
->rel
.count
= 0;
11695 esdo
->rela
.count
= 0;
11697 if (esdo
->this_hdr
.sh_offset
== (file_ptr
) -1)
11699 /* Cache the section contents so that they can be compressed
11700 later. Use bfd_malloc since it will be freed by
11701 bfd_compress_section_contents. */
11702 unsigned char *contents
= esdo
->this_hdr
.contents
;
11703 if ((o
->flags
& SEC_ELF_COMPRESS
) == 0 || contents
!= NULL
)
11706 = (unsigned char *) bfd_malloc (esdo
->this_hdr
.sh_size
);
11707 if (contents
== NULL
)
11709 esdo
->this_hdr
.contents
= contents
;
11713 /* We have now assigned file positions for all the sections except
11714 .symtab, .strtab, and non-loaded reloc sections. We start the
11715 .symtab section at the current file position, and write directly
11716 to it. We build the .strtab section in memory. */
11717 bfd_get_symcount (abfd
) = 0;
11718 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11719 /* sh_name is set in prep_headers. */
11720 symtab_hdr
->sh_type
= SHT_SYMTAB
;
11721 /* sh_flags, sh_addr and sh_size all start off zero. */
11722 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
11723 /* sh_link is set in assign_section_numbers. */
11724 /* sh_info is set below. */
11725 /* sh_offset is set just below. */
11726 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
11728 if (max_sym_count
< 20)
11729 max_sym_count
= 20;
11730 htab
->strtabsize
= max_sym_count
;
11731 amt
= max_sym_count
* sizeof (struct elf_sym_strtab
);
11732 htab
->strtab
= (struct elf_sym_strtab
*) bfd_malloc (amt
);
11733 if (htab
->strtab
== NULL
)
11735 /* The real buffer will be allocated in elf_link_swap_symbols_out. */
11737 = (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF)
11738 ? (Elf_External_Sym_Shndx
*) -1 : NULL
);
11740 if (info
->strip
!= strip_all
|| emit_relocs
)
11742 file_ptr off
= elf_next_file_pos (abfd
);
11744 _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, TRUE
);
11746 /* Note that at this point elf_next_file_pos (abfd) is
11747 incorrect. We do not yet know the size of the .symtab section.
11748 We correct next_file_pos below, after we do know the size. */
11750 /* Start writing out the symbol table. The first symbol is always a
11752 elfsym
.st_value
= 0;
11753 elfsym
.st_size
= 0;
11754 elfsym
.st_info
= 0;
11755 elfsym
.st_other
= 0;
11756 elfsym
.st_shndx
= SHN_UNDEF
;
11757 elfsym
.st_target_internal
= 0;
11758 if (elf_link_output_symstrtab (&flinfo
, NULL
, &elfsym
,
11759 bfd_und_section_ptr
, NULL
) != 1)
11762 /* Output a symbol for each section. We output these even if we are
11763 discarding local symbols, since they are used for relocs. These
11764 symbols have no names. We store the index of each one in the
11765 index field of the section, so that we can find it again when
11766 outputting relocs. */
11768 elfsym
.st_size
= 0;
11769 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
11770 elfsym
.st_other
= 0;
11771 elfsym
.st_value
= 0;
11772 elfsym
.st_target_internal
= 0;
11773 for (i
= 1; i
< elf_numsections (abfd
); i
++)
11775 o
= bfd_section_from_elf_index (abfd
, i
);
11778 o
->target_index
= bfd_get_symcount (abfd
);
11779 elfsym
.st_shndx
= i
;
11780 if (!bfd_link_relocatable (info
))
11781 elfsym
.st_value
= o
->vma
;
11782 if (elf_link_output_symstrtab (&flinfo
, NULL
, &elfsym
, o
,
11789 /* Allocate some memory to hold information read in from the input
11791 if (max_contents_size
!= 0)
11793 flinfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
11794 if (flinfo
.contents
== NULL
)
11798 if (max_external_reloc_size
!= 0)
11800 flinfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
11801 if (flinfo
.external_relocs
== NULL
)
11805 if (max_internal_reloc_count
!= 0)
11807 amt
= max_internal_reloc_count
* sizeof (Elf_Internal_Rela
);
11808 flinfo
.internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
11809 if (flinfo
.internal_relocs
== NULL
)
11813 if (max_sym_count
!= 0)
11815 amt
= max_sym_count
* bed
->s
->sizeof_sym
;
11816 flinfo
.external_syms
= (bfd_byte
*) bfd_malloc (amt
);
11817 if (flinfo
.external_syms
== NULL
)
11820 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
11821 flinfo
.internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
11822 if (flinfo
.internal_syms
== NULL
)
11825 amt
= max_sym_count
* sizeof (long);
11826 flinfo
.indices
= (long int *) bfd_malloc (amt
);
11827 if (flinfo
.indices
== NULL
)
11830 amt
= max_sym_count
* sizeof (asection
*);
11831 flinfo
.sections
= (asection
**) bfd_malloc (amt
);
11832 if (flinfo
.sections
== NULL
)
11836 if (max_sym_shndx_count
!= 0)
11838 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
11839 flinfo
.locsym_shndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
11840 if (flinfo
.locsym_shndx
== NULL
)
11846 bfd_vma base
, end
= 0;
11849 for (sec
= htab
->tls_sec
;
11850 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
11853 bfd_size_type size
= sec
->size
;
11856 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
11858 struct bfd_link_order
*ord
= sec
->map_tail
.link_order
;
11861 size
= ord
->offset
+ ord
->size
;
11863 end
= sec
->vma
+ size
;
11865 base
= htab
->tls_sec
->vma
;
11866 /* Only align end of TLS section if static TLS doesn't have special
11867 alignment requirements. */
11868 if (bed
->static_tls_alignment
== 1)
11869 end
= align_power (end
, htab
->tls_sec
->alignment_power
);
11870 htab
->tls_size
= end
- base
;
11873 /* Reorder SHF_LINK_ORDER sections. */
11874 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11876 if (!elf_fixup_link_order (abfd
, o
))
11880 if (!_bfd_elf_fixup_eh_frame_hdr (info
))
11883 /* Since ELF permits relocations to be against local symbols, we
11884 must have the local symbols available when we do the relocations.
11885 Since we would rather only read the local symbols once, and we
11886 would rather not keep them in memory, we handle all the
11887 relocations for a single input file at the same time.
11889 Unfortunately, there is no way to know the total number of local
11890 symbols until we have seen all of them, and the local symbol
11891 indices precede the global symbol indices. This means that when
11892 we are generating relocatable output, and we see a reloc against
11893 a global symbol, we can not know the symbol index until we have
11894 finished examining all the local symbols to see which ones we are
11895 going to output. To deal with this, we keep the relocations in
11896 memory, and don't output them until the end of the link. This is
11897 an unfortunate waste of memory, but I don't see a good way around
11898 it. Fortunately, it only happens when performing a relocatable
11899 link, which is not the common case. FIXME: If keep_memory is set
11900 we could write the relocs out and then read them again; I don't
11901 know how bad the memory loss will be. */
11903 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
11904 sub
->output_has_begun
= FALSE
;
11905 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11907 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11909 if (p
->type
== bfd_indirect_link_order
11910 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
11911 == bfd_target_elf_flavour
)
11912 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
11914 if (! sub
->output_has_begun
)
11916 if (! elf_link_input_bfd (&flinfo
, sub
))
11918 sub
->output_has_begun
= TRUE
;
11921 else if (p
->type
== bfd_section_reloc_link_order
11922 || p
->type
== bfd_symbol_reloc_link_order
)
11924 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
11929 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
11931 if (p
->type
== bfd_indirect_link_order
11932 && (bfd_get_flavour (sub
)
11933 == bfd_target_elf_flavour
)
11934 && (elf_elfheader (sub
)->e_ident
[EI_CLASS
]
11935 != bed
->s
->elfclass
))
11937 const char *iclass
, *oclass
;
11939 switch (bed
->s
->elfclass
)
11941 case ELFCLASS64
: oclass
= "ELFCLASS64"; break;
11942 case ELFCLASS32
: oclass
= "ELFCLASS32"; break;
11943 case ELFCLASSNONE
: oclass
= "ELFCLASSNONE"; break;
11947 switch (elf_elfheader (sub
)->e_ident
[EI_CLASS
])
11949 case ELFCLASS64
: iclass
= "ELFCLASS64"; break;
11950 case ELFCLASS32
: iclass
= "ELFCLASS32"; break;
11951 case ELFCLASSNONE
: iclass
= "ELFCLASSNONE"; break;
11955 bfd_set_error (bfd_error_wrong_format
);
11957 /* xgettext:c-format */
11958 (_("%B: file class %s incompatible with %s"),
11959 sub
, iclass
, oclass
);
11968 /* Free symbol buffer if needed. */
11969 if (!info
->reduce_memory_overheads
)
11971 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
11972 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
11973 && elf_tdata (sub
)->symbuf
)
11975 free (elf_tdata (sub
)->symbuf
);
11976 elf_tdata (sub
)->symbuf
= NULL
;
11980 /* Output any global symbols that got converted to local in a
11981 version script or due to symbol visibility. We do this in a
11982 separate step since ELF requires all local symbols to appear
11983 prior to any global symbols. FIXME: We should only do this if
11984 some global symbols were, in fact, converted to become local.
11985 FIXME: Will this work correctly with the Irix 5 linker? */
11986 eoinfo
.failed
= FALSE
;
11987 eoinfo
.flinfo
= &flinfo
;
11988 eoinfo
.localsyms
= TRUE
;
11989 eoinfo
.file_sym_done
= FALSE
;
11990 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11994 /* If backend needs to output some local symbols not present in the hash
11995 table, do it now. */
11996 if (bed
->elf_backend_output_arch_local_syms
11997 && (info
->strip
!= strip_all
|| emit_relocs
))
11999 typedef int (*out_sym_func
)
12000 (void *, const char *, Elf_Internal_Sym
*, asection
*,
12001 struct elf_link_hash_entry
*);
12003 if (! ((*bed
->elf_backend_output_arch_local_syms
)
12004 (abfd
, info
, &flinfo
,
12005 (out_sym_func
) elf_link_output_symstrtab
)))
12009 /* That wrote out all the local symbols. Finish up the symbol table
12010 with the global symbols. Even if we want to strip everything we
12011 can, we still need to deal with those global symbols that got
12012 converted to local in a version script. */
12014 /* The sh_info field records the index of the first non local symbol. */
12015 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
12018 && htab
->dynsym
!= NULL
12019 && htab
->dynsym
->output_section
!= bfd_abs_section_ptr
)
12021 Elf_Internal_Sym sym
;
12022 bfd_byte
*dynsym
= htab
->dynsym
->contents
;
12024 o
= htab
->dynsym
->output_section
;
12025 elf_section_data (o
)->this_hdr
.sh_info
= htab
->local_dynsymcount
+ 1;
12027 /* Write out the section symbols for the output sections. */
12028 if (bfd_link_pic (info
)
12029 || htab
->is_relocatable_executable
)
12035 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
12037 sym
.st_target_internal
= 0;
12039 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12045 dynindx
= elf_section_data (s
)->dynindx
;
12048 indx
= elf_section_data (s
)->this_idx
;
12049 BFD_ASSERT (indx
> 0);
12050 sym
.st_shndx
= indx
;
12051 if (! check_dynsym (abfd
, &sym
))
12053 sym
.st_value
= s
->vma
;
12054 dest
= dynsym
+ dynindx
* bed
->s
->sizeof_sym
;
12055 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
12059 /* Write out the local dynsyms. */
12060 if (htab
->dynlocal
)
12062 struct elf_link_local_dynamic_entry
*e
;
12063 for (e
= htab
->dynlocal
; e
; e
= e
->next
)
12068 /* Copy the internal symbol and turn off visibility.
12069 Note that we saved a word of storage and overwrote
12070 the original st_name with the dynstr_index. */
12072 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
12074 s
= bfd_section_from_elf_index (e
->input_bfd
,
12079 elf_section_data (s
->output_section
)->this_idx
;
12080 if (! check_dynsym (abfd
, &sym
))
12082 sym
.st_value
= (s
->output_section
->vma
12084 + e
->isym
.st_value
);
12087 dest
= dynsym
+ e
->dynindx
* bed
->s
->sizeof_sym
;
12088 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
12093 /* We get the global symbols from the hash table. */
12094 eoinfo
.failed
= FALSE
;
12095 eoinfo
.localsyms
= FALSE
;
12096 eoinfo
.flinfo
= &flinfo
;
12097 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
12101 /* If backend needs to output some symbols not present in the hash
12102 table, do it now. */
12103 if (bed
->elf_backend_output_arch_syms
12104 && (info
->strip
!= strip_all
|| emit_relocs
))
12106 typedef int (*out_sym_func
)
12107 (void *, const char *, Elf_Internal_Sym
*, asection
*,
12108 struct elf_link_hash_entry
*);
12110 if (! ((*bed
->elf_backend_output_arch_syms
)
12111 (abfd
, info
, &flinfo
,
12112 (out_sym_func
) elf_link_output_symstrtab
)))
12116 /* Finalize the .strtab section. */
12117 _bfd_elf_strtab_finalize (flinfo
.symstrtab
);
12119 /* Swap out the .strtab section. */
12120 if (!elf_link_swap_symbols_out (&flinfo
))
12123 /* Now we know the size of the symtab section. */
12124 if (bfd_get_symcount (abfd
) > 0)
12126 /* Finish up and write out the symbol string table (.strtab)
12128 Elf_Internal_Shdr
*symstrtab_hdr
= NULL
;
12129 file_ptr off
= symtab_hdr
->sh_offset
+ symtab_hdr
->sh_size
;
12131 if (elf_symtab_shndx_list (abfd
))
12133 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
12135 if (symtab_shndx_hdr
!= NULL
&& symtab_shndx_hdr
->sh_name
!= 0)
12137 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
12138 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
12139 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
12140 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
12141 symtab_shndx_hdr
->sh_size
= amt
;
12143 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
12146 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
12147 || (bfd_bwrite (flinfo
.symshndxbuf
, amt
, abfd
) != amt
))
12152 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
12153 /* sh_name was set in prep_headers. */
12154 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
12155 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
12156 symstrtab_hdr
->sh_addr
= 0;
12157 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (flinfo
.symstrtab
);
12158 symstrtab_hdr
->sh_entsize
= 0;
12159 symstrtab_hdr
->sh_link
= 0;
12160 symstrtab_hdr
->sh_info
= 0;
12161 /* sh_offset is set just below. */
12162 symstrtab_hdr
->sh_addralign
= 1;
12164 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
,
12166 elf_next_file_pos (abfd
) = off
;
12168 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
12169 || ! _bfd_elf_strtab_emit (abfd
, flinfo
.symstrtab
))
12173 if (info
->out_implib_bfd
&& !elf_output_implib (abfd
, info
))
12175 _bfd_error_handler (_("%B: failed to generate import library"),
12176 info
->out_implib_bfd
);
12180 /* Adjust the relocs to have the correct symbol indices. */
12181 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
12183 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
12186 if ((o
->flags
& SEC_RELOC
) == 0)
12189 sort
= bed
->sort_relocs_p
== NULL
|| (*bed
->sort_relocs_p
) (o
);
12190 if (esdo
->rel
.hdr
!= NULL
12191 && !elf_link_adjust_relocs (abfd
, o
, &esdo
->rel
, sort
, info
))
12193 if (esdo
->rela
.hdr
!= NULL
12194 && !elf_link_adjust_relocs (abfd
, o
, &esdo
->rela
, sort
, info
))
12197 /* Set the reloc_count field to 0 to prevent write_relocs from
12198 trying to swap the relocs out itself. */
12199 o
->reloc_count
= 0;
12202 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
12203 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
12205 /* If we are linking against a dynamic object, or generating a
12206 shared library, finish up the dynamic linking information. */
12209 bfd_byte
*dyncon
, *dynconend
;
12211 /* Fix up .dynamic entries. */
12212 o
= bfd_get_linker_section (dynobj
, ".dynamic");
12213 BFD_ASSERT (o
!= NULL
);
12215 dyncon
= o
->contents
;
12216 dynconend
= o
->contents
+ o
->size
;
12217 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
12219 Elf_Internal_Dyn dyn
;
12222 bfd_size_type sh_size
;
12225 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
12232 if (relativecount
> 0 && dyncon
+ bed
->s
->sizeof_dyn
< dynconend
)
12234 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
12236 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
12237 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
12240 dyn
.d_un
.d_val
= relativecount
;
12247 name
= info
->init_function
;
12250 name
= info
->fini_function
;
12253 struct elf_link_hash_entry
*h
;
12255 h
= elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
12257 && (h
->root
.type
== bfd_link_hash_defined
12258 || h
->root
.type
== bfd_link_hash_defweak
))
12260 dyn
.d_un
.d_ptr
= h
->root
.u
.def
.value
;
12261 o
= h
->root
.u
.def
.section
;
12262 if (o
->output_section
!= NULL
)
12263 dyn
.d_un
.d_ptr
+= (o
->output_section
->vma
12264 + o
->output_offset
);
12267 /* The symbol is imported from another shared
12268 library and does not apply to this one. */
12269 dyn
.d_un
.d_ptr
= 0;
12276 case DT_PREINIT_ARRAYSZ
:
12277 name
= ".preinit_array";
12279 case DT_INIT_ARRAYSZ
:
12280 name
= ".init_array";
12282 case DT_FINI_ARRAYSZ
:
12283 name
= ".fini_array";
12285 o
= bfd_get_section_by_name (abfd
, name
);
12289 (_("could not find section %s"), name
);
12294 (_("warning: %s section has zero size"), name
);
12295 dyn
.d_un
.d_val
= o
->size
;
12298 case DT_PREINIT_ARRAY
:
12299 name
= ".preinit_array";
12301 case DT_INIT_ARRAY
:
12302 name
= ".init_array";
12304 case DT_FINI_ARRAY
:
12305 name
= ".fini_array";
12307 o
= bfd_get_section_by_name (abfd
, name
);
12314 name
= ".gnu.hash";
12323 name
= ".gnu.version_d";
12326 name
= ".gnu.version_r";
12329 name
= ".gnu.version";
12331 o
= bfd_get_linker_section (dynobj
, name
);
12336 (_("could not find section %s"), name
);
12339 if (elf_section_data (o
->output_section
)->this_hdr
.sh_type
== SHT_NOTE
)
12342 (_("warning: section '%s' is being made into a note"), name
);
12343 bfd_set_error (bfd_error_nonrepresentable_section
);
12346 dyn
.d_un
.d_ptr
= o
->output_section
->vma
+ o
->output_offset
;
12353 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
12359 for (i
= 1; i
< elf_numsections (abfd
); i
++)
12361 Elf_Internal_Shdr
*hdr
;
12363 hdr
= elf_elfsections (abfd
)[i
];
12364 if (hdr
->sh_type
== type
12365 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
12367 sh_size
+= hdr
->sh_size
;
12369 || sh_addr
> hdr
->sh_addr
)
12370 sh_addr
= hdr
->sh_addr
;
12374 if (bed
->dtrel_excludes_plt
&& htab
->srelplt
!= NULL
)
12376 /* Don't count procedure linkage table relocs in the
12377 overall reloc count. */
12378 sh_size
-= htab
->srelplt
->size
;
12380 /* If the size is zero, make the address zero too.
12381 This is to avoid a glibc bug. If the backend
12382 emits DT_RELA/DT_RELASZ even when DT_RELASZ is
12383 zero, then we'll put DT_RELA at the end of
12384 DT_JMPREL. glibc will interpret the end of
12385 DT_RELA matching the end of DT_JMPREL as the
12386 case where DT_RELA includes DT_JMPREL, and for
12387 LD_BIND_NOW will decide that processing DT_RELA
12388 will process the PLT relocs too. Net result:
12389 No PLT relocs applied. */
12392 /* If .rela.plt is the first .rela section, exclude
12393 it from DT_RELA. */
12394 else if (sh_addr
== (htab
->srelplt
->output_section
->vma
12395 + htab
->srelplt
->output_offset
))
12396 sh_addr
+= htab
->srelplt
->size
;
12399 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
12400 dyn
.d_un
.d_val
= sh_size
;
12402 dyn
.d_un
.d_ptr
= sh_addr
;
12405 bed
->s
->swap_dyn_out (dynobj
, &dyn
, dyncon
);
12409 /* If we have created any dynamic sections, then output them. */
12410 if (dynobj
!= NULL
)
12412 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
12415 /* Check for DT_TEXTREL (late, in case the backend removes it). */
12416 if (((info
->warn_shared_textrel
&& bfd_link_pic (info
))
12417 || info
->error_textrel
)
12418 && (o
= bfd_get_linker_section (dynobj
, ".dynamic")) != NULL
)
12420 bfd_byte
*dyncon
, *dynconend
;
12422 dyncon
= o
->contents
;
12423 dynconend
= o
->contents
+ o
->size
;
12424 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
12426 Elf_Internal_Dyn dyn
;
12428 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
12430 if (dyn
.d_tag
== DT_TEXTREL
)
12432 if (info
->error_textrel
)
12433 info
->callbacks
->einfo
12434 (_("%P%X: read-only segment has dynamic relocations.\n"));
12436 info
->callbacks
->einfo
12437 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
12443 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
12445 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
12447 || o
->output_section
== bfd_abs_section_ptr
)
12449 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
12451 /* At this point, we are only interested in sections
12452 created by _bfd_elf_link_create_dynamic_sections. */
12455 if (htab
->stab_info
.stabstr
== o
)
12457 if (htab
->eh_info
.hdr_sec
== o
)
12459 if (strcmp (o
->name
, ".dynstr") != 0)
12461 if (! bfd_set_section_contents (abfd
, o
->output_section
,
12463 (file_ptr
) o
->output_offset
12464 * bfd_octets_per_byte (abfd
),
12470 /* The contents of the .dynstr section are actually in a
12474 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
12475 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
12476 || !_bfd_elf_strtab_emit (abfd
, htab
->dynstr
))
12482 if (!info
->resolve_section_groups
)
12484 bfd_boolean failed
= FALSE
;
12486 BFD_ASSERT (bfd_link_relocatable (info
));
12487 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
12492 /* If we have optimized stabs strings, output them. */
12493 if (htab
->stab_info
.stabstr
!= NULL
)
12495 if (!_bfd_write_stab_strings (abfd
, &htab
->stab_info
))
12499 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
12502 elf_final_link_free (abfd
, &flinfo
);
12504 elf_linker (abfd
) = TRUE
;
12508 bfd_byte
*contents
= (bfd_byte
*) bfd_malloc (attr_size
);
12509 if (contents
== NULL
)
12510 return FALSE
; /* Bail out and fail. */
12511 bfd_elf_set_obj_attr_contents (abfd
, contents
, attr_size
);
12512 bfd_set_section_contents (abfd
, attr_section
, contents
, 0, attr_size
);
12519 elf_final_link_free (abfd
, &flinfo
);
12523 /* Initialize COOKIE for input bfd ABFD. */
12526 init_reloc_cookie (struct elf_reloc_cookie
*cookie
,
12527 struct bfd_link_info
*info
, bfd
*abfd
)
12529 Elf_Internal_Shdr
*symtab_hdr
;
12530 const struct elf_backend_data
*bed
;
12532 bed
= get_elf_backend_data (abfd
);
12533 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
12535 cookie
->abfd
= abfd
;
12536 cookie
->sym_hashes
= elf_sym_hashes (abfd
);
12537 cookie
->bad_symtab
= elf_bad_symtab (abfd
);
12538 if (cookie
->bad_symtab
)
12540 cookie
->locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
12541 cookie
->extsymoff
= 0;
12545 cookie
->locsymcount
= symtab_hdr
->sh_info
;
12546 cookie
->extsymoff
= symtab_hdr
->sh_info
;
12549 if (bed
->s
->arch_size
== 32)
12550 cookie
->r_sym_shift
= 8;
12552 cookie
->r_sym_shift
= 32;
12554 cookie
->locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
12555 if (cookie
->locsyms
== NULL
&& cookie
->locsymcount
!= 0)
12557 cookie
->locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
12558 cookie
->locsymcount
, 0,
12560 if (cookie
->locsyms
== NULL
)
12562 info
->callbacks
->einfo (_("%P%X: can not read symbols: %E\n"));
12565 if (info
->keep_memory
)
12566 symtab_hdr
->contents
= (bfd_byte
*) cookie
->locsyms
;
12571 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
12574 fini_reloc_cookie (struct elf_reloc_cookie
*cookie
, bfd
*abfd
)
12576 Elf_Internal_Shdr
*symtab_hdr
;
12578 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
12579 if (cookie
->locsyms
!= NULL
12580 && symtab_hdr
->contents
!= (unsigned char *) cookie
->locsyms
)
12581 free (cookie
->locsyms
);
12584 /* Initialize the relocation information in COOKIE for input section SEC
12585 of input bfd ABFD. */
12588 init_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
12589 struct bfd_link_info
*info
, bfd
*abfd
,
12592 if (sec
->reloc_count
== 0)
12594 cookie
->rels
= NULL
;
12595 cookie
->relend
= NULL
;
12599 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
12600 info
->keep_memory
);
12601 if (cookie
->rels
== NULL
)
12603 cookie
->rel
= cookie
->rels
;
12604 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
12606 cookie
->rel
= cookie
->rels
;
12610 /* Free the memory allocated by init_reloc_cookie_rels,
12614 fini_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
12617 if (cookie
->rels
&& elf_section_data (sec
)->relocs
!= cookie
->rels
)
12618 free (cookie
->rels
);
12621 /* Initialize the whole of COOKIE for input section SEC. */
12624 init_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
12625 struct bfd_link_info
*info
,
12628 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
12630 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
12635 fini_reloc_cookie (cookie
, sec
->owner
);
12640 /* Free the memory allocated by init_reloc_cookie_for_section,
12644 fini_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
12647 fini_reloc_cookie_rels (cookie
, sec
);
12648 fini_reloc_cookie (cookie
, sec
->owner
);
12651 /* Garbage collect unused sections. */
12653 /* Default gc_mark_hook. */
12656 _bfd_elf_gc_mark_hook (asection
*sec
,
12657 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12658 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
12659 struct elf_link_hash_entry
*h
,
12660 Elf_Internal_Sym
*sym
)
12664 switch (h
->root
.type
)
12666 case bfd_link_hash_defined
:
12667 case bfd_link_hash_defweak
:
12668 return h
->root
.u
.def
.section
;
12670 case bfd_link_hash_common
:
12671 return h
->root
.u
.c
.p
->section
;
12678 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
12683 /* Return the global debug definition section. */
12686 elf_gc_mark_debug_section (asection
*sec ATTRIBUTE_UNUSED
,
12687 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12688 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
12689 struct elf_link_hash_entry
*h
,
12690 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
12693 && (h
->root
.type
== bfd_link_hash_defined
12694 || h
->root
.type
== bfd_link_hash_defweak
)
12695 && (h
->root
.u
.def
.section
->flags
& SEC_DEBUGGING
) != 0)
12696 return h
->root
.u
.def
.section
;
12701 /* COOKIE->rel describes a relocation against section SEC, which is
12702 a section we've decided to keep. Return the section that contains
12703 the relocation symbol, or NULL if no section contains it. */
12706 _bfd_elf_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
12707 elf_gc_mark_hook_fn gc_mark_hook
,
12708 struct elf_reloc_cookie
*cookie
,
12709 bfd_boolean
*start_stop
)
12711 unsigned long r_symndx
;
12712 struct elf_link_hash_entry
*h
;
12714 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
12715 if (r_symndx
== STN_UNDEF
)
12718 if (r_symndx
>= cookie
->locsymcount
12719 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
12721 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
12724 info
->callbacks
->einfo (_("%F%P: corrupt input: %B\n"),
12728 while (h
->root
.type
== bfd_link_hash_indirect
12729 || h
->root
.type
== bfd_link_hash_warning
)
12730 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
12732 /* If this symbol is weak and there is a non-weak definition, we
12733 keep the non-weak definition because many backends put
12734 dynamic reloc info on the non-weak definition for code
12735 handling copy relocs. */
12736 if (h
->u
.weakdef
!= NULL
)
12737 h
->u
.weakdef
->mark
= 1;
12739 if (start_stop
!= NULL
)
12741 /* To work around a glibc bug, mark XXX input sections
12742 when there is a reference to __start_XXX or __stop_XXX
12746 asection
*s
= h
->u2
.start_stop_section
;
12747 *start_stop
= !s
->gc_mark
;
12752 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
12755 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
12756 &cookie
->locsyms
[r_symndx
]);
12759 /* COOKIE->rel describes a relocation against section SEC, which is
12760 a section we've decided to keep. Mark the section that contains
12761 the relocation symbol. */
12764 _bfd_elf_gc_mark_reloc (struct bfd_link_info
*info
,
12766 elf_gc_mark_hook_fn gc_mark_hook
,
12767 struct elf_reloc_cookie
*cookie
)
12770 bfd_boolean start_stop
= FALSE
;
12772 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
, &start_stop
);
12773 while (rsec
!= NULL
)
12775 if (!rsec
->gc_mark
)
12777 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
12778 || (rsec
->owner
->flags
& DYNAMIC
) != 0)
12780 else if (!_bfd_elf_gc_mark (info
, rsec
, gc_mark_hook
))
12785 rsec
= bfd_get_next_section_by_name (rsec
->owner
, rsec
);
12790 /* The mark phase of garbage collection. For a given section, mark
12791 it and any sections in this section's group, and all the sections
12792 which define symbols to which it refers. */
12795 _bfd_elf_gc_mark (struct bfd_link_info
*info
,
12797 elf_gc_mark_hook_fn gc_mark_hook
)
12800 asection
*group_sec
, *eh_frame
;
12804 /* Mark all the sections in the group. */
12805 group_sec
= elf_section_data (sec
)->next_in_group
;
12806 if (group_sec
&& !group_sec
->gc_mark
)
12807 if (!_bfd_elf_gc_mark (info
, group_sec
, gc_mark_hook
))
12810 /* Look through the section relocs. */
12812 eh_frame
= elf_eh_frame_section (sec
->owner
);
12813 if ((sec
->flags
& SEC_RELOC
) != 0
12814 && sec
->reloc_count
> 0
12815 && sec
!= eh_frame
)
12817 struct elf_reloc_cookie cookie
;
12819 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
12823 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
12824 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
12829 fini_reloc_cookie_for_section (&cookie
, sec
);
12833 if (ret
&& eh_frame
&& elf_fde_list (sec
))
12835 struct elf_reloc_cookie cookie
;
12837 if (!init_reloc_cookie_for_section (&cookie
, info
, eh_frame
))
12841 if (!_bfd_elf_gc_mark_fdes (info
, sec
, eh_frame
,
12842 gc_mark_hook
, &cookie
))
12844 fini_reloc_cookie_for_section (&cookie
, eh_frame
);
12848 eh_frame
= elf_section_eh_frame_entry (sec
);
12849 if (ret
&& eh_frame
&& !eh_frame
->gc_mark
)
12850 if (!_bfd_elf_gc_mark (info
, eh_frame
, gc_mark_hook
))
12856 /* Scan and mark sections in a special or debug section group. */
12859 _bfd_elf_gc_mark_debug_special_section_group (asection
*grp
)
12861 /* Point to first section of section group. */
12863 /* Used to iterate the section group. */
12866 bfd_boolean is_special_grp
= TRUE
;
12867 bfd_boolean is_debug_grp
= TRUE
;
12869 /* First scan to see if group contains any section other than debug
12870 and special section. */
12871 ssec
= msec
= elf_next_in_group (grp
);
12874 if ((msec
->flags
& SEC_DEBUGGING
) == 0)
12875 is_debug_grp
= FALSE
;
12877 if ((msec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) != 0)
12878 is_special_grp
= FALSE
;
12880 msec
= elf_next_in_group (msec
);
12882 while (msec
!= ssec
);
12884 /* If this is a pure debug section group or pure special section group,
12885 keep all sections in this group. */
12886 if (is_debug_grp
|| is_special_grp
)
12891 msec
= elf_next_in_group (msec
);
12893 while (msec
!= ssec
);
12897 /* Keep debug and special sections. */
12900 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
12901 elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
12905 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12908 bfd_boolean some_kept
;
12909 bfd_boolean debug_frag_seen
;
12910 bfd_boolean has_kept_debug_info
;
12912 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
12915 /* Ensure all linker created sections are kept,
12916 see if any other section is already marked,
12917 and note if we have any fragmented debug sections. */
12918 debug_frag_seen
= some_kept
= has_kept_debug_info
= FALSE
;
12919 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
12921 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12923 else if (isec
->gc_mark
12924 && (isec
->flags
& SEC_ALLOC
) != 0
12925 && elf_section_type (isec
) != SHT_NOTE
)
12928 if (!debug_frag_seen
12929 && (isec
->flags
& SEC_DEBUGGING
)
12930 && CONST_STRNEQ (isec
->name
, ".debug_line."))
12931 debug_frag_seen
= TRUE
;
12934 /* If no non-note alloc section in this file will be kept, then
12935 we can toss out the debug and special sections. */
12939 /* Keep debug and special sections like .comment when they are
12940 not part of a group. Also keep section groups that contain
12941 just debug sections or special sections. */
12942 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
12944 if ((isec
->flags
& SEC_GROUP
) != 0)
12945 _bfd_elf_gc_mark_debug_special_section_group (isec
);
12946 else if (((isec
->flags
& SEC_DEBUGGING
) != 0
12947 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
12948 && elf_next_in_group (isec
) == NULL
)
12950 if (isec
->gc_mark
&& (isec
->flags
& SEC_DEBUGGING
) != 0)
12951 has_kept_debug_info
= TRUE
;
12954 /* Look for CODE sections which are going to be discarded,
12955 and find and discard any fragmented debug sections which
12956 are associated with that code section. */
12957 if (debug_frag_seen
)
12958 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
12959 if ((isec
->flags
& SEC_CODE
) != 0
12960 && isec
->gc_mark
== 0)
12965 ilen
= strlen (isec
->name
);
12967 /* Association is determined by the name of the debug
12968 section containing the name of the code section as
12969 a suffix. For example .debug_line.text.foo is a
12970 debug section associated with .text.foo. */
12971 for (dsec
= ibfd
->sections
; dsec
!= NULL
; dsec
= dsec
->next
)
12975 if (dsec
->gc_mark
== 0
12976 || (dsec
->flags
& SEC_DEBUGGING
) == 0)
12979 dlen
= strlen (dsec
->name
);
12982 && strncmp (dsec
->name
+ (dlen
- ilen
),
12983 isec
->name
, ilen
) == 0)
12988 /* Mark debug sections referenced by kept debug sections. */
12989 if (has_kept_debug_info
)
12990 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
12992 && (isec
->flags
& SEC_DEBUGGING
) != 0)
12993 if (!_bfd_elf_gc_mark (info
, isec
,
12994 elf_gc_mark_debug_section
))
13000 /* The sweep phase of garbage collection. Remove all garbage sections. */
13002 typedef bfd_boolean (*gc_sweep_hook_fn
)
13003 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
13006 elf_gc_sweep (bfd
*abfd
, struct bfd_link_info
*info
)
13009 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13010 gc_sweep_hook_fn gc_sweep_hook
= bed
->gc_sweep_hook
;
13012 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
13016 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
13017 || !(*bed
->relocs_compatible
) (sub
->xvec
, abfd
->xvec
))
13020 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
13022 /* When any section in a section group is kept, we keep all
13023 sections in the section group. If the first member of
13024 the section group is excluded, we will also exclude the
13026 if (o
->flags
& SEC_GROUP
)
13028 asection
*first
= elf_next_in_group (o
);
13029 o
->gc_mark
= first
->gc_mark
;
13035 /* Skip sweeping sections already excluded. */
13036 if (o
->flags
& SEC_EXCLUDE
)
13039 /* Since this is early in the link process, it is simple
13040 to remove a section from the output. */
13041 o
->flags
|= SEC_EXCLUDE
;
13043 if (info
->print_gc_sections
&& o
->size
!= 0)
13044 /* xgettext:c-format */
13045 _bfd_error_handler (_("Removing unused section '%A' in file '%B'"),
13048 /* But we also have to update some of the relocation
13049 info we collected before. */
13051 && (o
->flags
& SEC_RELOC
) != 0
13052 && o
->reloc_count
!= 0
13053 && !((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
13054 && (o
->flags
& SEC_DEBUGGING
) != 0)
13055 && !bfd_is_abs_section (o
->output_section
))
13057 Elf_Internal_Rela
*internal_relocs
;
13061 = _bfd_elf_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
13062 info
->keep_memory
);
13063 if (internal_relocs
== NULL
)
13066 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
13068 if (elf_section_data (o
)->relocs
!= internal_relocs
)
13069 free (internal_relocs
);
13080 /* Propagate collected vtable information. This is called through
13081 elf_link_hash_traverse. */
13084 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
13086 /* Those that are not vtables. */
13088 || h
->u2
.vtable
== NULL
13089 || h
->u2
.vtable
->parent
== NULL
)
13092 /* Those vtables that do not have parents, we cannot merge. */
13093 if (h
->u2
.vtable
->parent
== (struct elf_link_hash_entry
*) -1)
13096 /* If we've already been done, exit. */
13097 if (h
->u2
.vtable
->used
&& h
->u2
.vtable
->used
[-1])
13100 /* Make sure the parent's table is up to date. */
13101 elf_gc_propagate_vtable_entries_used (h
->u2
.vtable
->parent
, okp
);
13103 if (h
->u2
.vtable
->used
== NULL
)
13105 /* None of this table's entries were referenced. Re-use the
13107 h
->u2
.vtable
->used
= h
->u2
.vtable
->parent
->u2
.vtable
->used
;
13108 h
->u2
.vtable
->size
= h
->u2
.vtable
->parent
->u2
.vtable
->size
;
13113 bfd_boolean
*cu
, *pu
;
13115 /* Or the parent's entries into ours. */
13116 cu
= h
->u2
.vtable
->used
;
13118 pu
= h
->u2
.vtable
->parent
->u2
.vtable
->used
;
13121 const struct elf_backend_data
*bed
;
13122 unsigned int log_file_align
;
13124 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
13125 log_file_align
= bed
->s
->log_file_align
;
13126 n
= h
->u2
.vtable
->parent
->u2
.vtable
->size
>> log_file_align
;
13141 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
, void *okp
)
13144 bfd_vma hstart
, hend
;
13145 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
13146 const struct elf_backend_data
*bed
;
13147 unsigned int log_file_align
;
13149 /* Take care of both those symbols that do not describe vtables as
13150 well as those that are not loaded. */
13152 || h
->u2
.vtable
== NULL
13153 || h
->u2
.vtable
->parent
== NULL
)
13156 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
13157 || h
->root
.type
== bfd_link_hash_defweak
);
13159 sec
= h
->root
.u
.def
.section
;
13160 hstart
= h
->root
.u
.def
.value
;
13161 hend
= hstart
+ h
->size
;
13163 relstart
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, TRUE
);
13165 return *(bfd_boolean
*) okp
= FALSE
;
13166 bed
= get_elf_backend_data (sec
->owner
);
13167 log_file_align
= bed
->s
->log_file_align
;
13169 relend
= relstart
+ sec
->reloc_count
;
13171 for (rel
= relstart
; rel
< relend
; ++rel
)
13172 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
13174 /* If the entry is in use, do nothing. */
13175 if (h
->u2
.vtable
->used
13176 && (rel
->r_offset
- hstart
) < h
->u2
.vtable
->size
)
13178 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
13179 if (h
->u2
.vtable
->used
[entry
])
13182 /* Otherwise, kill it. */
13183 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
13189 /* Mark sections containing dynamically referenced symbols. When
13190 building shared libraries, we must assume that any visible symbol is
13194 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry
*h
, void *inf
)
13196 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
13197 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
13199 if ((h
->root
.type
== bfd_link_hash_defined
13200 || h
->root
.type
== bfd_link_hash_defweak
)
13202 || ((h
->def_regular
|| ELF_COMMON_DEF_P (h
))
13203 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
13204 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
13205 && (!bfd_link_executable (info
)
13206 || info
->gc_keep_exported
13207 || info
->export_dynamic
13210 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
13211 && (h
->versioned
>= versioned
13212 || !bfd_hide_sym_by_version (info
->version_info
,
13213 h
->root
.root
.string
)))))
13214 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
13219 /* Keep all sections containing symbols undefined on the command-line,
13220 and the section containing the entry symbol. */
13223 _bfd_elf_gc_keep (struct bfd_link_info
*info
)
13225 struct bfd_sym_chain
*sym
;
13227 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
13229 struct elf_link_hash_entry
*h
;
13231 h
= elf_link_hash_lookup (elf_hash_table (info
), sym
->name
,
13232 FALSE
, FALSE
, FALSE
);
13235 && (h
->root
.type
== bfd_link_hash_defined
13236 || h
->root
.type
== bfd_link_hash_defweak
)
13237 && !bfd_is_abs_section (h
->root
.u
.def
.section
)
13238 && !bfd_is_und_section (h
->root
.u
.def
.section
))
13239 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
13244 bfd_elf_parse_eh_frame_entries (bfd
*abfd ATTRIBUTE_UNUSED
,
13245 struct bfd_link_info
*info
)
13247 bfd
*ibfd
= info
->input_bfds
;
13249 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
13252 struct elf_reloc_cookie cookie
;
13254 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
13257 if (!init_reloc_cookie (&cookie
, info
, ibfd
))
13260 for (sec
= ibfd
->sections
; sec
; sec
= sec
->next
)
13262 if (CONST_STRNEQ (bfd_section_name (ibfd
, sec
), ".eh_frame_entry")
13263 && init_reloc_cookie_rels (&cookie
, info
, ibfd
, sec
))
13265 _bfd_elf_parse_eh_frame_entry (info
, sec
, &cookie
);
13266 fini_reloc_cookie_rels (&cookie
, sec
);
13273 /* Do mark and sweep of unused sections. */
13276 bfd_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
13278 bfd_boolean ok
= TRUE
;
13280 elf_gc_mark_hook_fn gc_mark_hook
;
13281 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13282 struct elf_link_hash_table
*htab
;
13284 if (!bed
->can_gc_sections
13285 || !is_elf_hash_table (info
->hash
))
13287 _bfd_error_handler(_("Warning: gc-sections option ignored"));
13291 bed
->gc_keep (info
);
13292 htab
= elf_hash_table (info
);
13294 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
13295 at the .eh_frame section if we can mark the FDEs individually. */
13296 for (sub
= info
->input_bfds
;
13297 info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
&& sub
!= NULL
;
13298 sub
= sub
->link
.next
)
13301 struct elf_reloc_cookie cookie
;
13303 sec
= bfd_get_section_by_name (sub
, ".eh_frame");
13304 while (sec
&& init_reloc_cookie_for_section (&cookie
, info
, sec
))
13306 _bfd_elf_parse_eh_frame (sub
, info
, sec
, &cookie
);
13307 if (elf_section_data (sec
)->sec_info
13308 && (sec
->flags
& SEC_LINKER_CREATED
) == 0)
13309 elf_eh_frame_section (sub
) = sec
;
13310 fini_reloc_cookie_for_section (&cookie
, sec
);
13311 sec
= bfd_get_next_section_by_name (NULL
, sec
);
13315 /* Apply transitive closure to the vtable entry usage info. */
13316 elf_link_hash_traverse (htab
, elf_gc_propagate_vtable_entries_used
, &ok
);
13320 /* Kill the vtable relocations that were not used. */
13321 elf_link_hash_traverse (htab
, elf_gc_smash_unused_vtentry_relocs
, &ok
);
13325 /* Mark dynamically referenced symbols. */
13326 if (htab
->dynamic_sections_created
|| info
->gc_keep_exported
)
13327 elf_link_hash_traverse (htab
, bed
->gc_mark_dynamic_ref
, info
);
13329 /* Grovel through relocs to find out who stays ... */
13330 gc_mark_hook
= bed
->gc_mark_hook
;
13331 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
13335 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
13336 || !(*bed
->relocs_compatible
) (sub
->xvec
, abfd
->xvec
))
13339 /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
13340 Also treat note sections as a root, if the section is not part
13342 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
13344 && (o
->flags
& SEC_EXCLUDE
) == 0
13345 && ((o
->flags
& SEC_KEEP
) != 0
13346 || (elf_section_data (o
)->this_hdr
.sh_type
== SHT_NOTE
13347 && elf_next_in_group (o
) == NULL
)))
13349 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
13354 /* Allow the backend to mark additional target specific sections. */
13355 bed
->gc_mark_extra_sections (info
, gc_mark_hook
);
13357 /* ... and mark SEC_EXCLUDE for those that go. */
13358 return elf_gc_sweep (abfd
, info
);
13361 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
13364 bfd_elf_gc_record_vtinherit (bfd
*abfd
,
13366 struct elf_link_hash_entry
*h
,
13369 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
13370 struct elf_link_hash_entry
**search
, *child
;
13371 size_t extsymcount
;
13372 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13374 /* The sh_info field of the symtab header tells us where the
13375 external symbols start. We don't care about the local symbols at
13377 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/ bed
->s
->sizeof_sym
;
13378 if (!elf_bad_symtab (abfd
))
13379 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
13381 sym_hashes
= elf_sym_hashes (abfd
);
13382 sym_hashes_end
= sym_hashes
+ extsymcount
;
13384 /* Hunt down the child symbol, which is in this section at the same
13385 offset as the relocation. */
13386 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
13388 if ((child
= *search
) != NULL
13389 && (child
->root
.type
== bfd_link_hash_defined
13390 || child
->root
.type
== bfd_link_hash_defweak
)
13391 && child
->root
.u
.def
.section
== sec
13392 && child
->root
.u
.def
.value
== offset
)
13396 /* xgettext:c-format */
13397 _bfd_error_handler (_("%B: %A+%lu: No symbol found for INHERIT"),
13398 abfd
, sec
, (unsigned long) offset
);
13399 bfd_set_error (bfd_error_invalid_operation
);
13403 if (!child
->u2
.vtable
)
13405 child
->u2
.vtable
= ((struct elf_link_virtual_table_entry
*)
13406 bfd_zalloc (abfd
, sizeof (*child
->u2
.vtable
)));
13407 if (!child
->u2
.vtable
)
13412 /* This *should* only be the absolute section. It could potentially
13413 be that someone has defined a non-global vtable though, which
13414 would be bad. It isn't worth paging in the local symbols to be
13415 sure though; that case should simply be handled by the assembler. */
13417 child
->u2
.vtable
->parent
= (struct elf_link_hash_entry
*) -1;
13420 child
->u2
.vtable
->parent
= h
;
13425 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
13428 bfd_elf_gc_record_vtentry (bfd
*abfd ATTRIBUTE_UNUSED
,
13429 asection
*sec ATTRIBUTE_UNUSED
,
13430 struct elf_link_hash_entry
*h
,
13433 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13434 unsigned int log_file_align
= bed
->s
->log_file_align
;
13438 h
->u2
.vtable
= ((struct elf_link_virtual_table_entry
*)
13439 bfd_zalloc (abfd
, sizeof (*h
->u2
.vtable
)));
13444 if (addend
>= h
->u2
.vtable
->size
)
13446 size_t size
, bytes
, file_align
;
13447 bfd_boolean
*ptr
= h
->u2
.vtable
->used
;
13449 /* While the symbol is undefined, we have to be prepared to handle
13451 file_align
= 1 << log_file_align
;
13452 if (h
->root
.type
== bfd_link_hash_undefined
)
13453 size
= addend
+ file_align
;
13457 if (addend
>= size
)
13459 /* Oops! We've got a reference past the defined end of
13460 the table. This is probably a bug -- shall we warn? */
13461 size
= addend
+ file_align
;
13464 size
= (size
+ file_align
- 1) & -file_align
;
13466 /* Allocate one extra entry for use as a "done" flag for the
13467 consolidation pass. */
13468 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bfd_boolean
);
13472 ptr
= (bfd_boolean
*) bfd_realloc (ptr
- 1, bytes
);
13478 oldbytes
= (((h
->u2
.vtable
->size
>> log_file_align
) + 1)
13479 * sizeof (bfd_boolean
));
13480 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
13484 ptr
= (bfd_boolean
*) bfd_zmalloc (bytes
);
13489 /* And arrange for that done flag to be at index -1. */
13490 h
->u2
.vtable
->used
= ptr
+ 1;
13491 h
->u2
.vtable
->size
= size
;
13494 h
->u2
.vtable
->used
[addend
>> log_file_align
] = TRUE
;
13499 /* Map an ELF section header flag to its corresponding string. */
13503 flagword flag_value
;
13504 } elf_flags_to_name_table
;
13506 static elf_flags_to_name_table elf_flags_to_names
[] =
13508 { "SHF_WRITE", SHF_WRITE
},
13509 { "SHF_ALLOC", SHF_ALLOC
},
13510 { "SHF_EXECINSTR", SHF_EXECINSTR
},
13511 { "SHF_MERGE", SHF_MERGE
},
13512 { "SHF_STRINGS", SHF_STRINGS
},
13513 { "SHF_INFO_LINK", SHF_INFO_LINK
},
13514 { "SHF_LINK_ORDER", SHF_LINK_ORDER
},
13515 { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING
},
13516 { "SHF_GROUP", SHF_GROUP
},
13517 { "SHF_TLS", SHF_TLS
},
13518 { "SHF_MASKOS", SHF_MASKOS
},
13519 { "SHF_EXCLUDE", SHF_EXCLUDE
},
13522 /* Returns TRUE if the section is to be included, otherwise FALSE. */
13524 bfd_elf_lookup_section_flags (struct bfd_link_info
*info
,
13525 struct flag_info
*flaginfo
,
13528 const bfd_vma sh_flags
= elf_section_flags (section
);
13530 if (!flaginfo
->flags_initialized
)
13532 bfd
*obfd
= info
->output_bfd
;
13533 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
13534 struct flag_info_list
*tf
= flaginfo
->flag_list
;
13536 int without_hex
= 0;
13538 for (tf
= flaginfo
->flag_list
; tf
!= NULL
; tf
= tf
->next
)
13541 flagword (*lookup
) (char *);
13543 lookup
= bed
->elf_backend_lookup_section_flags_hook
;
13544 if (lookup
!= NULL
)
13546 flagword hexval
= (*lookup
) ((char *) tf
->name
);
13550 if (tf
->with
== with_flags
)
13551 with_hex
|= hexval
;
13552 else if (tf
->with
== without_flags
)
13553 without_hex
|= hexval
;
13558 for (i
= 0; i
< ARRAY_SIZE (elf_flags_to_names
); ++i
)
13560 if (strcmp (tf
->name
, elf_flags_to_names
[i
].flag_name
) == 0)
13562 if (tf
->with
== with_flags
)
13563 with_hex
|= elf_flags_to_names
[i
].flag_value
;
13564 else if (tf
->with
== without_flags
)
13565 without_hex
|= elf_flags_to_names
[i
].flag_value
;
13572 info
->callbacks
->einfo
13573 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf
->name
);
13577 flaginfo
->flags_initialized
= TRUE
;
13578 flaginfo
->only_with_flags
|= with_hex
;
13579 flaginfo
->not_with_flags
|= without_hex
;
13582 if ((flaginfo
->only_with_flags
& sh_flags
) != flaginfo
->only_with_flags
)
13585 if ((flaginfo
->not_with_flags
& sh_flags
) != 0)
13591 struct alloc_got_off_arg
{
13593 struct bfd_link_info
*info
;
13596 /* We need a special top-level link routine to convert got reference counts
13597 to real got offsets. */
13600 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *arg
)
13602 struct alloc_got_off_arg
*gofarg
= (struct alloc_got_off_arg
*) arg
;
13603 bfd
*obfd
= gofarg
->info
->output_bfd
;
13604 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
13606 if (h
->got
.refcount
> 0)
13608 h
->got
.offset
= gofarg
->gotoff
;
13609 gofarg
->gotoff
+= bed
->got_elt_size (obfd
, gofarg
->info
, h
, NULL
, 0);
13612 h
->got
.offset
= (bfd_vma
) -1;
13617 /* And an accompanying bit to work out final got entry offsets once
13618 we're done. Should be called from final_link. */
13621 bfd_elf_gc_common_finalize_got_offsets (bfd
*abfd
,
13622 struct bfd_link_info
*info
)
13625 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13627 struct alloc_got_off_arg gofarg
;
13629 BFD_ASSERT (abfd
== info
->output_bfd
);
13631 if (! is_elf_hash_table (info
->hash
))
13634 /* The GOT offset is relative to the .got section, but the GOT header is
13635 put into the .got.plt section, if the backend uses it. */
13636 if (bed
->want_got_plt
)
13639 gotoff
= bed
->got_header_size
;
13641 /* Do the local .got entries first. */
13642 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
13644 bfd_signed_vma
*local_got
;
13645 size_t j
, locsymcount
;
13646 Elf_Internal_Shdr
*symtab_hdr
;
13648 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
13651 local_got
= elf_local_got_refcounts (i
);
13655 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
13656 if (elf_bad_symtab (i
))
13657 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
13659 locsymcount
= symtab_hdr
->sh_info
;
13661 for (j
= 0; j
< locsymcount
; ++j
)
13663 if (local_got
[j
] > 0)
13665 local_got
[j
] = gotoff
;
13666 gotoff
+= bed
->got_elt_size (abfd
, info
, NULL
, i
, j
);
13669 local_got
[j
] = (bfd_vma
) -1;
13673 /* Then the global .got entries. .plt refcounts are handled by
13674 adjust_dynamic_symbol */
13675 gofarg
.gotoff
= gotoff
;
13676 gofarg
.info
= info
;
13677 elf_link_hash_traverse (elf_hash_table (info
),
13678 elf_gc_allocate_got_offsets
,
13683 /* Many folk need no more in the way of final link than this, once
13684 got entry reference counting is enabled. */
13687 bfd_elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
13689 if (!bfd_elf_gc_common_finalize_got_offsets (abfd
, info
))
13692 /* Invoke the regular ELF backend linker to do all the work. */
13693 return bfd_elf_final_link (abfd
, info
);
13697 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
13699 struct elf_reloc_cookie
*rcookie
= (struct elf_reloc_cookie
*) cookie
;
13701 if (rcookie
->bad_symtab
)
13702 rcookie
->rel
= rcookie
->rels
;
13704 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
13706 unsigned long r_symndx
;
13708 if (! rcookie
->bad_symtab
)
13709 if (rcookie
->rel
->r_offset
> offset
)
13711 if (rcookie
->rel
->r_offset
!= offset
)
13714 r_symndx
= rcookie
->rel
->r_info
>> rcookie
->r_sym_shift
;
13715 if (r_symndx
== STN_UNDEF
)
13718 if (r_symndx
>= rcookie
->locsymcount
13719 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
13721 struct elf_link_hash_entry
*h
;
13723 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
13725 while (h
->root
.type
== bfd_link_hash_indirect
13726 || h
->root
.type
== bfd_link_hash_warning
)
13727 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
13729 if ((h
->root
.type
== bfd_link_hash_defined
13730 || h
->root
.type
== bfd_link_hash_defweak
)
13731 && (h
->root
.u
.def
.section
->owner
!= rcookie
->abfd
13732 || h
->root
.u
.def
.section
->kept_section
!= NULL
13733 || discarded_section (h
->root
.u
.def
.section
)))
13738 /* It's not a relocation against a global symbol,
13739 but it could be a relocation against a local
13740 symbol for a discarded section. */
13742 Elf_Internal_Sym
*isym
;
13744 /* Need to: get the symbol; get the section. */
13745 isym
= &rcookie
->locsyms
[r_symndx
];
13746 isec
= bfd_section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
13748 && (isec
->kept_section
!= NULL
13749 || discarded_section (isec
)))
13757 /* Discard unneeded references to discarded sections.
13758 Returns -1 on error, 1 if any section's size was changed, 0 if
13759 nothing changed. This function assumes that the relocations are in
13760 sorted order, which is true for all known assemblers. */
13763 bfd_elf_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
13765 struct elf_reloc_cookie cookie
;
13770 if (info
->traditional_format
13771 || !is_elf_hash_table (info
->hash
))
13774 o
= bfd_get_section_by_name (output_bfd
, ".stab");
13779 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
13782 || i
->reloc_count
== 0
13783 || i
->sec_info_type
!= SEC_INFO_TYPE_STABS
)
13787 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
13790 if (!init_reloc_cookie_for_section (&cookie
, info
, i
))
13793 if (_bfd_discard_section_stabs (abfd
, i
,
13794 elf_section_data (i
)->sec_info
,
13795 bfd_elf_reloc_symbol_deleted_p
,
13799 fini_reloc_cookie_for_section (&cookie
, i
);
13804 if (info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
)
13805 o
= bfd_get_section_by_name (output_bfd
, ".eh_frame");
13809 int eh_changed
= 0;
13811 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
13817 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
13820 if (!init_reloc_cookie_for_section (&cookie
, info
, i
))
13823 _bfd_elf_parse_eh_frame (abfd
, info
, i
, &cookie
);
13824 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, i
,
13825 bfd_elf_reloc_symbol_deleted_p
,
13829 if (i
->size
!= i
->rawsize
)
13833 fini_reloc_cookie_for_section (&cookie
, i
);
13836 elf_link_hash_traverse (elf_hash_table (info
),
13837 _bfd_elf_adjust_eh_frame_global_symbol
, NULL
);
13840 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
13842 const struct elf_backend_data
*bed
;
13844 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
13847 bed
= get_elf_backend_data (abfd
);
13849 if (bed
->elf_backend_discard_info
!= NULL
)
13851 if (!init_reloc_cookie (&cookie
, info
, abfd
))
13854 if ((*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
13857 fini_reloc_cookie (&cookie
, abfd
);
13861 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
13862 _bfd_elf_end_eh_frame_parsing (info
);
13864 if (info
->eh_frame_hdr_type
13865 && !bfd_link_relocatable (info
)
13866 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
13873 _bfd_elf_section_already_linked (bfd
*abfd
,
13875 struct bfd_link_info
*info
)
13878 const char *name
, *key
;
13879 struct bfd_section_already_linked
*l
;
13880 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
13882 if (sec
->output_section
== bfd_abs_section_ptr
)
13885 flags
= sec
->flags
;
13887 /* Return if it isn't a linkonce section. A comdat group section
13888 also has SEC_LINK_ONCE set. */
13889 if ((flags
& SEC_LINK_ONCE
) == 0)
13892 /* Don't put group member sections on our list of already linked
13893 sections. They are handled as a group via their group section. */
13894 if (elf_sec_group (sec
) != NULL
)
13897 /* For a SHT_GROUP section, use the group signature as the key. */
13899 if ((flags
& SEC_GROUP
) != 0
13900 && elf_next_in_group (sec
) != NULL
13901 && elf_group_name (elf_next_in_group (sec
)) != NULL
)
13902 key
= elf_group_name (elf_next_in_group (sec
));
13905 /* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */
13906 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
13907 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
13910 /* Must be a user linkonce section that doesn't follow gcc's
13911 naming convention. In this case we won't be matching
13912 single member groups. */
13916 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
13918 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
13920 /* We may have 2 different types of sections on the list: group
13921 sections with a signature of <key> (<key> is some string),
13922 and linkonce sections named .gnu.linkonce.<type>.<key>.
13923 Match like sections. LTO plugin sections are an exception.
13924 They are always named .gnu.linkonce.t.<key> and match either
13925 type of section. */
13926 if (((flags
& SEC_GROUP
) == (l
->sec
->flags
& SEC_GROUP
)
13927 && ((flags
& SEC_GROUP
) != 0
13928 || strcmp (name
, l
->sec
->name
) == 0))
13929 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
13931 /* The section has already been linked. See if we should
13932 issue a warning. */
13933 if (!_bfd_handle_already_linked (sec
, l
, info
))
13936 if (flags
& SEC_GROUP
)
13938 asection
*first
= elf_next_in_group (sec
);
13939 asection
*s
= first
;
13943 s
->output_section
= bfd_abs_section_ptr
;
13944 /* Record which group discards it. */
13945 s
->kept_section
= l
->sec
;
13946 s
= elf_next_in_group (s
);
13947 /* These lists are circular. */
13957 /* A single member comdat group section may be discarded by a
13958 linkonce section and vice versa. */
13959 if ((flags
& SEC_GROUP
) != 0)
13961 asection
*first
= elf_next_in_group (sec
);
13963 if (first
!= NULL
&& elf_next_in_group (first
) == first
)
13964 /* Check this single member group against linkonce sections. */
13965 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
13966 if ((l
->sec
->flags
& SEC_GROUP
) == 0
13967 && bfd_elf_match_symbols_in_sections (l
->sec
, first
, info
))
13969 first
->output_section
= bfd_abs_section_ptr
;
13970 first
->kept_section
= l
->sec
;
13971 sec
->output_section
= bfd_abs_section_ptr
;
13976 /* Check this linkonce section against single member groups. */
13977 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
13978 if (l
->sec
->flags
& SEC_GROUP
)
13980 asection
*first
= elf_next_in_group (l
->sec
);
13983 && elf_next_in_group (first
) == first
13984 && bfd_elf_match_symbols_in_sections (first
, sec
, info
))
13986 sec
->output_section
= bfd_abs_section_ptr
;
13987 sec
->kept_section
= first
;
13992 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
13993 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
13994 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
13995 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
13996 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
13997 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
13998 `.gnu.linkonce.t.F' section from a different bfd not requiring any
13999 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
14000 The reverse order cannot happen as there is never a bfd with only the
14001 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
14002 matter as here were are looking only for cross-bfd sections. */
14004 if ((flags
& SEC_GROUP
) == 0 && CONST_STRNEQ (name
, ".gnu.linkonce.r."))
14005 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
14006 if ((l
->sec
->flags
& SEC_GROUP
) == 0
14007 && CONST_STRNEQ (l
->sec
->name
, ".gnu.linkonce.t."))
14009 if (abfd
!= l
->sec
->owner
)
14010 sec
->output_section
= bfd_abs_section_ptr
;
14014 /* This is the first section with this name. Record it. */
14015 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
14016 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
14017 return sec
->output_section
== bfd_abs_section_ptr
;
14021 _bfd_elf_common_definition (Elf_Internal_Sym
*sym
)
14023 return sym
->st_shndx
== SHN_COMMON
;
14027 _bfd_elf_common_section_index (asection
*sec ATTRIBUTE_UNUSED
)
14033 _bfd_elf_common_section (asection
*sec ATTRIBUTE_UNUSED
)
14035 return bfd_com_section_ptr
;
14039 _bfd_elf_default_got_elt_size (bfd
*abfd
,
14040 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
14041 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
14042 bfd
*ibfd ATTRIBUTE_UNUSED
,
14043 unsigned long symndx ATTRIBUTE_UNUSED
)
14045 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14046 return bed
->s
->arch_size
/ 8;
14049 /* Routines to support the creation of dynamic relocs. */
14051 /* Returns the name of the dynamic reloc section associated with SEC. */
14053 static const char *
14054 get_dynamic_reloc_section_name (bfd
* abfd
,
14056 bfd_boolean is_rela
)
14059 const char *old_name
= bfd_get_section_name (NULL
, sec
);
14060 const char *prefix
= is_rela
? ".rela" : ".rel";
14062 if (old_name
== NULL
)
14065 name
= bfd_alloc (abfd
, strlen (prefix
) + strlen (old_name
) + 1);
14066 sprintf (name
, "%s%s", prefix
, old_name
);
14071 /* Returns the dynamic reloc section associated with SEC.
14072 If necessary compute the name of the dynamic reloc section based
14073 on SEC's name (looked up in ABFD's string table) and the setting
14077 _bfd_elf_get_dynamic_reloc_section (bfd
* abfd
,
14079 bfd_boolean is_rela
)
14081 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
14083 if (reloc_sec
== NULL
)
14085 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
14089 reloc_sec
= bfd_get_linker_section (abfd
, name
);
14091 if (reloc_sec
!= NULL
)
14092 elf_section_data (sec
)->sreloc
= reloc_sec
;
14099 /* Returns the dynamic reloc section associated with SEC. If the
14100 section does not exist it is created and attached to the DYNOBJ
14101 bfd and stored in the SRELOC field of SEC's elf_section_data
14104 ALIGNMENT is the alignment for the newly created section and
14105 IS_RELA defines whether the name should be .rela.<SEC's name>
14106 or .rel.<SEC's name>. The section name is looked up in the
14107 string table associated with ABFD. */
14110 _bfd_elf_make_dynamic_reloc_section (asection
*sec
,
14112 unsigned int alignment
,
14114 bfd_boolean is_rela
)
14116 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
14118 if (reloc_sec
== NULL
)
14120 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
14125 reloc_sec
= bfd_get_linker_section (dynobj
, name
);
14127 if (reloc_sec
== NULL
)
14129 flagword flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
14130 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
14131 if ((sec
->flags
& SEC_ALLOC
) != 0)
14132 flags
|= SEC_ALLOC
| SEC_LOAD
;
14134 reloc_sec
= bfd_make_section_anyway_with_flags (dynobj
, name
, flags
);
14135 if (reloc_sec
!= NULL
)
14137 /* _bfd_elf_get_sec_type_attr chooses a section type by
14138 name. Override as it may be wrong, eg. for a user
14139 section named "auto" we'll get ".relauto" which is
14140 seen to be a .rela section. */
14141 elf_section_type (reloc_sec
) = is_rela
? SHT_RELA
: SHT_REL
;
14142 if (! bfd_set_section_alignment (dynobj
, reloc_sec
, alignment
))
14147 elf_section_data (sec
)->sreloc
= reloc_sec
;
14153 /* Copy the ELF symbol type and other attributes for a linker script
14154 assignment from HSRC to HDEST. Generally this should be treated as
14155 if we found a strong non-dynamic definition for HDEST (except that
14156 ld ignores multiple definition errors). */
14158 _bfd_elf_copy_link_hash_symbol_type (bfd
*abfd
,
14159 struct bfd_link_hash_entry
*hdest
,
14160 struct bfd_link_hash_entry
*hsrc
)
14162 struct elf_link_hash_entry
*ehdest
= (struct elf_link_hash_entry
*) hdest
;
14163 struct elf_link_hash_entry
*ehsrc
= (struct elf_link_hash_entry
*) hsrc
;
14164 Elf_Internal_Sym isym
;
14166 ehdest
->type
= ehsrc
->type
;
14167 ehdest
->target_internal
= ehsrc
->target_internal
;
14169 isym
.st_other
= ehsrc
->other
;
14170 elf_merge_st_other (abfd
, ehdest
, &isym
, NULL
, TRUE
, FALSE
);
14173 /* Append a RELA relocation REL to section S in BFD. */
14176 elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
14178 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14179 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
14180 BFD_ASSERT (loc
+ bed
->s
->sizeof_rela
<= s
->contents
+ s
->size
);
14181 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
14184 /* Append a REL relocation REL to section S in BFD. */
14187 elf_append_rel (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
14189 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14190 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rel
);
14191 BFD_ASSERT (loc
+ bed
->s
->sizeof_rel
<= s
->contents
+ s
->size
);
14192 bed
->s
->swap_reloc_out (abfd
, rel
, loc
);
14195 /* Define __start, __stop, .startof. or .sizeof. symbol. */
14197 struct bfd_link_hash_entry
*
14198 bfd_elf_define_start_stop (struct bfd_link_info
*info
,
14199 const char *symbol
, asection
*sec
)
14201 struct bfd_link_hash_entry
*h
;
14203 h
= bfd_generic_define_start_stop (info
, symbol
, sec
);
14206 struct elf_link_hash_entry
*eh
= (struct elf_link_hash_entry
*) h
;
14207 eh
->start_stop
= 1;
14208 eh
->u2
.start_stop_section
= sec
;
14209 _bfd_elf_link_hash_hide_symbol (info
, eh
, TRUE
);
14210 if (ELF_ST_VISIBILITY (eh
->other
) != STV_INTERNAL
)
14211 eh
->other
= ((eh
->other
& ~ELF_ST_VISIBILITY (-1))