1 /* ELF linking support for BFD.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
29 #include "safe-ctype.h"
30 #include "libiberty.h"
33 /* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
36 struct elf_info_failed
38 struct bfd_link_info
*info
;
39 struct bfd_elf_version_tree
*verdefs
;
43 /* This structure is used to pass information to
44 _bfd_elf_link_find_version_dependencies. */
46 struct elf_find_verdep_info
48 /* General link information. */
49 struct bfd_link_info
*info
;
50 /* The number of dependencies. */
52 /* Whether we had a failure. */
56 static bfd_boolean _bfd_elf_fix_symbol_flags
57 (struct elf_link_hash_entry
*, struct elf_info_failed
*);
59 /* Define a symbol in a dynamic linkage section. */
61 struct elf_link_hash_entry
*
62 _bfd_elf_define_linkage_sym (bfd
*abfd
,
63 struct bfd_link_info
*info
,
67 struct elf_link_hash_entry
*h
;
68 struct bfd_link_hash_entry
*bh
;
69 const struct elf_backend_data
*bed
;
71 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
74 /* Zap symbol defined in an as-needed lib that wasn't linked.
75 This is a symptom of a larger problem: Absolute symbols
76 defined in shared libraries can't be overridden, because we
77 lose the link to the bfd which is via the symbol section. */
78 h
->root
.type
= bfd_link_hash_new
;
82 if (!_bfd_generic_link_add_one_symbol (info
, abfd
, name
, BSF_GLOBAL
,
84 get_elf_backend_data (abfd
)->collect
,
87 h
= (struct elf_link_hash_entry
*) bh
;
91 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
93 bed
= get_elf_backend_data (abfd
);
94 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
99 _bfd_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
103 struct elf_link_hash_entry
*h
;
104 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
105 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
107 /* This function may be called more than once. */
108 s
= bfd_get_section_by_name (abfd
, ".got");
109 if (s
!= NULL
&& (s
->flags
& SEC_LINKER_CREATED
) != 0)
112 flags
= bed
->dynamic_sec_flags
;
114 s
= bfd_make_section_with_flags (abfd
,
115 (bed
->rela_plts_and_copies_p
116 ? ".rela.got" : ".rel.got"),
117 (bed
->dynamic_sec_flags
120 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
124 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
126 || !bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
130 if (bed
->want_got_plt
)
132 s
= bfd_make_section_with_flags (abfd
, ".got.plt", flags
);
134 || !bfd_set_section_alignment (abfd
, s
,
135 bed
->s
->log_file_align
))
140 /* The first bit of the global offset table is the header. */
141 s
->size
+= bed
->got_header_size
;
143 if (bed
->want_got_sym
)
145 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
146 (or .got.plt) section. We don't do this in the linker script
147 because we don't want to define the symbol if we are not creating
148 a global offset table. */
149 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
150 "_GLOBAL_OFFSET_TABLE_");
151 elf_hash_table (info
)->hgot
= h
;
159 /* Create a strtab to hold the dynamic symbol names. */
161 _bfd_elf_link_create_dynstrtab (bfd
*abfd
, struct bfd_link_info
*info
)
163 struct elf_link_hash_table
*hash_table
;
165 hash_table
= elf_hash_table (info
);
166 if (hash_table
->dynobj
== NULL
)
167 hash_table
->dynobj
= abfd
;
169 if (hash_table
->dynstr
== NULL
)
171 hash_table
->dynstr
= _bfd_elf_strtab_init ();
172 if (hash_table
->dynstr
== NULL
)
178 /* Create some sections which will be filled in with dynamic linking
179 information. ABFD is an input file which requires dynamic sections
180 to be created. The dynamic sections take up virtual memory space
181 when the final executable is run, so we need to create them before
182 addresses are assigned to the output sections. We work out the
183 actual contents and size of these sections later. */
186 _bfd_elf_link_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
190 const struct elf_backend_data
*bed
;
192 if (! is_elf_hash_table (info
->hash
))
195 if (elf_hash_table (info
)->dynamic_sections_created
)
198 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
201 abfd
= elf_hash_table (info
)->dynobj
;
202 bed
= get_elf_backend_data (abfd
);
204 flags
= bed
->dynamic_sec_flags
;
206 /* A dynamically linked executable has a .interp section, but a
207 shared library does not. */
208 if (info
->executable
)
210 s
= bfd_make_section_with_flags (abfd
, ".interp",
211 flags
| SEC_READONLY
);
216 /* Create sections to hold version informations. These are removed
217 if they are not needed. */
218 s
= bfd_make_section_with_flags (abfd
, ".gnu.version_d",
219 flags
| SEC_READONLY
);
221 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
224 s
= bfd_make_section_with_flags (abfd
, ".gnu.version",
225 flags
| SEC_READONLY
);
227 || ! bfd_set_section_alignment (abfd
, s
, 1))
230 s
= bfd_make_section_with_flags (abfd
, ".gnu.version_r",
231 flags
| SEC_READONLY
);
233 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
236 s
= bfd_make_section_with_flags (abfd
, ".dynsym",
237 flags
| SEC_READONLY
);
239 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
242 s
= bfd_make_section_with_flags (abfd
, ".dynstr",
243 flags
| SEC_READONLY
);
247 s
= bfd_make_section_with_flags (abfd
, ".dynamic", flags
);
249 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
252 /* The special symbol _DYNAMIC is always set to the start of the
253 .dynamic section. We could set _DYNAMIC in a linker script, but we
254 only want to define it if we are, in fact, creating a .dynamic
255 section. We don't want to define it if there is no .dynamic
256 section, since on some ELF platforms the start up code examines it
257 to decide how to initialize the process. */
258 if (!_bfd_elf_define_linkage_sym (abfd
, info
, s
, "_DYNAMIC"))
263 s
= bfd_make_section_with_flags (abfd
, ".hash", flags
| SEC_READONLY
);
265 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
267 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
270 if (info
->emit_gnu_hash
)
272 s
= bfd_make_section_with_flags (abfd
, ".gnu.hash",
273 flags
| SEC_READONLY
);
275 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
277 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
278 4 32-bit words followed by variable count of 64-bit words, then
279 variable count of 32-bit words. */
280 if (bed
->s
->arch_size
== 64)
281 elf_section_data (s
)->this_hdr
.sh_entsize
= 0;
283 elf_section_data (s
)->this_hdr
.sh_entsize
= 4;
286 /* Let the backend create the rest of the sections. This lets the
287 backend set the right flags. The backend will normally create
288 the .got and .plt sections. */
289 if (bed
->elf_backend_create_dynamic_sections
== NULL
290 || ! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
293 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
298 /* Create dynamic sections when linking against a dynamic object. */
301 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
303 flagword flags
, pltflags
;
304 struct elf_link_hash_entry
*h
;
306 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
307 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
309 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
310 .rel[a].bss sections. */
311 flags
= bed
->dynamic_sec_flags
;
314 if (bed
->plt_not_loaded
)
315 /* We do not clear SEC_ALLOC here because we still want the OS to
316 allocate space for the section; it's just that there's nothing
317 to read in from the object file. */
318 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
320 pltflags
|= SEC_ALLOC
| SEC_CODE
| SEC_LOAD
;
321 if (bed
->plt_readonly
)
322 pltflags
|= SEC_READONLY
;
324 s
= bfd_make_section_with_flags (abfd
, ".plt", pltflags
);
326 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
330 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
332 if (bed
->want_plt_sym
)
334 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
335 "_PROCEDURE_LINKAGE_TABLE_");
336 elf_hash_table (info
)->hplt
= h
;
341 s
= bfd_make_section_with_flags (abfd
,
342 (bed
->rela_plts_and_copies_p
343 ? ".rela.plt" : ".rel.plt"),
344 flags
| SEC_READONLY
);
346 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
350 if (! _bfd_elf_create_got_section (abfd
, info
))
353 if (bed
->want_dynbss
)
355 /* The .dynbss section is a place to put symbols which are defined
356 by dynamic objects, are referenced by regular objects, and are
357 not functions. We must allocate space for them in the process
358 image and use a R_*_COPY reloc to tell the dynamic linker to
359 initialize them at run time. The linker script puts the .dynbss
360 section into the .bss section of the final image. */
361 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
363 | SEC_LINKER_CREATED
));
367 /* The .rel[a].bss section holds copy relocs. This section is not
368 normally needed. We need to create it here, though, so that the
369 linker will map it to an output section. We can't just create it
370 only if we need it, because we will not know whether we need it
371 until we have seen all the input files, and the first time the
372 main linker code calls BFD after examining all the input files
373 (size_dynamic_sections) the input sections have already been
374 mapped to the output sections. If the section turns out not to
375 be needed, we can discard it later. We will never need this
376 section when generating a shared object, since they do not use
380 s
= bfd_make_section_with_flags (abfd
,
381 (bed
->rela_plts_and_copies_p
382 ? ".rela.bss" : ".rel.bss"),
383 flags
| SEC_READONLY
);
385 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
393 /* Record a new dynamic symbol. We record the dynamic symbols as we
394 read the input files, since we need to have a list of all of them
395 before we can determine the final sizes of the output sections.
396 Note that we may actually call this function even though we are not
397 going to output any dynamic symbols; in some cases we know that a
398 symbol should be in the dynamic symbol table, but only if there is
402 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
403 struct elf_link_hash_entry
*h
)
405 if (h
->dynindx
== -1)
407 struct elf_strtab_hash
*dynstr
;
412 /* XXX: The ABI draft says the linker must turn hidden and
413 internal symbols into STB_LOCAL symbols when producing the
414 DSO. However, if ld.so honors st_other in the dynamic table,
415 this would not be necessary. */
416 switch (ELF_ST_VISIBILITY (h
->other
))
420 if (h
->root
.type
!= bfd_link_hash_undefined
421 && h
->root
.type
!= bfd_link_hash_undefweak
)
424 if (!elf_hash_table (info
)->is_relocatable_executable
)
432 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
433 ++elf_hash_table (info
)->dynsymcount
;
435 dynstr
= elf_hash_table (info
)->dynstr
;
438 /* Create a strtab to hold the dynamic symbol names. */
439 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
444 /* We don't put any version information in the dynamic string
446 name
= h
->root
.root
.string
;
447 p
= strchr (name
, ELF_VER_CHR
);
449 /* We know that the p points into writable memory. In fact,
450 there are only a few symbols that have read-only names, being
451 those like _GLOBAL_OFFSET_TABLE_ that are created specially
452 by the backends. Most symbols will have names pointing into
453 an ELF string table read from a file, or to objalloc memory. */
456 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
461 if (indx
== (bfd_size_type
) -1)
463 h
->dynstr_index
= indx
;
469 /* Mark a symbol dynamic. */
472 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info
*info
,
473 struct elf_link_hash_entry
*h
,
474 Elf_Internal_Sym
*sym
)
476 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
478 /* It may be called more than once on the same H. */
479 if(h
->dynamic
|| info
->relocatable
)
482 if ((info
->dynamic_data
483 && (h
->type
== STT_OBJECT
485 && ELF_ST_TYPE (sym
->st_info
) == STT_OBJECT
)))
487 && h
->root
.type
== bfd_link_hash_new
488 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
492 /* Record an assignment to a symbol made by a linker script. We need
493 this in case some dynamic object refers to this symbol. */
496 bfd_elf_record_link_assignment (bfd
*output_bfd
,
497 struct bfd_link_info
*info
,
502 struct elf_link_hash_entry
*h
, *hv
;
503 struct elf_link_hash_table
*htab
;
504 const struct elf_backend_data
*bed
;
506 if (!is_elf_hash_table (info
->hash
))
509 htab
= elf_hash_table (info
);
510 h
= elf_link_hash_lookup (htab
, name
, !provide
, TRUE
, FALSE
);
514 switch (h
->root
.type
)
516 case bfd_link_hash_defined
:
517 case bfd_link_hash_defweak
:
518 case bfd_link_hash_common
:
520 case bfd_link_hash_undefweak
:
521 case bfd_link_hash_undefined
:
522 /* Since we're defining the symbol, don't let it seem to have not
523 been defined. record_dynamic_symbol and size_dynamic_sections
524 may depend on this. */
525 h
->root
.type
= bfd_link_hash_new
;
526 if (h
->root
.u
.undef
.next
!= NULL
|| htab
->root
.undefs_tail
== &h
->root
)
527 bfd_link_repair_undef_list (&htab
->root
);
529 case bfd_link_hash_new
:
530 bfd_elf_link_mark_dynamic_symbol (info
, h
, NULL
);
533 case bfd_link_hash_indirect
:
534 /* We had a versioned symbol in a dynamic library. We make the
535 the versioned symbol point to this one. */
536 bed
= get_elf_backend_data (output_bfd
);
538 while (hv
->root
.type
== bfd_link_hash_indirect
539 || hv
->root
.type
== bfd_link_hash_warning
)
540 hv
= (struct elf_link_hash_entry
*) hv
->root
.u
.i
.link
;
541 /* We don't need to update h->root.u since linker will set them
543 h
->root
.type
= bfd_link_hash_undefined
;
544 hv
->root
.type
= bfd_link_hash_indirect
;
545 hv
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
546 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hv
);
548 case bfd_link_hash_warning
:
553 /* If this symbol is being provided by the linker script, and it is
554 currently defined by a dynamic object, but not by a regular
555 object, then mark it as undefined so that the generic linker will
556 force the correct value. */
560 h
->root
.type
= bfd_link_hash_undefined
;
562 /* If this symbol is not being provided by the linker script, and it is
563 currently defined by a dynamic object, but not by a regular object,
564 then clear out any version information because the symbol will not be
565 associated with the dynamic object any more. */
569 h
->verinfo
.verdef
= NULL
;
573 if (provide
&& hidden
)
575 bed
= get_elf_backend_data (output_bfd
);
576 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
577 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
580 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
582 if (!info
->relocatable
584 && (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
585 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
))
591 || (info
->executable
&& elf_hash_table (info
)->is_relocatable_executable
))
594 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
597 /* If this is a weak defined symbol, and we know a corresponding
598 real symbol from the same dynamic object, make sure the real
599 symbol is also made into a dynamic symbol. */
600 if (h
->u
.weakdef
!= NULL
601 && h
->u
.weakdef
->dynindx
== -1)
603 if (! bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
611 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
612 success, and 2 on a failure caused by attempting to record a symbol
613 in a discarded section, eg. a discarded link-once section symbol. */
616 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
621 struct elf_link_local_dynamic_entry
*entry
;
622 struct elf_link_hash_table
*eht
;
623 struct elf_strtab_hash
*dynstr
;
624 unsigned long dynstr_index
;
626 Elf_External_Sym_Shndx eshndx
;
627 char esym
[sizeof (Elf64_External_Sym
)];
629 if (! is_elf_hash_table (info
->hash
))
632 /* See if the entry exists already. */
633 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
634 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
637 amt
= sizeof (*entry
);
638 entry
= (struct elf_link_local_dynamic_entry
*) bfd_alloc (input_bfd
, amt
);
642 /* Go find the symbol, so that we can find it's name. */
643 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
644 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
646 bfd_release (input_bfd
, entry
);
650 if (entry
->isym
.st_shndx
!= SHN_UNDEF
651 && entry
->isym
.st_shndx
< SHN_LORESERVE
)
655 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
656 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
658 /* We can still bfd_release here as nothing has done another
659 bfd_alloc. We can't do this later in this function. */
660 bfd_release (input_bfd
, entry
);
665 name
= (bfd_elf_string_from_elf_section
666 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
667 entry
->isym
.st_name
));
669 dynstr
= elf_hash_table (info
)->dynstr
;
672 /* Create a strtab to hold the dynamic symbol names. */
673 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
678 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, FALSE
);
679 if (dynstr_index
== (unsigned long) -1)
681 entry
->isym
.st_name
= dynstr_index
;
683 eht
= elf_hash_table (info
);
685 entry
->next
= eht
->dynlocal
;
686 eht
->dynlocal
= entry
;
687 entry
->input_bfd
= input_bfd
;
688 entry
->input_indx
= input_indx
;
691 /* Whatever binding the symbol had before, it's now local. */
693 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
695 /* The dynindx will be set at the end of size_dynamic_sections. */
700 /* Return the dynindex of a local dynamic symbol. */
703 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
707 struct elf_link_local_dynamic_entry
*e
;
709 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
710 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
715 /* This function is used to renumber the dynamic symbols, if some of
716 them are removed because they are marked as local. This is called
717 via elf_link_hash_traverse. */
720 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
723 size_t *count
= (size_t *) data
;
728 if (h
->dynindx
!= -1)
729 h
->dynindx
= ++(*count
);
735 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
736 STB_LOCAL binding. */
739 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
742 size_t *count
= (size_t *) data
;
744 if (!h
->forced_local
)
747 if (h
->dynindx
!= -1)
748 h
->dynindx
= ++(*count
);
753 /* Return true if the dynamic symbol for a given section should be
754 omitted when creating a shared library. */
756 _bfd_elf_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
757 struct bfd_link_info
*info
,
760 struct elf_link_hash_table
*htab
;
762 switch (elf_section_data (p
)->this_hdr
.sh_type
)
766 /* If sh_type is yet undecided, assume it could be
767 SHT_PROGBITS/SHT_NOBITS. */
769 htab
= elf_hash_table (info
);
770 if (p
== htab
->tls_sec
)
773 if (htab
->text_index_section
!= NULL
)
774 return p
!= htab
->text_index_section
&& p
!= htab
->data_index_section
;
776 if (strcmp (p
->name
, ".got") == 0
777 || strcmp (p
->name
, ".got.plt") == 0
778 || strcmp (p
->name
, ".plt") == 0)
782 if (htab
->dynobj
!= NULL
783 && (ip
= bfd_get_section_by_name (htab
->dynobj
, p
->name
)) != NULL
784 && (ip
->flags
& SEC_LINKER_CREATED
)
785 && ip
->output_section
== p
)
790 /* There shouldn't be section relative relocations
791 against any other section. */
797 /* Assign dynsym indices. In a shared library we generate a section
798 symbol for each output section, which come first. Next come symbols
799 which have been forced to local binding. Then all of the back-end
800 allocated local dynamic syms, followed by the rest of the global
804 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
,
805 struct bfd_link_info
*info
,
806 unsigned long *section_sym_count
)
808 unsigned long dynsymcount
= 0;
810 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
812 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
814 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
815 if ((p
->flags
& SEC_EXCLUDE
) == 0
816 && (p
->flags
& SEC_ALLOC
) != 0
817 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
818 elf_section_data (p
)->dynindx
= ++dynsymcount
;
820 elf_section_data (p
)->dynindx
= 0;
822 *section_sym_count
= dynsymcount
;
824 elf_link_hash_traverse (elf_hash_table (info
),
825 elf_link_renumber_local_hash_table_dynsyms
,
828 if (elf_hash_table (info
)->dynlocal
)
830 struct elf_link_local_dynamic_entry
*p
;
831 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
832 p
->dynindx
= ++dynsymcount
;
835 elf_link_hash_traverse (elf_hash_table (info
),
836 elf_link_renumber_hash_table_dynsyms
,
839 /* There is an unused NULL entry at the head of the table which
840 we must account for in our count. Unless there weren't any
841 symbols, which means we'll have no table at all. */
842 if (dynsymcount
!= 0)
845 elf_hash_table (info
)->dynsymcount
= dynsymcount
;
849 /* Merge st_other field. */
852 elf_merge_st_other (bfd
*abfd
, struct elf_link_hash_entry
*h
,
853 Elf_Internal_Sym
*isym
, bfd_boolean definition
,
856 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
858 /* If st_other has a processor-specific meaning, specific
859 code might be needed here. We never merge the visibility
860 attribute with the one from a dynamic object. */
861 if (bed
->elf_backend_merge_symbol_attribute
)
862 (*bed
->elf_backend_merge_symbol_attribute
) (h
, isym
, definition
,
865 /* If this symbol has default visibility and the user has requested
866 we not re-export it, then mark it as hidden. */
870 || (abfd
->my_archive
&& abfd
->my_archive
->no_export
))
871 && ELF_ST_VISIBILITY (isym
->st_other
) != STV_INTERNAL
)
872 isym
->st_other
= (STV_HIDDEN
873 | (isym
->st_other
& ~ELF_ST_VISIBILITY (-1)));
875 if (!dynamic
&& ELF_ST_VISIBILITY (isym
->st_other
) != 0)
877 unsigned char hvis
, symvis
, other
, nvis
;
879 /* Only merge the visibility. Leave the remainder of the
880 st_other field to elf_backend_merge_symbol_attribute. */
881 other
= h
->other
& ~ELF_ST_VISIBILITY (-1);
883 /* Combine visibilities, using the most constraining one. */
884 hvis
= ELF_ST_VISIBILITY (h
->other
);
885 symvis
= ELF_ST_VISIBILITY (isym
->st_other
);
891 nvis
= hvis
< symvis
? hvis
: symvis
;
893 h
->other
= other
| nvis
;
897 /* This function is called when we want to define a new symbol. It
898 handles the various cases which arise when we find a definition in
899 a dynamic object, or when there is already a definition in a
900 dynamic object. The new symbol is described by NAME, SYM, PSEC,
901 and PVALUE. We set SYM_HASH to the hash table entry. We set
902 OVERRIDE if the old symbol is overriding a new definition. We set
903 TYPE_CHANGE_OK if it is OK for the type to change. We set
904 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
905 change, we mean that we shouldn't warn if the type or size does
906 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic
907 object is overridden by a regular object. */
910 _bfd_elf_merge_symbol (bfd
*abfd
,
911 struct bfd_link_info
*info
,
913 Elf_Internal_Sym
*sym
,
916 unsigned int *pold_alignment
,
917 struct elf_link_hash_entry
**sym_hash
,
919 bfd_boolean
*override
,
920 bfd_boolean
*type_change_ok
,
921 bfd_boolean
*size_change_ok
)
923 asection
*sec
, *oldsec
;
924 struct elf_link_hash_entry
*h
;
925 struct elf_link_hash_entry
*flip
;
928 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
929 bfd_boolean newweak
, oldweak
, newfunc
, oldfunc
;
930 const struct elf_backend_data
*bed
;
936 bind
= ELF_ST_BIND (sym
->st_info
);
938 /* Silently discard TLS symbols from --just-syms. There's no way to
939 combine a static TLS block with a new TLS block for this executable. */
940 if (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
941 && sec
->sec_info_type
== ELF_INFO_TYPE_JUST_SYMS
)
947 if (! bfd_is_und_section (sec
))
948 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
950 h
= ((struct elf_link_hash_entry
*)
951 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
956 bed
= get_elf_backend_data (abfd
);
958 /* This code is for coping with dynamic objects, and is only useful
959 if we are doing an ELF link. */
960 if (!(*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
963 /* For merging, we only care about real symbols. */
965 while (h
->root
.type
== bfd_link_hash_indirect
966 || h
->root
.type
== bfd_link_hash_warning
)
967 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
969 /* We have to check it for every instance since the first few may be
970 refereences and not all compilers emit symbol type for undefined
972 bfd_elf_link_mark_dynamic_symbol (info
, h
, sym
);
974 /* If we just created the symbol, mark it as being an ELF symbol.
975 Other than that, there is nothing to do--there is no merge issue
976 with a newly defined symbol--so we just return. */
978 if (h
->root
.type
== bfd_link_hash_new
)
984 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
987 switch (h
->root
.type
)
994 case bfd_link_hash_undefined
:
995 case bfd_link_hash_undefweak
:
996 oldbfd
= h
->root
.u
.undef
.abfd
;
1000 case bfd_link_hash_defined
:
1001 case bfd_link_hash_defweak
:
1002 oldbfd
= h
->root
.u
.def
.section
->owner
;
1003 oldsec
= h
->root
.u
.def
.section
;
1006 case bfd_link_hash_common
:
1007 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
1008 oldsec
= h
->root
.u
.c
.p
->section
;
1012 /* Differentiate strong and weak symbols. */
1013 newweak
= bind
== STB_WEAK
;
1014 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
1015 || h
->root
.type
== bfd_link_hash_undefweak
);
1017 /* In cases involving weak versioned symbols, we may wind up trying
1018 to merge a symbol with itself. Catch that here, to avoid the
1019 confusion that results if we try to override a symbol with
1020 itself. The additional tests catch cases like
1021 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1022 dynamic object, which we do want to handle here. */
1024 && (newweak
|| oldweak
)
1025 && ((abfd
->flags
& DYNAMIC
) == 0
1026 || !h
->def_regular
))
1029 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1030 respectively, is from a dynamic object. */
1032 newdyn
= (abfd
->flags
& DYNAMIC
) != 0;
1036 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
1037 else if (oldsec
!= NULL
)
1039 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1040 indices used by MIPS ELF. */
1041 olddyn
= (oldsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
1044 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1045 respectively, appear to be a definition rather than reference. */
1047 newdef
= !bfd_is_und_section (sec
) && !bfd_is_com_section (sec
);
1049 olddef
= (h
->root
.type
!= bfd_link_hash_undefined
1050 && h
->root
.type
!= bfd_link_hash_undefweak
1051 && h
->root
.type
!= bfd_link_hash_common
);
1053 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1054 respectively, appear to be a function. */
1056 newfunc
= (ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1057 && bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)));
1059 oldfunc
= (h
->type
!= STT_NOTYPE
1060 && bed
->is_function_type (h
->type
));
1062 /* When we try to create a default indirect symbol from the dynamic
1063 definition with the default version, we skip it if its type and
1064 the type of existing regular definition mismatch. We only do it
1065 if the existing regular definition won't be dynamic. */
1066 if (pold_alignment
== NULL
1068 && !info
->export_dynamic
1073 && (olddef
|| h
->root
.type
== bfd_link_hash_common
)
1074 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1075 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1076 && h
->type
!= STT_NOTYPE
1077 && !(newfunc
&& oldfunc
))
1083 /* Check TLS symbol. We don't check undefined symbol introduced by
1085 if ((ELF_ST_TYPE (sym
->st_info
) == STT_TLS
|| h
->type
== STT_TLS
)
1086 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1090 bfd_boolean ntdef
, tdef
;
1091 asection
*ntsec
, *tsec
;
1093 if (h
->type
== STT_TLS
)
1113 (*_bfd_error_handler
)
1114 (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1115 tbfd
, tsec
, ntbfd
, ntsec
, h
->root
.root
.string
);
1116 else if (!tdef
&& !ntdef
)
1117 (*_bfd_error_handler
)
1118 (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1119 tbfd
, ntbfd
, h
->root
.root
.string
);
1121 (*_bfd_error_handler
)
1122 (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1123 tbfd
, tsec
, ntbfd
, h
->root
.root
.string
);
1125 (*_bfd_error_handler
)
1126 (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1127 tbfd
, ntbfd
, ntsec
, h
->root
.root
.string
);
1129 bfd_set_error (bfd_error_bad_value
);
1133 /* We need to remember if a symbol has a definition in a dynamic
1134 object or is weak in all dynamic objects. Internal and hidden
1135 visibility will make it unavailable to dynamic objects. */
1136 if (newdyn
&& !h
->dynamic_def
)
1138 if (!bfd_is_und_section (sec
))
1142 /* Check if this symbol is weak in all dynamic objects. If it
1143 is the first time we see it in a dynamic object, we mark
1144 if it is weak. Otherwise, we clear it. */
1145 if (!h
->ref_dynamic
)
1147 if (bind
== STB_WEAK
)
1148 h
->dynamic_weak
= 1;
1150 else if (bind
!= STB_WEAK
)
1151 h
->dynamic_weak
= 0;
1155 /* If the old symbol has non-default visibility, we ignore the new
1156 definition from a dynamic object. */
1158 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1159 && !bfd_is_und_section (sec
))
1162 /* Make sure this symbol is dynamic. */
1164 /* A protected symbol has external availability. Make sure it is
1165 recorded as dynamic.
1167 FIXME: Should we check type and size for protected symbol? */
1168 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1169 return bfd_elf_link_record_dynamic_symbol (info
, h
);
1174 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
1177 /* If the new symbol with non-default visibility comes from a
1178 relocatable file and the old definition comes from a dynamic
1179 object, we remove the old definition. */
1180 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1182 /* Handle the case where the old dynamic definition is
1183 default versioned. We need to copy the symbol info from
1184 the symbol with default version to the normal one if it
1185 was referenced before. */
1188 struct elf_link_hash_entry
*vh
= *sym_hash
;
1190 vh
->root
.type
= h
->root
.type
;
1191 h
->root
.type
= bfd_link_hash_indirect
;
1192 (*bed
->elf_backend_copy_indirect_symbol
) (info
, vh
, h
);
1193 /* Protected symbols will override the dynamic definition
1194 with default version. */
1195 if (ELF_ST_VISIBILITY (sym
->st_other
) == STV_PROTECTED
)
1197 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) vh
;
1198 vh
->dynamic_def
= 1;
1199 vh
->ref_dynamic
= 1;
1203 h
->root
.type
= vh
->root
.type
;
1204 vh
->ref_dynamic
= 0;
1205 /* We have to hide it here since it was made dynamic
1206 global with extra bits when the symbol info was
1207 copied from the old dynamic definition. */
1208 (*bed
->elf_backend_hide_symbol
) (info
, vh
, TRUE
);
1216 if ((h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1217 && bfd_is_und_section (sec
))
1219 /* If the new symbol is undefined and the old symbol was
1220 also undefined before, we need to make sure
1221 _bfd_generic_link_add_one_symbol doesn't mess
1222 up the linker hash table undefs list. Since the old
1223 definition came from a dynamic object, it is still on the
1225 h
->root
.type
= bfd_link_hash_undefined
;
1226 h
->root
.u
.undef
.abfd
= abfd
;
1230 h
->root
.type
= bfd_link_hash_new
;
1231 h
->root
.u
.undef
.abfd
= NULL
;
1240 /* FIXME: Should we check type and size for protected symbol? */
1246 if (bind
== STB_GNU_UNIQUE
)
1247 h
->unique_global
= 1;
1249 /* If a new weak symbol definition comes from a regular file and the
1250 old symbol comes from a dynamic library, we treat the new one as
1251 strong. Similarly, an old weak symbol definition from a regular
1252 file is treated as strong when the new symbol comes from a dynamic
1253 library. Further, an old weak symbol from a dynamic library is
1254 treated as strong if the new symbol is from a dynamic library.
1255 This reflects the way glibc's ld.so works.
1257 Do this before setting *type_change_ok or *size_change_ok so that
1258 we warn properly when dynamic library symbols are overridden. */
1260 if (newdef
&& !newdyn
&& olddyn
)
1262 if (olddef
&& newdyn
)
1265 /* Allow changes between different types of function symbol. */
1266 if (newfunc
&& oldfunc
)
1267 *type_change_ok
= TRUE
;
1269 /* It's OK to change the type if either the existing symbol or the
1270 new symbol is weak. A type change is also OK if the old symbol
1271 is undefined and the new symbol is defined. */
1276 && h
->root
.type
== bfd_link_hash_undefined
))
1277 *type_change_ok
= TRUE
;
1279 /* It's OK to change the size if either the existing symbol or the
1280 new symbol is weak, or if the old symbol is undefined. */
1283 || h
->root
.type
== bfd_link_hash_undefined
)
1284 *size_change_ok
= TRUE
;
1286 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1287 symbol, respectively, appears to be a common symbol in a dynamic
1288 object. If a symbol appears in an uninitialized section, and is
1289 not weak, and is not a function, then it may be a common symbol
1290 which was resolved when the dynamic object was created. We want
1291 to treat such symbols specially, because they raise special
1292 considerations when setting the symbol size: if the symbol
1293 appears as a common symbol in a regular object, and the size in
1294 the regular object is larger, we must make sure that we use the
1295 larger size. This problematic case can always be avoided in C,
1296 but it must be handled correctly when using Fortran shared
1299 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1300 likewise for OLDDYNCOMMON and OLDDEF.
1302 Note that this test is just a heuristic, and that it is quite
1303 possible to have an uninitialized symbol in a shared object which
1304 is really a definition, rather than a common symbol. This could
1305 lead to some minor confusion when the symbol really is a common
1306 symbol in some regular object. However, I think it will be
1312 && (sec
->flags
& SEC_ALLOC
) != 0
1313 && (sec
->flags
& SEC_LOAD
) == 0
1316 newdyncommon
= TRUE
;
1318 newdyncommon
= FALSE
;
1322 && h
->root
.type
== bfd_link_hash_defined
1324 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1325 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
1328 olddyncommon
= TRUE
;
1330 olddyncommon
= FALSE
;
1332 /* We now know everything about the old and new symbols. We ask the
1333 backend to check if we can merge them. */
1334 if (bed
->merge_symbol
1335 && !bed
->merge_symbol (info
, sym_hash
, h
, sym
, psec
, pvalue
,
1336 pold_alignment
, skip
, override
,
1337 type_change_ok
, size_change_ok
,
1338 &newdyn
, &newdef
, &newdyncommon
, &newweak
,
1340 &olddyn
, &olddef
, &olddyncommon
, &oldweak
,
1344 /* If both the old and the new symbols look like common symbols in a
1345 dynamic object, set the size of the symbol to the larger of the
1350 && sym
->st_size
!= h
->size
)
1352 /* Since we think we have two common symbols, issue a multiple
1353 common warning if desired. Note that we only warn if the
1354 size is different. If the size is the same, we simply let
1355 the old symbol override the new one as normally happens with
1356 symbols defined in dynamic objects. */
1358 if (! ((*info
->callbacks
->multiple_common
)
1359 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1362 if (sym
->st_size
> h
->size
)
1363 h
->size
= sym
->st_size
;
1365 *size_change_ok
= TRUE
;
1368 /* If we are looking at a dynamic object, and we have found a
1369 definition, we need to see if the symbol was already defined by
1370 some other object. If so, we want to use the existing
1371 definition, and we do not want to report a multiple symbol
1372 definition error; we do this by clobbering *PSEC to be
1373 bfd_und_section_ptr.
1375 We treat a common symbol as a definition if the symbol in the
1376 shared library is a function, since common symbols always
1377 represent variables; this can cause confusion in principle, but
1378 any such confusion would seem to indicate an erroneous program or
1379 shared library. We also permit a common symbol in a regular
1380 object to override a weak symbol in a shared object. */
1385 || (h
->root
.type
== bfd_link_hash_common
1386 && (newweak
|| newfunc
))))
1390 newdyncommon
= FALSE
;
1392 *psec
= sec
= bfd_und_section_ptr
;
1393 *size_change_ok
= TRUE
;
1395 /* If we get here when the old symbol is a common symbol, then
1396 we are explicitly letting it override a weak symbol or
1397 function in a dynamic object, and we don't want to warn about
1398 a type change. If the old symbol is a defined symbol, a type
1399 change warning may still be appropriate. */
1401 if (h
->root
.type
== bfd_link_hash_common
)
1402 *type_change_ok
= TRUE
;
1405 /* Handle the special case of an old common symbol merging with a
1406 new symbol which looks like a common symbol in a shared object.
1407 We change *PSEC and *PVALUE to make the new symbol look like a
1408 common symbol, and let _bfd_generic_link_add_one_symbol do the
1412 && h
->root
.type
== bfd_link_hash_common
)
1416 newdyncommon
= FALSE
;
1417 *pvalue
= sym
->st_size
;
1418 *psec
= sec
= bed
->common_section (oldsec
);
1419 *size_change_ok
= TRUE
;
1422 /* Skip weak definitions of symbols that are already defined. */
1423 if (newdef
&& olddef
&& newweak
)
1425 /* Don't skip new non-IR weak syms. */
1426 if (!((oldbfd
->flags
& BFD_PLUGIN
) != 0
1427 && (abfd
->flags
& BFD_PLUGIN
) == 0))
1430 /* Merge st_other. If the symbol already has a dynamic index,
1431 but visibility says it should not be visible, turn it into a
1433 elf_merge_st_other (abfd
, h
, sym
, newdef
, newdyn
);
1434 if (h
->dynindx
!= -1)
1435 switch (ELF_ST_VISIBILITY (h
->other
))
1439 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1444 /* If the old symbol is from a dynamic object, and the new symbol is
1445 a definition which is not from a dynamic object, then the new
1446 symbol overrides the old symbol. Symbols from regular files
1447 always take precedence over symbols from dynamic objects, even if
1448 they are defined after the dynamic object in the link.
1450 As above, we again permit a common symbol in a regular object to
1451 override a definition in a shared object if the shared object
1452 symbol is a function or is weak. */
1457 || (bfd_is_com_section (sec
)
1458 && (oldweak
|| oldfunc
)))
1463 /* Change the hash table entry to undefined, and let
1464 _bfd_generic_link_add_one_symbol do the right thing with the
1467 h
->root
.type
= bfd_link_hash_undefined
;
1468 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1469 *size_change_ok
= TRUE
;
1472 olddyncommon
= FALSE
;
1474 /* We again permit a type change when a common symbol may be
1475 overriding a function. */
1477 if (bfd_is_com_section (sec
))
1481 /* If a common symbol overrides a function, make sure
1482 that it isn't defined dynamically nor has type
1485 h
->type
= STT_NOTYPE
;
1487 *type_change_ok
= TRUE
;
1490 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1493 /* This union may have been set to be non-NULL when this symbol
1494 was seen in a dynamic object. We must force the union to be
1495 NULL, so that it is correct for a regular symbol. */
1496 h
->verinfo
.vertree
= NULL
;
1499 /* Handle the special case of a new common symbol merging with an
1500 old symbol that looks like it might be a common symbol defined in
1501 a shared object. Note that we have already handled the case in
1502 which a new common symbol should simply override the definition
1503 in the shared library. */
1506 && bfd_is_com_section (sec
)
1509 /* It would be best if we could set the hash table entry to a
1510 common symbol, but we don't know what to use for the section
1511 or the alignment. */
1512 if (! ((*info
->callbacks
->multiple_common
)
1513 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1516 /* If the presumed common symbol in the dynamic object is
1517 larger, pretend that the new symbol has its size. */
1519 if (h
->size
> *pvalue
)
1522 /* We need to remember the alignment required by the symbol
1523 in the dynamic object. */
1524 BFD_ASSERT (pold_alignment
);
1525 *pold_alignment
= h
->root
.u
.def
.section
->alignment_power
;
1528 olddyncommon
= FALSE
;
1530 h
->root
.type
= bfd_link_hash_undefined
;
1531 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1533 *size_change_ok
= TRUE
;
1534 *type_change_ok
= TRUE
;
1536 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1539 h
->verinfo
.vertree
= NULL
;
1544 /* Handle the case where we had a versioned symbol in a dynamic
1545 library and now find a definition in a normal object. In this
1546 case, we make the versioned symbol point to the normal one. */
1547 flip
->root
.type
= h
->root
.type
;
1548 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1549 h
->root
.type
= bfd_link_hash_indirect
;
1550 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1551 (*bed
->elf_backend_copy_indirect_symbol
) (info
, flip
, h
);
1555 flip
->ref_dynamic
= 1;
1562 /* This function is called to create an indirect symbol from the
1563 default for the symbol with the default version if needed. The
1564 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
1565 set DYNSYM if the new indirect symbol is dynamic. */
1568 _bfd_elf_add_default_symbol (bfd
*abfd
,
1569 struct bfd_link_info
*info
,
1570 struct elf_link_hash_entry
*h
,
1572 Elf_Internal_Sym
*sym
,
1575 bfd_boolean
*dynsym
,
1576 bfd_boolean override
)
1578 bfd_boolean type_change_ok
;
1579 bfd_boolean size_change_ok
;
1582 struct elf_link_hash_entry
*hi
;
1583 struct bfd_link_hash_entry
*bh
;
1584 const struct elf_backend_data
*bed
;
1585 bfd_boolean collect
;
1586 bfd_boolean dynamic
;
1588 size_t len
, shortlen
;
1591 /* If this symbol has a version, and it is the default version, we
1592 create an indirect symbol from the default name to the fully
1593 decorated name. This will cause external references which do not
1594 specify a version to be bound to this version of the symbol. */
1595 p
= strchr (name
, ELF_VER_CHR
);
1596 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
1601 /* We are overridden by an old definition. We need to check if we
1602 need to create the indirect symbol from the default name. */
1603 hi
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
,
1605 BFD_ASSERT (hi
!= NULL
);
1608 while (hi
->root
.type
== bfd_link_hash_indirect
1609 || hi
->root
.type
== bfd_link_hash_warning
)
1611 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1617 bed
= get_elf_backend_data (abfd
);
1618 collect
= bed
->collect
;
1619 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1621 shortlen
= p
- name
;
1622 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1623 if (shortname
== NULL
)
1625 memcpy (shortname
, name
, shortlen
);
1626 shortname
[shortlen
] = '\0';
1628 /* We are going to create a new symbol. Merge it with any existing
1629 symbol with this name. For the purposes of the merge, act as
1630 though we were defining the symbol we just defined, although we
1631 actually going to define an indirect symbol. */
1632 type_change_ok
= FALSE
;
1633 size_change_ok
= FALSE
;
1635 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1636 NULL
, &hi
, &skip
, &override
,
1637 &type_change_ok
, &size_change_ok
))
1646 if (! (_bfd_generic_link_add_one_symbol
1647 (info
, abfd
, shortname
, BSF_INDIRECT
, bfd_ind_section_ptr
,
1648 0, name
, FALSE
, collect
, &bh
)))
1650 hi
= (struct elf_link_hash_entry
*) bh
;
1654 /* In this case the symbol named SHORTNAME is overriding the
1655 indirect symbol we want to add. We were planning on making
1656 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1657 is the name without a version. NAME is the fully versioned
1658 name, and it is the default version.
1660 Overriding means that we already saw a definition for the
1661 symbol SHORTNAME in a regular object, and it is overriding
1662 the symbol defined in the dynamic object.
1664 When this happens, we actually want to change NAME, the
1665 symbol we just added, to refer to SHORTNAME. This will cause
1666 references to NAME in the shared object to become references
1667 to SHORTNAME in the regular object. This is what we expect
1668 when we override a function in a shared object: that the
1669 references in the shared object will be mapped to the
1670 definition in the regular object. */
1672 while (hi
->root
.type
== bfd_link_hash_indirect
1673 || hi
->root
.type
== bfd_link_hash_warning
)
1674 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1676 h
->root
.type
= bfd_link_hash_indirect
;
1677 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1681 hi
->ref_dynamic
= 1;
1685 if (! bfd_elf_link_record_dynamic_symbol (info
, hi
))
1690 /* Now set HI to H, so that the following code will set the
1691 other fields correctly. */
1695 /* Check if HI is a warning symbol. */
1696 if (hi
->root
.type
== bfd_link_hash_warning
)
1697 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1699 /* If there is a duplicate definition somewhere, then HI may not
1700 point to an indirect symbol. We will have reported an error to
1701 the user in that case. */
1703 if (hi
->root
.type
== bfd_link_hash_indirect
)
1705 struct elf_link_hash_entry
*ht
;
1707 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1708 (*bed
->elf_backend_copy_indirect_symbol
) (info
, ht
, hi
);
1710 /* See if the new flags lead us to realize that the symbol must
1716 if (! info
->executable
1722 if (hi
->ref_regular
)
1728 /* We also need to define an indirection from the nondefault version
1732 len
= strlen (name
);
1733 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, len
);
1734 if (shortname
== NULL
)
1736 memcpy (shortname
, name
, shortlen
);
1737 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1739 /* Once again, merge with any existing symbol. */
1740 type_change_ok
= FALSE
;
1741 size_change_ok
= FALSE
;
1743 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1744 NULL
, &hi
, &skip
, &override
,
1745 &type_change_ok
, &size_change_ok
))
1753 /* Here SHORTNAME is a versioned name, so we don't expect to see
1754 the type of override we do in the case above unless it is
1755 overridden by a versioned definition. */
1756 if (hi
->root
.type
!= bfd_link_hash_defined
1757 && hi
->root
.type
!= bfd_link_hash_defweak
)
1758 (*_bfd_error_handler
)
1759 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1765 if (! (_bfd_generic_link_add_one_symbol
1766 (info
, abfd
, shortname
, BSF_INDIRECT
,
1767 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
1769 hi
= (struct elf_link_hash_entry
*) bh
;
1771 /* If there is a duplicate definition somewhere, then HI may not
1772 point to an indirect symbol. We will have reported an error
1773 to the user in that case. */
1775 if (hi
->root
.type
== bfd_link_hash_indirect
)
1777 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
1779 /* See if the new flags lead us to realize that the symbol
1785 if (! info
->executable
1791 if (hi
->ref_regular
)
1801 /* This routine is used to export all defined symbols into the dynamic
1802 symbol table. It is called via elf_link_hash_traverse. */
1805 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
1807 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1809 /* Ignore indirect symbols. These are added by the versioning code. */
1810 if (h
->root
.type
== bfd_link_hash_indirect
)
1813 /* Ignore this if we won't export it. */
1814 if (!eif
->info
->export_dynamic
&& !h
->dynamic
)
1817 if (h
->dynindx
== -1
1823 if (eif
->verdefs
== NULL
1824 || (bfd_find_version_for_sym (eif
->verdefs
, h
->root
.root
.string
, &hide
)
1827 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1838 /* Look through the symbols which are defined in other shared
1839 libraries and referenced here. Update the list of version
1840 dependencies. This will be put into the .gnu.version_r section.
1841 This function is called via elf_link_hash_traverse. */
1844 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1847 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
1848 Elf_Internal_Verneed
*t
;
1849 Elf_Internal_Vernaux
*a
;
1852 /* We only care about symbols defined in shared objects with version
1857 || h
->verinfo
.verdef
== NULL
)
1860 /* See if we already know about this version. */
1861 for (t
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1865 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1868 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1869 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1875 /* This is a new version. Add it to tree we are building. */
1880 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1883 rinfo
->failed
= TRUE
;
1887 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1888 t
->vn_nextref
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1889 elf_tdata (rinfo
->info
->output_bfd
)->verref
= t
;
1893 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1896 rinfo
->failed
= TRUE
;
1900 /* Note that we are copying a string pointer here, and testing it
1901 above. If bfd_elf_string_from_elf_section is ever changed to
1902 discard the string data when low in memory, this will have to be
1904 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1906 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1907 a
->vna_nextptr
= t
->vn_auxptr
;
1909 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1912 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1919 /* Figure out appropriate versions for all the symbols. We may not
1920 have the version number script until we have read all of the input
1921 files, so until that point we don't know which symbols should be
1922 local. This function is called via elf_link_hash_traverse. */
1925 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1927 struct elf_info_failed
*sinfo
;
1928 struct bfd_link_info
*info
;
1929 const struct elf_backend_data
*bed
;
1930 struct elf_info_failed eif
;
1934 sinfo
= (struct elf_info_failed
*) data
;
1937 /* Fix the symbol flags. */
1940 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1943 sinfo
->failed
= TRUE
;
1947 /* We only need version numbers for symbols defined in regular
1949 if (!h
->def_regular
)
1952 bed
= get_elf_backend_data (info
->output_bfd
);
1953 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1954 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1956 struct bfd_elf_version_tree
*t
;
1961 /* There are two consecutive ELF_VER_CHR characters if this is
1962 not a hidden symbol. */
1964 if (*p
== ELF_VER_CHR
)
1970 /* If there is no version string, we can just return out. */
1978 /* Look for the version. If we find it, it is no longer weak. */
1979 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1981 if (strcmp (t
->name
, p
) == 0)
1985 struct bfd_elf_version_expr
*d
;
1987 len
= p
- h
->root
.root
.string
;
1988 alc
= (char *) bfd_malloc (len
);
1991 sinfo
->failed
= TRUE
;
1994 memcpy (alc
, h
->root
.root
.string
, len
- 1);
1995 alc
[len
- 1] = '\0';
1996 if (alc
[len
- 2] == ELF_VER_CHR
)
1997 alc
[len
- 2] = '\0';
1999 h
->verinfo
.vertree
= t
;
2003 if (t
->globals
.list
!= NULL
)
2004 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
2006 /* See if there is anything to force this symbol to
2008 if (d
== NULL
&& t
->locals
.list
!= NULL
)
2010 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
2013 && ! info
->export_dynamic
)
2014 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2022 /* If we are building an application, we need to create a
2023 version node for this version. */
2024 if (t
== NULL
&& info
->executable
)
2026 struct bfd_elf_version_tree
**pp
;
2029 /* If we aren't going to export this symbol, we don't need
2030 to worry about it. */
2031 if (h
->dynindx
== -1)
2035 t
= (struct bfd_elf_version_tree
*) bfd_zalloc (info
->output_bfd
, amt
);
2038 sinfo
->failed
= TRUE
;
2043 t
->name_indx
= (unsigned int) -1;
2047 /* Don't count anonymous version tag. */
2048 if (sinfo
->verdefs
!= NULL
&& sinfo
->verdefs
->vernum
== 0)
2050 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
2052 t
->vernum
= version_index
;
2056 h
->verinfo
.vertree
= t
;
2060 /* We could not find the version for a symbol when
2061 generating a shared archive. Return an error. */
2062 (*_bfd_error_handler
)
2063 (_("%B: version node not found for symbol %s"),
2064 info
->output_bfd
, h
->root
.root
.string
);
2065 bfd_set_error (bfd_error_bad_value
);
2066 sinfo
->failed
= TRUE
;
2074 /* If we don't have a version for this symbol, see if we can find
2076 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
2080 h
->verinfo
.vertree
= bfd_find_version_for_sym (sinfo
->verdefs
,
2081 h
->root
.root
.string
, &hide
);
2082 if (h
->verinfo
.vertree
!= NULL
&& hide
)
2083 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2089 /* Read and swap the relocs from the section indicated by SHDR. This
2090 may be either a REL or a RELA section. The relocations are
2091 translated into RELA relocations and stored in INTERNAL_RELOCS,
2092 which should have already been allocated to contain enough space.
2093 The EXTERNAL_RELOCS are a buffer where the external form of the
2094 relocations should be stored.
2096 Returns FALSE if something goes wrong. */
2099 elf_link_read_relocs_from_section (bfd
*abfd
,
2101 Elf_Internal_Shdr
*shdr
,
2102 void *external_relocs
,
2103 Elf_Internal_Rela
*internal_relocs
)
2105 const struct elf_backend_data
*bed
;
2106 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2107 const bfd_byte
*erela
;
2108 const bfd_byte
*erelaend
;
2109 Elf_Internal_Rela
*irela
;
2110 Elf_Internal_Shdr
*symtab_hdr
;
2113 /* Position ourselves at the start of the section. */
2114 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2117 /* Read the relocations. */
2118 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
2121 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2122 nsyms
= NUM_SHDR_ENTRIES (symtab_hdr
);
2124 bed
= get_elf_backend_data (abfd
);
2126 /* Convert the external relocations to the internal format. */
2127 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2128 swap_in
= bed
->s
->swap_reloc_in
;
2129 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2130 swap_in
= bed
->s
->swap_reloca_in
;
2133 bfd_set_error (bfd_error_wrong_format
);
2137 erela
= (const bfd_byte
*) external_relocs
;
2138 erelaend
= erela
+ shdr
->sh_size
;
2139 irela
= internal_relocs
;
2140 while (erela
< erelaend
)
2144 (*swap_in
) (abfd
, erela
, irela
);
2145 r_symndx
= ELF32_R_SYM (irela
->r_info
);
2146 if (bed
->s
->arch_size
== 64)
2150 if ((size_t) r_symndx
>= nsyms
)
2152 (*_bfd_error_handler
)
2153 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2154 " for offset 0x%lx in section `%A'"),
2156 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2157 bfd_set_error (bfd_error_bad_value
);
2161 else if (r_symndx
!= STN_UNDEF
)
2163 (*_bfd_error_handler
)
2164 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2165 " when the object file has no symbol table"),
2167 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2168 bfd_set_error (bfd_error_bad_value
);
2171 irela
+= bed
->s
->int_rels_per_ext_rel
;
2172 erela
+= shdr
->sh_entsize
;
2178 /* Read and swap the relocs for a section O. They may have been
2179 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2180 not NULL, they are used as buffers to read into. They are known to
2181 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2182 the return value is allocated using either malloc or bfd_alloc,
2183 according to the KEEP_MEMORY argument. If O has two relocation
2184 sections (both REL and RELA relocations), then the REL_HDR
2185 relocations will appear first in INTERNAL_RELOCS, followed by the
2186 RELA_HDR relocations. */
2189 _bfd_elf_link_read_relocs (bfd
*abfd
,
2191 void *external_relocs
,
2192 Elf_Internal_Rela
*internal_relocs
,
2193 bfd_boolean keep_memory
)
2195 void *alloc1
= NULL
;
2196 Elf_Internal_Rela
*alloc2
= NULL
;
2197 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2198 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
2199 Elf_Internal_Rela
*internal_rela_relocs
;
2201 if (esdo
->relocs
!= NULL
)
2202 return esdo
->relocs
;
2204 if (o
->reloc_count
== 0)
2207 if (internal_relocs
== NULL
)
2211 size
= o
->reloc_count
;
2212 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
2214 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2216 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2217 if (internal_relocs
== NULL
)
2221 if (external_relocs
== NULL
)
2223 bfd_size_type size
= 0;
2226 size
+= esdo
->rel
.hdr
->sh_size
;
2228 size
+= esdo
->rela
.hdr
->sh_size
;
2230 alloc1
= bfd_malloc (size
);
2233 external_relocs
= alloc1
;
2236 internal_rela_relocs
= internal_relocs
;
2239 if (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rel
.hdr
,
2243 external_relocs
= (((bfd_byte
*) external_relocs
)
2244 + esdo
->rel
.hdr
->sh_size
);
2245 internal_rela_relocs
+= (NUM_SHDR_ENTRIES (esdo
->rel
.hdr
)
2246 * bed
->s
->int_rels_per_ext_rel
);
2250 && (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rela
.hdr
,
2252 internal_rela_relocs
)))
2255 /* Cache the results for next time, if we can. */
2257 esdo
->relocs
= internal_relocs
;
2262 /* Don't free alloc2, since if it was allocated we are passing it
2263 back (under the name of internal_relocs). */
2265 return internal_relocs
;
2273 bfd_release (abfd
, alloc2
);
2280 /* Compute the size of, and allocate space for, REL_HDR which is the
2281 section header for a section containing relocations for O. */
2284 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2285 struct bfd_elf_section_reloc_data
*reldata
)
2287 Elf_Internal_Shdr
*rel_hdr
= reldata
->hdr
;
2289 /* That allows us to calculate the size of the section. */
2290 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reldata
->count
;
2292 /* The contents field must last into write_object_contents, so we
2293 allocate it with bfd_alloc rather than malloc. Also since we
2294 cannot be sure that the contents will actually be filled in,
2295 we zero the allocated space. */
2296 rel_hdr
->contents
= (unsigned char *) bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2297 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2300 if (reldata
->hashes
== NULL
&& reldata
->count
)
2302 struct elf_link_hash_entry
**p
;
2304 p
= (struct elf_link_hash_entry
**)
2305 bfd_zmalloc (reldata
->count
* sizeof (struct elf_link_hash_entry
*));
2309 reldata
->hashes
= p
;
2315 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2316 originated from the section given by INPUT_REL_HDR) to the
2320 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2321 asection
*input_section
,
2322 Elf_Internal_Shdr
*input_rel_hdr
,
2323 Elf_Internal_Rela
*internal_relocs
,
2324 struct elf_link_hash_entry
**rel_hash
2327 Elf_Internal_Rela
*irela
;
2328 Elf_Internal_Rela
*irelaend
;
2330 struct bfd_elf_section_reloc_data
*output_reldata
;
2331 asection
*output_section
;
2332 const struct elf_backend_data
*bed
;
2333 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2334 struct bfd_elf_section_data
*esdo
;
2336 output_section
= input_section
->output_section
;
2338 bed
= get_elf_backend_data (output_bfd
);
2339 esdo
= elf_section_data (output_section
);
2340 if (esdo
->rel
.hdr
&& esdo
->rel
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2342 output_reldata
= &esdo
->rel
;
2343 swap_out
= bed
->s
->swap_reloc_out
;
2345 else if (esdo
->rela
.hdr
2346 && esdo
->rela
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2348 output_reldata
= &esdo
->rela
;
2349 swap_out
= bed
->s
->swap_reloca_out
;
2353 (*_bfd_error_handler
)
2354 (_("%B: relocation size mismatch in %B section %A"),
2355 output_bfd
, input_section
->owner
, input_section
);
2356 bfd_set_error (bfd_error_wrong_format
);
2360 erel
= output_reldata
->hdr
->contents
;
2361 erel
+= output_reldata
->count
* input_rel_hdr
->sh_entsize
;
2362 irela
= internal_relocs
;
2363 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2364 * bed
->s
->int_rels_per_ext_rel
);
2365 while (irela
< irelaend
)
2367 (*swap_out
) (output_bfd
, irela
, erel
);
2368 irela
+= bed
->s
->int_rels_per_ext_rel
;
2369 erel
+= input_rel_hdr
->sh_entsize
;
2372 /* Bump the counter, so that we know where to add the next set of
2374 output_reldata
->count
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2379 /* Make weak undefined symbols in PIE dynamic. */
2382 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info
*info
,
2383 struct elf_link_hash_entry
*h
)
2387 && h
->root
.type
== bfd_link_hash_undefweak
)
2388 return bfd_elf_link_record_dynamic_symbol (info
, h
);
2393 /* Fix up the flags for a symbol. This handles various cases which
2394 can only be fixed after all the input files are seen. This is
2395 currently called by both adjust_dynamic_symbol and
2396 assign_sym_version, which is unnecessary but perhaps more robust in
2397 the face of future changes. */
2400 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2401 struct elf_info_failed
*eif
)
2403 const struct elf_backend_data
*bed
;
2405 /* If this symbol was mentioned in a non-ELF file, try to set
2406 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2407 permit a non-ELF file to correctly refer to a symbol defined in
2408 an ELF dynamic object. */
2411 while (h
->root
.type
== bfd_link_hash_indirect
)
2412 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2414 if (h
->root
.type
!= bfd_link_hash_defined
2415 && h
->root
.type
!= bfd_link_hash_defweak
)
2418 h
->ref_regular_nonweak
= 1;
2422 if (h
->root
.u
.def
.section
->owner
!= NULL
2423 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2424 == bfd_target_elf_flavour
))
2427 h
->ref_regular_nonweak
= 1;
2433 if (h
->dynindx
== -1
2437 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2446 /* Unfortunately, NON_ELF is only correct if the symbol
2447 was first seen in a non-ELF file. Fortunately, if the symbol
2448 was first seen in an ELF file, we're probably OK unless the
2449 symbol was defined in a non-ELF file. Catch that case here.
2450 FIXME: We're still in trouble if the symbol was first seen in
2451 a dynamic object, and then later in a non-ELF regular object. */
2452 if ((h
->root
.type
== bfd_link_hash_defined
2453 || h
->root
.type
== bfd_link_hash_defweak
)
2455 && (h
->root
.u
.def
.section
->owner
!= NULL
2456 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2457 != bfd_target_elf_flavour
)
2458 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2459 && !h
->def_dynamic
)))
2463 /* Backend specific symbol fixup. */
2464 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2465 if (bed
->elf_backend_fixup_symbol
2466 && !(*bed
->elf_backend_fixup_symbol
) (eif
->info
, h
))
2469 /* If this is a final link, and the symbol was defined as a common
2470 symbol in a regular object file, and there was no definition in
2471 any dynamic object, then the linker will have allocated space for
2472 the symbol in a common section but the DEF_REGULAR
2473 flag will not have been set. */
2474 if (h
->root
.type
== bfd_link_hash_defined
2478 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2481 /* If -Bsymbolic was used (which means to bind references to global
2482 symbols to the definition within the shared object), and this
2483 symbol was defined in a regular object, then it actually doesn't
2484 need a PLT entry. Likewise, if the symbol has non-default
2485 visibility. If the symbol has hidden or internal visibility, we
2486 will force it local. */
2488 && eif
->info
->shared
2489 && is_elf_hash_table (eif
->info
->hash
)
2490 && (SYMBOLIC_BIND (eif
->info
, h
)
2491 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2494 bfd_boolean force_local
;
2496 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2497 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2498 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2501 /* If a weak undefined symbol has non-default visibility, we also
2502 hide it from the dynamic linker. */
2503 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2504 && h
->root
.type
== bfd_link_hash_undefweak
)
2505 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2507 /* If this is a weak defined symbol in a dynamic object, and we know
2508 the real definition in the dynamic object, copy interesting flags
2509 over to the real definition. */
2510 if (h
->u
.weakdef
!= NULL
)
2512 struct elf_link_hash_entry
*weakdef
;
2514 weakdef
= h
->u
.weakdef
;
2515 if (h
->root
.type
== bfd_link_hash_indirect
)
2516 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2518 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2519 || h
->root
.type
== bfd_link_hash_defweak
);
2520 BFD_ASSERT (weakdef
->def_dynamic
);
2522 /* If the real definition is defined by a regular object file,
2523 don't do anything special. See the longer description in
2524 _bfd_elf_adjust_dynamic_symbol, below. */
2525 if (weakdef
->def_regular
)
2526 h
->u
.weakdef
= NULL
;
2529 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2530 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2531 (*bed
->elf_backend_copy_indirect_symbol
) (eif
->info
, weakdef
, h
);
2538 /* Make the backend pick a good value for a dynamic symbol. This is
2539 called via elf_link_hash_traverse, and also calls itself
2543 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2545 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2547 const struct elf_backend_data
*bed
;
2549 if (! is_elf_hash_table (eif
->info
->hash
))
2552 /* Ignore indirect symbols. These are added by the versioning code. */
2553 if (h
->root
.type
== bfd_link_hash_indirect
)
2556 /* Fix the symbol flags. */
2557 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2560 /* If this symbol does not require a PLT entry, and it is not
2561 defined by a dynamic object, or is not referenced by a regular
2562 object, ignore it. We do have to handle a weak defined symbol,
2563 even if no regular object refers to it, if we decided to add it
2564 to the dynamic symbol table. FIXME: Do we normally need to worry
2565 about symbols which are defined by one dynamic object and
2566 referenced by another one? */
2568 && h
->type
!= STT_GNU_IFUNC
2572 && (h
->u
.weakdef
== NULL
|| h
->u
.weakdef
->dynindx
== -1))))
2574 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
2578 /* If we've already adjusted this symbol, don't do it again. This
2579 can happen via a recursive call. */
2580 if (h
->dynamic_adjusted
)
2583 /* Don't look at this symbol again. Note that we must set this
2584 after checking the above conditions, because we may look at a
2585 symbol once, decide not to do anything, and then get called
2586 recursively later after REF_REGULAR is set below. */
2587 h
->dynamic_adjusted
= 1;
2589 /* If this is a weak definition, and we know a real definition, and
2590 the real symbol is not itself defined by a regular object file,
2591 then get a good value for the real definition. We handle the
2592 real symbol first, for the convenience of the backend routine.
2594 Note that there is a confusing case here. If the real definition
2595 is defined by a regular object file, we don't get the real symbol
2596 from the dynamic object, but we do get the weak symbol. If the
2597 processor backend uses a COPY reloc, then if some routine in the
2598 dynamic object changes the real symbol, we will not see that
2599 change in the corresponding weak symbol. This is the way other
2600 ELF linkers work as well, and seems to be a result of the shared
2603 I will clarify this issue. Most SVR4 shared libraries define the
2604 variable _timezone and define timezone as a weak synonym. The
2605 tzset call changes _timezone. If you write
2606 extern int timezone;
2608 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2609 you might expect that, since timezone is a synonym for _timezone,
2610 the same number will print both times. However, if the processor
2611 backend uses a COPY reloc, then actually timezone will be copied
2612 into your process image, and, since you define _timezone
2613 yourself, _timezone will not. Thus timezone and _timezone will
2614 wind up at different memory locations. The tzset call will set
2615 _timezone, leaving timezone unchanged. */
2617 if (h
->u
.weakdef
!= NULL
)
2619 /* If we get to this point, we know there is an implicit
2620 reference by a regular object file via the weak symbol H.
2621 FIXME: Is this really true? What if the traversal finds
2622 H->U.WEAKDEF before it finds H? */
2623 h
->u
.weakdef
->ref_regular
= 1;
2625 if (! _bfd_elf_adjust_dynamic_symbol (h
->u
.weakdef
, eif
))
2629 /* If a symbol has no type and no size and does not require a PLT
2630 entry, then we are probably about to do the wrong thing here: we
2631 are probably going to create a COPY reloc for an empty object.
2632 This case can arise when a shared object is built with assembly
2633 code, and the assembly code fails to set the symbol type. */
2635 && h
->type
== STT_NOTYPE
2637 (*_bfd_error_handler
)
2638 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2639 h
->root
.root
.string
);
2641 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2642 bed
= get_elf_backend_data (dynobj
);
2644 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2653 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2657 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry
*h
,
2660 unsigned int power_of_two
;
2662 asection
*sec
= h
->root
.u
.def
.section
;
2664 /* The section aligment of definition is the maximum alignment
2665 requirement of symbols defined in the section. Since we don't
2666 know the symbol alignment requirement, we start with the
2667 maximum alignment and check low bits of the symbol address
2668 for the minimum alignment. */
2669 power_of_two
= bfd_get_section_alignment (sec
->owner
, sec
);
2670 mask
= ((bfd_vma
) 1 << power_of_two
) - 1;
2671 while ((h
->root
.u
.def
.value
& mask
) != 0)
2677 if (power_of_two
> bfd_get_section_alignment (dynbss
->owner
,
2680 /* Adjust the section alignment if needed. */
2681 if (! bfd_set_section_alignment (dynbss
->owner
, dynbss
,
2686 /* We make sure that the symbol will be aligned properly. */
2687 dynbss
->size
= BFD_ALIGN (dynbss
->size
, mask
+ 1);
2689 /* Define the symbol as being at this point in DYNBSS. */
2690 h
->root
.u
.def
.section
= dynbss
;
2691 h
->root
.u
.def
.value
= dynbss
->size
;
2693 /* Increment the size of DYNBSS to make room for the symbol. */
2694 dynbss
->size
+= h
->size
;
2699 /* Adjust all external symbols pointing into SEC_MERGE sections
2700 to reflect the object merging within the sections. */
2703 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2707 if ((h
->root
.type
== bfd_link_hash_defined
2708 || h
->root
.type
== bfd_link_hash_defweak
)
2709 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2710 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
2712 bfd
*output_bfd
= (bfd
*) data
;
2714 h
->root
.u
.def
.value
=
2715 _bfd_merged_section_offset (output_bfd
,
2716 &h
->root
.u
.def
.section
,
2717 elf_section_data (sec
)->sec_info
,
2718 h
->root
.u
.def
.value
);
2724 /* Returns false if the symbol referred to by H should be considered
2725 to resolve local to the current module, and true if it should be
2726 considered to bind dynamically. */
2729 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2730 struct bfd_link_info
*info
,
2731 bfd_boolean not_local_protected
)
2733 bfd_boolean binding_stays_local_p
;
2734 const struct elf_backend_data
*bed
;
2735 struct elf_link_hash_table
*hash_table
;
2740 while (h
->root
.type
== bfd_link_hash_indirect
2741 || h
->root
.type
== bfd_link_hash_warning
)
2742 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2744 /* If it was forced local, then clearly it's not dynamic. */
2745 if (h
->dynindx
== -1)
2747 if (h
->forced_local
)
2750 /* Identify the cases where name binding rules say that a
2751 visible symbol resolves locally. */
2752 binding_stays_local_p
= info
->executable
|| SYMBOLIC_BIND (info
, h
);
2754 switch (ELF_ST_VISIBILITY (h
->other
))
2761 hash_table
= elf_hash_table (info
);
2762 if (!is_elf_hash_table (hash_table
))
2765 bed
= get_elf_backend_data (hash_table
->dynobj
);
2767 /* Proper resolution for function pointer equality may require
2768 that these symbols perhaps be resolved dynamically, even though
2769 we should be resolving them to the current module. */
2770 if (!not_local_protected
|| !bed
->is_function_type (h
->type
))
2771 binding_stays_local_p
= TRUE
;
2778 /* If it isn't defined locally, then clearly it's dynamic. */
2779 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
2782 /* Otherwise, the symbol is dynamic if binding rules don't tell
2783 us that it remains local. */
2784 return !binding_stays_local_p
;
2787 /* Return true if the symbol referred to by H should be considered
2788 to resolve local to the current module, and false otherwise. Differs
2789 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2790 undefined symbols. The two functions are virtually identical except
2791 for the place where forced_local and dynindx == -1 are tested. If
2792 either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2793 the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2794 the symbol is local only for defined symbols.
2795 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2796 !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2797 treatment of undefined weak symbols. For those that do not make
2798 undefined weak symbols dynamic, both functions may return false. */
2801 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2802 struct bfd_link_info
*info
,
2803 bfd_boolean local_protected
)
2805 const struct elf_backend_data
*bed
;
2806 struct elf_link_hash_table
*hash_table
;
2808 /* If it's a local sym, of course we resolve locally. */
2812 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
2813 if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
2814 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
2817 /* Common symbols that become definitions don't get the DEF_REGULAR
2818 flag set, so test it first, and don't bail out. */
2819 if (ELF_COMMON_DEF_P (h
))
2821 /* If we don't have a definition in a regular file, then we can't
2822 resolve locally. The sym is either undefined or dynamic. */
2823 else if (!h
->def_regular
)
2826 /* Forced local symbols resolve locally. */
2827 if (h
->forced_local
)
2830 /* As do non-dynamic symbols. */
2831 if (h
->dynindx
== -1)
2834 /* At this point, we know the symbol is defined and dynamic. In an
2835 executable it must resolve locally, likewise when building symbolic
2836 shared libraries. */
2837 if (info
->executable
|| SYMBOLIC_BIND (info
, h
))
2840 /* Now deal with defined dynamic symbols in shared libraries. Ones
2841 with default visibility might not resolve locally. */
2842 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2845 hash_table
= elf_hash_table (info
);
2846 if (!is_elf_hash_table (hash_table
))
2849 bed
= get_elf_backend_data (hash_table
->dynobj
);
2851 /* STV_PROTECTED non-function symbols are local. */
2852 if (!bed
->is_function_type (h
->type
))
2855 /* Function pointer equality tests may require that STV_PROTECTED
2856 symbols be treated as dynamic symbols. If the address of a
2857 function not defined in an executable is set to that function's
2858 plt entry in the executable, then the address of the function in
2859 a shared library must also be the plt entry in the executable. */
2860 return local_protected
;
2863 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2864 aligned. Returns the first TLS output section. */
2866 struct bfd_section
*
2867 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
2869 struct bfd_section
*sec
, *tls
;
2870 unsigned int align
= 0;
2872 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2873 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
2877 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
2878 if (sec
->alignment_power
> align
)
2879 align
= sec
->alignment_power
;
2881 elf_hash_table (info
)->tls_sec
= tls
;
2883 /* Ensure the alignment of the first section is the largest alignment,
2884 so that the tls segment starts aligned. */
2886 tls
->alignment_power
= align
;
2891 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2893 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
2894 Elf_Internal_Sym
*sym
)
2896 const struct elf_backend_data
*bed
;
2898 /* Local symbols do not count, but target specific ones might. */
2899 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
2900 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
2903 bed
= get_elf_backend_data (abfd
);
2904 /* Function symbols do not count. */
2905 if (bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)))
2908 /* If the section is undefined, then so is the symbol. */
2909 if (sym
->st_shndx
== SHN_UNDEF
)
2912 /* If the symbol is defined in the common section, then
2913 it is a common definition and so does not count. */
2914 if (bed
->common_definition (sym
))
2917 /* If the symbol is in a target specific section then we
2918 must rely upon the backend to tell us what it is. */
2919 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
2920 /* FIXME - this function is not coded yet:
2922 return _bfd_is_global_symbol_definition (abfd, sym);
2924 Instead for now assume that the definition is not global,
2925 Even if this is wrong, at least the linker will behave
2926 in the same way that it used to do. */
2932 /* Search the symbol table of the archive element of the archive ABFD
2933 whose archive map contains a mention of SYMDEF, and determine if
2934 the symbol is defined in this element. */
2936 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
2938 Elf_Internal_Shdr
* hdr
;
2939 bfd_size_type symcount
;
2940 bfd_size_type extsymcount
;
2941 bfd_size_type extsymoff
;
2942 Elf_Internal_Sym
*isymbuf
;
2943 Elf_Internal_Sym
*isym
;
2944 Elf_Internal_Sym
*isymend
;
2947 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
2951 if (! bfd_check_format (abfd
, bfd_object
))
2954 /* If we have already included the element containing this symbol in the
2955 link then we do not need to include it again. Just claim that any symbol
2956 it contains is not a definition, so that our caller will not decide to
2957 (re)include this element. */
2958 if (abfd
->archive_pass
)
2961 /* Select the appropriate symbol table. */
2962 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
2963 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2965 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2967 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2969 /* The sh_info field of the symtab header tells us where the
2970 external symbols start. We don't care about the local symbols. */
2971 if (elf_bad_symtab (abfd
))
2973 extsymcount
= symcount
;
2978 extsymcount
= symcount
- hdr
->sh_info
;
2979 extsymoff
= hdr
->sh_info
;
2982 if (extsymcount
== 0)
2985 /* Read in the symbol table. */
2986 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
2988 if (isymbuf
== NULL
)
2991 /* Scan the symbol table looking for SYMDEF. */
2993 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
2997 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3002 if (strcmp (name
, symdef
->name
) == 0)
3004 result
= is_global_data_symbol_definition (abfd
, isym
);
3014 /* Add an entry to the .dynamic table. */
3017 _bfd_elf_add_dynamic_entry (struct bfd_link_info
*info
,
3021 struct elf_link_hash_table
*hash_table
;
3022 const struct elf_backend_data
*bed
;
3024 bfd_size_type newsize
;
3025 bfd_byte
*newcontents
;
3026 Elf_Internal_Dyn dyn
;
3028 hash_table
= elf_hash_table (info
);
3029 if (! is_elf_hash_table (hash_table
))
3032 bed
= get_elf_backend_data (hash_table
->dynobj
);
3033 s
= bfd_get_section_by_name (hash_table
->dynobj
, ".dynamic");
3034 BFD_ASSERT (s
!= NULL
);
3036 newsize
= s
->size
+ bed
->s
->sizeof_dyn
;
3037 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
3038 if (newcontents
== NULL
)
3042 dyn
.d_un
.d_val
= val
;
3043 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
, newcontents
+ s
->size
);
3046 s
->contents
= newcontents
;
3051 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3052 otherwise just check whether one already exists. Returns -1 on error,
3053 1 if a DT_NEEDED tag already exists, and 0 on success. */
3056 elf_add_dt_needed_tag (bfd
*abfd
,
3057 struct bfd_link_info
*info
,
3061 struct elf_link_hash_table
*hash_table
;
3062 bfd_size_type oldsize
;
3063 bfd_size_type strindex
;
3065 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
3068 hash_table
= elf_hash_table (info
);
3069 oldsize
= _bfd_elf_strtab_size (hash_table
->dynstr
);
3070 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, soname
, FALSE
);
3071 if (strindex
== (bfd_size_type
) -1)
3074 if (oldsize
== _bfd_elf_strtab_size (hash_table
->dynstr
))
3077 const struct elf_backend_data
*bed
;
3080 bed
= get_elf_backend_data (hash_table
->dynobj
);
3081 sdyn
= bfd_get_section_by_name (hash_table
->dynobj
, ".dynamic");
3083 for (extdyn
= sdyn
->contents
;
3084 extdyn
< sdyn
->contents
+ sdyn
->size
;
3085 extdyn
+= bed
->s
->sizeof_dyn
)
3087 Elf_Internal_Dyn dyn
;
3089 bed
->s
->swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
3090 if (dyn
.d_tag
== DT_NEEDED
3091 && dyn
.d_un
.d_val
== strindex
)
3093 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3101 if (!_bfd_elf_link_create_dynamic_sections (hash_table
->dynobj
, info
))
3104 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
3108 /* We were just checking for existence of the tag. */
3109 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3115 on_needed_list (const char *soname
, struct bfd_link_needed_list
*needed
)
3117 for (; needed
!= NULL
; needed
= needed
->next
)
3118 if (strcmp (soname
, needed
->name
) == 0)
3124 /* Sort symbol by value and section. */
3126 elf_sort_symbol (const void *arg1
, const void *arg2
)
3128 const struct elf_link_hash_entry
*h1
;
3129 const struct elf_link_hash_entry
*h2
;
3130 bfd_signed_vma vdiff
;
3132 h1
= *(const struct elf_link_hash_entry
**) arg1
;
3133 h2
= *(const struct elf_link_hash_entry
**) arg2
;
3134 vdiff
= h1
->root
.u
.def
.value
- h2
->root
.u
.def
.value
;
3136 return vdiff
> 0 ? 1 : -1;
3139 long sdiff
= h1
->root
.u
.def
.section
->id
- h2
->root
.u
.def
.section
->id
;
3141 return sdiff
> 0 ? 1 : -1;
3146 /* This function is used to adjust offsets into .dynstr for
3147 dynamic symbols. This is called via elf_link_hash_traverse. */
3150 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
3152 struct elf_strtab_hash
*dynstr
= (struct elf_strtab_hash
*) data
;
3154 if (h
->dynindx
!= -1)
3155 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
3159 /* Assign string offsets in .dynstr, update all structures referencing
3163 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
3165 struct elf_link_hash_table
*hash_table
= elf_hash_table (info
);
3166 struct elf_link_local_dynamic_entry
*entry
;
3167 struct elf_strtab_hash
*dynstr
= hash_table
->dynstr
;
3168 bfd
*dynobj
= hash_table
->dynobj
;
3171 const struct elf_backend_data
*bed
;
3174 _bfd_elf_strtab_finalize (dynstr
);
3175 size
= _bfd_elf_strtab_size (dynstr
);
3177 bed
= get_elf_backend_data (dynobj
);
3178 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3179 BFD_ASSERT (sdyn
!= NULL
);
3181 /* Update all .dynamic entries referencing .dynstr strings. */
3182 for (extdyn
= sdyn
->contents
;
3183 extdyn
< sdyn
->contents
+ sdyn
->size
;
3184 extdyn
+= bed
->s
->sizeof_dyn
)
3186 Elf_Internal_Dyn dyn
;
3188 bed
->s
->swap_dyn_in (dynobj
, extdyn
, &dyn
);
3192 dyn
.d_un
.d_val
= size
;
3202 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
3207 bed
->s
->swap_dyn_out (dynobj
, &dyn
, extdyn
);
3210 /* Now update local dynamic symbols. */
3211 for (entry
= hash_table
->dynlocal
; entry
; entry
= entry
->next
)
3212 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
3213 entry
->isym
.st_name
);
3215 /* And the rest of dynamic symbols. */
3216 elf_link_hash_traverse (hash_table
, elf_adjust_dynstr_offsets
, dynstr
);
3218 /* Adjust version definitions. */
3219 if (elf_tdata (output_bfd
)->cverdefs
)
3224 Elf_Internal_Verdef def
;
3225 Elf_Internal_Verdaux defaux
;
3227 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
3231 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
3233 p
+= sizeof (Elf_External_Verdef
);
3234 if (def
.vd_aux
!= sizeof (Elf_External_Verdef
))
3236 for (i
= 0; i
< def
.vd_cnt
; ++i
)
3238 _bfd_elf_swap_verdaux_in (output_bfd
,
3239 (Elf_External_Verdaux
*) p
, &defaux
);
3240 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
3242 _bfd_elf_swap_verdaux_out (output_bfd
,
3243 &defaux
, (Elf_External_Verdaux
*) p
);
3244 p
+= sizeof (Elf_External_Verdaux
);
3247 while (def
.vd_next
);
3250 /* Adjust version references. */
3251 if (elf_tdata (output_bfd
)->verref
)
3256 Elf_Internal_Verneed need
;
3257 Elf_Internal_Vernaux needaux
;
3259 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
3263 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
3265 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
3266 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
3267 (Elf_External_Verneed
*) p
);
3268 p
+= sizeof (Elf_External_Verneed
);
3269 for (i
= 0; i
< need
.vn_cnt
; ++i
)
3271 _bfd_elf_swap_vernaux_in (output_bfd
,
3272 (Elf_External_Vernaux
*) p
, &needaux
);
3273 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
3275 _bfd_elf_swap_vernaux_out (output_bfd
,
3277 (Elf_External_Vernaux
*) p
);
3278 p
+= sizeof (Elf_External_Vernaux
);
3281 while (need
.vn_next
);
3287 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3288 The default is to only match when the INPUT and OUTPUT are exactly
3292 _bfd_elf_default_relocs_compatible (const bfd_target
*input
,
3293 const bfd_target
*output
)
3295 return input
== output
;
3298 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3299 This version is used when different targets for the same architecture
3300 are virtually identical. */
3303 _bfd_elf_relocs_compatible (const bfd_target
*input
,
3304 const bfd_target
*output
)
3306 const struct elf_backend_data
*obed
, *ibed
;
3308 if (input
== output
)
3311 ibed
= xvec_get_elf_backend_data (input
);
3312 obed
= xvec_get_elf_backend_data (output
);
3314 if (ibed
->arch
!= obed
->arch
)
3317 /* If both backends are using this function, deem them compatible. */
3318 return ibed
->relocs_compatible
== obed
->relocs_compatible
;
3321 /* Add symbols from an ELF object file to the linker hash table. */
3324 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3326 Elf_Internal_Ehdr
*ehdr
;
3327 Elf_Internal_Shdr
*hdr
;
3328 bfd_size_type symcount
;
3329 bfd_size_type extsymcount
;
3330 bfd_size_type extsymoff
;
3331 struct elf_link_hash_entry
**sym_hash
;
3332 bfd_boolean dynamic
;
3333 Elf_External_Versym
*extversym
= NULL
;
3334 Elf_External_Versym
*ever
;
3335 struct elf_link_hash_entry
*weaks
;
3336 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
3337 bfd_size_type nondeflt_vers_cnt
= 0;
3338 Elf_Internal_Sym
*isymbuf
= NULL
;
3339 Elf_Internal_Sym
*isym
;
3340 Elf_Internal_Sym
*isymend
;
3341 const struct elf_backend_data
*bed
;
3342 bfd_boolean add_needed
;
3343 struct elf_link_hash_table
*htab
;
3345 void *alloc_mark
= NULL
;
3346 struct bfd_hash_entry
**old_table
= NULL
;
3347 unsigned int old_size
= 0;
3348 unsigned int old_count
= 0;
3349 void *old_tab
= NULL
;
3352 struct bfd_link_hash_entry
*old_undefs
= NULL
;
3353 struct bfd_link_hash_entry
*old_undefs_tail
= NULL
;
3354 long old_dynsymcount
= 0;
3356 size_t hashsize
= 0;
3358 htab
= elf_hash_table (info
);
3359 bed
= get_elf_backend_data (abfd
);
3361 if ((abfd
->flags
& DYNAMIC
) == 0)
3367 /* You can't use -r against a dynamic object. Also, there's no
3368 hope of using a dynamic object which does not exactly match
3369 the format of the output file. */
3370 if (info
->relocatable
3371 || !is_elf_hash_table (htab
)
3372 || info
->output_bfd
->xvec
!= abfd
->xvec
)
3374 if (info
->relocatable
)
3375 bfd_set_error (bfd_error_invalid_operation
);
3377 bfd_set_error (bfd_error_wrong_format
);
3382 ehdr
= elf_elfheader (abfd
);
3383 if (info
->warn_alternate_em
3384 && bed
->elf_machine_code
!= ehdr
->e_machine
3385 && ((bed
->elf_machine_alt1
!= 0
3386 && ehdr
->e_machine
== bed
->elf_machine_alt1
)
3387 || (bed
->elf_machine_alt2
!= 0
3388 && ehdr
->e_machine
== bed
->elf_machine_alt2
)))
3389 info
->callbacks
->einfo
3390 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3391 ehdr
->e_machine
, abfd
, bed
->elf_machine_code
);
3393 /* As a GNU extension, any input sections which are named
3394 .gnu.warning.SYMBOL are treated as warning symbols for the given
3395 symbol. This differs from .gnu.warning sections, which generate
3396 warnings when they are included in an output file. */
3397 /* PR 12761: Also generate this warning when building shared libraries. */
3398 if (info
->executable
|| info
->shared
)
3402 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3406 name
= bfd_get_section_name (abfd
, s
);
3407 if (CONST_STRNEQ (name
, ".gnu.warning."))
3412 name
+= sizeof ".gnu.warning." - 1;
3414 /* If this is a shared object, then look up the symbol
3415 in the hash table. If it is there, and it is already
3416 been defined, then we will not be using the entry
3417 from this shared object, so we don't need to warn.
3418 FIXME: If we see the definition in a regular object
3419 later on, we will warn, but we shouldn't. The only
3420 fix is to keep track of what warnings we are supposed
3421 to emit, and then handle them all at the end of the
3425 struct elf_link_hash_entry
*h
;
3427 h
= elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
3429 /* FIXME: What about bfd_link_hash_common? */
3431 && (h
->root
.type
== bfd_link_hash_defined
3432 || h
->root
.type
== bfd_link_hash_defweak
))
3434 /* We don't want to issue this warning. Clobber
3435 the section size so that the warning does not
3436 get copied into the output file. */
3443 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
3447 if (! bfd_get_section_contents (abfd
, s
, msg
, 0, sz
))
3452 if (! (_bfd_generic_link_add_one_symbol
3453 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
3454 FALSE
, bed
->collect
, NULL
)))
3457 if (! info
->relocatable
)
3459 /* Clobber the section size so that the warning does
3460 not get copied into the output file. */
3463 /* Also set SEC_EXCLUDE, so that symbols defined in
3464 the warning section don't get copied to the output. */
3465 s
->flags
|= SEC_EXCLUDE
;
3474 /* If we are creating a shared library, create all the dynamic
3475 sections immediately. We need to attach them to something,
3476 so we attach them to this BFD, provided it is the right
3477 format. FIXME: If there are no input BFD's of the same
3478 format as the output, we can't make a shared library. */
3480 && is_elf_hash_table (htab
)
3481 && info
->output_bfd
->xvec
== abfd
->xvec
3482 && !htab
->dynamic_sections_created
)
3484 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
3488 else if (!is_elf_hash_table (htab
))
3493 const char *soname
= NULL
;
3495 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
3498 /* ld --just-symbols and dynamic objects don't mix very well.
3499 ld shouldn't allow it. */
3500 if ((s
= abfd
->sections
) != NULL
3501 && s
->sec_info_type
== ELF_INFO_TYPE_JUST_SYMS
)
3504 /* If this dynamic lib was specified on the command line with
3505 --as-needed in effect, then we don't want to add a DT_NEEDED
3506 tag unless the lib is actually used. Similary for libs brought
3507 in by another lib's DT_NEEDED. When --no-add-needed is used
3508 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3509 any dynamic library in DT_NEEDED tags in the dynamic lib at
3511 add_needed
= (elf_dyn_lib_class (abfd
)
3512 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
3513 | DYN_NO_NEEDED
)) == 0;
3515 s
= bfd_get_section_by_name (abfd
, ".dynamic");
3520 unsigned int elfsec
;
3521 unsigned long shlink
;
3523 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
3530 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
3531 if (elfsec
== SHN_BAD
)
3532 goto error_free_dyn
;
3533 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
3535 for (extdyn
= dynbuf
;
3536 extdyn
< dynbuf
+ s
->size
;
3537 extdyn
+= bed
->s
->sizeof_dyn
)
3539 Elf_Internal_Dyn dyn
;
3541 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
3542 if (dyn
.d_tag
== DT_SONAME
)
3544 unsigned int tagv
= dyn
.d_un
.d_val
;
3545 soname
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3547 goto error_free_dyn
;
3549 if (dyn
.d_tag
== DT_NEEDED
)
3551 struct bfd_link_needed_list
*n
, **pn
;
3553 unsigned int tagv
= dyn
.d_un
.d_val
;
3555 amt
= sizeof (struct bfd_link_needed_list
);
3556 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3557 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3558 if (n
== NULL
|| fnm
== NULL
)
3559 goto error_free_dyn
;
3560 amt
= strlen (fnm
) + 1;
3561 anm
= (char *) bfd_alloc (abfd
, amt
);
3563 goto error_free_dyn
;
3564 memcpy (anm
, fnm
, amt
);
3568 for (pn
= &htab
->needed
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3572 if (dyn
.d_tag
== DT_RUNPATH
)
3574 struct bfd_link_needed_list
*n
, **pn
;
3576 unsigned int tagv
= dyn
.d_un
.d_val
;
3578 amt
= sizeof (struct bfd_link_needed_list
);
3579 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3580 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3581 if (n
== NULL
|| fnm
== NULL
)
3582 goto error_free_dyn
;
3583 amt
= strlen (fnm
) + 1;
3584 anm
= (char *) bfd_alloc (abfd
, amt
);
3586 goto error_free_dyn
;
3587 memcpy (anm
, fnm
, amt
);
3591 for (pn
= & runpath
;
3597 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3598 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
3600 struct bfd_link_needed_list
*n
, **pn
;
3602 unsigned int tagv
= dyn
.d_un
.d_val
;
3604 amt
= sizeof (struct bfd_link_needed_list
);
3605 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3606 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3607 if (n
== NULL
|| fnm
== NULL
)
3608 goto error_free_dyn
;
3609 amt
= strlen (fnm
) + 1;
3610 anm
= (char *) bfd_alloc (abfd
, amt
);
3612 goto error_free_dyn
;
3613 memcpy (anm
, fnm
, amt
);
3623 if (dyn
.d_tag
== DT_AUDIT
)
3625 unsigned int tagv
= dyn
.d_un
.d_val
;
3626 audit
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3633 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3634 frees all more recently bfd_alloc'd blocks as well. */
3640 struct bfd_link_needed_list
**pn
;
3641 for (pn
= &htab
->runpath
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3646 /* We do not want to include any of the sections in a dynamic
3647 object in the output file. We hack by simply clobbering the
3648 list of sections in the BFD. This could be handled more
3649 cleanly by, say, a new section flag; the existing
3650 SEC_NEVER_LOAD flag is not the one we want, because that one
3651 still implies that the section takes up space in the output
3653 bfd_section_list_clear (abfd
);
3655 /* Find the name to use in a DT_NEEDED entry that refers to this
3656 object. If the object has a DT_SONAME entry, we use it.
3657 Otherwise, if the generic linker stuck something in
3658 elf_dt_name, we use that. Otherwise, we just use the file
3660 if (soname
== NULL
|| *soname
== '\0')
3662 soname
= elf_dt_name (abfd
);
3663 if (soname
== NULL
|| *soname
== '\0')
3664 soname
= bfd_get_filename (abfd
);
3667 /* Save the SONAME because sometimes the linker emulation code
3668 will need to know it. */
3669 elf_dt_name (abfd
) = soname
;
3671 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
3675 /* If we have already included this dynamic object in the
3676 link, just ignore it. There is no reason to include a
3677 particular dynamic object more than once. */
3681 /* Save the DT_AUDIT entry for the linker emulation code. */
3682 elf_dt_audit (abfd
) = audit
;
3685 /* If this is a dynamic object, we always link against the .dynsym
3686 symbol table, not the .symtab symbol table. The dynamic linker
3687 will only see the .dynsym symbol table, so there is no reason to
3688 look at .symtab for a dynamic object. */
3690 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
3691 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3693 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3695 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
3697 /* The sh_info field of the symtab header tells us where the
3698 external symbols start. We don't care about the local symbols at
3700 if (elf_bad_symtab (abfd
))
3702 extsymcount
= symcount
;
3707 extsymcount
= symcount
- hdr
->sh_info
;
3708 extsymoff
= hdr
->sh_info
;
3712 if (extsymcount
!= 0)
3714 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3716 if (isymbuf
== NULL
)
3719 /* We store a pointer to the hash table entry for each external
3721 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3722 sym_hash
= (struct elf_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3723 if (sym_hash
== NULL
)
3724 goto error_free_sym
;
3725 elf_sym_hashes (abfd
) = sym_hash
;
3730 /* Read in any version definitions. */
3731 if (!_bfd_elf_slurp_version_tables (abfd
,
3732 info
->default_imported_symver
))
3733 goto error_free_sym
;
3735 /* Read in the symbol versions, but don't bother to convert them
3736 to internal format. */
3737 if (elf_dynversym (abfd
) != 0)
3739 Elf_Internal_Shdr
*versymhdr
;
3741 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
3742 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
3743 if (extversym
== NULL
)
3744 goto error_free_sym
;
3745 amt
= versymhdr
->sh_size
;
3746 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
3747 || bfd_bread (extversym
, amt
, abfd
) != amt
)
3748 goto error_free_vers
;
3752 /* If we are loading an as-needed shared lib, save the symbol table
3753 state before we start adding symbols. If the lib turns out
3754 to be unneeded, restore the state. */
3755 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
3760 for (entsize
= 0, i
= 0; i
< htab
->root
.table
.size
; i
++)
3762 struct bfd_hash_entry
*p
;
3763 struct elf_link_hash_entry
*h
;
3765 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3767 h
= (struct elf_link_hash_entry
*) p
;
3768 entsize
+= htab
->root
.table
.entsize
;
3769 if (h
->root
.type
== bfd_link_hash_warning
)
3770 entsize
+= htab
->root
.table
.entsize
;
3774 tabsize
= htab
->root
.table
.size
* sizeof (struct bfd_hash_entry
*);
3775 hashsize
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3776 old_tab
= bfd_malloc (tabsize
+ entsize
+ hashsize
);
3777 if (old_tab
== NULL
)
3778 goto error_free_vers
;
3780 /* Remember the current objalloc pointer, so that all mem for
3781 symbols added can later be reclaimed. */
3782 alloc_mark
= bfd_hash_allocate (&htab
->root
.table
, 1);
3783 if (alloc_mark
== NULL
)
3784 goto error_free_vers
;
3786 /* Make a special call to the linker "notice" function to
3787 tell it that we are about to handle an as-needed lib. */
3788 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
3789 notice_as_needed
, 0, NULL
))
3790 goto error_free_vers
;
3792 /* Clone the symbol table and sym hashes. Remember some
3793 pointers into the symbol table, and dynamic symbol count. */
3794 old_hash
= (char *) old_tab
+ tabsize
;
3795 old_ent
= (char *) old_hash
+ hashsize
;
3796 memcpy (old_tab
, htab
->root
.table
.table
, tabsize
);
3797 memcpy (old_hash
, sym_hash
, hashsize
);
3798 old_undefs
= htab
->root
.undefs
;
3799 old_undefs_tail
= htab
->root
.undefs_tail
;
3800 old_table
= htab
->root
.table
.table
;
3801 old_size
= htab
->root
.table
.size
;
3802 old_count
= htab
->root
.table
.count
;
3803 old_dynsymcount
= htab
->dynsymcount
;
3805 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
3807 struct bfd_hash_entry
*p
;
3808 struct elf_link_hash_entry
*h
;
3810 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3812 memcpy (old_ent
, p
, htab
->root
.table
.entsize
);
3813 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3814 h
= (struct elf_link_hash_entry
*) p
;
3815 if (h
->root
.type
== bfd_link_hash_warning
)
3817 memcpy (old_ent
, h
->root
.u
.i
.link
, htab
->root
.table
.entsize
);
3818 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3825 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
3826 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
3828 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
3832 asection
*sec
, *new_sec
;
3835 struct elf_link_hash_entry
*h
;
3836 bfd_boolean definition
;
3837 bfd_boolean size_change_ok
;
3838 bfd_boolean type_change_ok
;
3839 bfd_boolean new_weakdef
;
3840 bfd_boolean override
;
3842 unsigned int old_alignment
;
3844 bfd
* undef_bfd
= NULL
;
3848 flags
= BSF_NO_FLAGS
;
3850 value
= isym
->st_value
;
3852 common
= bed
->common_definition (isym
);
3854 bind
= ELF_ST_BIND (isym
->st_info
);
3858 /* This should be impossible, since ELF requires that all
3859 global symbols follow all local symbols, and that sh_info
3860 point to the first global symbol. Unfortunately, Irix 5
3865 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
3873 case STB_GNU_UNIQUE
:
3874 flags
= BSF_GNU_UNIQUE
;
3878 /* Leave it up to the processor backend. */
3882 if (isym
->st_shndx
== SHN_UNDEF
)
3883 sec
= bfd_und_section_ptr
;
3884 else if (isym
->st_shndx
== SHN_ABS
)
3885 sec
= bfd_abs_section_ptr
;
3886 else if (isym
->st_shndx
== SHN_COMMON
)
3888 sec
= bfd_com_section_ptr
;
3889 /* What ELF calls the size we call the value. What ELF
3890 calls the value we call the alignment. */
3891 value
= isym
->st_size
;
3895 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3897 sec
= bfd_abs_section_ptr
;
3898 else if (sec
->kept_section
)
3900 /* Symbols from discarded section are undefined. We keep
3902 sec
= bfd_und_section_ptr
;
3903 isym
->st_shndx
= SHN_UNDEF
;
3905 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
3909 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3912 goto error_free_vers
;
3914 if (isym
->st_shndx
== SHN_COMMON
3915 && (abfd
->flags
& BFD_PLUGIN
) != 0)
3917 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
3921 flagword sflags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
3923 xc
= bfd_make_section_with_flags (abfd
, "COMMON", sflags
);
3925 goto error_free_vers
;
3929 else if (isym
->st_shndx
== SHN_COMMON
3930 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
3931 && !info
->relocatable
)
3933 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
3937 flagword sflags
= (SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_IS_COMMON
3938 | SEC_LINKER_CREATED
);
3939 tcomm
= bfd_make_section_with_flags (abfd
, ".tcommon", sflags
);
3941 goto error_free_vers
;
3945 else if (bed
->elf_add_symbol_hook
)
3947 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
3949 goto error_free_vers
;
3951 /* The hook function sets the name to NULL if this symbol
3952 should be skipped for some reason. */
3957 /* Sanity check that all possibilities were handled. */
3960 bfd_set_error (bfd_error_bad_value
);
3961 goto error_free_vers
;
3964 if (bfd_is_und_section (sec
)
3965 || bfd_is_com_section (sec
))
3970 size_change_ok
= FALSE
;
3971 type_change_ok
= bed
->type_change_ok
;
3976 if (is_elf_hash_table (htab
))
3978 Elf_Internal_Versym iver
;
3979 unsigned int vernum
= 0;
3982 /* If this is a definition of a symbol which was previously
3983 referenced in a non-weak manner then make a note of the bfd
3984 that contained the reference. This is used if we need to
3985 refer to the source of the reference later on. */
3986 if (! bfd_is_und_section (sec
))
3988 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
3991 && h
->root
.type
== bfd_link_hash_undefined
3992 && h
->root
.u
.undef
.abfd
)
3993 undef_bfd
= h
->root
.u
.undef
.abfd
;
3998 if (info
->default_imported_symver
)
3999 /* Use the default symbol version created earlier. */
4000 iver
.vs_vers
= elf_tdata (abfd
)->cverdefs
;
4005 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
4007 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
4009 /* If this is a hidden symbol, or if it is not version
4010 1, we append the version name to the symbol name.
4011 However, we do not modify a non-hidden absolute symbol
4012 if it is not a function, because it might be the version
4013 symbol itself. FIXME: What if it isn't? */
4014 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
4016 && (!bfd_is_abs_section (sec
)
4017 || bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
)))))
4020 size_t namelen
, verlen
, newlen
;
4023 if (isym
->st_shndx
!= SHN_UNDEF
)
4025 if (vernum
> elf_tdata (abfd
)->cverdefs
)
4027 else if (vernum
> 1)
4029 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
4035 (*_bfd_error_handler
)
4036 (_("%B: %s: invalid version %u (max %d)"),
4038 elf_tdata (abfd
)->cverdefs
);
4039 bfd_set_error (bfd_error_bad_value
);
4040 goto error_free_vers
;
4045 /* We cannot simply test for the number of
4046 entries in the VERNEED section since the
4047 numbers for the needed versions do not start
4049 Elf_Internal_Verneed
*t
;
4052 for (t
= elf_tdata (abfd
)->verref
;
4056 Elf_Internal_Vernaux
*a
;
4058 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
4060 if (a
->vna_other
== vernum
)
4062 verstr
= a
->vna_nodename
;
4071 (*_bfd_error_handler
)
4072 (_("%B: %s: invalid needed version %d"),
4073 abfd
, name
, vernum
);
4074 bfd_set_error (bfd_error_bad_value
);
4075 goto error_free_vers
;
4079 namelen
= strlen (name
);
4080 verlen
= strlen (verstr
);
4081 newlen
= namelen
+ verlen
+ 2;
4082 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4083 && isym
->st_shndx
!= SHN_UNDEF
)
4086 newname
= (char *) bfd_hash_allocate (&htab
->root
.table
, newlen
);
4087 if (newname
== NULL
)
4088 goto error_free_vers
;
4089 memcpy (newname
, name
, namelen
);
4090 p
= newname
+ namelen
;
4092 /* If this is a defined non-hidden version symbol,
4093 we add another @ to the name. This indicates the
4094 default version of the symbol. */
4095 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4096 && isym
->st_shndx
!= SHN_UNDEF
)
4098 memcpy (p
, verstr
, verlen
+ 1);
4103 /* If necessary, make a second attempt to locate the bfd
4104 containing an unresolved, non-weak reference to the
4106 if (! bfd_is_und_section (sec
) && undef_bfd
== NULL
)
4108 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
4111 && h
->root
.type
== bfd_link_hash_undefined
4112 && h
->root
.u
.undef
.abfd
)
4113 undef_bfd
= h
->root
.u
.undef
.abfd
;
4116 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
,
4117 &value
, &old_alignment
,
4118 sym_hash
, &skip
, &override
,
4119 &type_change_ok
, &size_change_ok
))
4120 goto error_free_vers
;
4129 while (h
->root
.type
== bfd_link_hash_indirect
4130 || h
->root
.type
== bfd_link_hash_warning
)
4131 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4133 /* Remember the old alignment if this is a common symbol, so
4134 that we don't reduce the alignment later on. We can't
4135 check later, because _bfd_generic_link_add_one_symbol
4136 will set a default for the alignment which we want to
4137 override. We also remember the old bfd where the existing
4138 definition comes from. */
4139 switch (h
->root
.type
)
4144 case bfd_link_hash_defined
:
4145 case bfd_link_hash_defweak
:
4146 old_bfd
= h
->root
.u
.def
.section
->owner
;
4149 case bfd_link_hash_common
:
4150 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
4151 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
4155 if (elf_tdata (abfd
)->verdef
!= NULL
4159 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
4162 if (! (_bfd_generic_link_add_one_symbol
4163 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
4164 (struct bfd_link_hash_entry
**) sym_hash
)))
4165 goto error_free_vers
;
4168 while (h
->root
.type
== bfd_link_hash_indirect
4169 || h
->root
.type
== bfd_link_hash_warning
)
4170 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4173 if (is_elf_hash_table (htab
))
4174 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
4176 new_weakdef
= FALSE
;
4179 && (flags
& BSF_WEAK
) != 0
4180 && !bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
))
4181 && is_elf_hash_table (htab
)
4182 && h
->u
.weakdef
== NULL
)
4184 /* Keep a list of all weak defined non function symbols from
4185 a dynamic object, using the weakdef field. Later in this
4186 function we will set the weakdef field to the correct
4187 value. We only put non-function symbols from dynamic
4188 objects on this list, because that happens to be the only
4189 time we need to know the normal symbol corresponding to a
4190 weak symbol, and the information is time consuming to
4191 figure out. If the weakdef field is not already NULL,
4192 then this symbol was already defined by some previous
4193 dynamic object, and we will be using that previous
4194 definition anyhow. */
4196 h
->u
.weakdef
= weaks
;
4201 /* Set the alignment of a common symbol. */
4202 if ((common
|| bfd_is_com_section (sec
))
4203 && h
->root
.type
== bfd_link_hash_common
)
4208 align
= bfd_log2 (isym
->st_value
);
4211 /* The new symbol is a common symbol in a shared object.
4212 We need to get the alignment from the section. */
4213 align
= new_sec
->alignment_power
;
4215 if (align
> old_alignment
)
4216 h
->root
.u
.c
.p
->alignment_power
= align
;
4218 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
4221 if (is_elf_hash_table (htab
))
4225 /* Check the alignment when a common symbol is involved. This
4226 can change when a common symbol is overridden by a normal
4227 definition or a common symbol is ignored due to the old
4228 normal definition. We need to make sure the maximum
4229 alignment is maintained. */
4230 if ((old_alignment
|| common
)
4231 && h
->root
.type
!= bfd_link_hash_common
)
4233 unsigned int common_align
;
4234 unsigned int normal_align
;
4235 unsigned int symbol_align
;
4239 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
4240 if (h
->root
.u
.def
.section
->owner
!= NULL
4241 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
4243 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
4244 if (normal_align
> symbol_align
)
4245 normal_align
= symbol_align
;
4248 normal_align
= symbol_align
;
4252 common_align
= old_alignment
;
4253 common_bfd
= old_bfd
;
4258 common_align
= bfd_log2 (isym
->st_value
);
4260 normal_bfd
= old_bfd
;
4263 if (normal_align
< common_align
)
4265 /* PR binutils/2735 */
4266 if (normal_bfd
== NULL
)
4267 (*_bfd_error_handler
)
4268 (_("Warning: alignment %u of common symbol `%s' in %B"
4269 " is greater than the alignment (%u) of its section %A"),
4270 common_bfd
, h
->root
.u
.def
.section
,
4271 1 << common_align
, name
, 1 << normal_align
);
4273 (*_bfd_error_handler
)
4274 (_("Warning: alignment %u of symbol `%s' in %B"
4275 " is smaller than %u in %B"),
4276 normal_bfd
, common_bfd
,
4277 1 << normal_align
, name
, 1 << common_align
);
4281 /* Remember the symbol size if it isn't undefined. */
4282 if ((isym
->st_size
!= 0 && isym
->st_shndx
!= SHN_UNDEF
)
4283 && (definition
|| h
->size
== 0))
4286 && h
->size
!= isym
->st_size
4287 && ! size_change_ok
)
4288 (*_bfd_error_handler
)
4289 (_("Warning: size of symbol `%s' changed"
4290 " from %lu in %B to %lu in %B"),
4292 name
, (unsigned long) h
->size
,
4293 (unsigned long) isym
->st_size
);
4295 h
->size
= isym
->st_size
;
4298 /* If this is a common symbol, then we always want H->SIZE
4299 to be the size of the common symbol. The code just above
4300 won't fix the size if a common symbol becomes larger. We
4301 don't warn about a size change here, because that is
4302 covered by --warn-common. Allow changed between different
4304 if (h
->root
.type
== bfd_link_hash_common
)
4305 h
->size
= h
->root
.u
.c
.size
;
4307 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
4308 && (definition
|| h
->type
== STT_NOTYPE
))
4310 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
4312 /* Turn an IFUNC symbol from a DSO into a normal FUNC
4314 if (type
== STT_GNU_IFUNC
4315 && (abfd
->flags
& DYNAMIC
) != 0)
4318 if (h
->type
!= type
)
4320 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
4321 (*_bfd_error_handler
)
4322 (_("Warning: type of symbol `%s' changed"
4323 " from %d to %d in %B"),
4324 abfd
, name
, h
->type
, type
);
4330 /* Merge st_other field. */
4331 elf_merge_st_other (abfd
, h
, isym
, definition
, dynamic
);
4333 /* Set a flag in the hash table entry indicating the type of
4334 reference or definition we just found. Keep a count of
4335 the number of dynamic symbols we find. A dynamic symbol
4336 is one which is referenced or defined by both a regular
4337 object and a shared object. */
4344 if (bind
!= STB_WEAK
)
4345 h
->ref_regular_nonweak
= 1;
4357 if (! info
->executable
4370 || (h
->u
.weakdef
!= NULL
4372 && h
->u
.weakdef
->dynindx
!= -1))
4376 if (definition
&& (sec
->flags
& SEC_DEBUGGING
) && !info
->relocatable
)
4378 /* We don't want to make debug symbol dynamic. */
4383 h
->target_internal
= isym
->st_target_internal
;
4385 /* Check to see if we need to add an indirect symbol for
4386 the default name. */
4387 if (definition
|| h
->root
.type
== bfd_link_hash_common
)
4388 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
4389 &sec
, &value
, &dynsym
,
4391 goto error_free_vers
;
4393 if (definition
&& !dynamic
)
4395 char *p
= strchr (name
, ELF_VER_CHR
);
4396 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
4398 /* Queue non-default versions so that .symver x, x@FOO
4399 aliases can be checked. */
4402 amt
= ((isymend
- isym
+ 1)
4403 * sizeof (struct elf_link_hash_entry
*));
4405 (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4407 goto error_free_vers
;
4409 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
4413 if (dynsym
&& h
->dynindx
== -1)
4415 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4416 goto error_free_vers
;
4417 if (h
->u
.weakdef
!= NULL
4419 && h
->u
.weakdef
->dynindx
== -1)
4421 if (!bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
4422 goto error_free_vers
;
4425 else if (dynsym
&& h
->dynindx
!= -1)
4426 /* If the symbol already has a dynamic index, but
4427 visibility says it should not be visible, turn it into
4429 switch (ELF_ST_VISIBILITY (h
->other
))
4433 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
4443 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0
4444 && !on_needed_list (elf_dt_name (abfd
), htab
->needed
))))
4447 const char *soname
= elf_dt_name (abfd
);
4449 /* A symbol from a library loaded via DT_NEEDED of some
4450 other library is referenced by a regular object.
4451 Add a DT_NEEDED entry for it. Issue an error if
4452 --no-add-needed is used and the reference was not
4454 if (undef_bfd
!= NULL
4455 && (elf_dyn_lib_class (abfd
) & DYN_NO_NEEDED
) != 0)
4457 (*_bfd_error_handler
)
4458 (_("%B: undefined reference to symbol '%s'"),
4460 (*_bfd_error_handler
)
4461 (_("note: '%s' is defined in DSO %B so try adding it to the linker command line"),
4463 bfd_set_error (bfd_error_invalid_operation
);
4464 goto error_free_vers
;
4467 elf_dyn_lib_class (abfd
) = (enum dynamic_lib_link_class
)
4468 (elf_dyn_lib_class (abfd
) & ~DYN_AS_NEEDED
);
4471 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
4473 goto error_free_vers
;
4475 BFD_ASSERT (ret
== 0);
4480 if (extversym
!= NULL
)
4486 if (isymbuf
!= NULL
)
4492 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4496 /* Restore the symbol table. */
4497 if (bed
->as_needed_cleanup
)
4498 (*bed
->as_needed_cleanup
) (abfd
, info
);
4499 old_hash
= (char *) old_tab
+ tabsize
;
4500 old_ent
= (char *) old_hash
+ hashsize
;
4501 sym_hash
= elf_sym_hashes (abfd
);
4502 htab
->root
.table
.table
= old_table
;
4503 htab
->root
.table
.size
= old_size
;
4504 htab
->root
.table
.count
= old_count
;
4505 memcpy (htab
->root
.table
.table
, old_tab
, tabsize
);
4506 memcpy (sym_hash
, old_hash
, hashsize
);
4507 htab
->root
.undefs
= old_undefs
;
4508 htab
->root
.undefs_tail
= old_undefs_tail
;
4509 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4511 struct bfd_hash_entry
*p
;
4512 struct elf_link_hash_entry
*h
;
4514 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4516 h
= (struct elf_link_hash_entry
*) p
;
4517 if (h
->root
.type
== bfd_link_hash_warning
)
4518 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4519 if (h
->dynindx
>= old_dynsymcount
)
4520 _bfd_elf_strtab_delref (htab
->dynstr
, h
->dynstr_index
);
4522 memcpy (p
, old_ent
, htab
->root
.table
.entsize
);
4523 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4524 h
= (struct elf_link_hash_entry
*) p
;
4525 if (h
->root
.type
== bfd_link_hash_warning
)
4527 memcpy (h
->root
.u
.i
.link
, old_ent
, htab
->root
.table
.entsize
);
4528 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4533 /* Make a special call to the linker "notice" function to
4534 tell it that symbols added for crefs may need to be removed. */
4535 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4536 notice_not_needed
, 0, NULL
))
4537 goto error_free_vers
;
4540 objalloc_free_block ((struct objalloc
*) htab
->root
.table
.memory
,
4542 if (nondeflt_vers
!= NULL
)
4543 free (nondeflt_vers
);
4547 if (old_tab
!= NULL
)
4549 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4550 notice_needed
, 0, NULL
))
4551 goto error_free_vers
;
4556 /* Now that all the symbols from this input file are created, handle
4557 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4558 if (nondeflt_vers
!= NULL
)
4560 bfd_size_type cnt
, symidx
;
4562 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
4564 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
4565 char *shortname
, *p
;
4567 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
4569 || (h
->root
.type
!= bfd_link_hash_defined
4570 && h
->root
.type
!= bfd_link_hash_defweak
))
4573 amt
= p
- h
->root
.root
.string
;
4574 shortname
= (char *) bfd_malloc (amt
+ 1);
4576 goto error_free_vers
;
4577 memcpy (shortname
, h
->root
.root
.string
, amt
);
4578 shortname
[amt
] = '\0';
4580 hi
= (struct elf_link_hash_entry
*)
4581 bfd_link_hash_lookup (&htab
->root
, shortname
,
4582 FALSE
, FALSE
, FALSE
);
4584 && hi
->root
.type
== h
->root
.type
4585 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
4586 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
4588 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
4589 hi
->root
.type
= bfd_link_hash_indirect
;
4590 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
4591 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
4592 sym_hash
= elf_sym_hashes (abfd
);
4594 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
4595 if (sym_hash
[symidx
] == hi
)
4597 sym_hash
[symidx
] = h
;
4603 free (nondeflt_vers
);
4604 nondeflt_vers
= NULL
;
4607 /* Now set the weakdefs field correctly for all the weak defined
4608 symbols we found. The only way to do this is to search all the
4609 symbols. Since we only need the information for non functions in
4610 dynamic objects, that's the only time we actually put anything on
4611 the list WEAKS. We need this information so that if a regular
4612 object refers to a symbol defined weakly in a dynamic object, the
4613 real symbol in the dynamic object is also put in the dynamic
4614 symbols; we also must arrange for both symbols to point to the
4615 same memory location. We could handle the general case of symbol
4616 aliasing, but a general symbol alias can only be generated in
4617 assembler code, handling it correctly would be very time
4618 consuming, and other ELF linkers don't handle general aliasing
4622 struct elf_link_hash_entry
**hpp
;
4623 struct elf_link_hash_entry
**hppend
;
4624 struct elf_link_hash_entry
**sorted_sym_hash
;
4625 struct elf_link_hash_entry
*h
;
4628 /* Since we have to search the whole symbol list for each weak
4629 defined symbol, search time for N weak defined symbols will be
4630 O(N^2). Binary search will cut it down to O(NlogN). */
4631 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4632 sorted_sym_hash
= (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4633 if (sorted_sym_hash
== NULL
)
4635 sym_hash
= sorted_sym_hash
;
4636 hpp
= elf_sym_hashes (abfd
);
4637 hppend
= hpp
+ extsymcount
;
4639 for (; hpp
< hppend
; hpp
++)
4643 && h
->root
.type
== bfd_link_hash_defined
4644 && !bed
->is_function_type (h
->type
))
4652 qsort (sorted_sym_hash
, sym_count
,
4653 sizeof (struct elf_link_hash_entry
*),
4656 while (weaks
!= NULL
)
4658 struct elf_link_hash_entry
*hlook
;
4665 weaks
= hlook
->u
.weakdef
;
4666 hlook
->u
.weakdef
= NULL
;
4668 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4669 || hlook
->root
.type
== bfd_link_hash_defweak
4670 || hlook
->root
.type
== bfd_link_hash_common
4671 || hlook
->root
.type
== bfd_link_hash_indirect
);
4672 slook
= hlook
->root
.u
.def
.section
;
4673 vlook
= hlook
->root
.u
.def
.value
;
4680 bfd_signed_vma vdiff
;
4682 h
= sorted_sym_hash
[idx
];
4683 vdiff
= vlook
- h
->root
.u
.def
.value
;
4690 long sdiff
= slook
->id
- h
->root
.u
.def
.section
->id
;
4703 /* We didn't find a value/section match. */
4707 for (i
= ilook
; i
< sym_count
; i
++)
4709 h
= sorted_sym_hash
[i
];
4711 /* Stop if value or section doesn't match. */
4712 if (h
->root
.u
.def
.value
!= vlook
4713 || h
->root
.u
.def
.section
!= slook
)
4715 else if (h
!= hlook
)
4717 hlook
->u
.weakdef
= h
;
4719 /* If the weak definition is in the list of dynamic
4720 symbols, make sure the real definition is put
4722 if (hlook
->dynindx
!= -1 && h
->dynindx
== -1)
4724 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4727 free (sorted_sym_hash
);
4732 /* If the real definition is in the list of dynamic
4733 symbols, make sure the weak definition is put
4734 there as well. If we don't do this, then the
4735 dynamic loader might not merge the entries for the
4736 real definition and the weak definition. */
4737 if (h
->dynindx
!= -1 && hlook
->dynindx
== -1)
4739 if (! bfd_elf_link_record_dynamic_symbol (info
, hlook
))
4740 goto err_free_sym_hash
;
4747 free (sorted_sym_hash
);
4750 if (bed
->check_directives
4751 && !(*bed
->check_directives
) (abfd
, info
))
4754 /* If this object is the same format as the output object, and it is
4755 not a shared library, then let the backend look through the
4758 This is required to build global offset table entries and to
4759 arrange for dynamic relocs. It is not required for the
4760 particular common case of linking non PIC code, even when linking
4761 against shared libraries, but unfortunately there is no way of
4762 knowing whether an object file has been compiled PIC or not.
4763 Looking through the relocs is not particularly time consuming.
4764 The problem is that we must either (1) keep the relocs in memory,
4765 which causes the linker to require additional runtime memory or
4766 (2) read the relocs twice from the input file, which wastes time.
4767 This would be a good case for using mmap.
4769 I have no idea how to handle linking PIC code into a file of a
4770 different format. It probably can't be done. */
4772 && is_elf_hash_table (htab
)
4773 && bed
->check_relocs
!= NULL
4774 && elf_object_id (abfd
) == elf_hash_table_id (htab
)
4775 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
4779 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4781 Elf_Internal_Rela
*internal_relocs
;
4784 if ((o
->flags
& SEC_RELOC
) == 0
4785 || o
->reloc_count
== 0
4786 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
4787 && (o
->flags
& SEC_DEBUGGING
) != 0)
4788 || bfd_is_abs_section (o
->output_section
))
4791 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
4793 if (internal_relocs
== NULL
)
4796 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
4798 if (elf_section_data (o
)->relocs
!= internal_relocs
)
4799 free (internal_relocs
);
4806 /* If this is a non-traditional link, try to optimize the handling
4807 of the .stab/.stabstr sections. */
4809 && ! info
->traditional_format
4810 && is_elf_hash_table (htab
)
4811 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
4815 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
4816 if (stabstr
!= NULL
)
4818 bfd_size_type string_offset
= 0;
4821 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
4822 if (CONST_STRNEQ (stab
->name
, ".stab")
4823 && (!stab
->name
[5] ||
4824 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
4825 && (stab
->flags
& SEC_MERGE
) == 0
4826 && !bfd_is_abs_section (stab
->output_section
))
4828 struct bfd_elf_section_data
*secdata
;
4830 secdata
= elf_section_data (stab
);
4831 if (! _bfd_link_section_stabs (abfd
, &htab
->stab_info
, stab
,
4832 stabstr
, &secdata
->sec_info
,
4835 if (secdata
->sec_info
)
4836 stab
->sec_info_type
= ELF_INFO_TYPE_STABS
;
4841 if (is_elf_hash_table (htab
) && add_needed
)
4843 /* Add this bfd to the loaded list. */
4844 struct elf_link_loaded_list
*n
;
4846 n
= (struct elf_link_loaded_list
*)
4847 bfd_alloc (abfd
, sizeof (struct elf_link_loaded_list
));
4851 n
->next
= htab
->loaded
;
4858 if (old_tab
!= NULL
)
4860 if (nondeflt_vers
!= NULL
)
4861 free (nondeflt_vers
);
4862 if (extversym
!= NULL
)
4865 if (isymbuf
!= NULL
)
4871 /* Return the linker hash table entry of a symbol that might be
4872 satisfied by an archive symbol. Return -1 on error. */
4874 struct elf_link_hash_entry
*
4875 _bfd_elf_archive_symbol_lookup (bfd
*abfd
,
4876 struct bfd_link_info
*info
,
4879 struct elf_link_hash_entry
*h
;
4883 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, TRUE
);
4887 /* If this is a default version (the name contains @@), look up the
4888 symbol again with only one `@' as well as without the version.
4889 The effect is that references to the symbol with and without the
4890 version will be matched by the default symbol in the archive. */
4892 p
= strchr (name
, ELF_VER_CHR
);
4893 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
4896 /* First check with only one `@'. */
4897 len
= strlen (name
);
4898 copy
= (char *) bfd_alloc (abfd
, len
);
4900 return (struct elf_link_hash_entry
*) 0 - 1;
4902 first
= p
- name
+ 1;
4903 memcpy (copy
, name
, first
);
4904 memcpy (copy
+ first
, name
+ first
+ 1, len
- first
);
4906 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
, FALSE
, FALSE
, TRUE
);
4909 /* We also need to check references to the symbol without the
4911 copy
[first
- 1] = '\0';
4912 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
4913 FALSE
, FALSE
, TRUE
);
4916 bfd_release (abfd
, copy
);
4920 /* Add symbols from an ELF archive file to the linker hash table. We
4921 don't use _bfd_generic_link_add_archive_symbols because of a
4922 problem which arises on UnixWare. The UnixWare libc.so is an
4923 archive which includes an entry libc.so.1 which defines a bunch of
4924 symbols. The libc.so archive also includes a number of other
4925 object files, which also define symbols, some of which are the same
4926 as those defined in libc.so.1. Correct linking requires that we
4927 consider each object file in turn, and include it if it defines any
4928 symbols we need. _bfd_generic_link_add_archive_symbols does not do
4929 this; it looks through the list of undefined symbols, and includes
4930 any object file which defines them. When this algorithm is used on
4931 UnixWare, it winds up pulling in libc.so.1 early and defining a
4932 bunch of symbols. This means that some of the other objects in the
4933 archive are not included in the link, which is incorrect since they
4934 precede libc.so.1 in the archive.
4936 Fortunately, ELF archive handling is simpler than that done by
4937 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4938 oddities. In ELF, if we find a symbol in the archive map, and the
4939 symbol is currently undefined, we know that we must pull in that
4942 Unfortunately, we do have to make multiple passes over the symbol
4943 table until nothing further is resolved. */
4946 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4949 bfd_boolean
*defined
= NULL
;
4950 bfd_boolean
*included
= NULL
;
4954 const struct elf_backend_data
*bed
;
4955 struct elf_link_hash_entry
* (*archive_symbol_lookup
)
4956 (bfd
*, struct bfd_link_info
*, const char *);
4958 if (! bfd_has_map (abfd
))
4960 /* An empty archive is a special case. */
4961 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
4963 bfd_set_error (bfd_error_no_armap
);
4967 /* Keep track of all symbols we know to be already defined, and all
4968 files we know to be already included. This is to speed up the
4969 second and subsequent passes. */
4970 c
= bfd_ardata (abfd
)->symdef_count
;
4974 amt
*= sizeof (bfd_boolean
);
4975 defined
= (bfd_boolean
*) bfd_zmalloc (amt
);
4976 included
= (bfd_boolean
*) bfd_zmalloc (amt
);
4977 if (defined
== NULL
|| included
== NULL
)
4980 symdefs
= bfd_ardata (abfd
)->symdefs
;
4981 bed
= get_elf_backend_data (abfd
);
4982 archive_symbol_lookup
= bed
->elf_backend_archive_symbol_lookup
;
4995 symdefend
= symdef
+ c
;
4996 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
4998 struct elf_link_hash_entry
*h
;
5000 struct bfd_link_hash_entry
*undefs_tail
;
5003 if (defined
[i
] || included
[i
])
5005 if (symdef
->file_offset
== last
)
5011 h
= archive_symbol_lookup (abfd
, info
, symdef
->name
);
5012 if (h
== (struct elf_link_hash_entry
*) 0 - 1)
5018 if (h
->root
.type
== bfd_link_hash_common
)
5020 /* We currently have a common symbol. The archive map contains
5021 a reference to this symbol, so we may want to include it. We
5022 only want to include it however, if this archive element
5023 contains a definition of the symbol, not just another common
5026 Unfortunately some archivers (including GNU ar) will put
5027 declarations of common symbols into their archive maps, as
5028 well as real definitions, so we cannot just go by the archive
5029 map alone. Instead we must read in the element's symbol
5030 table and check that to see what kind of symbol definition
5032 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
5035 else if (h
->root
.type
!= bfd_link_hash_undefined
)
5037 if (h
->root
.type
!= bfd_link_hash_undefweak
)
5042 /* We need to include this archive member. */
5043 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
5044 if (element
== NULL
)
5047 if (! bfd_check_format (element
, bfd_object
))
5050 /* Doublecheck that we have not included this object
5051 already--it should be impossible, but there may be
5052 something wrong with the archive. */
5053 if (element
->archive_pass
!= 0)
5055 bfd_set_error (bfd_error_bad_value
);
5058 element
->archive_pass
= 1;
5060 undefs_tail
= info
->hash
->undefs_tail
;
5062 if (!(*info
->callbacks
5063 ->add_archive_element
) (info
, element
, symdef
->name
, &element
))
5065 if (!bfd_link_add_symbols (element
, info
))
5068 /* If there are any new undefined symbols, we need to make
5069 another pass through the archive in order to see whether
5070 they can be defined. FIXME: This isn't perfect, because
5071 common symbols wind up on undefs_tail and because an
5072 undefined symbol which is defined later on in this pass
5073 does not require another pass. This isn't a bug, but it
5074 does make the code less efficient than it could be. */
5075 if (undefs_tail
!= info
->hash
->undefs_tail
)
5078 /* Look backward to mark all symbols from this object file
5079 which we have already seen in this pass. */
5083 included
[mark
] = TRUE
;
5088 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
5090 /* We mark subsequent symbols from this object file as we go
5091 on through the loop. */
5092 last
= symdef
->file_offset
;
5103 if (defined
!= NULL
)
5105 if (included
!= NULL
)
5110 /* Given an ELF BFD, add symbols to the global hash table as
5114 bfd_elf_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5116 switch (bfd_get_format (abfd
))
5119 return elf_link_add_object_symbols (abfd
, info
);
5121 return elf_link_add_archive_symbols (abfd
, info
);
5123 bfd_set_error (bfd_error_wrong_format
);
5128 struct hash_codes_info
5130 unsigned long *hashcodes
;
5134 /* This function will be called though elf_link_hash_traverse to store
5135 all hash value of the exported symbols in an array. */
5138 elf_collect_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5140 struct hash_codes_info
*inf
= (struct hash_codes_info
*) data
;
5146 /* Ignore indirect symbols. These are added by the versioning code. */
5147 if (h
->dynindx
== -1)
5150 name
= h
->root
.root
.string
;
5151 p
= strchr (name
, ELF_VER_CHR
);
5154 alc
= (char *) bfd_malloc (p
- name
+ 1);
5160 memcpy (alc
, name
, p
- name
);
5161 alc
[p
- name
] = '\0';
5165 /* Compute the hash value. */
5166 ha
= bfd_elf_hash (name
);
5168 /* Store the found hash value in the array given as the argument. */
5169 *(inf
->hashcodes
)++ = ha
;
5171 /* And store it in the struct so that we can put it in the hash table
5173 h
->u
.elf_hash_value
= ha
;
5181 struct collect_gnu_hash_codes
5184 const struct elf_backend_data
*bed
;
5185 unsigned long int nsyms
;
5186 unsigned long int maskbits
;
5187 unsigned long int *hashcodes
;
5188 unsigned long int *hashval
;
5189 unsigned long int *indx
;
5190 unsigned long int *counts
;
5193 long int min_dynindx
;
5194 unsigned long int bucketcount
;
5195 unsigned long int symindx
;
5196 long int local_indx
;
5197 long int shift1
, shift2
;
5198 unsigned long int mask
;
5202 /* This function will be called though elf_link_hash_traverse to store
5203 all hash value of the exported symbols in an array. */
5206 elf_collect_gnu_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5208 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5214 /* Ignore indirect symbols. These are added by the versioning code. */
5215 if (h
->dynindx
== -1)
5218 /* Ignore also local symbols and undefined symbols. */
5219 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5222 name
= h
->root
.root
.string
;
5223 p
= strchr (name
, ELF_VER_CHR
);
5226 alc
= (char *) bfd_malloc (p
- name
+ 1);
5232 memcpy (alc
, name
, p
- name
);
5233 alc
[p
- name
] = '\0';
5237 /* Compute the hash value. */
5238 ha
= bfd_elf_gnu_hash (name
);
5240 /* Store the found hash value in the array for compute_bucket_count,
5241 and also for .dynsym reordering purposes. */
5242 s
->hashcodes
[s
->nsyms
] = ha
;
5243 s
->hashval
[h
->dynindx
] = ha
;
5245 if (s
->min_dynindx
< 0 || s
->min_dynindx
> h
->dynindx
)
5246 s
->min_dynindx
= h
->dynindx
;
5254 /* This function will be called though elf_link_hash_traverse to do
5255 final dynaminc symbol renumbering. */
5258 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry
*h
, void *data
)
5260 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5261 unsigned long int bucket
;
5262 unsigned long int val
;
5264 /* Ignore indirect symbols. */
5265 if (h
->dynindx
== -1)
5268 /* Ignore also local symbols and undefined symbols. */
5269 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5271 if (h
->dynindx
>= s
->min_dynindx
)
5272 h
->dynindx
= s
->local_indx
++;
5276 bucket
= s
->hashval
[h
->dynindx
] % s
->bucketcount
;
5277 val
= (s
->hashval
[h
->dynindx
] >> s
->shift1
)
5278 & ((s
->maskbits
>> s
->shift1
) - 1);
5279 s
->bitmask
[val
] |= ((bfd_vma
) 1) << (s
->hashval
[h
->dynindx
] & s
->mask
);
5281 |= ((bfd_vma
) 1) << ((s
->hashval
[h
->dynindx
] >> s
->shift2
) & s
->mask
);
5282 val
= s
->hashval
[h
->dynindx
] & ~(unsigned long int) 1;
5283 if (s
->counts
[bucket
] == 1)
5284 /* Last element terminates the chain. */
5286 bfd_put_32 (s
->output_bfd
, val
,
5287 s
->contents
+ (s
->indx
[bucket
] - s
->symindx
) * 4);
5288 --s
->counts
[bucket
];
5289 h
->dynindx
= s
->indx
[bucket
]++;
5293 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5296 _bfd_elf_hash_symbol (struct elf_link_hash_entry
*h
)
5298 return !(h
->forced_local
5299 || h
->root
.type
== bfd_link_hash_undefined
5300 || h
->root
.type
== bfd_link_hash_undefweak
5301 || ((h
->root
.type
== bfd_link_hash_defined
5302 || h
->root
.type
== bfd_link_hash_defweak
)
5303 && h
->root
.u
.def
.section
->output_section
== NULL
));
5306 /* Array used to determine the number of hash table buckets to use
5307 based on the number of symbols there are. If there are fewer than
5308 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5309 fewer than 37 we use 17 buckets, and so forth. We never use more
5310 than 32771 buckets. */
5312 static const size_t elf_buckets
[] =
5314 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5318 /* Compute bucket count for hashing table. We do not use a static set
5319 of possible tables sizes anymore. Instead we determine for all
5320 possible reasonable sizes of the table the outcome (i.e., the
5321 number of collisions etc) and choose the best solution. The
5322 weighting functions are not too simple to allow the table to grow
5323 without bounds. Instead one of the weighting factors is the size.
5324 Therefore the result is always a good payoff between few collisions
5325 (= short chain lengths) and table size. */
5327 compute_bucket_count (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5328 unsigned long int *hashcodes ATTRIBUTE_UNUSED
,
5329 unsigned long int nsyms
,
5332 size_t best_size
= 0;
5333 unsigned long int i
;
5335 /* We have a problem here. The following code to optimize the table
5336 size requires an integer type with more the 32 bits. If
5337 BFD_HOST_U_64_BIT is set we know about such a type. */
5338 #ifdef BFD_HOST_U_64_BIT
5343 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
5344 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
5345 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5346 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
5347 unsigned long int *counts
;
5349 unsigned int no_improvement_count
= 0;
5351 /* Possible optimization parameters: if we have NSYMS symbols we say
5352 that the hashing table must at least have NSYMS/4 and at most
5354 minsize
= nsyms
/ 4;
5357 best_size
= maxsize
= nsyms
* 2;
5362 if ((best_size
& 31) == 0)
5366 /* Create array where we count the collisions in. We must use bfd_malloc
5367 since the size could be large. */
5369 amt
*= sizeof (unsigned long int);
5370 counts
= (unsigned long int *) bfd_malloc (amt
);
5374 /* Compute the "optimal" size for the hash table. The criteria is a
5375 minimal chain length. The minor criteria is (of course) the size
5377 for (i
= minsize
; i
< maxsize
; ++i
)
5379 /* Walk through the array of hashcodes and count the collisions. */
5380 BFD_HOST_U_64_BIT max
;
5381 unsigned long int j
;
5382 unsigned long int fact
;
5384 if (gnu_hash
&& (i
& 31) == 0)
5387 memset (counts
, '\0', i
* sizeof (unsigned long int));
5389 /* Determine how often each hash bucket is used. */
5390 for (j
= 0; j
< nsyms
; ++j
)
5391 ++counts
[hashcodes
[j
] % i
];
5393 /* For the weight function we need some information about the
5394 pagesize on the target. This is information need not be 100%
5395 accurate. Since this information is not available (so far) we
5396 define it here to a reasonable default value. If it is crucial
5397 to have a better value some day simply define this value. */
5398 # ifndef BFD_TARGET_PAGESIZE
5399 # define BFD_TARGET_PAGESIZE (4096)
5402 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5404 max
= (2 + dynsymcount
) * bed
->s
->sizeof_hash_entry
;
5407 /* Variant 1: optimize for short chains. We add the squares
5408 of all the chain lengths (which favors many small chain
5409 over a few long chains). */
5410 for (j
= 0; j
< i
; ++j
)
5411 max
+= counts
[j
] * counts
[j
];
5413 /* This adds penalties for the overall size of the table. */
5414 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5417 /* Variant 2: Optimize a lot more for small table. Here we
5418 also add squares of the size but we also add penalties for
5419 empty slots (the +1 term). */
5420 for (j
= 0; j
< i
; ++j
)
5421 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
5423 /* The overall size of the table is considered, but not as
5424 strong as in variant 1, where it is squared. */
5425 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5429 /* Compare with current best results. */
5430 if (max
< best_chlen
)
5434 no_improvement_count
= 0;
5436 /* PR 11843: Avoid futile long searches for the best bucket size
5437 when there are a large number of symbols. */
5438 else if (++no_improvement_count
== 100)
5445 #endif /* defined (BFD_HOST_U_64_BIT) */
5447 /* This is the fallback solution if no 64bit type is available or if we
5448 are not supposed to spend much time on optimizations. We select the
5449 bucket count using a fixed set of numbers. */
5450 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5452 best_size
= elf_buckets
[i
];
5453 if (nsyms
< elf_buckets
[i
+ 1])
5456 if (gnu_hash
&& best_size
< 2)
5463 /* Size any SHT_GROUP section for ld -r. */
5466 _bfd_elf_size_group_sections (struct bfd_link_info
*info
)
5470 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
5471 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
5472 && !_bfd_elf_fixup_group_sections (ibfd
, bfd_abs_section_ptr
))
5477 /* Set up the sizes and contents of the ELF dynamic sections. This is
5478 called by the ELF linker emulation before_allocation routine. We
5479 must set the sizes of the sections before the linker sets the
5480 addresses of the various sections. */
5483 bfd_elf_size_dynamic_sections (bfd
*output_bfd
,
5486 const char *filter_shlib
,
5488 const char *depaudit
,
5489 const char * const *auxiliary_filters
,
5490 struct bfd_link_info
*info
,
5491 asection
**sinterpptr
,
5492 struct bfd_elf_version_tree
*verdefs
)
5494 bfd_size_type soname_indx
;
5496 const struct elf_backend_data
*bed
;
5497 struct elf_info_failed asvinfo
;
5501 soname_indx
= (bfd_size_type
) -1;
5503 if (!is_elf_hash_table (info
->hash
))
5506 bed
= get_elf_backend_data (output_bfd
);
5507 if (info
->execstack
)
5508 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
5509 else if (info
->noexecstack
)
5510 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
;
5514 asection
*notesec
= NULL
;
5517 for (inputobj
= info
->input_bfds
;
5519 inputobj
= inputobj
->link_next
)
5523 if (inputobj
->flags
& (DYNAMIC
| EXEC_P
| BFD_LINKER_CREATED
))
5525 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
5528 if (s
->flags
& SEC_CODE
)
5532 else if (bed
->default_execstack
)
5537 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| exec
;
5538 if (exec
&& info
->relocatable
5539 && notesec
->output_section
!= bfd_abs_section_ptr
)
5540 notesec
->output_section
->flags
|= SEC_CODE
;
5544 /* Any syms created from now on start with -1 in
5545 got.refcount/offset and plt.refcount/offset. */
5546 elf_hash_table (info
)->init_got_refcount
5547 = elf_hash_table (info
)->init_got_offset
;
5548 elf_hash_table (info
)->init_plt_refcount
5549 = elf_hash_table (info
)->init_plt_offset
;
5551 if (info
->relocatable
5552 && !_bfd_elf_size_group_sections (info
))
5555 /* The backend may have to create some sections regardless of whether
5556 we're dynamic or not. */
5557 if (bed
->elf_backend_always_size_sections
5558 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
5561 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
5564 dynobj
= elf_hash_table (info
)->dynobj
;
5566 /* If there were no dynamic objects in the link, there is nothing to
5571 if (elf_hash_table (info
)->dynamic_sections_created
)
5573 struct elf_info_failed eif
;
5574 struct elf_link_hash_entry
*h
;
5576 struct bfd_elf_version_tree
*t
;
5577 struct bfd_elf_version_expr
*d
;
5579 bfd_boolean all_defined
;
5581 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5582 BFD_ASSERT (*sinterpptr
!= NULL
|| !info
->executable
);
5586 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5588 if (soname_indx
== (bfd_size_type
) -1
5589 || !_bfd_elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
5595 if (!_bfd_elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
5597 info
->flags
|= DF_SYMBOLIC
;
5604 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5606 if (indx
== (bfd_size_type
) -1
5607 || !_bfd_elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5610 if (info
->new_dtags
)
5612 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
, indx
);
5613 if (!_bfd_elf_add_dynamic_entry (info
, DT_RUNPATH
, indx
))
5618 if (filter_shlib
!= NULL
)
5622 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5623 filter_shlib
, TRUE
);
5624 if (indx
== (bfd_size_type
) -1
5625 || !_bfd_elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
5629 if (auxiliary_filters
!= NULL
)
5631 const char * const *p
;
5633 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
5637 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5639 if (indx
== (bfd_size_type
) -1
5640 || !_bfd_elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
5649 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, audit
,
5651 if (indx
== (bfd_size_type
) -1
5652 || !_bfd_elf_add_dynamic_entry (info
, DT_AUDIT
, indx
))
5656 if (depaudit
!= NULL
)
5660 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, depaudit
,
5662 if (indx
== (bfd_size_type
) -1
5663 || !_bfd_elf_add_dynamic_entry (info
, DT_DEPAUDIT
, indx
))
5668 eif
.verdefs
= verdefs
;
5671 /* If we are supposed to export all symbols into the dynamic symbol
5672 table (this is not the normal case), then do so. */
5673 if (info
->export_dynamic
5674 || (info
->executable
&& info
->dynamic
))
5676 elf_link_hash_traverse (elf_hash_table (info
),
5677 _bfd_elf_export_symbol
,
5683 /* Make all global versions with definition. */
5684 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5685 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5686 if (!d
->symver
&& d
->literal
)
5688 const char *verstr
, *name
;
5689 size_t namelen
, verlen
, newlen
;
5690 char *newname
, *p
, leading_char
;
5691 struct elf_link_hash_entry
*newh
;
5693 leading_char
= bfd_get_symbol_leading_char (output_bfd
);
5695 namelen
= strlen (name
) + (leading_char
!= '\0');
5697 verlen
= strlen (verstr
);
5698 newlen
= namelen
+ verlen
+ 3;
5700 newname
= (char *) bfd_malloc (newlen
);
5701 if (newname
== NULL
)
5703 newname
[0] = leading_char
;
5704 memcpy (newname
+ (leading_char
!= '\0'), name
, namelen
);
5706 /* Check the hidden versioned definition. */
5707 p
= newname
+ namelen
;
5709 memcpy (p
, verstr
, verlen
+ 1);
5710 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5711 newname
, FALSE
, FALSE
,
5714 || (newh
->root
.type
!= bfd_link_hash_defined
5715 && newh
->root
.type
!= bfd_link_hash_defweak
))
5717 /* Check the default versioned definition. */
5719 memcpy (p
, verstr
, verlen
+ 1);
5720 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5721 newname
, FALSE
, FALSE
,
5726 /* Mark this version if there is a definition and it is
5727 not defined in a shared object. */
5729 && !newh
->def_dynamic
5730 && (newh
->root
.type
== bfd_link_hash_defined
5731 || newh
->root
.type
== bfd_link_hash_defweak
))
5735 /* Attach all the symbols to their version information. */
5736 asvinfo
.info
= info
;
5737 asvinfo
.verdefs
= verdefs
;
5738 asvinfo
.failed
= FALSE
;
5740 elf_link_hash_traverse (elf_hash_table (info
),
5741 _bfd_elf_link_assign_sym_version
,
5746 if (!info
->allow_undefined_version
)
5748 /* Check if all global versions have a definition. */
5750 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5751 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5752 if (d
->literal
&& !d
->symver
&& !d
->script
)
5754 (*_bfd_error_handler
)
5755 (_("%s: undefined version: %s"),
5756 d
->pattern
, t
->name
);
5757 all_defined
= FALSE
;
5762 bfd_set_error (bfd_error_bad_value
);
5767 /* Find all symbols which were defined in a dynamic object and make
5768 the backend pick a reasonable value for them. */
5769 elf_link_hash_traverse (elf_hash_table (info
),
5770 _bfd_elf_adjust_dynamic_symbol
,
5775 /* Add some entries to the .dynamic section. We fill in some of the
5776 values later, in bfd_elf_final_link, but we must add the entries
5777 now so that we know the final size of the .dynamic section. */
5779 /* If there are initialization and/or finalization functions to
5780 call then add the corresponding DT_INIT/DT_FINI entries. */
5781 h
= (info
->init_function
5782 ? elf_link_hash_lookup (elf_hash_table (info
),
5783 info
->init_function
, FALSE
,
5790 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT
, 0))
5793 h
= (info
->fini_function
5794 ? elf_link_hash_lookup (elf_hash_table (info
),
5795 info
->fini_function
, FALSE
,
5802 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI
, 0))
5806 s
= bfd_get_section_by_name (output_bfd
, ".preinit_array");
5807 if (s
!= NULL
&& s
->linker_has_input
)
5809 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5810 if (! info
->executable
)
5815 for (sub
= info
->input_bfds
; sub
!= NULL
;
5816 sub
= sub
->link_next
)
5817 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
)
5818 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5819 if (elf_section_data (o
)->this_hdr
.sh_type
5820 == SHT_PREINIT_ARRAY
)
5822 (*_bfd_error_handler
)
5823 (_("%B: .preinit_array section is not allowed in DSO"),
5828 bfd_set_error (bfd_error_nonrepresentable_section
);
5832 if (!_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
5833 || !_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
5836 s
= bfd_get_section_by_name (output_bfd
, ".init_array");
5837 if (s
!= NULL
&& s
->linker_has_input
)
5839 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
5840 || !_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
5843 s
= bfd_get_section_by_name (output_bfd
, ".fini_array");
5844 if (s
!= NULL
&& s
->linker_has_input
)
5846 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
5847 || !_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
5851 dynstr
= bfd_get_section_by_name (dynobj
, ".dynstr");
5852 /* If .dynstr is excluded from the link, we don't want any of
5853 these tags. Strictly, we should be checking each section
5854 individually; This quick check covers for the case where
5855 someone does a /DISCARD/ : { *(*) }. */
5856 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
5858 bfd_size_type strsize
;
5860 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
5861 if ((info
->emit_hash
5862 && !_bfd_elf_add_dynamic_entry (info
, DT_HASH
, 0))
5863 || (info
->emit_gnu_hash
5864 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_HASH
, 0))
5865 || !_bfd_elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5866 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5867 || !_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5868 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMENT
,
5869 bed
->s
->sizeof_sym
))
5874 /* The backend must work out the sizes of all the other dynamic
5876 if (bed
->elf_backend_size_dynamic_sections
5877 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5880 if (elf_hash_table (info
)->dynamic_sections_created
)
5882 unsigned long section_sym_count
;
5885 /* Set up the version definition section. */
5886 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
5887 BFD_ASSERT (s
!= NULL
);
5889 /* We may have created additional version definitions if we are
5890 just linking a regular application. */
5891 verdefs
= asvinfo
.verdefs
;
5893 /* Skip anonymous version tag. */
5894 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
5895 verdefs
= verdefs
->next
;
5897 if (verdefs
== NULL
&& !info
->create_default_symver
)
5898 s
->flags
|= SEC_EXCLUDE
;
5903 struct bfd_elf_version_tree
*t
;
5905 Elf_Internal_Verdef def
;
5906 Elf_Internal_Verdaux defaux
;
5907 struct bfd_link_hash_entry
*bh
;
5908 struct elf_link_hash_entry
*h
;
5914 /* Make space for the base version. */
5915 size
+= sizeof (Elf_External_Verdef
);
5916 size
+= sizeof (Elf_External_Verdaux
);
5919 /* Make space for the default version. */
5920 if (info
->create_default_symver
)
5922 size
+= sizeof (Elf_External_Verdef
);
5926 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5928 struct bfd_elf_version_deps
*n
;
5930 /* Don't emit base version twice. */
5934 size
+= sizeof (Elf_External_Verdef
);
5935 size
+= sizeof (Elf_External_Verdaux
);
5938 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
5939 size
+= sizeof (Elf_External_Verdaux
);
5943 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
5944 if (s
->contents
== NULL
&& s
->size
!= 0)
5947 /* Fill in the version definition section. */
5951 def
.vd_version
= VER_DEF_CURRENT
;
5952 def
.vd_flags
= VER_FLG_BASE
;
5955 if (info
->create_default_symver
)
5957 def
.vd_aux
= 2 * sizeof (Elf_External_Verdef
);
5958 def
.vd_next
= sizeof (Elf_External_Verdef
);
5962 def
.vd_aux
= sizeof (Elf_External_Verdef
);
5963 def
.vd_next
= (sizeof (Elf_External_Verdef
)
5964 + sizeof (Elf_External_Verdaux
));
5967 if (soname_indx
!= (bfd_size_type
) -1)
5969 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
5971 def
.vd_hash
= bfd_elf_hash (soname
);
5972 defaux
.vda_name
= soname_indx
;
5979 name
= lbasename (output_bfd
->filename
);
5980 def
.vd_hash
= bfd_elf_hash (name
);
5981 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5983 if (indx
== (bfd_size_type
) -1)
5985 defaux
.vda_name
= indx
;
5987 defaux
.vda_next
= 0;
5989 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
5990 (Elf_External_Verdef
*) p
);
5991 p
+= sizeof (Elf_External_Verdef
);
5992 if (info
->create_default_symver
)
5994 /* Add a symbol representing this version. */
5996 if (! (_bfd_generic_link_add_one_symbol
5997 (info
, dynobj
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
5999 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6001 h
= (struct elf_link_hash_entry
*) bh
;
6004 h
->type
= STT_OBJECT
;
6005 h
->verinfo
.vertree
= NULL
;
6007 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6010 /* Create a duplicate of the base version with the same
6011 aux block, but different flags. */
6014 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6016 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6017 + sizeof (Elf_External_Verdaux
));
6020 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6021 (Elf_External_Verdef
*) p
);
6022 p
+= sizeof (Elf_External_Verdef
);
6024 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6025 (Elf_External_Verdaux
*) p
);
6026 p
+= sizeof (Elf_External_Verdaux
);
6028 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6031 struct bfd_elf_version_deps
*n
;
6033 /* Don't emit the base version twice. */
6038 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6041 /* Add a symbol representing this version. */
6043 if (! (_bfd_generic_link_add_one_symbol
6044 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6046 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6048 h
= (struct elf_link_hash_entry
*) bh
;
6051 h
->type
= STT_OBJECT
;
6052 h
->verinfo
.vertree
= t
;
6054 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6057 def
.vd_version
= VER_DEF_CURRENT
;
6059 if (t
->globals
.list
== NULL
6060 && t
->locals
.list
== NULL
6062 def
.vd_flags
|= VER_FLG_WEAK
;
6063 def
.vd_ndx
= t
->vernum
+ (info
->create_default_symver
? 2 : 1);
6064 def
.vd_cnt
= cdeps
+ 1;
6065 def
.vd_hash
= bfd_elf_hash (t
->name
);
6066 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6069 /* If a basever node is next, it *must* be the last node in
6070 the chain, otherwise Verdef construction breaks. */
6071 if (t
->next
!= NULL
&& t
->next
->vernum
== 0)
6072 BFD_ASSERT (t
->next
->next
== NULL
);
6074 if (t
->next
!= NULL
&& t
->next
->vernum
!= 0)
6075 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6076 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
6078 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6079 (Elf_External_Verdef
*) p
);
6080 p
+= sizeof (Elf_External_Verdef
);
6082 defaux
.vda_name
= h
->dynstr_index
;
6083 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6085 defaux
.vda_next
= 0;
6086 if (t
->deps
!= NULL
)
6087 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6088 t
->name_indx
= defaux
.vda_name
;
6090 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6091 (Elf_External_Verdaux
*) p
);
6092 p
+= sizeof (Elf_External_Verdaux
);
6094 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6096 if (n
->version_needed
== NULL
)
6098 /* This can happen if there was an error in the
6100 defaux
.vda_name
= 0;
6104 defaux
.vda_name
= n
->version_needed
->name_indx
;
6105 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6108 if (n
->next
== NULL
)
6109 defaux
.vda_next
= 0;
6111 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6113 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6114 (Elf_External_Verdaux
*) p
);
6115 p
+= sizeof (Elf_External_Verdaux
);
6119 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
6120 || !_bfd_elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
6123 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
6126 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
6128 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
6131 else if (info
->flags
& DF_BIND_NOW
)
6133 if (!_bfd_elf_add_dynamic_entry (info
, DT_BIND_NOW
, 0))
6139 if (info
->executable
)
6140 info
->flags_1
&= ~ (DF_1_INITFIRST
6143 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
6147 /* Work out the size of the version reference section. */
6149 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
6150 BFD_ASSERT (s
!= NULL
);
6152 struct elf_find_verdep_info sinfo
;
6155 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
6156 if (sinfo
.vers
== 0)
6158 sinfo
.failed
= FALSE
;
6160 elf_link_hash_traverse (elf_hash_table (info
),
6161 _bfd_elf_link_find_version_dependencies
,
6166 if (elf_tdata (output_bfd
)->verref
== NULL
)
6167 s
->flags
|= SEC_EXCLUDE
;
6170 Elf_Internal_Verneed
*t
;
6175 /* Build the version dependency section. */
6178 for (t
= elf_tdata (output_bfd
)->verref
;
6182 Elf_Internal_Vernaux
*a
;
6184 size
+= sizeof (Elf_External_Verneed
);
6186 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6187 size
+= sizeof (Elf_External_Vernaux
);
6191 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6192 if (s
->contents
== NULL
)
6196 for (t
= elf_tdata (output_bfd
)->verref
;
6201 Elf_Internal_Vernaux
*a
;
6205 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6208 t
->vn_version
= VER_NEED_CURRENT
;
6210 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6211 elf_dt_name (t
->vn_bfd
) != NULL
6212 ? elf_dt_name (t
->vn_bfd
)
6213 : lbasename (t
->vn_bfd
->filename
),
6215 if (indx
== (bfd_size_type
) -1)
6218 t
->vn_aux
= sizeof (Elf_External_Verneed
);
6219 if (t
->vn_nextref
== NULL
)
6222 t
->vn_next
= (sizeof (Elf_External_Verneed
)
6223 + caux
* sizeof (Elf_External_Vernaux
));
6225 _bfd_elf_swap_verneed_out (output_bfd
, t
,
6226 (Elf_External_Verneed
*) p
);
6227 p
+= sizeof (Elf_External_Verneed
);
6229 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6231 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
6232 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6233 a
->vna_nodename
, FALSE
);
6234 if (indx
== (bfd_size_type
) -1)
6237 if (a
->vna_nextptr
== NULL
)
6240 a
->vna_next
= sizeof (Elf_External_Vernaux
);
6242 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
6243 (Elf_External_Vernaux
*) p
);
6244 p
+= sizeof (Elf_External_Vernaux
);
6248 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
6249 || !_bfd_elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
6252 elf_tdata (output_bfd
)->cverrefs
= crefs
;
6256 if ((elf_tdata (output_bfd
)->cverrefs
== 0
6257 && elf_tdata (output_bfd
)->cverdefs
== 0)
6258 || _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6259 §ion_sym_count
) == 0)
6261 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
6262 s
->flags
|= SEC_EXCLUDE
;
6268 /* Find the first non-excluded output section. We'll use its
6269 section symbol for some emitted relocs. */
6271 _bfd_elf_init_1_index_section (bfd
*output_bfd
, struct bfd_link_info
*info
)
6275 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6276 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
6277 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6279 elf_hash_table (info
)->text_index_section
= s
;
6284 /* Find two non-excluded output sections, one for code, one for data.
6285 We'll use their section symbols for some emitted relocs. */
6287 _bfd_elf_init_2_index_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6291 /* Data first, since setting text_index_section changes
6292 _bfd_elf_link_omit_section_dynsym. */
6293 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6294 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
)) == SEC_ALLOC
)
6295 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6297 elf_hash_table (info
)->data_index_section
= s
;
6301 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6302 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
))
6303 == (SEC_ALLOC
| SEC_READONLY
))
6304 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6306 elf_hash_table (info
)->text_index_section
= s
;
6310 if (elf_hash_table (info
)->text_index_section
== NULL
)
6311 elf_hash_table (info
)->text_index_section
6312 = elf_hash_table (info
)->data_index_section
;
6316 bfd_elf_size_dynsym_hash_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
6318 const struct elf_backend_data
*bed
;
6320 if (!is_elf_hash_table (info
->hash
))
6323 bed
= get_elf_backend_data (output_bfd
);
6324 (*bed
->elf_backend_init_index_section
) (output_bfd
, info
);
6326 if (elf_hash_table (info
)->dynamic_sections_created
)
6330 bfd_size_type dynsymcount
;
6331 unsigned long section_sym_count
;
6332 unsigned int dtagcount
;
6334 dynobj
= elf_hash_table (info
)->dynobj
;
6336 /* Assign dynsym indicies. In a shared library we generate a
6337 section symbol for each output section, which come first.
6338 Next come all of the back-end allocated local dynamic syms,
6339 followed by the rest of the global symbols. */
6341 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6342 §ion_sym_count
);
6344 /* Work out the size of the symbol version section. */
6345 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
6346 BFD_ASSERT (s
!= NULL
);
6347 if (dynsymcount
!= 0
6348 && (s
->flags
& SEC_EXCLUDE
) == 0)
6350 s
->size
= dynsymcount
* sizeof (Elf_External_Versym
);
6351 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6352 if (s
->contents
== NULL
)
6355 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
6359 /* Set the size of the .dynsym and .hash sections. We counted
6360 the number of dynamic symbols in elf_link_add_object_symbols.
6361 We will build the contents of .dynsym and .hash when we build
6362 the final symbol table, because until then we do not know the
6363 correct value to give the symbols. We built the .dynstr
6364 section as we went along in elf_link_add_object_symbols. */
6365 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
6366 BFD_ASSERT (s
!= NULL
);
6367 s
->size
= dynsymcount
* bed
->s
->sizeof_sym
;
6369 if (dynsymcount
!= 0)
6371 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6372 if (s
->contents
== NULL
)
6375 /* The first entry in .dynsym is a dummy symbol.
6376 Clear all the section syms, in case we don't output them all. */
6377 ++section_sym_count
;
6378 memset (s
->contents
, 0, section_sym_count
* bed
->s
->sizeof_sym
);
6381 elf_hash_table (info
)->bucketcount
= 0;
6383 /* Compute the size of the hashing table. As a side effect this
6384 computes the hash values for all the names we export. */
6385 if (info
->emit_hash
)
6387 unsigned long int *hashcodes
;
6388 struct hash_codes_info hashinf
;
6390 unsigned long int nsyms
;
6392 size_t hash_entry_size
;
6394 /* Compute the hash values for all exported symbols. At the same
6395 time store the values in an array so that we could use them for
6397 amt
= dynsymcount
* sizeof (unsigned long int);
6398 hashcodes
= (unsigned long int *) bfd_malloc (amt
);
6399 if (hashcodes
== NULL
)
6401 hashinf
.hashcodes
= hashcodes
;
6402 hashinf
.error
= FALSE
;
6404 /* Put all hash values in HASHCODES. */
6405 elf_link_hash_traverse (elf_hash_table (info
),
6406 elf_collect_hash_codes
, &hashinf
);
6413 nsyms
= hashinf
.hashcodes
- hashcodes
;
6415 = compute_bucket_count (info
, hashcodes
, nsyms
, 0);
6418 if (bucketcount
== 0)
6421 elf_hash_table (info
)->bucketcount
= bucketcount
;
6423 s
= bfd_get_section_by_name (dynobj
, ".hash");
6424 BFD_ASSERT (s
!= NULL
);
6425 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
6426 s
->size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
6427 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6428 if (s
->contents
== NULL
)
6431 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
6432 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
6433 s
->contents
+ hash_entry_size
);
6436 if (info
->emit_gnu_hash
)
6439 unsigned char *contents
;
6440 struct collect_gnu_hash_codes cinfo
;
6444 memset (&cinfo
, 0, sizeof (cinfo
));
6446 /* Compute the hash values for all exported symbols. At the same
6447 time store the values in an array so that we could use them for
6449 amt
= dynsymcount
* 2 * sizeof (unsigned long int);
6450 cinfo
.hashcodes
= (long unsigned int *) bfd_malloc (amt
);
6451 if (cinfo
.hashcodes
== NULL
)
6454 cinfo
.hashval
= cinfo
.hashcodes
+ dynsymcount
;
6455 cinfo
.min_dynindx
= -1;
6456 cinfo
.output_bfd
= output_bfd
;
6459 /* Put all hash values in HASHCODES. */
6460 elf_link_hash_traverse (elf_hash_table (info
),
6461 elf_collect_gnu_hash_codes
, &cinfo
);
6464 free (cinfo
.hashcodes
);
6469 = compute_bucket_count (info
, cinfo
.hashcodes
, cinfo
.nsyms
, 1);
6471 if (bucketcount
== 0)
6473 free (cinfo
.hashcodes
);
6477 s
= bfd_get_section_by_name (dynobj
, ".gnu.hash");
6478 BFD_ASSERT (s
!= NULL
);
6480 if (cinfo
.nsyms
== 0)
6482 /* Empty .gnu.hash section is special. */
6483 BFD_ASSERT (cinfo
.min_dynindx
== -1);
6484 free (cinfo
.hashcodes
);
6485 s
->size
= 5 * 4 + bed
->s
->arch_size
/ 8;
6486 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6487 if (contents
== NULL
)
6489 s
->contents
= contents
;
6490 /* 1 empty bucket. */
6491 bfd_put_32 (output_bfd
, 1, contents
);
6492 /* SYMIDX above the special symbol 0. */
6493 bfd_put_32 (output_bfd
, 1, contents
+ 4);
6494 /* Just one word for bitmask. */
6495 bfd_put_32 (output_bfd
, 1, contents
+ 8);
6496 /* Only hash fn bloom filter. */
6497 bfd_put_32 (output_bfd
, 0, contents
+ 12);
6498 /* No hashes are valid - empty bitmask. */
6499 bfd_put (bed
->s
->arch_size
, output_bfd
, 0, contents
+ 16);
6500 /* No hashes in the only bucket. */
6501 bfd_put_32 (output_bfd
, 0,
6502 contents
+ 16 + bed
->s
->arch_size
/ 8);
6506 unsigned long int maskwords
, maskbitslog2
, x
;
6507 BFD_ASSERT (cinfo
.min_dynindx
!= -1);
6511 while ((x
>>= 1) != 0)
6513 if (maskbitslog2
< 3)
6515 else if ((1 << (maskbitslog2
- 2)) & cinfo
.nsyms
)
6516 maskbitslog2
= maskbitslog2
+ 3;
6518 maskbitslog2
= maskbitslog2
+ 2;
6519 if (bed
->s
->arch_size
== 64)
6521 if (maskbitslog2
== 5)
6527 cinfo
.mask
= (1 << cinfo
.shift1
) - 1;
6528 cinfo
.shift2
= maskbitslog2
;
6529 cinfo
.maskbits
= 1 << maskbitslog2
;
6530 maskwords
= 1 << (maskbitslog2
- cinfo
.shift1
);
6531 amt
= bucketcount
* sizeof (unsigned long int) * 2;
6532 amt
+= maskwords
* sizeof (bfd_vma
);
6533 cinfo
.bitmask
= (bfd_vma
*) bfd_malloc (amt
);
6534 if (cinfo
.bitmask
== NULL
)
6536 free (cinfo
.hashcodes
);
6540 cinfo
.counts
= (long unsigned int *) (cinfo
.bitmask
+ maskwords
);
6541 cinfo
.indx
= cinfo
.counts
+ bucketcount
;
6542 cinfo
.symindx
= dynsymcount
- cinfo
.nsyms
;
6543 memset (cinfo
.bitmask
, 0, maskwords
* sizeof (bfd_vma
));
6545 /* Determine how often each hash bucket is used. */
6546 memset (cinfo
.counts
, 0, bucketcount
* sizeof (cinfo
.counts
[0]));
6547 for (i
= 0; i
< cinfo
.nsyms
; ++i
)
6548 ++cinfo
.counts
[cinfo
.hashcodes
[i
] % bucketcount
];
6550 for (i
= 0, cnt
= cinfo
.symindx
; i
< bucketcount
; ++i
)
6551 if (cinfo
.counts
[i
] != 0)
6553 cinfo
.indx
[i
] = cnt
;
6554 cnt
+= cinfo
.counts
[i
];
6556 BFD_ASSERT (cnt
== dynsymcount
);
6557 cinfo
.bucketcount
= bucketcount
;
6558 cinfo
.local_indx
= cinfo
.min_dynindx
;
6560 s
->size
= (4 + bucketcount
+ cinfo
.nsyms
) * 4;
6561 s
->size
+= cinfo
.maskbits
/ 8;
6562 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6563 if (contents
== NULL
)
6565 free (cinfo
.bitmask
);
6566 free (cinfo
.hashcodes
);
6570 s
->contents
= contents
;
6571 bfd_put_32 (output_bfd
, bucketcount
, contents
);
6572 bfd_put_32 (output_bfd
, cinfo
.symindx
, contents
+ 4);
6573 bfd_put_32 (output_bfd
, maskwords
, contents
+ 8);
6574 bfd_put_32 (output_bfd
, cinfo
.shift2
, contents
+ 12);
6575 contents
+= 16 + cinfo
.maskbits
/ 8;
6577 for (i
= 0; i
< bucketcount
; ++i
)
6579 if (cinfo
.counts
[i
] == 0)
6580 bfd_put_32 (output_bfd
, 0, contents
);
6582 bfd_put_32 (output_bfd
, cinfo
.indx
[i
], contents
);
6586 cinfo
.contents
= contents
;
6588 /* Renumber dynamic symbols, populate .gnu.hash section. */
6589 elf_link_hash_traverse (elf_hash_table (info
),
6590 elf_renumber_gnu_hash_syms
, &cinfo
);
6592 contents
= s
->contents
+ 16;
6593 for (i
= 0; i
< maskwords
; ++i
)
6595 bfd_put (bed
->s
->arch_size
, output_bfd
, cinfo
.bitmask
[i
],
6597 contents
+= bed
->s
->arch_size
/ 8;
6600 free (cinfo
.bitmask
);
6601 free (cinfo
.hashcodes
);
6605 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
6606 BFD_ASSERT (s
!= NULL
);
6608 elf_finalize_dynstr (output_bfd
, info
);
6610 s
->size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6612 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
6613 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0))
6620 /* Indicate that we are only retrieving symbol values from this
6624 _bfd_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
6626 if (is_elf_hash_table (info
->hash
))
6627 sec
->sec_info_type
= ELF_INFO_TYPE_JUST_SYMS
;
6628 _bfd_generic_link_just_syms (sec
, info
);
6631 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
6634 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
6637 BFD_ASSERT (sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
6638 sec
->sec_info_type
= ELF_INFO_TYPE_NONE
;
6641 /* Finish SHF_MERGE section merging. */
6644 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6649 if (!is_elf_hash_table (info
->hash
))
6652 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
6653 if ((ibfd
->flags
& DYNAMIC
) == 0)
6654 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6655 if ((sec
->flags
& SEC_MERGE
) != 0
6656 && !bfd_is_abs_section (sec
->output_section
))
6658 struct bfd_elf_section_data
*secdata
;
6660 secdata
= elf_section_data (sec
);
6661 if (! _bfd_add_merge_section (abfd
,
6662 &elf_hash_table (info
)->merge_info
,
6663 sec
, &secdata
->sec_info
))
6665 else if (secdata
->sec_info
)
6666 sec
->sec_info_type
= ELF_INFO_TYPE_MERGE
;
6669 if (elf_hash_table (info
)->merge_info
!= NULL
)
6670 _bfd_merge_sections (abfd
, info
, elf_hash_table (info
)->merge_info
,
6671 merge_sections_remove_hook
);
6675 /* Create an entry in an ELF linker hash table. */
6677 struct bfd_hash_entry
*
6678 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
6679 struct bfd_hash_table
*table
,
6682 /* Allocate the structure if it has not already been allocated by a
6686 entry
= (struct bfd_hash_entry
*)
6687 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
6692 /* Call the allocation method of the superclass. */
6693 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
6696 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
6697 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
6699 /* Set local fields. */
6702 ret
->got
= htab
->init_got_refcount
;
6703 ret
->plt
= htab
->init_plt_refcount
;
6704 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
6705 - offsetof (struct elf_link_hash_entry
, size
)));
6706 /* Assume that we have been called by a non-ELF symbol reader.
6707 This flag is then reset by the code which reads an ELF input
6708 file. This ensures that a symbol created by a non-ELF symbol
6709 reader will have the flag set correctly. */
6716 /* Copy data from an indirect symbol to its direct symbol, hiding the
6717 old indirect symbol. Also used for copying flags to a weakdef. */
6720 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info
*info
,
6721 struct elf_link_hash_entry
*dir
,
6722 struct elf_link_hash_entry
*ind
)
6724 struct elf_link_hash_table
*htab
;
6726 /* Copy down any references that we may have already seen to the
6727 symbol which just became indirect. */
6729 dir
->ref_dynamic
|= ind
->ref_dynamic
;
6730 dir
->ref_regular
|= ind
->ref_regular
;
6731 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
6732 dir
->non_got_ref
|= ind
->non_got_ref
;
6733 dir
->needs_plt
|= ind
->needs_plt
;
6734 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
6736 if (ind
->root
.type
!= bfd_link_hash_indirect
)
6739 /* Copy over the global and procedure linkage table refcount entries.
6740 These may have been already set up by a check_relocs routine. */
6741 htab
= elf_hash_table (info
);
6742 if (ind
->got
.refcount
> htab
->init_got_refcount
.refcount
)
6744 if (dir
->got
.refcount
< 0)
6745 dir
->got
.refcount
= 0;
6746 dir
->got
.refcount
+= ind
->got
.refcount
;
6747 ind
->got
.refcount
= htab
->init_got_refcount
.refcount
;
6750 if (ind
->plt
.refcount
> htab
->init_plt_refcount
.refcount
)
6752 if (dir
->plt
.refcount
< 0)
6753 dir
->plt
.refcount
= 0;
6754 dir
->plt
.refcount
+= ind
->plt
.refcount
;
6755 ind
->plt
.refcount
= htab
->init_plt_refcount
.refcount
;
6758 if (ind
->dynindx
!= -1)
6760 if (dir
->dynindx
!= -1)
6761 _bfd_elf_strtab_delref (htab
->dynstr
, dir
->dynstr_index
);
6762 dir
->dynindx
= ind
->dynindx
;
6763 dir
->dynstr_index
= ind
->dynstr_index
;
6765 ind
->dynstr_index
= 0;
6770 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
6771 struct elf_link_hash_entry
*h
,
6772 bfd_boolean force_local
)
6774 /* STT_GNU_IFUNC symbol must go through PLT. */
6775 if (h
->type
!= STT_GNU_IFUNC
)
6777 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
6782 h
->forced_local
= 1;
6783 if (h
->dynindx
!= -1)
6786 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
6792 /* Initialize an ELF linker hash table. */
6795 _bfd_elf_link_hash_table_init
6796 (struct elf_link_hash_table
*table
,
6798 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
6799 struct bfd_hash_table
*,
6801 unsigned int entsize
,
6802 enum elf_target_id target_id
)
6805 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
6807 memset (table
, 0, sizeof * table
);
6808 table
->init_got_refcount
.refcount
= can_refcount
- 1;
6809 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
6810 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
6811 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
6812 /* The first dynamic symbol is a dummy. */
6813 table
->dynsymcount
= 1;
6815 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
6817 table
->root
.type
= bfd_link_elf_hash_table
;
6818 table
->hash_table_id
= target_id
;
6823 /* Create an ELF linker hash table. */
6825 struct bfd_link_hash_table
*
6826 _bfd_elf_link_hash_table_create (bfd
*abfd
)
6828 struct elf_link_hash_table
*ret
;
6829 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
6831 ret
= (struct elf_link_hash_table
*) bfd_malloc (amt
);
6835 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
,
6836 sizeof (struct elf_link_hash_entry
),
6846 /* This is a hook for the ELF emulation code in the generic linker to
6847 tell the backend linker what file name to use for the DT_NEEDED
6848 entry for a dynamic object. */
6851 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
6853 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6854 && bfd_get_format (abfd
) == bfd_object
)
6855 elf_dt_name (abfd
) = name
;
6859 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
6862 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6863 && bfd_get_format (abfd
) == bfd_object
)
6864 lib_class
= elf_dyn_lib_class (abfd
);
6871 bfd_elf_set_dyn_lib_class (bfd
*abfd
, enum dynamic_lib_link_class lib_class
)
6873 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6874 && bfd_get_format (abfd
) == bfd_object
)
6875 elf_dyn_lib_class (abfd
) = lib_class
;
6878 /* Get the list of DT_NEEDED entries for a link. This is a hook for
6879 the linker ELF emulation code. */
6881 struct bfd_link_needed_list
*
6882 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
6883 struct bfd_link_info
*info
)
6885 if (! is_elf_hash_table (info
->hash
))
6887 return elf_hash_table (info
)->needed
;
6890 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
6891 hook for the linker ELF emulation code. */
6893 struct bfd_link_needed_list
*
6894 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
6895 struct bfd_link_info
*info
)
6897 if (! is_elf_hash_table (info
->hash
))
6899 return elf_hash_table (info
)->runpath
;
6902 /* Get the name actually used for a dynamic object for a link. This
6903 is the SONAME entry if there is one. Otherwise, it is the string
6904 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
6907 bfd_elf_get_dt_soname (bfd
*abfd
)
6909 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6910 && bfd_get_format (abfd
) == bfd_object
)
6911 return elf_dt_name (abfd
);
6915 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
6916 the ELF linker emulation code. */
6919 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
6920 struct bfd_link_needed_list
**pneeded
)
6923 bfd_byte
*dynbuf
= NULL
;
6924 unsigned int elfsec
;
6925 unsigned long shlink
;
6926 bfd_byte
*extdyn
, *extdynend
;
6928 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
6932 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
6933 || bfd_get_format (abfd
) != bfd_object
)
6936 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6937 if (s
== NULL
|| s
->size
== 0)
6940 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
6943 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
6944 if (elfsec
== SHN_BAD
)
6947 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
6949 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
6950 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
6953 extdynend
= extdyn
+ s
->size
;
6954 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
6956 Elf_Internal_Dyn dyn
;
6958 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
6960 if (dyn
.d_tag
== DT_NULL
)
6963 if (dyn
.d_tag
== DT_NEEDED
)
6966 struct bfd_link_needed_list
*l
;
6967 unsigned int tagv
= dyn
.d_un
.d_val
;
6970 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
6975 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
6996 struct elf_symbuf_symbol
6998 unsigned long st_name
; /* Symbol name, index in string tbl */
6999 unsigned char st_info
; /* Type and binding attributes */
7000 unsigned char st_other
; /* Visibilty, and target specific */
7003 struct elf_symbuf_head
7005 struct elf_symbuf_symbol
*ssym
;
7006 bfd_size_type count
;
7007 unsigned int st_shndx
;
7014 Elf_Internal_Sym
*isym
;
7015 struct elf_symbuf_symbol
*ssym
;
7020 /* Sort references to symbols by ascending section number. */
7023 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
7025 const Elf_Internal_Sym
*s1
= *(const Elf_Internal_Sym
**) arg1
;
7026 const Elf_Internal_Sym
*s2
= *(const Elf_Internal_Sym
**) arg2
;
7028 return s1
->st_shndx
- s2
->st_shndx
;
7032 elf_sym_name_compare (const void *arg1
, const void *arg2
)
7034 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
7035 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
7036 return strcmp (s1
->name
, s2
->name
);
7039 static struct elf_symbuf_head
*
7040 elf_create_symbuf (bfd_size_type symcount
, Elf_Internal_Sym
*isymbuf
)
7042 Elf_Internal_Sym
**ind
, **indbufend
, **indbuf
;
7043 struct elf_symbuf_symbol
*ssym
;
7044 struct elf_symbuf_head
*ssymbuf
, *ssymhead
;
7045 bfd_size_type i
, shndx_count
, total_size
;
7047 indbuf
= (Elf_Internal_Sym
**) bfd_malloc2 (symcount
, sizeof (*indbuf
));
7051 for (ind
= indbuf
, i
= 0; i
< symcount
; i
++)
7052 if (isymbuf
[i
].st_shndx
!= SHN_UNDEF
)
7053 *ind
++ = &isymbuf
[i
];
7056 qsort (indbuf
, indbufend
- indbuf
, sizeof (Elf_Internal_Sym
*),
7057 elf_sort_elf_symbol
);
7060 if (indbufend
> indbuf
)
7061 for (ind
= indbuf
, shndx_count
++; ind
< indbufend
- 1; ind
++)
7062 if (ind
[0]->st_shndx
!= ind
[1]->st_shndx
)
7065 total_size
= ((shndx_count
+ 1) * sizeof (*ssymbuf
)
7066 + (indbufend
- indbuf
) * sizeof (*ssym
));
7067 ssymbuf
= (struct elf_symbuf_head
*) bfd_malloc (total_size
);
7068 if (ssymbuf
== NULL
)
7074 ssym
= (struct elf_symbuf_symbol
*) (ssymbuf
+ shndx_count
+ 1);
7075 ssymbuf
->ssym
= NULL
;
7076 ssymbuf
->count
= shndx_count
;
7077 ssymbuf
->st_shndx
= 0;
7078 for (ssymhead
= ssymbuf
, ind
= indbuf
; ind
< indbufend
; ssym
++, ind
++)
7080 if (ind
== indbuf
|| ssymhead
->st_shndx
!= (*ind
)->st_shndx
)
7083 ssymhead
->ssym
= ssym
;
7084 ssymhead
->count
= 0;
7085 ssymhead
->st_shndx
= (*ind
)->st_shndx
;
7087 ssym
->st_name
= (*ind
)->st_name
;
7088 ssym
->st_info
= (*ind
)->st_info
;
7089 ssym
->st_other
= (*ind
)->st_other
;
7092 BFD_ASSERT ((bfd_size_type
) (ssymhead
- ssymbuf
) == shndx_count
7093 && (((bfd_hostptr_t
) ssym
- (bfd_hostptr_t
) ssymbuf
)
7100 /* Check if 2 sections define the same set of local and global
7104 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
,
7105 struct bfd_link_info
*info
)
7108 const struct elf_backend_data
*bed1
, *bed2
;
7109 Elf_Internal_Shdr
*hdr1
, *hdr2
;
7110 bfd_size_type symcount1
, symcount2
;
7111 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
7112 struct elf_symbuf_head
*ssymbuf1
, *ssymbuf2
;
7113 Elf_Internal_Sym
*isym
, *isymend
;
7114 struct elf_symbol
*symtable1
= NULL
, *symtable2
= NULL
;
7115 bfd_size_type count1
, count2
, i
;
7116 unsigned int shndx1
, shndx2
;
7122 /* Both sections have to be in ELF. */
7123 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
7124 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
7127 if (elf_section_type (sec1
) != elf_section_type (sec2
))
7130 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
7131 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
7132 if (shndx1
== SHN_BAD
|| shndx2
== SHN_BAD
)
7135 bed1
= get_elf_backend_data (bfd1
);
7136 bed2
= get_elf_backend_data (bfd2
);
7137 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
7138 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
7139 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
7140 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
7142 if (symcount1
== 0 || symcount2
== 0)
7148 ssymbuf1
= (struct elf_symbuf_head
*) elf_tdata (bfd1
)->symbuf
;
7149 ssymbuf2
= (struct elf_symbuf_head
*) elf_tdata (bfd2
)->symbuf
;
7151 if (ssymbuf1
== NULL
)
7153 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
7155 if (isymbuf1
== NULL
)
7158 if (!info
->reduce_memory_overheads
)
7159 elf_tdata (bfd1
)->symbuf
= ssymbuf1
7160 = elf_create_symbuf (symcount1
, isymbuf1
);
7163 if (ssymbuf1
== NULL
|| ssymbuf2
== NULL
)
7165 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
7167 if (isymbuf2
== NULL
)
7170 if (ssymbuf1
!= NULL
&& !info
->reduce_memory_overheads
)
7171 elf_tdata (bfd2
)->symbuf
= ssymbuf2
7172 = elf_create_symbuf (symcount2
, isymbuf2
);
7175 if (ssymbuf1
!= NULL
&& ssymbuf2
!= NULL
)
7177 /* Optimized faster version. */
7178 bfd_size_type lo
, hi
, mid
;
7179 struct elf_symbol
*symp
;
7180 struct elf_symbuf_symbol
*ssym
, *ssymend
;
7183 hi
= ssymbuf1
->count
;
7188 mid
= (lo
+ hi
) / 2;
7189 if (shndx1
< ssymbuf1
[mid
].st_shndx
)
7191 else if (shndx1
> ssymbuf1
[mid
].st_shndx
)
7195 count1
= ssymbuf1
[mid
].count
;
7202 hi
= ssymbuf2
->count
;
7207 mid
= (lo
+ hi
) / 2;
7208 if (shndx2
< ssymbuf2
[mid
].st_shndx
)
7210 else if (shndx2
> ssymbuf2
[mid
].st_shndx
)
7214 count2
= ssymbuf2
[mid
].count
;
7220 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7223 symtable1
= (struct elf_symbol
*)
7224 bfd_malloc (count1
* sizeof (struct elf_symbol
));
7225 symtable2
= (struct elf_symbol
*)
7226 bfd_malloc (count2
* sizeof (struct elf_symbol
));
7227 if (symtable1
== NULL
|| symtable2
== NULL
)
7231 for (ssym
= ssymbuf1
->ssym
, ssymend
= ssym
+ count1
;
7232 ssym
< ssymend
; ssym
++, symp
++)
7234 symp
->u
.ssym
= ssym
;
7235 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
7241 for (ssym
= ssymbuf2
->ssym
, ssymend
= ssym
+ count2
;
7242 ssym
< ssymend
; ssym
++, symp
++)
7244 symp
->u
.ssym
= ssym
;
7245 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
7250 /* Sort symbol by name. */
7251 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7252 elf_sym_name_compare
);
7253 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7254 elf_sym_name_compare
);
7256 for (i
= 0; i
< count1
; i
++)
7257 /* Two symbols must have the same binding, type and name. */
7258 if (symtable1
[i
].u
.ssym
->st_info
!= symtable2
[i
].u
.ssym
->st_info
7259 || symtable1
[i
].u
.ssym
->st_other
!= symtable2
[i
].u
.ssym
->st_other
7260 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7267 symtable1
= (struct elf_symbol
*)
7268 bfd_malloc (symcount1
* sizeof (struct elf_symbol
));
7269 symtable2
= (struct elf_symbol
*)
7270 bfd_malloc (symcount2
* sizeof (struct elf_symbol
));
7271 if (symtable1
== NULL
|| symtable2
== NULL
)
7274 /* Count definitions in the section. */
7276 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
; isym
< isymend
; isym
++)
7277 if (isym
->st_shndx
== shndx1
)
7278 symtable1
[count1
++].u
.isym
= isym
;
7281 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
; isym
< isymend
; isym
++)
7282 if (isym
->st_shndx
== shndx2
)
7283 symtable2
[count2
++].u
.isym
= isym
;
7285 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7288 for (i
= 0; i
< count1
; i
++)
7290 = bfd_elf_string_from_elf_section (bfd1
, hdr1
->sh_link
,
7291 symtable1
[i
].u
.isym
->st_name
);
7293 for (i
= 0; i
< count2
; i
++)
7295 = bfd_elf_string_from_elf_section (bfd2
, hdr2
->sh_link
,
7296 symtable2
[i
].u
.isym
->st_name
);
7298 /* Sort symbol by name. */
7299 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7300 elf_sym_name_compare
);
7301 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7302 elf_sym_name_compare
);
7304 for (i
= 0; i
< count1
; i
++)
7305 /* Two symbols must have the same binding, type and name. */
7306 if (symtable1
[i
].u
.isym
->st_info
!= symtable2
[i
].u
.isym
->st_info
7307 || symtable1
[i
].u
.isym
->st_other
!= symtable2
[i
].u
.isym
->st_other
7308 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7326 /* Return TRUE if 2 section types are compatible. */
7329 _bfd_elf_match_sections_by_type (bfd
*abfd
, const asection
*asec
,
7330 bfd
*bbfd
, const asection
*bsec
)
7334 || abfd
->xvec
->flavour
!= bfd_target_elf_flavour
7335 || bbfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7338 return elf_section_type (asec
) == elf_section_type (bsec
);
7341 /* Final phase of ELF linker. */
7343 /* A structure we use to avoid passing large numbers of arguments. */
7345 struct elf_final_link_info
7347 /* General link information. */
7348 struct bfd_link_info
*info
;
7351 /* Symbol string table. */
7352 struct bfd_strtab_hash
*symstrtab
;
7353 /* .dynsym section. */
7354 asection
*dynsym_sec
;
7355 /* .hash section. */
7357 /* symbol version section (.gnu.version). */
7358 asection
*symver_sec
;
7359 /* Buffer large enough to hold contents of any section. */
7361 /* Buffer large enough to hold external relocs of any section. */
7362 void *external_relocs
;
7363 /* Buffer large enough to hold internal relocs of any section. */
7364 Elf_Internal_Rela
*internal_relocs
;
7365 /* Buffer large enough to hold external local symbols of any input
7367 bfd_byte
*external_syms
;
7368 /* And a buffer for symbol section indices. */
7369 Elf_External_Sym_Shndx
*locsym_shndx
;
7370 /* Buffer large enough to hold internal local symbols of any input
7372 Elf_Internal_Sym
*internal_syms
;
7373 /* Array large enough to hold a symbol index for each local symbol
7374 of any input BFD. */
7376 /* Array large enough to hold a section pointer for each local
7377 symbol of any input BFD. */
7378 asection
**sections
;
7379 /* Buffer to hold swapped out symbols. */
7381 /* And one for symbol section indices. */
7382 Elf_External_Sym_Shndx
*symshndxbuf
;
7383 /* Number of swapped out symbols in buffer. */
7384 size_t symbuf_count
;
7385 /* Number of symbols which fit in symbuf. */
7387 /* And same for symshndxbuf. */
7388 size_t shndxbuf_size
;
7391 /* This struct is used to pass information to elf_link_output_extsym. */
7393 struct elf_outext_info
7396 bfd_boolean localsyms
;
7397 struct elf_final_link_info
*finfo
;
7401 /* Support for evaluating a complex relocation.
7403 Complex relocations are generalized, self-describing relocations. The
7404 implementation of them consists of two parts: complex symbols, and the
7405 relocations themselves.
7407 The relocations are use a reserved elf-wide relocation type code (R_RELC
7408 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7409 information (start bit, end bit, word width, etc) into the addend. This
7410 information is extracted from CGEN-generated operand tables within gas.
7412 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7413 internal) representing prefix-notation expressions, including but not
7414 limited to those sorts of expressions normally encoded as addends in the
7415 addend field. The symbol mangling format is:
7418 | <unary-operator> ':' <node>
7419 | <binary-operator> ':' <node> ':' <node>
7422 <literal> := 's' <digits=N> ':' <N character symbol name>
7423 | 'S' <digits=N> ':' <N character section name>
7427 <binary-operator> := as in C
7428 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7431 set_symbol_value (bfd
*bfd_with_globals
,
7432 Elf_Internal_Sym
*isymbuf
,
7437 struct elf_link_hash_entry
**sym_hashes
;
7438 struct elf_link_hash_entry
*h
;
7439 size_t extsymoff
= locsymcount
;
7441 if (symidx
< locsymcount
)
7443 Elf_Internal_Sym
*sym
;
7445 sym
= isymbuf
+ symidx
;
7446 if (ELF_ST_BIND (sym
->st_info
) == STB_LOCAL
)
7448 /* It is a local symbol: move it to the
7449 "absolute" section and give it a value. */
7450 sym
->st_shndx
= SHN_ABS
;
7451 sym
->st_value
= val
;
7454 BFD_ASSERT (elf_bad_symtab (bfd_with_globals
));
7458 /* It is a global symbol: set its link type
7459 to "defined" and give it a value. */
7461 sym_hashes
= elf_sym_hashes (bfd_with_globals
);
7462 h
= sym_hashes
[symidx
- extsymoff
];
7463 while (h
->root
.type
== bfd_link_hash_indirect
7464 || h
->root
.type
== bfd_link_hash_warning
)
7465 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7466 h
->root
.type
= bfd_link_hash_defined
;
7467 h
->root
.u
.def
.value
= val
;
7468 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
7472 resolve_symbol (const char *name
,
7474 struct elf_final_link_info
*finfo
,
7476 Elf_Internal_Sym
*isymbuf
,
7479 Elf_Internal_Sym
*sym
;
7480 struct bfd_link_hash_entry
*global_entry
;
7481 const char *candidate
= NULL
;
7482 Elf_Internal_Shdr
*symtab_hdr
;
7485 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
7487 for (i
= 0; i
< locsymcount
; ++ i
)
7491 if (ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7494 candidate
= bfd_elf_string_from_elf_section (input_bfd
,
7495 symtab_hdr
->sh_link
,
7498 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7499 name
, candidate
, (unsigned long) sym
->st_value
);
7501 if (candidate
&& strcmp (candidate
, name
) == 0)
7503 asection
*sec
= finfo
->sections
[i
];
7505 *result
= _bfd_elf_rel_local_sym (input_bfd
, sym
, &sec
, 0);
7506 *result
+= sec
->output_offset
+ sec
->output_section
->vma
;
7508 printf ("Found symbol with value %8.8lx\n",
7509 (unsigned long) *result
);
7515 /* Hmm, haven't found it yet. perhaps it is a global. */
7516 global_entry
= bfd_link_hash_lookup (finfo
->info
->hash
, name
,
7517 FALSE
, FALSE
, TRUE
);
7521 if (global_entry
->type
== bfd_link_hash_defined
7522 || global_entry
->type
== bfd_link_hash_defweak
)
7524 *result
= (global_entry
->u
.def
.value
7525 + global_entry
->u
.def
.section
->output_section
->vma
7526 + global_entry
->u
.def
.section
->output_offset
);
7528 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7529 global_entry
->root
.string
, (unsigned long) *result
);
7538 resolve_section (const char *name
,
7545 for (curr
= sections
; curr
; curr
= curr
->next
)
7546 if (strcmp (curr
->name
, name
) == 0)
7548 *result
= curr
->vma
;
7552 /* Hmm. still haven't found it. try pseudo-section names. */
7553 for (curr
= sections
; curr
; curr
= curr
->next
)
7555 len
= strlen (curr
->name
);
7556 if (len
> strlen (name
))
7559 if (strncmp (curr
->name
, name
, len
) == 0)
7561 if (strncmp (".end", name
+ len
, 4) == 0)
7563 *result
= curr
->vma
+ curr
->size
;
7567 /* Insert more pseudo-section names here, if you like. */
7575 undefined_reference (const char *reftype
, const char *name
)
7577 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7582 eval_symbol (bfd_vma
*result
,
7585 struct elf_final_link_info
*finfo
,
7587 Elf_Internal_Sym
*isymbuf
,
7596 const char *sym
= *symp
;
7598 bfd_boolean symbol_is_section
= FALSE
;
7603 if (len
< 1 || len
> sizeof (symbuf
))
7605 bfd_set_error (bfd_error_invalid_operation
);
7618 *result
= strtoul (sym
, (char **) symp
, 16);
7622 symbol_is_section
= TRUE
;
7625 symlen
= strtol (sym
, (char **) symp
, 10);
7626 sym
= *symp
+ 1; /* Skip the trailing ':'. */
7628 if (symend
< sym
|| symlen
+ 1 > sizeof (symbuf
))
7630 bfd_set_error (bfd_error_invalid_operation
);
7634 memcpy (symbuf
, sym
, symlen
);
7635 symbuf
[symlen
] = '\0';
7636 *symp
= sym
+ symlen
;
7638 /* Is it always possible, with complex symbols, that gas "mis-guessed"
7639 the symbol as a section, or vice-versa. so we're pretty liberal in our
7640 interpretation here; section means "try section first", not "must be a
7641 section", and likewise with symbol. */
7643 if (symbol_is_section
)
7645 if (!resolve_section (symbuf
, finfo
->output_bfd
->sections
, result
)
7646 && !resolve_symbol (symbuf
, input_bfd
, finfo
, result
,
7647 isymbuf
, locsymcount
))
7649 undefined_reference ("section", symbuf
);
7655 if (!resolve_symbol (symbuf
, input_bfd
, finfo
, result
,
7656 isymbuf
, locsymcount
)
7657 && !resolve_section (symbuf
, finfo
->output_bfd
->sections
,
7660 undefined_reference ("symbol", symbuf
);
7667 /* All that remains are operators. */
7669 #define UNARY_OP(op) \
7670 if (strncmp (sym, #op, strlen (#op)) == 0) \
7672 sym += strlen (#op); \
7676 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
7677 isymbuf, locsymcount, signed_p)) \
7680 *result = op ((bfd_signed_vma) a); \
7686 #define BINARY_OP(op) \
7687 if (strncmp (sym, #op, strlen (#op)) == 0) \
7689 sym += strlen (#op); \
7693 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
7694 isymbuf, locsymcount, signed_p)) \
7697 if (!eval_symbol (&b, symp, input_bfd, finfo, dot, \
7698 isymbuf, locsymcount, signed_p)) \
7701 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7731 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym
);
7732 bfd_set_error (bfd_error_invalid_operation
);
7738 put_value (bfd_vma size
,
7739 unsigned long chunksz
,
7744 location
+= (size
- chunksz
);
7746 for (; size
; size
-= chunksz
, location
-= chunksz
, x
>>= (chunksz
* 8))
7754 bfd_put_8 (input_bfd
, x
, location
);
7757 bfd_put_16 (input_bfd
, x
, location
);
7760 bfd_put_32 (input_bfd
, x
, location
);
7764 bfd_put_64 (input_bfd
, x
, location
);
7774 get_value (bfd_vma size
,
7775 unsigned long chunksz
,
7781 for (; size
; size
-= chunksz
, location
+= chunksz
)
7789 x
= (x
<< (8 * chunksz
)) | bfd_get_8 (input_bfd
, location
);
7792 x
= (x
<< (8 * chunksz
)) | bfd_get_16 (input_bfd
, location
);
7795 x
= (x
<< (8 * chunksz
)) | bfd_get_32 (input_bfd
, location
);
7799 x
= (x
<< (8 * chunksz
)) | bfd_get_64 (input_bfd
, location
);
7810 decode_complex_addend (unsigned long *start
, /* in bits */
7811 unsigned long *oplen
, /* in bits */
7812 unsigned long *len
, /* in bits */
7813 unsigned long *wordsz
, /* in bytes */
7814 unsigned long *chunksz
, /* in bytes */
7815 unsigned long *lsb0_p
,
7816 unsigned long *signed_p
,
7817 unsigned long *trunc_p
,
7818 unsigned long encoded
)
7820 * start
= encoded
& 0x3F;
7821 * len
= (encoded
>> 6) & 0x3F;
7822 * oplen
= (encoded
>> 12) & 0x3F;
7823 * wordsz
= (encoded
>> 18) & 0xF;
7824 * chunksz
= (encoded
>> 22) & 0xF;
7825 * lsb0_p
= (encoded
>> 27) & 1;
7826 * signed_p
= (encoded
>> 28) & 1;
7827 * trunc_p
= (encoded
>> 29) & 1;
7830 bfd_reloc_status_type
7831 bfd_elf_perform_complex_relocation (bfd
*input_bfd
,
7832 asection
*input_section ATTRIBUTE_UNUSED
,
7834 Elf_Internal_Rela
*rel
,
7837 bfd_vma shift
, x
, mask
;
7838 unsigned long start
, oplen
, len
, wordsz
, chunksz
, lsb0_p
, signed_p
, trunc_p
;
7839 bfd_reloc_status_type r
;
7841 /* Perform this reloc, since it is complex.
7842 (this is not to say that it necessarily refers to a complex
7843 symbol; merely that it is a self-describing CGEN based reloc.
7844 i.e. the addend has the complete reloc information (bit start, end,
7845 word size, etc) encoded within it.). */
7847 decode_complex_addend (&start
, &oplen
, &len
, &wordsz
,
7848 &chunksz
, &lsb0_p
, &signed_p
,
7849 &trunc_p
, rel
->r_addend
);
7851 mask
= (((1L << (len
- 1)) - 1) << 1) | 1;
7854 shift
= (start
+ 1) - len
;
7856 shift
= (8 * wordsz
) - (start
+ len
);
7858 /* FIXME: octets_per_byte. */
7859 x
= get_value (wordsz
, chunksz
, input_bfd
, contents
+ rel
->r_offset
);
7862 printf ("Doing complex reloc: "
7863 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7864 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7865 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7866 lsb0_p
, signed_p
, trunc_p
, wordsz
, chunksz
, start
, len
,
7867 oplen
, (unsigned long) x
, (unsigned long) mask
,
7868 (unsigned long) relocation
);
7873 /* Now do an overflow check. */
7874 r
= bfd_check_overflow ((signed_p
7875 ? complain_overflow_signed
7876 : complain_overflow_unsigned
),
7877 len
, 0, (8 * wordsz
),
7881 x
= (x
& ~(mask
<< shift
)) | ((relocation
& mask
) << shift
);
7884 printf (" relocation: %8.8lx\n"
7885 " shifted mask: %8.8lx\n"
7886 " shifted/masked reloc: %8.8lx\n"
7887 " result: %8.8lx\n",
7888 (unsigned long) relocation
, (unsigned long) (mask
<< shift
),
7889 (unsigned long) ((relocation
& mask
) << shift
), (unsigned long) x
);
7891 /* FIXME: octets_per_byte. */
7892 put_value (wordsz
, chunksz
, input_bfd
, x
, contents
+ rel
->r_offset
);
7896 /* When performing a relocatable link, the input relocations are
7897 preserved. But, if they reference global symbols, the indices
7898 referenced must be updated. Update all the relocations found in
7902 elf_link_adjust_relocs (bfd
*abfd
,
7903 struct bfd_elf_section_reloc_data
*reldata
)
7906 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7908 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
7909 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
7910 bfd_vma r_type_mask
;
7912 unsigned int count
= reldata
->count
;
7913 struct elf_link_hash_entry
**rel_hash
= reldata
->hashes
;
7915 if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
7917 swap_in
= bed
->s
->swap_reloc_in
;
7918 swap_out
= bed
->s
->swap_reloc_out
;
7920 else if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
7922 swap_in
= bed
->s
->swap_reloca_in
;
7923 swap_out
= bed
->s
->swap_reloca_out
;
7928 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
7931 if (bed
->s
->arch_size
== 32)
7938 r_type_mask
= 0xffffffff;
7942 erela
= reldata
->hdr
->contents
;
7943 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= reldata
->hdr
->sh_entsize
)
7945 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
7948 if (*rel_hash
== NULL
)
7951 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
7953 (*swap_in
) (abfd
, erela
, irela
);
7954 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
7955 irela
[j
].r_info
= ((bfd_vma
) (*rel_hash
)->indx
<< r_sym_shift
7956 | (irela
[j
].r_info
& r_type_mask
));
7957 (*swap_out
) (abfd
, irela
, erela
);
7961 struct elf_link_sort_rela
7967 enum elf_reloc_type_class type
;
7968 /* We use this as an array of size int_rels_per_ext_rel. */
7969 Elf_Internal_Rela rela
[1];
7973 elf_link_sort_cmp1 (const void *A
, const void *B
)
7975 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
7976 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
7977 int relativea
, relativeb
;
7979 relativea
= a
->type
== reloc_class_relative
;
7980 relativeb
= b
->type
== reloc_class_relative
;
7982 if (relativea
< relativeb
)
7984 if (relativea
> relativeb
)
7986 if ((a
->rela
->r_info
& a
->u
.sym_mask
) < (b
->rela
->r_info
& b
->u
.sym_mask
))
7988 if ((a
->rela
->r_info
& a
->u
.sym_mask
) > (b
->rela
->r_info
& b
->u
.sym_mask
))
7990 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
7992 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
7998 elf_link_sort_cmp2 (const void *A
, const void *B
)
8000 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8001 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8004 if (a
->u
.offset
< b
->u
.offset
)
8006 if (a
->u
.offset
> b
->u
.offset
)
8008 copya
= (a
->type
== reloc_class_copy
) * 2 + (a
->type
== reloc_class_plt
);
8009 copyb
= (b
->type
== reloc_class_copy
) * 2 + (b
->type
== reloc_class_plt
);
8014 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8016 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8022 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
8024 asection
*dynamic_relocs
;
8027 bfd_size_type count
, size
;
8028 size_t i
, ret
, sort_elt
, ext_size
;
8029 bfd_byte
*sort
, *s_non_relative
, *p
;
8030 struct elf_link_sort_rela
*sq
;
8031 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8032 int i2e
= bed
->s
->int_rels_per_ext_rel
;
8033 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8034 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8035 struct bfd_link_order
*lo
;
8037 bfd_boolean use_rela
;
8039 /* Find a dynamic reloc section. */
8040 rela_dyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
8041 rel_dyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
8042 if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0
8043 && rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8045 bfd_boolean use_rela_initialised
= FALSE
;
8047 /* This is just here to stop gcc from complaining.
8048 It's initialization checking code is not perfect. */
8051 /* Both sections are present. Examine the sizes
8052 of the indirect sections to help us choose. */
8053 for (lo
= rela_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8054 if (lo
->type
== bfd_indirect_link_order
)
8056 asection
*o
= lo
->u
.indirect
.section
;
8058 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8060 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8061 /* Section size is divisible by both rel and rela sizes.
8062 It is of no help to us. */
8066 /* Section size is only divisible by rela. */
8067 if (use_rela_initialised
&& (use_rela
== FALSE
))
8070 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8071 bfd_set_error (bfd_error_invalid_operation
);
8077 use_rela_initialised
= TRUE
;
8081 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8083 /* Section size is only divisible by rel. */
8084 if (use_rela_initialised
&& (use_rela
== TRUE
))
8087 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8088 bfd_set_error (bfd_error_invalid_operation
);
8094 use_rela_initialised
= TRUE
;
8099 /* The section size is not divisible by either - something is wrong. */
8101 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8102 bfd_set_error (bfd_error_invalid_operation
);
8107 for (lo
= rel_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8108 if (lo
->type
== bfd_indirect_link_order
)
8110 asection
*o
= lo
->u
.indirect
.section
;
8112 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8114 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8115 /* Section size is divisible by both rel and rela sizes.
8116 It is of no help to us. */
8120 /* Section size is only divisible by rela. */
8121 if (use_rela_initialised
&& (use_rela
== FALSE
))
8124 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8125 bfd_set_error (bfd_error_invalid_operation
);
8131 use_rela_initialised
= TRUE
;
8135 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8137 /* Section size is only divisible by rel. */
8138 if (use_rela_initialised
&& (use_rela
== TRUE
))
8141 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8142 bfd_set_error (bfd_error_invalid_operation
);
8148 use_rela_initialised
= TRUE
;
8153 /* The section size is not divisible by either - something is wrong. */
8155 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8156 bfd_set_error (bfd_error_invalid_operation
);
8161 if (! use_rela_initialised
)
8165 else if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0)
8167 else if (rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8174 dynamic_relocs
= rela_dyn
;
8175 ext_size
= bed
->s
->sizeof_rela
;
8176 swap_in
= bed
->s
->swap_reloca_in
;
8177 swap_out
= bed
->s
->swap_reloca_out
;
8181 dynamic_relocs
= rel_dyn
;
8182 ext_size
= bed
->s
->sizeof_rel
;
8183 swap_in
= bed
->s
->swap_reloc_in
;
8184 swap_out
= bed
->s
->swap_reloc_out
;
8188 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8189 if (lo
->type
== bfd_indirect_link_order
)
8190 size
+= lo
->u
.indirect
.section
->size
;
8192 if (size
!= dynamic_relocs
->size
)
8195 sort_elt
= (sizeof (struct elf_link_sort_rela
)
8196 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
8198 count
= dynamic_relocs
->size
/ ext_size
;
8201 sort
= (bfd_byte
*) bfd_zmalloc (sort_elt
* count
);
8205 (*info
->callbacks
->warning
)
8206 (info
, _("Not enough memory to sort relocations"), 0, abfd
, 0, 0);
8210 if (bed
->s
->arch_size
== 32)
8211 r_sym_mask
= ~(bfd_vma
) 0xff;
8213 r_sym_mask
= ~(bfd_vma
) 0xffffffff;
8215 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8216 if (lo
->type
== bfd_indirect_link_order
)
8218 bfd_byte
*erel
, *erelend
;
8219 asection
*o
= lo
->u
.indirect
.section
;
8221 if (o
->contents
== NULL
&& o
->size
!= 0)
8223 /* This is a reloc section that is being handled as a normal
8224 section. See bfd_section_from_shdr. We can't combine
8225 relocs in this case. */
8230 erelend
= o
->contents
+ o
->size
;
8231 /* FIXME: octets_per_byte. */
8232 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8234 while (erel
< erelend
)
8236 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8238 (*swap_in
) (abfd
, erel
, s
->rela
);
8239 s
->type
= (*bed
->elf_backend_reloc_type_class
) (s
->rela
);
8240 s
->u
.sym_mask
= r_sym_mask
;
8246 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
8248 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
8250 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8251 if (s
->type
!= reloc_class_relative
)
8257 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
8258 for (; i
< count
; i
++, p
+= sort_elt
)
8260 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
8261 if (((sp
->rela
->r_info
^ sq
->rela
->r_info
) & r_sym_mask
) != 0)
8263 sp
->u
.offset
= sq
->rela
->r_offset
;
8266 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
8268 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8269 if (lo
->type
== bfd_indirect_link_order
)
8271 bfd_byte
*erel
, *erelend
;
8272 asection
*o
= lo
->u
.indirect
.section
;
8275 erelend
= o
->contents
+ o
->size
;
8276 /* FIXME: octets_per_byte. */
8277 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8278 while (erel
< erelend
)
8280 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8281 (*swap_out
) (abfd
, s
->rela
, erel
);
8288 *psec
= dynamic_relocs
;
8292 /* Flush the output symbols to the file. */
8295 elf_link_flush_output_syms (struct elf_final_link_info
*finfo
,
8296 const struct elf_backend_data
*bed
)
8298 if (finfo
->symbuf_count
> 0)
8300 Elf_Internal_Shdr
*hdr
;
8304 hdr
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
8305 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
8306 amt
= finfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8307 if (bfd_seek (finfo
->output_bfd
, pos
, SEEK_SET
) != 0
8308 || bfd_bwrite (finfo
->symbuf
, amt
, finfo
->output_bfd
) != amt
)
8311 hdr
->sh_size
+= amt
;
8312 finfo
->symbuf_count
= 0;
8318 /* Add a symbol to the output symbol table. */
8321 elf_link_output_sym (struct elf_final_link_info
*finfo
,
8323 Elf_Internal_Sym
*elfsym
,
8324 asection
*input_sec
,
8325 struct elf_link_hash_entry
*h
)
8328 Elf_External_Sym_Shndx
*destshndx
;
8329 int (*output_symbol_hook
)
8330 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*, asection
*,
8331 struct elf_link_hash_entry
*);
8332 const struct elf_backend_data
*bed
;
8334 bed
= get_elf_backend_data (finfo
->output_bfd
);
8335 output_symbol_hook
= bed
->elf_backend_link_output_symbol_hook
;
8336 if (output_symbol_hook
!= NULL
)
8338 int ret
= (*output_symbol_hook
) (finfo
->info
, name
, elfsym
, input_sec
, h
);
8343 if (name
== NULL
|| *name
== '\0')
8344 elfsym
->st_name
= 0;
8345 else if (input_sec
->flags
& SEC_EXCLUDE
)
8346 elfsym
->st_name
= 0;
8349 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
8351 if (elfsym
->st_name
== (unsigned long) -1)
8355 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
8357 if (! elf_link_flush_output_syms (finfo
, bed
))
8361 dest
= finfo
->symbuf
+ finfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8362 destshndx
= finfo
->symshndxbuf
;
8363 if (destshndx
!= NULL
)
8365 if (bfd_get_symcount (finfo
->output_bfd
) >= finfo
->shndxbuf_size
)
8369 amt
= finfo
->shndxbuf_size
* sizeof (Elf_External_Sym_Shndx
);
8370 destshndx
= (Elf_External_Sym_Shndx
*) bfd_realloc (destshndx
,
8372 if (destshndx
== NULL
)
8374 finfo
->symshndxbuf
= destshndx
;
8375 memset ((char *) destshndx
+ amt
, 0, amt
);
8376 finfo
->shndxbuf_size
*= 2;
8378 destshndx
+= bfd_get_symcount (finfo
->output_bfd
);
8381 bed
->s
->swap_symbol_out (finfo
->output_bfd
, elfsym
, dest
, destshndx
);
8382 finfo
->symbuf_count
+= 1;
8383 bfd_get_symcount (finfo
->output_bfd
) += 1;
8388 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8391 check_dynsym (bfd
*abfd
, Elf_Internal_Sym
*sym
)
8393 if (sym
->st_shndx
>= (SHN_LORESERVE
& 0xffff)
8394 && sym
->st_shndx
< SHN_LORESERVE
)
8396 /* The gABI doesn't support dynamic symbols in output sections
8398 (*_bfd_error_handler
)
8399 (_("%B: Too many sections: %d (>= %d)"),
8400 abfd
, bfd_count_sections (abfd
), SHN_LORESERVE
& 0xffff);
8401 bfd_set_error (bfd_error_nonrepresentable_section
);
8407 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8408 allowing an unsatisfied unversioned symbol in the DSO to match a
8409 versioned symbol that would normally require an explicit version.
8410 We also handle the case that a DSO references a hidden symbol
8411 which may be satisfied by a versioned symbol in another DSO. */
8414 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
8415 const struct elf_backend_data
*bed
,
8416 struct elf_link_hash_entry
*h
)
8419 struct elf_link_loaded_list
*loaded
;
8421 if (!is_elf_hash_table (info
->hash
))
8424 switch (h
->root
.type
)
8430 case bfd_link_hash_undefined
:
8431 case bfd_link_hash_undefweak
:
8432 abfd
= h
->root
.u
.undef
.abfd
;
8433 if ((abfd
->flags
& DYNAMIC
) == 0
8434 || (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) == 0)
8438 case bfd_link_hash_defined
:
8439 case bfd_link_hash_defweak
:
8440 abfd
= h
->root
.u
.def
.section
->owner
;
8443 case bfd_link_hash_common
:
8444 abfd
= h
->root
.u
.c
.p
->section
->owner
;
8447 BFD_ASSERT (abfd
!= NULL
);
8449 for (loaded
= elf_hash_table (info
)->loaded
;
8451 loaded
= loaded
->next
)
8454 Elf_Internal_Shdr
*hdr
;
8455 bfd_size_type symcount
;
8456 bfd_size_type extsymcount
;
8457 bfd_size_type extsymoff
;
8458 Elf_Internal_Shdr
*versymhdr
;
8459 Elf_Internal_Sym
*isym
;
8460 Elf_Internal_Sym
*isymend
;
8461 Elf_Internal_Sym
*isymbuf
;
8462 Elf_External_Versym
*ever
;
8463 Elf_External_Versym
*extversym
;
8465 input
= loaded
->abfd
;
8467 /* We check each DSO for a possible hidden versioned definition. */
8469 || (input
->flags
& DYNAMIC
) == 0
8470 || elf_dynversym (input
) == 0)
8473 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
8475 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
8476 if (elf_bad_symtab (input
))
8478 extsymcount
= symcount
;
8483 extsymcount
= symcount
- hdr
->sh_info
;
8484 extsymoff
= hdr
->sh_info
;
8487 if (extsymcount
== 0)
8490 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
8492 if (isymbuf
== NULL
)
8495 /* Read in any version definitions. */
8496 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
8497 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
8498 if (extversym
== NULL
)
8501 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
8502 || (bfd_bread (extversym
, versymhdr
->sh_size
, input
)
8503 != versymhdr
->sh_size
))
8511 ever
= extversym
+ extsymoff
;
8512 isymend
= isymbuf
+ extsymcount
;
8513 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
8516 Elf_Internal_Versym iver
;
8517 unsigned short version_index
;
8519 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
8520 || isym
->st_shndx
== SHN_UNDEF
)
8523 name
= bfd_elf_string_from_elf_section (input
,
8526 if (strcmp (name
, h
->root
.root
.string
) != 0)
8529 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
8531 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
8533 && h
->forced_local
))
8535 /* If we have a non-hidden versioned sym, then it should
8536 have provided a definition for the undefined sym unless
8537 it is defined in a non-shared object and forced local.
8542 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
8543 if (version_index
== 1 || version_index
== 2)
8545 /* This is the base or first version. We can use it. */
8559 /* Add an external symbol to the symbol table. This is called from
8560 the hash table traversal routine. When generating a shared object,
8561 we go through the symbol table twice. The first time we output
8562 anything that might have been forced to local scope in a version
8563 script. The second time we output the symbols that are still
8567 elf_link_output_extsym (struct bfd_hash_entry
*bh
, void *data
)
8569 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
8570 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
8571 struct elf_final_link_info
*finfo
= eoinfo
->finfo
;
8573 Elf_Internal_Sym sym
;
8574 asection
*input_sec
;
8575 const struct elf_backend_data
*bed
;
8579 if (h
->root
.type
== bfd_link_hash_warning
)
8581 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8582 if (h
->root
.type
== bfd_link_hash_new
)
8586 /* Decide whether to output this symbol in this pass. */
8587 if (eoinfo
->localsyms
)
8589 if (!h
->forced_local
)
8594 if (h
->forced_local
)
8598 bed
= get_elf_backend_data (finfo
->output_bfd
);
8600 if (h
->root
.type
== bfd_link_hash_undefined
)
8602 /* If we have an undefined symbol reference here then it must have
8603 come from a shared library that is being linked in. (Undefined
8604 references in regular files have already been handled unless
8605 they are in unreferenced sections which are removed by garbage
8607 bfd_boolean ignore_undef
= FALSE
;
8609 /* Some symbols may be special in that the fact that they're
8610 undefined can be safely ignored - let backend determine that. */
8611 if (bed
->elf_backend_ignore_undef_symbol
)
8612 ignore_undef
= bed
->elf_backend_ignore_undef_symbol (h
);
8614 /* If we are reporting errors for this situation then do so now. */
8617 && (!h
->ref_regular
|| finfo
->info
->gc_sections
)
8618 && ! elf_link_check_versioned_symbol (finfo
->info
, bed
, h
)
8619 && finfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
8621 if (! (finfo
->info
->callbacks
->undefined_symbol
8622 (finfo
->info
, h
->root
.root
.string
,
8623 h
->ref_regular
? NULL
: h
->root
.u
.undef
.abfd
,
8624 NULL
, 0, finfo
->info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
)))
8626 bfd_set_error (bfd_error_bad_value
);
8627 eoinfo
->failed
= TRUE
;
8633 /* We should also warn if a forced local symbol is referenced from
8634 shared libraries. */
8635 if (! finfo
->info
->relocatable
8636 && (! finfo
->info
->shared
)
8641 && ! elf_link_check_versioned_symbol (finfo
->info
, bed
, h
))
8646 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
8647 msg
= _("%B: internal symbol `%s' in %B is referenced by DSO");
8648 else if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
8649 msg
= _("%B: hidden symbol `%s' in %B is referenced by DSO");
8651 msg
= _("%B: local symbol `%s' in %B is referenced by DSO");
8652 def_bfd
= finfo
->output_bfd
;
8653 if (h
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
8654 def_bfd
= h
->root
.u
.def
.section
->owner
;
8655 (*_bfd_error_handler
) (msg
, finfo
->output_bfd
, def_bfd
,
8656 h
->root
.root
.string
);
8657 bfd_set_error (bfd_error_bad_value
);
8658 eoinfo
->failed
= TRUE
;
8662 /* We don't want to output symbols that have never been mentioned by
8663 a regular file, or that we have been told to strip. However, if
8664 h->indx is set to -2, the symbol is used by a reloc and we must
8668 else if ((h
->def_dynamic
8670 || h
->root
.type
== bfd_link_hash_new
)
8674 else if (finfo
->info
->strip
== strip_all
)
8676 else if (finfo
->info
->strip
== strip_some
8677 && bfd_hash_lookup (finfo
->info
->keep_hash
,
8678 h
->root
.root
.string
, FALSE
, FALSE
) == NULL
)
8680 else if (finfo
->info
->strip_discarded
8681 && (h
->root
.type
== bfd_link_hash_defined
8682 || h
->root
.type
== bfd_link_hash_defweak
)
8683 && elf_discarded_section (h
->root
.u
.def
.section
))
8685 else if ((h
->root
.type
== bfd_link_hash_undefined
8686 || h
->root
.type
== bfd_link_hash_undefweak
)
8687 && h
->root
.u
.undef
.abfd
!= NULL
8688 && (h
->root
.u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0)
8693 /* If we're stripping it, and it's not a dynamic symbol, there's
8694 nothing else to do unless it is a forced local symbol or a
8695 STT_GNU_IFUNC symbol. */
8698 && h
->type
!= STT_GNU_IFUNC
8699 && !h
->forced_local
)
8703 sym
.st_size
= h
->size
;
8704 sym
.st_other
= h
->other
;
8705 if (h
->forced_local
)
8707 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
8708 /* Turn off visibility on local symbol. */
8709 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
8711 else if (h
->unique_global
)
8712 sym
.st_info
= ELF_ST_INFO (STB_GNU_UNIQUE
, h
->type
);
8713 else if (h
->root
.type
== bfd_link_hash_undefweak
8714 || h
->root
.type
== bfd_link_hash_defweak
)
8715 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
8717 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
8718 sym
.st_target_internal
= h
->target_internal
;
8720 switch (h
->root
.type
)
8723 case bfd_link_hash_new
:
8724 case bfd_link_hash_warning
:
8728 case bfd_link_hash_undefined
:
8729 case bfd_link_hash_undefweak
:
8730 input_sec
= bfd_und_section_ptr
;
8731 sym
.st_shndx
= SHN_UNDEF
;
8734 case bfd_link_hash_defined
:
8735 case bfd_link_hash_defweak
:
8737 input_sec
= h
->root
.u
.def
.section
;
8738 if (input_sec
->output_section
!= NULL
)
8741 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
8742 input_sec
->output_section
);
8743 if (sym
.st_shndx
== SHN_BAD
)
8745 (*_bfd_error_handler
)
8746 (_("%B: could not find output section %A for input section %A"),
8747 finfo
->output_bfd
, input_sec
->output_section
, input_sec
);
8748 bfd_set_error (bfd_error_nonrepresentable_section
);
8749 eoinfo
->failed
= TRUE
;
8753 /* ELF symbols in relocatable files are section relative,
8754 but in nonrelocatable files they are virtual
8756 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
8757 if (! finfo
->info
->relocatable
)
8759 sym
.st_value
+= input_sec
->output_section
->vma
;
8760 if (h
->type
== STT_TLS
)
8762 asection
*tls_sec
= elf_hash_table (finfo
->info
)->tls_sec
;
8763 if (tls_sec
!= NULL
)
8764 sym
.st_value
-= tls_sec
->vma
;
8767 /* The TLS section may have been garbage collected. */
8768 BFD_ASSERT (finfo
->info
->gc_sections
8769 && !input_sec
->gc_mark
);
8776 BFD_ASSERT (input_sec
->owner
== NULL
8777 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
8778 sym
.st_shndx
= SHN_UNDEF
;
8779 input_sec
= bfd_und_section_ptr
;
8784 case bfd_link_hash_common
:
8785 input_sec
= h
->root
.u
.c
.p
->section
;
8786 sym
.st_shndx
= bed
->common_section_index (input_sec
);
8787 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
8790 case bfd_link_hash_indirect
:
8791 /* These symbols are created by symbol versioning. They point
8792 to the decorated version of the name. For example, if the
8793 symbol foo@@GNU_1.2 is the default, which should be used when
8794 foo is used with no version, then we add an indirect symbol
8795 foo which points to foo@@GNU_1.2. We ignore these symbols,
8796 since the indirected symbol is already in the hash table. */
8800 /* Give the processor backend a chance to tweak the symbol value,
8801 and also to finish up anything that needs to be done for this
8802 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
8803 forced local syms when non-shared is due to a historical quirk.
8804 STT_GNU_IFUNC symbol must go through PLT. */
8805 if ((h
->type
== STT_GNU_IFUNC
8807 && !finfo
->info
->relocatable
)
8808 || ((h
->dynindx
!= -1
8810 && ((finfo
->info
->shared
8811 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
8812 || h
->root
.type
!= bfd_link_hash_undefweak
))
8813 || !h
->forced_local
)
8814 && elf_hash_table (finfo
->info
)->dynamic_sections_created
))
8816 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
8817 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
8819 eoinfo
->failed
= TRUE
;
8824 /* If we are marking the symbol as undefined, and there are no
8825 non-weak references to this symbol from a regular object, then
8826 mark the symbol as weak undefined; if there are non-weak
8827 references, mark the symbol as strong. We can't do this earlier,
8828 because it might not be marked as undefined until the
8829 finish_dynamic_symbol routine gets through with it. */
8830 if (sym
.st_shndx
== SHN_UNDEF
8832 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
8833 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
8836 unsigned int type
= ELF_ST_TYPE (sym
.st_info
);
8838 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
8839 if (type
== STT_GNU_IFUNC
)
8842 if (h
->ref_regular_nonweak
)
8843 bindtype
= STB_GLOBAL
;
8845 bindtype
= STB_WEAK
;
8846 sym
.st_info
= ELF_ST_INFO (bindtype
, type
);
8849 /* If this is a symbol defined in a dynamic library, don't use the
8850 symbol size from the dynamic library. Relinking an executable
8851 against a new library may introduce gratuitous changes in the
8852 executable's symbols if we keep the size. */
8853 if (sym
.st_shndx
== SHN_UNDEF
8858 /* If a non-weak symbol with non-default visibility is not defined
8859 locally, it is a fatal error. */
8860 if (! finfo
->info
->relocatable
8861 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
8862 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
8863 && h
->root
.type
== bfd_link_hash_undefined
8868 if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
)
8869 msg
= _("%B: protected symbol `%s' isn't defined");
8870 else if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
)
8871 msg
= _("%B: internal symbol `%s' isn't defined");
8873 msg
= _("%B: hidden symbol `%s' isn't defined");
8874 (*_bfd_error_handler
) (msg
, finfo
->output_bfd
, h
->root
.root
.string
);
8875 bfd_set_error (bfd_error_bad_value
);
8876 eoinfo
->failed
= TRUE
;
8880 /* If this symbol should be put in the .dynsym section, then put it
8881 there now. We already know the symbol index. We also fill in
8882 the entry in the .hash section. */
8883 if (h
->dynindx
!= -1
8884 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
8888 sym
.st_name
= h
->dynstr_index
;
8889 esym
= finfo
->dynsym_sec
->contents
+ h
->dynindx
* bed
->s
->sizeof_sym
;
8890 if (! check_dynsym (finfo
->output_bfd
, &sym
))
8892 eoinfo
->failed
= TRUE
;
8895 bed
->s
->swap_symbol_out (finfo
->output_bfd
, &sym
, esym
, 0);
8897 if (finfo
->hash_sec
!= NULL
)
8899 size_t hash_entry_size
;
8900 bfd_byte
*bucketpos
;
8905 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
8906 bucket
= h
->u
.elf_hash_value
% bucketcount
;
8909 = elf_section_data (finfo
->hash_sec
)->this_hdr
.sh_entsize
;
8910 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
8911 + (bucket
+ 2) * hash_entry_size
);
8912 chain
= bfd_get (8 * hash_entry_size
, finfo
->output_bfd
, bucketpos
);
8913 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, h
->dynindx
, bucketpos
);
8914 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, chain
,
8915 ((bfd_byte
*) finfo
->hash_sec
->contents
8916 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
8919 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
8921 Elf_Internal_Versym iversym
;
8922 Elf_External_Versym
*eversym
;
8924 if (!h
->def_regular
)
8926 if (h
->verinfo
.verdef
== NULL
)
8927 iversym
.vs_vers
= 0;
8929 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
8933 if (h
->verinfo
.vertree
== NULL
)
8934 iversym
.vs_vers
= 1;
8936 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
8937 if (finfo
->info
->create_default_symver
)
8942 iversym
.vs_vers
|= VERSYM_HIDDEN
;
8944 eversym
= (Elf_External_Versym
*) finfo
->symver_sec
->contents
;
8945 eversym
+= h
->dynindx
;
8946 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
, eversym
);
8950 /* If we're stripping it, then it was just a dynamic symbol, and
8951 there's nothing else to do. */
8952 if (strip
|| (input_sec
->flags
& SEC_EXCLUDE
) != 0)
8955 indx
= bfd_get_symcount (finfo
->output_bfd
);
8956 ret
= elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
, h
);
8959 eoinfo
->failed
= TRUE
;
8964 else if (h
->indx
== -2)
8970 /* Return TRUE if special handling is done for relocs in SEC against
8971 symbols defined in discarded sections. */
8974 elf_section_ignore_discarded_relocs (asection
*sec
)
8976 const struct elf_backend_data
*bed
;
8978 switch (sec
->sec_info_type
)
8980 case ELF_INFO_TYPE_STABS
:
8981 case ELF_INFO_TYPE_EH_FRAME
:
8987 bed
= get_elf_backend_data (sec
->owner
);
8988 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
8989 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))
8995 /* Return a mask saying how ld should treat relocations in SEC against
8996 symbols defined in discarded sections. If this function returns
8997 COMPLAIN set, ld will issue a warning message. If this function
8998 returns PRETEND set, and the discarded section was link-once and the
8999 same size as the kept link-once section, ld will pretend that the
9000 symbol was actually defined in the kept section. Otherwise ld will
9001 zero the reloc (at least that is the intent, but some cooperation by
9002 the target dependent code is needed, particularly for REL targets). */
9005 _bfd_elf_default_action_discarded (asection
*sec
)
9007 if (sec
->flags
& SEC_DEBUGGING
)
9010 if (strcmp (".eh_frame", sec
->name
) == 0)
9013 if (strcmp (".gcc_except_table", sec
->name
) == 0)
9016 return COMPLAIN
| PRETEND
;
9019 /* Find a match between a section and a member of a section group. */
9022 match_group_member (asection
*sec
, asection
*group
,
9023 struct bfd_link_info
*info
)
9025 asection
*first
= elf_next_in_group (group
);
9026 asection
*s
= first
;
9030 if (bfd_elf_match_symbols_in_sections (s
, sec
, info
))
9033 s
= elf_next_in_group (s
);
9041 /* Check if the kept section of a discarded section SEC can be used
9042 to replace it. Return the replacement if it is OK. Otherwise return
9046 _bfd_elf_check_kept_section (asection
*sec
, struct bfd_link_info
*info
)
9050 kept
= sec
->kept_section
;
9053 if ((kept
->flags
& SEC_GROUP
) != 0)
9054 kept
= match_group_member (sec
, kept
, info
);
9056 && ((sec
->rawsize
!= 0 ? sec
->rawsize
: sec
->size
)
9057 != (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9059 sec
->kept_section
= kept
;
9064 /* Link an input file into the linker output file. This function
9065 handles all the sections and relocations of the input file at once.
9066 This is so that we only have to read the local symbols once, and
9067 don't have to keep them in memory. */
9070 elf_link_input_bfd (struct elf_final_link_info
*finfo
, bfd
*input_bfd
)
9072 int (*relocate_section
)
9073 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
9074 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
9076 Elf_Internal_Shdr
*symtab_hdr
;
9079 Elf_Internal_Sym
*isymbuf
;
9080 Elf_Internal_Sym
*isym
;
9081 Elf_Internal_Sym
*isymend
;
9083 asection
**ppsection
;
9085 const struct elf_backend_data
*bed
;
9086 struct elf_link_hash_entry
**sym_hashes
;
9087 bfd_size_type address_size
;
9088 bfd_vma r_type_mask
;
9091 output_bfd
= finfo
->output_bfd
;
9092 bed
= get_elf_backend_data (output_bfd
);
9093 relocate_section
= bed
->elf_backend_relocate_section
;
9095 /* If this is a dynamic object, we don't want to do anything here:
9096 we don't want the local symbols, and we don't want the section
9098 if ((input_bfd
->flags
& DYNAMIC
) != 0)
9101 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
9102 if (elf_bad_symtab (input_bfd
))
9104 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
9109 locsymcount
= symtab_hdr
->sh_info
;
9110 extsymoff
= symtab_hdr
->sh_info
;
9113 /* Read the local symbols. */
9114 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
9115 if (isymbuf
== NULL
&& locsymcount
!= 0)
9117 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
9118 finfo
->internal_syms
,
9119 finfo
->external_syms
,
9120 finfo
->locsym_shndx
);
9121 if (isymbuf
== NULL
)
9125 /* Find local symbol sections and adjust values of symbols in
9126 SEC_MERGE sections. Write out those local symbols we know are
9127 going into the output file. */
9128 isymend
= isymbuf
+ locsymcount
;
9129 for (isym
= isymbuf
, pindex
= finfo
->indices
, ppsection
= finfo
->sections
;
9131 isym
++, pindex
++, ppsection
++)
9135 Elf_Internal_Sym osym
;
9141 if (elf_bad_symtab (input_bfd
))
9143 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
9150 if (isym
->st_shndx
== SHN_UNDEF
)
9151 isec
= bfd_und_section_ptr
;
9152 else if (isym
->st_shndx
== SHN_ABS
)
9153 isec
= bfd_abs_section_ptr
;
9154 else if (isym
->st_shndx
== SHN_COMMON
)
9155 isec
= bfd_com_section_ptr
;
9158 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
9161 /* Don't attempt to output symbols with st_shnx in the
9162 reserved range other than SHN_ABS and SHN_COMMON. */
9166 else if (isec
->sec_info_type
== ELF_INFO_TYPE_MERGE
9167 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
9169 _bfd_merged_section_offset (output_bfd
, &isec
,
9170 elf_section_data (isec
)->sec_info
,
9176 /* Don't output the first, undefined, symbol. */
9177 if (ppsection
== finfo
->sections
)
9180 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
9182 /* We never output section symbols. Instead, we use the
9183 section symbol of the corresponding section in the output
9188 /* If we are stripping all symbols, we don't want to output this
9190 if (finfo
->info
->strip
== strip_all
)
9193 /* If we are discarding all local symbols, we don't want to
9194 output this one. If we are generating a relocatable output
9195 file, then some of the local symbols may be required by
9196 relocs; we output them below as we discover that they are
9198 if (finfo
->info
->discard
== discard_all
)
9201 /* If this symbol is defined in a section which we are
9202 discarding, we don't need to keep it. */
9203 if (isym
->st_shndx
!= SHN_UNDEF
9204 && isym
->st_shndx
< SHN_LORESERVE
9205 && bfd_section_removed_from_list (output_bfd
,
9206 isec
->output_section
))
9209 /* Get the name of the symbol. */
9210 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
9215 /* See if we are discarding symbols with this name. */
9216 if ((finfo
->info
->strip
== strip_some
9217 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
9219 || (((finfo
->info
->discard
== discard_sec_merge
9220 && (isec
->flags
& SEC_MERGE
) && ! finfo
->info
->relocatable
)
9221 || finfo
->info
->discard
== discard_l
)
9222 && bfd_is_local_label_name (input_bfd
, name
)))
9227 /* Adjust the section index for the output file. */
9228 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9229 isec
->output_section
);
9230 if (osym
.st_shndx
== SHN_BAD
)
9233 /* ELF symbols in relocatable files are section relative, but
9234 in executable files they are virtual addresses. Note that
9235 this code assumes that all ELF sections have an associated
9236 BFD section with a reasonable value for output_offset; below
9237 we assume that they also have a reasonable value for
9238 output_section. Any special sections must be set up to meet
9239 these requirements. */
9240 osym
.st_value
+= isec
->output_offset
;
9241 if (! finfo
->info
->relocatable
)
9243 osym
.st_value
+= isec
->output_section
->vma
;
9244 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
9246 /* STT_TLS symbols are relative to PT_TLS segment base. */
9247 BFD_ASSERT (elf_hash_table (finfo
->info
)->tls_sec
!= NULL
);
9248 osym
.st_value
-= elf_hash_table (finfo
->info
)->tls_sec
->vma
;
9252 indx
= bfd_get_symcount (output_bfd
);
9253 ret
= elf_link_output_sym (finfo
, name
, &osym
, isec
, NULL
);
9260 if (bed
->s
->arch_size
== 32)
9268 r_type_mask
= 0xffffffff;
9273 /* Relocate the contents of each section. */
9274 sym_hashes
= elf_sym_hashes (input_bfd
);
9275 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
9279 if (! o
->linker_mark
)
9281 /* This section was omitted from the link. */
9285 if (finfo
->info
->relocatable
9286 && (o
->flags
& (SEC_LINKER_CREATED
| SEC_GROUP
)) == SEC_GROUP
)
9288 /* Deal with the group signature symbol. */
9289 struct bfd_elf_section_data
*sec_data
= elf_section_data (o
);
9290 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
9291 asection
*osec
= o
->output_section
;
9293 if (symndx
>= locsymcount
9294 || (elf_bad_symtab (input_bfd
)
9295 && finfo
->sections
[symndx
] == NULL
))
9297 struct elf_link_hash_entry
*h
= sym_hashes
[symndx
- extsymoff
];
9298 while (h
->root
.type
== bfd_link_hash_indirect
9299 || h
->root
.type
== bfd_link_hash_warning
)
9300 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9301 /* Arrange for symbol to be output. */
9303 elf_section_data (osec
)->this_hdr
.sh_info
= -2;
9305 else if (ELF_ST_TYPE (isymbuf
[symndx
].st_info
) == STT_SECTION
)
9307 /* We'll use the output section target_index. */
9308 asection
*sec
= finfo
->sections
[symndx
]->output_section
;
9309 elf_section_data (osec
)->this_hdr
.sh_info
= sec
->target_index
;
9313 if (finfo
->indices
[symndx
] == -1)
9315 /* Otherwise output the local symbol now. */
9316 Elf_Internal_Sym sym
= isymbuf
[symndx
];
9317 asection
*sec
= finfo
->sections
[symndx
]->output_section
;
9322 name
= bfd_elf_string_from_elf_section (input_bfd
,
9323 symtab_hdr
->sh_link
,
9328 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9330 if (sym
.st_shndx
== SHN_BAD
)
9333 sym
.st_value
+= o
->output_offset
;
9335 indx
= bfd_get_symcount (output_bfd
);
9336 ret
= elf_link_output_sym (finfo
, name
, &sym
, o
, NULL
);
9340 finfo
->indices
[symndx
] = indx
;
9344 elf_section_data (osec
)->this_hdr
.sh_info
9345 = finfo
->indices
[symndx
];
9349 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
9350 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
9353 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
9355 /* Section was created by _bfd_elf_link_create_dynamic_sections
9360 /* Get the contents of the section. They have been cached by a
9361 relaxation routine. Note that o is a section in an input
9362 file, so the contents field will not have been set by any of
9363 the routines which work on output files. */
9364 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
9365 contents
= elf_section_data (o
)->this_hdr
.contents
;
9368 contents
= finfo
->contents
;
9369 if (! bfd_get_full_section_contents (input_bfd
, o
, &contents
))
9373 if ((o
->flags
& SEC_RELOC
) != 0)
9375 Elf_Internal_Rela
*internal_relocs
;
9376 Elf_Internal_Rela
*rel
, *relend
;
9377 int action_discarded
;
9380 /* Get the swapped relocs. */
9382 = _bfd_elf_link_read_relocs (input_bfd
, o
, finfo
->external_relocs
,
9383 finfo
->internal_relocs
, FALSE
);
9384 if (internal_relocs
== NULL
9385 && o
->reloc_count
> 0)
9388 /* We need to reverse-copy input .ctors/.dtors sections if
9389 they are placed in .init_array/.finit_array for output. */
9390 if (o
->size
> address_size
9391 && ((strncmp (o
->name
, ".ctors", 6) == 0
9392 && strcmp (o
->output_section
->name
,
9393 ".init_array") == 0)
9394 || (strncmp (o
->name
, ".dtors", 6) == 0
9395 && strcmp (o
->output_section
->name
,
9396 ".fini_array") == 0))
9397 && (o
->name
[6] == 0 || o
->name
[6] == '.'))
9399 if (o
->size
!= o
->reloc_count
* address_size
)
9401 (*_bfd_error_handler
)
9402 (_("error: %B: size of section %A is not "
9403 "multiple of address size"),
9405 bfd_set_error (bfd_error_on_input
);
9408 o
->flags
|= SEC_ELF_REVERSE_COPY
;
9411 action_discarded
= -1;
9412 if (!elf_section_ignore_discarded_relocs (o
))
9413 action_discarded
= (*bed
->action_discarded
) (o
);
9415 /* Run through the relocs evaluating complex reloc symbols and
9416 looking for relocs against symbols from discarded sections
9417 or section symbols from removed link-once sections.
9418 Complain about relocs against discarded sections. Zero
9419 relocs against removed link-once sections. */
9421 rel
= internal_relocs
;
9422 relend
= rel
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9423 for ( ; rel
< relend
; rel
++)
9425 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
9426 unsigned int s_type
;
9427 asection
**ps
, *sec
;
9428 struct elf_link_hash_entry
*h
= NULL
;
9429 const char *sym_name
;
9431 if (r_symndx
== STN_UNDEF
)
9434 if (r_symndx
>= locsymcount
9435 || (elf_bad_symtab (input_bfd
)
9436 && finfo
->sections
[r_symndx
] == NULL
))
9438 h
= sym_hashes
[r_symndx
- extsymoff
];
9440 /* Badly formatted input files can contain relocs that
9441 reference non-existant symbols. Check here so that
9442 we do not seg fault. */
9447 sprintf_vma (buffer
, rel
->r_info
);
9448 (*_bfd_error_handler
)
9449 (_("error: %B contains a reloc (0x%s) for section %A "
9450 "that references a non-existent global symbol"),
9451 input_bfd
, o
, buffer
);
9452 bfd_set_error (bfd_error_bad_value
);
9456 while (h
->root
.type
== bfd_link_hash_indirect
9457 || h
->root
.type
== bfd_link_hash_warning
)
9458 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9463 if (h
->root
.type
== bfd_link_hash_defined
9464 || h
->root
.type
== bfd_link_hash_defweak
)
9465 ps
= &h
->root
.u
.def
.section
;
9467 sym_name
= h
->root
.root
.string
;
9471 Elf_Internal_Sym
*sym
= isymbuf
+ r_symndx
;
9473 s_type
= ELF_ST_TYPE (sym
->st_info
);
9474 ps
= &finfo
->sections
[r_symndx
];
9475 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
9479 if ((s_type
== STT_RELC
|| s_type
== STT_SRELC
)
9480 && !finfo
->info
->relocatable
)
9483 bfd_vma dot
= (rel
->r_offset
9484 + o
->output_offset
+ o
->output_section
->vma
);
9486 printf ("Encountered a complex symbol!");
9487 printf (" (input_bfd %s, section %s, reloc %ld\n",
9488 input_bfd
->filename
, o
->name
,
9489 (long) (rel
- internal_relocs
));
9490 printf (" symbol: idx %8.8lx, name %s\n",
9491 r_symndx
, sym_name
);
9492 printf (" reloc : info %8.8lx, addr %8.8lx\n",
9493 (unsigned long) rel
->r_info
,
9494 (unsigned long) rel
->r_offset
);
9496 if (!eval_symbol (&val
, &sym_name
, input_bfd
, finfo
, dot
,
9497 isymbuf
, locsymcount
, s_type
== STT_SRELC
))
9500 /* Symbol evaluated OK. Update to absolute value. */
9501 set_symbol_value (input_bfd
, isymbuf
, locsymcount
,
9506 if (action_discarded
!= -1 && ps
!= NULL
)
9508 /* Complain if the definition comes from a
9509 discarded section. */
9510 if ((sec
= *ps
) != NULL
&& elf_discarded_section (sec
))
9512 BFD_ASSERT (r_symndx
!= STN_UNDEF
);
9513 if (action_discarded
& COMPLAIN
)
9514 (*finfo
->info
->callbacks
->einfo
)
9515 (_("%X`%s' referenced in section `%A' of %B: "
9516 "defined in discarded section `%A' of %B\n"),
9517 sym_name
, o
, input_bfd
, sec
, sec
->owner
);
9519 /* Try to do the best we can to support buggy old
9520 versions of gcc. Pretend that the symbol is
9521 really defined in the kept linkonce section.
9522 FIXME: This is quite broken. Modifying the
9523 symbol here means we will be changing all later
9524 uses of the symbol, not just in this section. */
9525 if (action_discarded
& PRETEND
)
9529 kept
= _bfd_elf_check_kept_section (sec
,
9541 /* Relocate the section by invoking a back end routine.
9543 The back end routine is responsible for adjusting the
9544 section contents as necessary, and (if using Rela relocs
9545 and generating a relocatable output file) adjusting the
9546 reloc addend as necessary.
9548 The back end routine does not have to worry about setting
9549 the reloc address or the reloc symbol index.
9551 The back end routine is given a pointer to the swapped in
9552 internal symbols, and can access the hash table entries
9553 for the external symbols via elf_sym_hashes (input_bfd).
9555 When generating relocatable output, the back end routine
9556 must handle STB_LOCAL/STT_SECTION symbols specially. The
9557 output symbol is going to be a section symbol
9558 corresponding to the output section, which will require
9559 the addend to be adjusted. */
9561 ret
= (*relocate_section
) (output_bfd
, finfo
->info
,
9562 input_bfd
, o
, contents
,
9570 || finfo
->info
->relocatable
9571 || finfo
->info
->emitrelocations
)
9573 Elf_Internal_Rela
*irela
;
9574 Elf_Internal_Rela
*irelaend
, *irelamid
;
9575 bfd_vma last_offset
;
9576 struct elf_link_hash_entry
**rel_hash
;
9577 struct elf_link_hash_entry
**rel_hash_list
, **rela_hash_list
;
9578 Elf_Internal_Shdr
*input_rel_hdr
, *input_rela_hdr
;
9579 unsigned int next_erel
;
9580 bfd_boolean rela_normal
;
9581 struct bfd_elf_section_data
*esdi
, *esdo
;
9583 esdi
= elf_section_data (o
);
9584 esdo
= elf_section_data (o
->output_section
);
9585 rela_normal
= FALSE
;
9587 /* Adjust the reloc addresses and symbol indices. */
9589 irela
= internal_relocs
;
9590 irelaend
= irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9591 rel_hash
= esdo
->rel
.hashes
+ esdo
->rel
.count
;
9592 /* We start processing the REL relocs, if any. When we reach
9593 IRELAMID in the loop, we switch to the RELA relocs. */
9595 if (esdi
->rel
.hdr
!= NULL
)
9596 irelamid
+= (NUM_SHDR_ENTRIES (esdi
->rel
.hdr
)
9597 * bed
->s
->int_rels_per_ext_rel
);
9598 rel_hash_list
= rel_hash
;
9599 rela_hash_list
= NULL
;
9600 last_offset
= o
->output_offset
;
9601 if (!finfo
->info
->relocatable
)
9602 last_offset
+= o
->output_section
->vma
;
9603 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
9605 unsigned long r_symndx
;
9607 Elf_Internal_Sym sym
;
9609 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
9615 if (irela
== irelamid
)
9617 rel_hash
= esdo
->rela
.hashes
+ esdo
->rela
.count
;
9618 rela_hash_list
= rel_hash
;
9619 rela_normal
= bed
->rela_normal
;
9622 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
9625 if (irela
->r_offset
>= (bfd_vma
) -2)
9627 /* This is a reloc for a deleted entry or somesuch.
9628 Turn it into an R_*_NONE reloc, at the same
9629 offset as the last reloc. elf_eh_frame.c and
9630 bfd_elf_discard_info rely on reloc offsets
9632 irela
->r_offset
= last_offset
;
9634 irela
->r_addend
= 0;
9638 irela
->r_offset
+= o
->output_offset
;
9640 /* Relocs in an executable have to be virtual addresses. */
9641 if (!finfo
->info
->relocatable
)
9642 irela
->r_offset
+= o
->output_section
->vma
;
9644 last_offset
= irela
->r_offset
;
9646 r_symndx
= irela
->r_info
>> r_sym_shift
;
9647 if (r_symndx
== STN_UNDEF
)
9650 if (r_symndx
>= locsymcount
9651 || (elf_bad_symtab (input_bfd
)
9652 && finfo
->sections
[r_symndx
] == NULL
))
9654 struct elf_link_hash_entry
*rh
;
9657 /* This is a reloc against a global symbol. We
9658 have not yet output all the local symbols, so
9659 we do not know the symbol index of any global
9660 symbol. We set the rel_hash entry for this
9661 reloc to point to the global hash table entry
9662 for this symbol. The symbol index is then
9663 set at the end of bfd_elf_final_link. */
9664 indx
= r_symndx
- extsymoff
;
9665 rh
= elf_sym_hashes (input_bfd
)[indx
];
9666 while (rh
->root
.type
== bfd_link_hash_indirect
9667 || rh
->root
.type
== bfd_link_hash_warning
)
9668 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
9670 /* Setting the index to -2 tells
9671 elf_link_output_extsym that this symbol is
9673 BFD_ASSERT (rh
->indx
< 0);
9681 /* This is a reloc against a local symbol. */
9684 sym
= isymbuf
[r_symndx
];
9685 sec
= finfo
->sections
[r_symndx
];
9686 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
9688 /* I suppose the backend ought to fill in the
9689 section of any STT_SECTION symbol against a
9690 processor specific section. */
9691 r_symndx
= STN_UNDEF
;
9692 if (bfd_is_abs_section (sec
))
9694 else if (sec
== NULL
|| sec
->owner
== NULL
)
9696 bfd_set_error (bfd_error_bad_value
);
9701 asection
*osec
= sec
->output_section
;
9703 /* If we have discarded a section, the output
9704 section will be the absolute section. In
9705 case of discarded SEC_MERGE sections, use
9706 the kept section. relocate_section should
9707 have already handled discarded linkonce
9709 if (bfd_is_abs_section (osec
)
9710 && sec
->kept_section
!= NULL
9711 && sec
->kept_section
->output_section
!= NULL
)
9713 osec
= sec
->kept_section
->output_section
;
9714 irela
->r_addend
-= osec
->vma
;
9717 if (!bfd_is_abs_section (osec
))
9719 r_symndx
= osec
->target_index
;
9720 if (r_symndx
== STN_UNDEF
)
9722 struct elf_link_hash_table
*htab
;
9725 htab
= elf_hash_table (finfo
->info
);
9726 oi
= htab
->text_index_section
;
9727 if ((osec
->flags
& SEC_READONLY
) == 0
9728 && htab
->data_index_section
!= NULL
)
9729 oi
= htab
->data_index_section
;
9733 irela
->r_addend
+= osec
->vma
- oi
->vma
;
9734 r_symndx
= oi
->target_index
;
9738 BFD_ASSERT (r_symndx
!= STN_UNDEF
);
9742 /* Adjust the addend according to where the
9743 section winds up in the output section. */
9745 irela
->r_addend
+= sec
->output_offset
;
9749 if (finfo
->indices
[r_symndx
] == -1)
9751 unsigned long shlink
;
9756 if (finfo
->info
->strip
== strip_all
)
9758 /* You can't do ld -r -s. */
9759 bfd_set_error (bfd_error_invalid_operation
);
9763 /* This symbol was skipped earlier, but
9764 since it is needed by a reloc, we
9765 must output it now. */
9766 shlink
= symtab_hdr
->sh_link
;
9767 name
= (bfd_elf_string_from_elf_section
9768 (input_bfd
, shlink
, sym
.st_name
));
9772 osec
= sec
->output_section
;
9774 _bfd_elf_section_from_bfd_section (output_bfd
,
9776 if (sym
.st_shndx
== SHN_BAD
)
9779 sym
.st_value
+= sec
->output_offset
;
9780 if (! finfo
->info
->relocatable
)
9782 sym
.st_value
+= osec
->vma
;
9783 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
9785 /* STT_TLS symbols are relative to PT_TLS
9787 BFD_ASSERT (elf_hash_table (finfo
->info
)
9789 sym
.st_value
-= (elf_hash_table (finfo
->info
)
9794 indx
= bfd_get_symcount (output_bfd
);
9795 ret
= elf_link_output_sym (finfo
, name
, &sym
, sec
,
9800 finfo
->indices
[r_symndx
] = indx
;
9805 r_symndx
= finfo
->indices
[r_symndx
];
9808 irela
->r_info
= ((bfd_vma
) r_symndx
<< r_sym_shift
9809 | (irela
->r_info
& r_type_mask
));
9812 /* Swap out the relocs. */
9813 input_rel_hdr
= esdi
->rel
.hdr
;
9814 if (input_rel_hdr
&& input_rel_hdr
->sh_size
!= 0)
9816 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
9821 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
9822 * bed
->s
->int_rels_per_ext_rel
);
9823 rel_hash_list
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
9826 input_rela_hdr
= esdi
->rela
.hdr
;
9827 if (input_rela_hdr
&& input_rela_hdr
->sh_size
!= 0)
9829 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
9838 /* Write out the modified section contents. */
9839 if (bed
->elf_backend_write_section
9840 && (*bed
->elf_backend_write_section
) (output_bfd
, finfo
->info
, o
,
9843 /* Section written out. */
9845 else switch (o
->sec_info_type
)
9847 case ELF_INFO_TYPE_STABS
:
9848 if (! (_bfd_write_section_stabs
9850 &elf_hash_table (finfo
->info
)->stab_info
,
9851 o
, &elf_section_data (o
)->sec_info
, contents
)))
9854 case ELF_INFO_TYPE_MERGE
:
9855 if (! _bfd_write_merged_section (output_bfd
, o
,
9856 elf_section_data (o
)->sec_info
))
9859 case ELF_INFO_TYPE_EH_FRAME
:
9861 if (! _bfd_elf_write_section_eh_frame (output_bfd
, finfo
->info
,
9868 /* FIXME: octets_per_byte. */
9869 if (! (o
->flags
& SEC_EXCLUDE
))
9871 file_ptr offset
= (file_ptr
) o
->output_offset
;
9872 bfd_size_type todo
= o
->size
;
9873 if ((o
->flags
& SEC_ELF_REVERSE_COPY
))
9875 /* Reverse-copy input section to output. */
9878 todo
-= address_size
;
9879 if (! bfd_set_section_contents (output_bfd
,
9887 offset
+= address_size
;
9891 else if (! bfd_set_section_contents (output_bfd
,
9905 /* Generate a reloc when linking an ELF file. This is a reloc
9906 requested by the linker, and does not come from any input file. This
9907 is used to build constructor and destructor tables when linking
9911 elf_reloc_link_order (bfd
*output_bfd
,
9912 struct bfd_link_info
*info
,
9913 asection
*output_section
,
9914 struct bfd_link_order
*link_order
)
9916 reloc_howto_type
*howto
;
9920 struct bfd_elf_section_reloc_data
*reldata
;
9921 struct elf_link_hash_entry
**rel_hash_ptr
;
9922 Elf_Internal_Shdr
*rel_hdr
;
9923 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
9924 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
9927 struct bfd_elf_section_data
*esdo
= elf_section_data (output_section
);
9929 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
9932 bfd_set_error (bfd_error_bad_value
);
9936 addend
= link_order
->u
.reloc
.p
->addend
;
9939 reldata
= &esdo
->rel
;
9940 else if (esdo
->rela
.hdr
)
9941 reldata
= &esdo
->rela
;
9948 /* Figure out the symbol index. */
9949 rel_hash_ptr
= reldata
->hashes
+ reldata
->count
;
9950 if (link_order
->type
== bfd_section_reloc_link_order
)
9952 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
9953 BFD_ASSERT (indx
!= 0);
9954 *rel_hash_ptr
= NULL
;
9958 struct elf_link_hash_entry
*h
;
9960 /* Treat a reloc against a defined symbol as though it were
9961 actually against the section. */
9962 h
= ((struct elf_link_hash_entry
*)
9963 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
9964 link_order
->u
.reloc
.p
->u
.name
,
9965 FALSE
, FALSE
, TRUE
));
9967 && (h
->root
.type
== bfd_link_hash_defined
9968 || h
->root
.type
== bfd_link_hash_defweak
))
9972 section
= h
->root
.u
.def
.section
;
9973 indx
= section
->output_section
->target_index
;
9974 *rel_hash_ptr
= NULL
;
9975 /* It seems that we ought to add the symbol value to the
9976 addend here, but in practice it has already been added
9977 because it was passed to constructor_callback. */
9978 addend
+= section
->output_section
->vma
+ section
->output_offset
;
9982 /* Setting the index to -2 tells elf_link_output_extsym that
9983 this symbol is used by a reloc. */
9990 if (! ((*info
->callbacks
->unattached_reloc
)
9991 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0)))
9997 /* If this is an inplace reloc, we must write the addend into the
9999 if (howto
->partial_inplace
&& addend
!= 0)
10001 bfd_size_type size
;
10002 bfd_reloc_status_type rstat
;
10005 const char *sym_name
;
10007 size
= (bfd_size_type
) bfd_get_reloc_size (howto
);
10008 buf
= (bfd_byte
*) bfd_zmalloc (size
);
10011 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
10018 case bfd_reloc_outofrange
:
10021 case bfd_reloc_overflow
:
10022 if (link_order
->type
== bfd_section_reloc_link_order
)
10023 sym_name
= bfd_section_name (output_bfd
,
10024 link_order
->u
.reloc
.p
->u
.section
);
10026 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
10027 if (! ((*info
->callbacks
->reloc_overflow
)
10028 (info
, NULL
, sym_name
, howto
->name
, addend
, NULL
,
10029 NULL
, (bfd_vma
) 0)))
10036 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
10037 link_order
->offset
, size
);
10043 /* The address of a reloc is relative to the section in a
10044 relocatable file, and is a virtual address in an executable
10046 offset
= link_order
->offset
;
10047 if (! info
->relocatable
)
10048 offset
+= output_section
->vma
;
10050 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
10052 irel
[i
].r_offset
= offset
;
10053 irel
[i
].r_info
= 0;
10054 irel
[i
].r_addend
= 0;
10056 if (bed
->s
->arch_size
== 32)
10057 irel
[0].r_info
= ELF32_R_INFO (indx
, howto
->type
);
10059 irel
[0].r_info
= ELF64_R_INFO (indx
, howto
->type
);
10061 rel_hdr
= reldata
->hdr
;
10062 erel
= rel_hdr
->contents
;
10063 if (rel_hdr
->sh_type
== SHT_REL
)
10065 erel
+= reldata
->count
* bed
->s
->sizeof_rel
;
10066 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
10070 irel
[0].r_addend
= addend
;
10071 erel
+= reldata
->count
* bed
->s
->sizeof_rela
;
10072 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
10081 /* Get the output vma of the section pointed to by the sh_link field. */
10084 elf_get_linked_section_vma (struct bfd_link_order
*p
)
10086 Elf_Internal_Shdr
**elf_shdrp
;
10090 s
= p
->u
.indirect
.section
;
10091 elf_shdrp
= elf_elfsections (s
->owner
);
10092 elfsec
= _bfd_elf_section_from_bfd_section (s
->owner
, s
);
10093 elfsec
= elf_shdrp
[elfsec
]->sh_link
;
10095 The Intel C compiler generates SHT_IA_64_UNWIND with
10096 SHF_LINK_ORDER. But it doesn't set the sh_link or
10097 sh_info fields. Hence we could get the situation
10098 where elfsec is 0. */
10101 const struct elf_backend_data
*bed
10102 = get_elf_backend_data (s
->owner
);
10103 if (bed
->link_order_error_handler
)
10104 bed
->link_order_error_handler
10105 (_("%B: warning: sh_link not set for section `%A'"), s
->owner
, s
);
10110 s
= elf_shdrp
[elfsec
]->bfd_section
;
10111 return s
->output_section
->vma
+ s
->output_offset
;
10116 /* Compare two sections based on the locations of the sections they are
10117 linked to. Used by elf_fixup_link_order. */
10120 compare_link_order (const void * a
, const void * b
)
10125 apos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)a
);
10126 bpos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)b
);
10129 return apos
> bpos
;
10133 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
10134 order as their linked sections. Returns false if this could not be done
10135 because an output section includes both ordered and unordered
10136 sections. Ideally we'd do this in the linker proper. */
10139 elf_fixup_link_order (bfd
*abfd
, asection
*o
)
10141 int seen_linkorder
;
10144 struct bfd_link_order
*p
;
10146 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10148 struct bfd_link_order
**sections
;
10149 asection
*s
, *other_sec
, *linkorder_sec
;
10153 linkorder_sec
= NULL
;
10155 seen_linkorder
= 0;
10156 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10158 if (p
->type
== bfd_indirect_link_order
)
10160 s
= p
->u
.indirect
.section
;
10162 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
10163 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
10164 && (elfsec
= _bfd_elf_section_from_bfd_section (sub
, s
))
10165 && elfsec
< elf_numsections (sub
)
10166 && elf_elfsections (sub
)[elfsec
]->sh_flags
& SHF_LINK_ORDER
10167 && elf_elfsections (sub
)[elfsec
]->sh_link
< elf_numsections (sub
))
10181 if (seen_other
&& seen_linkorder
)
10183 if (other_sec
&& linkorder_sec
)
10184 (*_bfd_error_handler
) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10186 linkorder_sec
->owner
, other_sec
,
10189 (*_bfd_error_handler
) (_("%A has both ordered and unordered sections"),
10191 bfd_set_error (bfd_error_bad_value
);
10196 if (!seen_linkorder
)
10199 sections
= (struct bfd_link_order
**)
10200 bfd_malloc (seen_linkorder
* sizeof (struct bfd_link_order
*));
10201 if (sections
== NULL
)
10203 seen_linkorder
= 0;
10205 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10207 sections
[seen_linkorder
++] = p
;
10209 /* Sort the input sections in the order of their linked section. */
10210 qsort (sections
, seen_linkorder
, sizeof (struct bfd_link_order
*),
10211 compare_link_order
);
10213 /* Change the offsets of the sections. */
10215 for (n
= 0; n
< seen_linkorder
; n
++)
10217 s
= sections
[n
]->u
.indirect
.section
;
10218 offset
&= ~(bfd_vma
) 0 << s
->alignment_power
;
10219 s
->output_offset
= offset
;
10220 sections
[n
]->offset
= offset
;
10221 /* FIXME: octets_per_byte. */
10222 offset
+= sections
[n
]->size
;
10230 /* Do the final step of an ELF link. */
10233 bfd_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10235 bfd_boolean dynamic
;
10236 bfd_boolean emit_relocs
;
10238 struct elf_final_link_info finfo
;
10240 struct bfd_link_order
*p
;
10242 bfd_size_type max_contents_size
;
10243 bfd_size_type max_external_reloc_size
;
10244 bfd_size_type max_internal_reloc_count
;
10245 bfd_size_type max_sym_count
;
10246 bfd_size_type max_sym_shndx_count
;
10248 Elf_Internal_Sym elfsym
;
10250 Elf_Internal_Shdr
*symtab_hdr
;
10251 Elf_Internal_Shdr
*symtab_shndx_hdr
;
10252 Elf_Internal_Shdr
*symstrtab_hdr
;
10253 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10254 struct elf_outext_info eoinfo
;
10255 bfd_boolean merged
;
10256 size_t relativecount
= 0;
10257 asection
*reldyn
= 0;
10259 asection
*attr_section
= NULL
;
10260 bfd_vma attr_size
= 0;
10261 const char *std_attrs_section
;
10263 if (! is_elf_hash_table (info
->hash
))
10267 abfd
->flags
|= DYNAMIC
;
10269 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
10270 dynobj
= elf_hash_table (info
)->dynobj
;
10272 emit_relocs
= (info
->relocatable
10273 || info
->emitrelocations
);
10276 finfo
.output_bfd
= abfd
;
10277 finfo
.symstrtab
= _bfd_elf_stringtab_init ();
10278 if (finfo
.symstrtab
== NULL
)
10283 finfo
.dynsym_sec
= NULL
;
10284 finfo
.hash_sec
= NULL
;
10285 finfo
.symver_sec
= NULL
;
10289 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
10290 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
10291 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
);
10292 finfo
.symver_sec
= bfd_get_section_by_name (dynobj
, ".gnu.version");
10293 /* Note that it is OK if symver_sec is NULL. */
10296 finfo
.contents
= NULL
;
10297 finfo
.external_relocs
= NULL
;
10298 finfo
.internal_relocs
= NULL
;
10299 finfo
.external_syms
= NULL
;
10300 finfo
.locsym_shndx
= NULL
;
10301 finfo
.internal_syms
= NULL
;
10302 finfo
.indices
= NULL
;
10303 finfo
.sections
= NULL
;
10304 finfo
.symbuf
= NULL
;
10305 finfo
.symshndxbuf
= NULL
;
10306 finfo
.symbuf_count
= 0;
10307 finfo
.shndxbuf_size
= 0;
10309 /* The object attributes have been merged. Remove the input
10310 sections from the link, and set the contents of the output
10312 std_attrs_section
= get_elf_backend_data (abfd
)->obj_attrs_section
;
10313 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10315 if ((std_attrs_section
&& strcmp (o
->name
, std_attrs_section
) == 0)
10316 || strcmp (o
->name
, ".gnu.attributes") == 0)
10318 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10320 asection
*input_section
;
10322 if (p
->type
!= bfd_indirect_link_order
)
10324 input_section
= p
->u
.indirect
.section
;
10325 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10326 elf_link_input_bfd ignores this section. */
10327 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10330 attr_size
= bfd_elf_obj_attr_size (abfd
);
10333 bfd_set_section_size (abfd
, o
, attr_size
);
10335 /* Skip this section later on. */
10336 o
->map_head
.link_order
= NULL
;
10339 o
->flags
|= SEC_EXCLUDE
;
10343 /* Count up the number of relocations we will output for each output
10344 section, so that we know the sizes of the reloc sections. We
10345 also figure out some maximum sizes. */
10346 max_contents_size
= 0;
10347 max_external_reloc_size
= 0;
10348 max_internal_reloc_count
= 0;
10350 max_sym_shndx_count
= 0;
10352 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10354 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10355 o
->reloc_count
= 0;
10357 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10359 unsigned int reloc_count
= 0;
10360 struct bfd_elf_section_data
*esdi
= NULL
;
10362 if (p
->type
== bfd_section_reloc_link_order
10363 || p
->type
== bfd_symbol_reloc_link_order
)
10365 else if (p
->type
== bfd_indirect_link_order
)
10369 sec
= p
->u
.indirect
.section
;
10370 esdi
= elf_section_data (sec
);
10372 /* Mark all sections which are to be included in the
10373 link. This will normally be every section. We need
10374 to do this so that we can identify any sections which
10375 the linker has decided to not include. */
10376 sec
->linker_mark
= TRUE
;
10378 if (sec
->flags
& SEC_MERGE
)
10381 if (info
->relocatable
|| info
->emitrelocations
)
10382 reloc_count
= sec
->reloc_count
;
10383 else if (bed
->elf_backend_count_relocs
)
10384 reloc_count
= (*bed
->elf_backend_count_relocs
) (info
, sec
);
10386 if (sec
->rawsize
> max_contents_size
)
10387 max_contents_size
= sec
->rawsize
;
10388 if (sec
->size
> max_contents_size
)
10389 max_contents_size
= sec
->size
;
10391 /* We are interested in just local symbols, not all
10393 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
10394 && (sec
->owner
->flags
& DYNAMIC
) == 0)
10398 if (elf_bad_symtab (sec
->owner
))
10399 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
10400 / bed
->s
->sizeof_sym
);
10402 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
10404 if (sym_count
> max_sym_count
)
10405 max_sym_count
= sym_count
;
10407 if (sym_count
> max_sym_shndx_count
10408 && elf_symtab_shndx (sec
->owner
) != 0)
10409 max_sym_shndx_count
= sym_count
;
10411 if ((sec
->flags
& SEC_RELOC
) != 0)
10413 size_t ext_size
= 0;
10415 if (esdi
->rel
.hdr
!= NULL
)
10416 ext_size
= esdi
->rel
.hdr
->sh_size
;
10417 if (esdi
->rela
.hdr
!= NULL
)
10418 ext_size
+= esdi
->rela
.hdr
->sh_size
;
10420 if (ext_size
> max_external_reloc_size
)
10421 max_external_reloc_size
= ext_size
;
10422 if (sec
->reloc_count
> max_internal_reloc_count
)
10423 max_internal_reloc_count
= sec
->reloc_count
;
10428 if (reloc_count
== 0)
10431 o
->reloc_count
+= reloc_count
;
10433 if (p
->type
== bfd_indirect_link_order
10434 && (info
->relocatable
|| info
->emitrelocations
))
10437 esdo
->rel
.count
+= NUM_SHDR_ENTRIES (esdi
->rel
.hdr
);
10438 if (esdi
->rela
.hdr
)
10439 esdo
->rela
.count
+= NUM_SHDR_ENTRIES (esdi
->rela
.hdr
);
10444 esdo
->rela
.count
+= reloc_count
;
10446 esdo
->rel
.count
+= reloc_count
;
10450 if (o
->reloc_count
> 0)
10451 o
->flags
|= SEC_RELOC
;
10454 /* Explicitly clear the SEC_RELOC flag. The linker tends to
10455 set it (this is probably a bug) and if it is set
10456 assign_section_numbers will create a reloc section. */
10457 o
->flags
&=~ SEC_RELOC
;
10460 /* If the SEC_ALLOC flag is not set, force the section VMA to
10461 zero. This is done in elf_fake_sections as well, but forcing
10462 the VMA to 0 here will ensure that relocs against these
10463 sections are handled correctly. */
10464 if ((o
->flags
& SEC_ALLOC
) == 0
10465 && ! o
->user_set_vma
)
10469 if (! info
->relocatable
&& merged
)
10470 elf_link_hash_traverse (elf_hash_table (info
),
10471 _bfd_elf_link_sec_merge_syms
, abfd
);
10473 /* Figure out the file positions for everything but the symbol table
10474 and the relocs. We set symcount to force assign_section_numbers
10475 to create a symbol table. */
10476 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
10477 BFD_ASSERT (! abfd
->output_has_begun
);
10478 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
10481 /* Set sizes, and assign file positions for reloc sections. */
10482 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10484 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10485 if ((o
->flags
& SEC_RELOC
) != 0)
10488 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rel
)))
10492 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rela
)))
10496 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10497 to count upwards while actually outputting the relocations. */
10498 esdo
->rel
.count
= 0;
10499 esdo
->rela
.count
= 0;
10502 _bfd_elf_assign_file_positions_for_relocs (abfd
);
10504 /* We have now assigned file positions for all the sections except
10505 .symtab and .strtab. We start the .symtab section at the current
10506 file position, and write directly to it. We build the .strtab
10507 section in memory. */
10508 bfd_get_symcount (abfd
) = 0;
10509 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10510 /* sh_name is set in prep_headers. */
10511 symtab_hdr
->sh_type
= SHT_SYMTAB
;
10512 /* sh_flags, sh_addr and sh_size all start off zero. */
10513 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
10514 /* sh_link is set in assign_section_numbers. */
10515 /* sh_info is set below. */
10516 /* sh_offset is set just below. */
10517 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
10519 off
= elf_tdata (abfd
)->next_file_pos
;
10520 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, TRUE
);
10522 /* Note that at this point elf_tdata (abfd)->next_file_pos is
10523 incorrect. We do not yet know the size of the .symtab section.
10524 We correct next_file_pos below, after we do know the size. */
10526 /* Allocate a buffer to hold swapped out symbols. This is to avoid
10527 continuously seeking to the right position in the file. */
10528 if (! info
->keep_memory
|| max_sym_count
< 20)
10529 finfo
.symbuf_size
= 20;
10531 finfo
.symbuf_size
= max_sym_count
;
10532 amt
= finfo
.symbuf_size
;
10533 amt
*= bed
->s
->sizeof_sym
;
10534 finfo
.symbuf
= (bfd_byte
*) bfd_malloc (amt
);
10535 if (finfo
.symbuf
== NULL
)
10537 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
10539 /* Wild guess at number of output symbols. realloc'd as needed. */
10540 amt
= 2 * max_sym_count
+ elf_numsections (abfd
) + 1000;
10541 finfo
.shndxbuf_size
= amt
;
10542 amt
*= sizeof (Elf_External_Sym_Shndx
);
10543 finfo
.symshndxbuf
= (Elf_External_Sym_Shndx
*) bfd_zmalloc (amt
);
10544 if (finfo
.symshndxbuf
== NULL
)
10548 /* Start writing out the symbol table. The first symbol is always a
10550 if (info
->strip
!= strip_all
10553 elfsym
.st_value
= 0;
10554 elfsym
.st_size
= 0;
10555 elfsym
.st_info
= 0;
10556 elfsym
.st_other
= 0;
10557 elfsym
.st_shndx
= SHN_UNDEF
;
10558 elfsym
.st_target_internal
= 0;
10559 if (elf_link_output_sym (&finfo
, NULL
, &elfsym
, bfd_und_section_ptr
,
10564 /* Output a symbol for each section. We output these even if we are
10565 discarding local symbols, since they are used for relocs. These
10566 symbols have no names. We store the index of each one in the
10567 index field of the section, so that we can find it again when
10568 outputting relocs. */
10569 if (info
->strip
!= strip_all
10572 elfsym
.st_size
= 0;
10573 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
10574 elfsym
.st_other
= 0;
10575 elfsym
.st_value
= 0;
10576 elfsym
.st_target_internal
= 0;
10577 for (i
= 1; i
< elf_numsections (abfd
); i
++)
10579 o
= bfd_section_from_elf_index (abfd
, i
);
10582 o
->target_index
= bfd_get_symcount (abfd
);
10583 elfsym
.st_shndx
= i
;
10584 if (!info
->relocatable
)
10585 elfsym
.st_value
= o
->vma
;
10586 if (elf_link_output_sym (&finfo
, NULL
, &elfsym
, o
, NULL
) != 1)
10592 /* Allocate some memory to hold information read in from the input
10594 if (max_contents_size
!= 0)
10596 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
10597 if (finfo
.contents
== NULL
)
10601 if (max_external_reloc_size
!= 0)
10603 finfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
10604 if (finfo
.external_relocs
== NULL
)
10608 if (max_internal_reloc_count
!= 0)
10610 amt
= max_internal_reloc_count
* bed
->s
->int_rels_per_ext_rel
;
10611 amt
*= sizeof (Elf_Internal_Rela
);
10612 finfo
.internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
10613 if (finfo
.internal_relocs
== NULL
)
10617 if (max_sym_count
!= 0)
10619 amt
= max_sym_count
* bed
->s
->sizeof_sym
;
10620 finfo
.external_syms
= (bfd_byte
*) bfd_malloc (amt
);
10621 if (finfo
.external_syms
== NULL
)
10624 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
10625 finfo
.internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
10626 if (finfo
.internal_syms
== NULL
)
10629 amt
= max_sym_count
* sizeof (long);
10630 finfo
.indices
= (long int *) bfd_malloc (amt
);
10631 if (finfo
.indices
== NULL
)
10634 amt
= max_sym_count
* sizeof (asection
*);
10635 finfo
.sections
= (asection
**) bfd_malloc (amt
);
10636 if (finfo
.sections
== NULL
)
10640 if (max_sym_shndx_count
!= 0)
10642 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
10643 finfo
.locsym_shndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
10644 if (finfo
.locsym_shndx
== NULL
)
10648 if (elf_hash_table (info
)->tls_sec
)
10650 bfd_vma base
, end
= 0;
10653 for (sec
= elf_hash_table (info
)->tls_sec
;
10654 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
10657 bfd_size_type size
= sec
->size
;
10660 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
10662 struct bfd_link_order
*ord
= sec
->map_tail
.link_order
;
10665 size
= ord
->offset
+ ord
->size
;
10667 end
= sec
->vma
+ size
;
10669 base
= elf_hash_table (info
)->tls_sec
->vma
;
10670 /* Only align end of TLS section if static TLS doesn't have special
10671 alignment requirements. */
10672 if (bed
->static_tls_alignment
== 1)
10673 end
= align_power (end
,
10674 elf_hash_table (info
)->tls_sec
->alignment_power
);
10675 elf_hash_table (info
)->tls_size
= end
- base
;
10678 /* Reorder SHF_LINK_ORDER sections. */
10679 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10681 if (!elf_fixup_link_order (abfd
, o
))
10685 /* Since ELF permits relocations to be against local symbols, we
10686 must have the local symbols available when we do the relocations.
10687 Since we would rather only read the local symbols once, and we
10688 would rather not keep them in memory, we handle all the
10689 relocations for a single input file at the same time.
10691 Unfortunately, there is no way to know the total number of local
10692 symbols until we have seen all of them, and the local symbol
10693 indices precede the global symbol indices. This means that when
10694 we are generating relocatable output, and we see a reloc against
10695 a global symbol, we can not know the symbol index until we have
10696 finished examining all the local symbols to see which ones we are
10697 going to output. To deal with this, we keep the relocations in
10698 memory, and don't output them until the end of the link. This is
10699 an unfortunate waste of memory, but I don't see a good way around
10700 it. Fortunately, it only happens when performing a relocatable
10701 link, which is not the common case. FIXME: If keep_memory is set
10702 we could write the relocs out and then read them again; I don't
10703 know how bad the memory loss will be. */
10705 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
10706 sub
->output_has_begun
= FALSE
;
10707 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10709 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10711 if (p
->type
== bfd_indirect_link_order
10712 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
10713 == bfd_target_elf_flavour
)
10714 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
10716 if (! sub
->output_has_begun
)
10718 if (! elf_link_input_bfd (&finfo
, sub
))
10720 sub
->output_has_begun
= TRUE
;
10723 else if (p
->type
== bfd_section_reloc_link_order
10724 || p
->type
== bfd_symbol_reloc_link_order
)
10726 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
10731 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
10733 if (p
->type
== bfd_indirect_link_order
10734 && (bfd_get_flavour (sub
)
10735 == bfd_target_elf_flavour
)
10736 && (elf_elfheader (sub
)->e_ident
[EI_CLASS
]
10737 != bed
->s
->elfclass
))
10739 const char *iclass
, *oclass
;
10741 if (bed
->s
->elfclass
== ELFCLASS64
)
10743 iclass
= "ELFCLASS32";
10744 oclass
= "ELFCLASS64";
10748 iclass
= "ELFCLASS64";
10749 oclass
= "ELFCLASS32";
10752 bfd_set_error (bfd_error_wrong_format
);
10753 (*_bfd_error_handler
)
10754 (_("%B: file class %s incompatible with %s"),
10755 sub
, iclass
, oclass
);
10764 /* Free symbol buffer if needed. */
10765 if (!info
->reduce_memory_overheads
)
10767 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
10768 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
10769 && elf_tdata (sub
)->symbuf
)
10771 free (elf_tdata (sub
)->symbuf
);
10772 elf_tdata (sub
)->symbuf
= NULL
;
10776 /* Output any global symbols that got converted to local in a
10777 version script or due to symbol visibility. We do this in a
10778 separate step since ELF requires all local symbols to appear
10779 prior to any global symbols. FIXME: We should only do this if
10780 some global symbols were, in fact, converted to become local.
10781 FIXME: Will this work correctly with the Irix 5 linker? */
10782 eoinfo
.failed
= FALSE
;
10783 eoinfo
.finfo
= &finfo
;
10784 eoinfo
.localsyms
= TRUE
;
10785 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
10789 /* If backend needs to output some local symbols not present in the hash
10790 table, do it now. */
10791 if (bed
->elf_backend_output_arch_local_syms
)
10793 typedef int (*out_sym_func
)
10794 (void *, const char *, Elf_Internal_Sym
*, asection
*,
10795 struct elf_link_hash_entry
*);
10797 if (! ((*bed
->elf_backend_output_arch_local_syms
)
10798 (abfd
, info
, &finfo
, (out_sym_func
) elf_link_output_sym
)))
10802 /* That wrote out all the local symbols. Finish up the symbol table
10803 with the global symbols. Even if we want to strip everything we
10804 can, we still need to deal with those global symbols that got
10805 converted to local in a version script. */
10807 /* The sh_info field records the index of the first non local symbol. */
10808 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
10811 && finfo
.dynsym_sec
->output_section
!= bfd_abs_section_ptr
)
10813 Elf_Internal_Sym sym
;
10814 bfd_byte
*dynsym
= finfo
.dynsym_sec
->contents
;
10815 long last_local
= 0;
10817 /* Write out the section symbols for the output sections. */
10818 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
10824 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
10826 sym
.st_target_internal
= 0;
10828 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
10834 dynindx
= elf_section_data (s
)->dynindx
;
10837 indx
= elf_section_data (s
)->this_idx
;
10838 BFD_ASSERT (indx
> 0);
10839 sym
.st_shndx
= indx
;
10840 if (! check_dynsym (abfd
, &sym
))
10842 sym
.st_value
= s
->vma
;
10843 dest
= dynsym
+ dynindx
* bed
->s
->sizeof_sym
;
10844 if (last_local
< dynindx
)
10845 last_local
= dynindx
;
10846 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
10850 /* Write out the local dynsyms. */
10851 if (elf_hash_table (info
)->dynlocal
)
10853 struct elf_link_local_dynamic_entry
*e
;
10854 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
10859 /* Copy the internal symbol and turn off visibility.
10860 Note that we saved a word of storage and overwrote
10861 the original st_name with the dynstr_index. */
10863 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
10865 s
= bfd_section_from_elf_index (e
->input_bfd
,
10870 elf_section_data (s
->output_section
)->this_idx
;
10871 if (! check_dynsym (abfd
, &sym
))
10873 sym
.st_value
= (s
->output_section
->vma
10875 + e
->isym
.st_value
);
10878 if (last_local
< e
->dynindx
)
10879 last_local
= e
->dynindx
;
10881 dest
= dynsym
+ e
->dynindx
* bed
->s
->sizeof_sym
;
10882 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
10886 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
=
10890 /* We get the global symbols from the hash table. */
10891 eoinfo
.failed
= FALSE
;
10892 eoinfo
.localsyms
= FALSE
;
10893 eoinfo
.finfo
= &finfo
;
10894 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
10898 /* If backend needs to output some symbols not present in the hash
10899 table, do it now. */
10900 if (bed
->elf_backend_output_arch_syms
)
10902 typedef int (*out_sym_func
)
10903 (void *, const char *, Elf_Internal_Sym
*, asection
*,
10904 struct elf_link_hash_entry
*);
10906 if (! ((*bed
->elf_backend_output_arch_syms
)
10907 (abfd
, info
, &finfo
, (out_sym_func
) elf_link_output_sym
)))
10911 /* Flush all symbols to the file. */
10912 if (! elf_link_flush_output_syms (&finfo
, bed
))
10915 /* Now we know the size of the symtab section. */
10916 off
+= symtab_hdr
->sh_size
;
10918 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
10919 if (symtab_shndx_hdr
->sh_name
!= 0)
10921 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
10922 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
10923 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
10924 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
10925 symtab_shndx_hdr
->sh_size
= amt
;
10927 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
10930 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
10931 || (bfd_bwrite (finfo
.symshndxbuf
, amt
, abfd
) != amt
))
10936 /* Finish up and write out the symbol string table (.strtab)
10938 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
10939 /* sh_name was set in prep_headers. */
10940 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
10941 symstrtab_hdr
->sh_flags
= 0;
10942 symstrtab_hdr
->sh_addr
= 0;
10943 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
10944 symstrtab_hdr
->sh_entsize
= 0;
10945 symstrtab_hdr
->sh_link
= 0;
10946 symstrtab_hdr
->sh_info
= 0;
10947 /* sh_offset is set just below. */
10948 symstrtab_hdr
->sh_addralign
= 1;
10950 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, TRUE
);
10951 elf_tdata (abfd
)->next_file_pos
= off
;
10953 if (bfd_get_symcount (abfd
) > 0)
10955 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
10956 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
10960 /* Adjust the relocs to have the correct symbol indices. */
10961 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10963 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10964 if ((o
->flags
& SEC_RELOC
) == 0)
10967 if (esdo
->rel
.hdr
!= NULL
)
10968 elf_link_adjust_relocs (abfd
, &esdo
->rel
);
10969 if (esdo
->rela
.hdr
!= NULL
)
10970 elf_link_adjust_relocs (abfd
, &esdo
->rela
);
10972 /* Set the reloc_count field to 0 to prevent write_relocs from
10973 trying to swap the relocs out itself. */
10974 o
->reloc_count
= 0;
10977 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
10978 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
10980 /* If we are linking against a dynamic object, or generating a
10981 shared library, finish up the dynamic linking information. */
10984 bfd_byte
*dyncon
, *dynconend
;
10986 /* Fix up .dynamic entries. */
10987 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
10988 BFD_ASSERT (o
!= NULL
);
10990 dyncon
= o
->contents
;
10991 dynconend
= o
->contents
+ o
->size
;
10992 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
10994 Elf_Internal_Dyn dyn
;
10998 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11005 if (relativecount
> 0 && dyncon
+ bed
->s
->sizeof_dyn
< dynconend
)
11007 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
11009 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
11010 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
11013 dyn
.d_un
.d_val
= relativecount
;
11020 name
= info
->init_function
;
11023 name
= info
->fini_function
;
11026 struct elf_link_hash_entry
*h
;
11028 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
11029 FALSE
, FALSE
, TRUE
);
11031 && (h
->root
.type
== bfd_link_hash_defined
11032 || h
->root
.type
== bfd_link_hash_defweak
))
11034 dyn
.d_un
.d_ptr
= h
->root
.u
.def
.value
;
11035 o
= h
->root
.u
.def
.section
;
11036 if (o
->output_section
!= NULL
)
11037 dyn
.d_un
.d_ptr
+= (o
->output_section
->vma
11038 + o
->output_offset
);
11041 /* The symbol is imported from another shared
11042 library and does not apply to this one. */
11043 dyn
.d_un
.d_ptr
= 0;
11050 case DT_PREINIT_ARRAYSZ
:
11051 name
= ".preinit_array";
11053 case DT_INIT_ARRAYSZ
:
11054 name
= ".init_array";
11056 case DT_FINI_ARRAYSZ
:
11057 name
= ".fini_array";
11059 o
= bfd_get_section_by_name (abfd
, name
);
11062 (*_bfd_error_handler
)
11063 (_("%B: could not find output section %s"), abfd
, name
);
11067 (*_bfd_error_handler
)
11068 (_("warning: %s section has zero size"), name
);
11069 dyn
.d_un
.d_val
= o
->size
;
11072 case DT_PREINIT_ARRAY
:
11073 name
= ".preinit_array";
11075 case DT_INIT_ARRAY
:
11076 name
= ".init_array";
11078 case DT_FINI_ARRAY
:
11079 name
= ".fini_array";
11086 name
= ".gnu.hash";
11095 name
= ".gnu.version_d";
11098 name
= ".gnu.version_r";
11101 name
= ".gnu.version";
11103 o
= bfd_get_section_by_name (abfd
, name
);
11106 (*_bfd_error_handler
)
11107 (_("%B: could not find output section %s"), abfd
, name
);
11110 if (elf_section_data (o
->output_section
)->this_hdr
.sh_type
== SHT_NOTE
)
11112 (*_bfd_error_handler
)
11113 (_("warning: section '%s' is being made into a note"), name
);
11114 bfd_set_error (bfd_error_nonrepresentable_section
);
11117 dyn
.d_un
.d_ptr
= o
->vma
;
11124 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
11128 dyn
.d_un
.d_val
= 0;
11129 dyn
.d_un
.d_ptr
= 0;
11130 for (i
= 1; i
< elf_numsections (abfd
); i
++)
11132 Elf_Internal_Shdr
*hdr
;
11134 hdr
= elf_elfsections (abfd
)[i
];
11135 if (hdr
->sh_type
== type
11136 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
11138 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
11139 dyn
.d_un
.d_val
+= hdr
->sh_size
;
11142 if (dyn
.d_un
.d_ptr
== 0
11143 || hdr
->sh_addr
< dyn
.d_un
.d_ptr
)
11144 dyn
.d_un
.d_ptr
= hdr
->sh_addr
;
11150 bed
->s
->swap_dyn_out (dynobj
, &dyn
, dyncon
);
11154 /* If we have created any dynamic sections, then output them. */
11155 if (dynobj
!= NULL
)
11157 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
11160 /* Check for DT_TEXTREL (late, in case the backend removes it). */
11161 if (info
->warn_shared_textrel
&& info
->shared
)
11163 bfd_byte
*dyncon
, *dynconend
;
11165 /* Fix up .dynamic entries. */
11166 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
11167 BFD_ASSERT (o
!= NULL
);
11169 dyncon
= o
->contents
;
11170 dynconend
= o
->contents
+ o
->size
;
11171 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
11173 Elf_Internal_Dyn dyn
;
11175 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11177 if (dyn
.d_tag
== DT_TEXTREL
)
11179 info
->callbacks
->einfo
11180 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11186 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
11188 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
11190 || o
->output_section
== bfd_abs_section_ptr
)
11192 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
11194 /* At this point, we are only interested in sections
11195 created by _bfd_elf_link_create_dynamic_sections. */
11198 if (elf_hash_table (info
)->stab_info
.stabstr
== o
)
11200 if (elf_hash_table (info
)->eh_info
.hdr_sec
== o
)
11202 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
11204 && (strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0))
11206 /* FIXME: octets_per_byte. */
11207 if (! bfd_set_section_contents (abfd
, o
->output_section
,
11209 (file_ptr
) o
->output_offset
,
11215 /* The contents of the .dynstr section are actually in a
11217 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
11218 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
11219 || ! _bfd_elf_strtab_emit (abfd
,
11220 elf_hash_table (info
)->dynstr
))
11226 if (info
->relocatable
)
11228 bfd_boolean failed
= FALSE
;
11230 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
11235 /* If we have optimized stabs strings, output them. */
11236 if (elf_hash_table (info
)->stab_info
.stabstr
!= NULL
)
11238 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
11242 if (info
->eh_frame_hdr
)
11244 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
11248 if (finfo
.symstrtab
!= NULL
)
11249 _bfd_stringtab_free (finfo
.symstrtab
);
11250 if (finfo
.contents
!= NULL
)
11251 free (finfo
.contents
);
11252 if (finfo
.external_relocs
!= NULL
)
11253 free (finfo
.external_relocs
);
11254 if (finfo
.internal_relocs
!= NULL
)
11255 free (finfo
.internal_relocs
);
11256 if (finfo
.external_syms
!= NULL
)
11257 free (finfo
.external_syms
);
11258 if (finfo
.locsym_shndx
!= NULL
)
11259 free (finfo
.locsym_shndx
);
11260 if (finfo
.internal_syms
!= NULL
)
11261 free (finfo
.internal_syms
);
11262 if (finfo
.indices
!= NULL
)
11263 free (finfo
.indices
);
11264 if (finfo
.sections
!= NULL
)
11265 free (finfo
.sections
);
11266 if (finfo
.symbuf
!= NULL
)
11267 free (finfo
.symbuf
);
11268 if (finfo
.symshndxbuf
!= NULL
)
11269 free (finfo
.symshndxbuf
);
11270 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11272 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11273 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
11274 free (esdo
->rel
.hashes
);
11275 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
11276 free (esdo
->rela
.hashes
);
11279 elf_tdata (abfd
)->linker
= TRUE
;
11283 bfd_byte
*contents
= (bfd_byte
*) bfd_malloc (attr_size
);
11284 if (contents
== NULL
)
11285 return FALSE
; /* Bail out and fail. */
11286 bfd_elf_set_obj_attr_contents (abfd
, contents
, attr_size
);
11287 bfd_set_section_contents (abfd
, attr_section
, contents
, 0, attr_size
);
11294 if (finfo
.symstrtab
!= NULL
)
11295 _bfd_stringtab_free (finfo
.symstrtab
);
11296 if (finfo
.contents
!= NULL
)
11297 free (finfo
.contents
);
11298 if (finfo
.external_relocs
!= NULL
)
11299 free (finfo
.external_relocs
);
11300 if (finfo
.internal_relocs
!= NULL
)
11301 free (finfo
.internal_relocs
);
11302 if (finfo
.external_syms
!= NULL
)
11303 free (finfo
.external_syms
);
11304 if (finfo
.locsym_shndx
!= NULL
)
11305 free (finfo
.locsym_shndx
);
11306 if (finfo
.internal_syms
!= NULL
)
11307 free (finfo
.internal_syms
);
11308 if (finfo
.indices
!= NULL
)
11309 free (finfo
.indices
);
11310 if (finfo
.sections
!= NULL
)
11311 free (finfo
.sections
);
11312 if (finfo
.symbuf
!= NULL
)
11313 free (finfo
.symbuf
);
11314 if (finfo
.symshndxbuf
!= NULL
)
11315 free (finfo
.symshndxbuf
);
11316 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11318 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11319 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
11320 free (esdo
->rel
.hashes
);
11321 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
11322 free (esdo
->rela
.hashes
);
11328 /* Initialize COOKIE for input bfd ABFD. */
11331 init_reloc_cookie (struct elf_reloc_cookie
*cookie
,
11332 struct bfd_link_info
*info
, bfd
*abfd
)
11334 Elf_Internal_Shdr
*symtab_hdr
;
11335 const struct elf_backend_data
*bed
;
11337 bed
= get_elf_backend_data (abfd
);
11338 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11340 cookie
->abfd
= abfd
;
11341 cookie
->sym_hashes
= elf_sym_hashes (abfd
);
11342 cookie
->bad_symtab
= elf_bad_symtab (abfd
);
11343 if (cookie
->bad_symtab
)
11345 cookie
->locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
11346 cookie
->extsymoff
= 0;
11350 cookie
->locsymcount
= symtab_hdr
->sh_info
;
11351 cookie
->extsymoff
= symtab_hdr
->sh_info
;
11354 if (bed
->s
->arch_size
== 32)
11355 cookie
->r_sym_shift
= 8;
11357 cookie
->r_sym_shift
= 32;
11359 cookie
->locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
11360 if (cookie
->locsyms
== NULL
&& cookie
->locsymcount
!= 0)
11362 cookie
->locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
11363 cookie
->locsymcount
, 0,
11365 if (cookie
->locsyms
== NULL
)
11367 info
->callbacks
->einfo (_("%P%X: can not read symbols: %E\n"));
11370 if (info
->keep_memory
)
11371 symtab_hdr
->contents
= (bfd_byte
*) cookie
->locsyms
;
11376 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
11379 fini_reloc_cookie (struct elf_reloc_cookie
*cookie
, bfd
*abfd
)
11381 Elf_Internal_Shdr
*symtab_hdr
;
11383 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11384 if (cookie
->locsyms
!= NULL
11385 && symtab_hdr
->contents
!= (unsigned char *) cookie
->locsyms
)
11386 free (cookie
->locsyms
);
11389 /* Initialize the relocation information in COOKIE for input section SEC
11390 of input bfd ABFD. */
11393 init_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11394 struct bfd_link_info
*info
, bfd
*abfd
,
11397 const struct elf_backend_data
*bed
;
11399 if (sec
->reloc_count
== 0)
11401 cookie
->rels
= NULL
;
11402 cookie
->relend
= NULL
;
11406 bed
= get_elf_backend_data (abfd
);
11408 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
11409 info
->keep_memory
);
11410 if (cookie
->rels
== NULL
)
11412 cookie
->rel
= cookie
->rels
;
11413 cookie
->relend
= (cookie
->rels
11414 + sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
);
11416 cookie
->rel
= cookie
->rels
;
11420 /* Free the memory allocated by init_reloc_cookie_rels,
11424 fini_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11427 if (cookie
->rels
&& elf_section_data (sec
)->relocs
!= cookie
->rels
)
11428 free (cookie
->rels
);
11431 /* Initialize the whole of COOKIE for input section SEC. */
11434 init_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11435 struct bfd_link_info
*info
,
11438 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
11440 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
11445 fini_reloc_cookie (cookie
, sec
->owner
);
11450 /* Free the memory allocated by init_reloc_cookie_for_section,
11454 fini_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11457 fini_reloc_cookie_rels (cookie
, sec
);
11458 fini_reloc_cookie (cookie
, sec
->owner
);
11461 /* Garbage collect unused sections. */
11463 /* Default gc_mark_hook. */
11466 _bfd_elf_gc_mark_hook (asection
*sec
,
11467 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11468 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
11469 struct elf_link_hash_entry
*h
,
11470 Elf_Internal_Sym
*sym
)
11472 const char *sec_name
;
11476 switch (h
->root
.type
)
11478 case bfd_link_hash_defined
:
11479 case bfd_link_hash_defweak
:
11480 return h
->root
.u
.def
.section
;
11482 case bfd_link_hash_common
:
11483 return h
->root
.u
.c
.p
->section
;
11485 case bfd_link_hash_undefined
:
11486 case bfd_link_hash_undefweak
:
11487 /* To work around a glibc bug, keep all XXX input sections
11488 when there is an as yet undefined reference to __start_XXX
11489 or __stop_XXX symbols. The linker will later define such
11490 symbols for orphan input sections that have a name
11491 representable as a C identifier. */
11492 if (strncmp (h
->root
.root
.string
, "__start_", 8) == 0)
11493 sec_name
= h
->root
.root
.string
+ 8;
11494 else if (strncmp (h
->root
.root
.string
, "__stop_", 7) == 0)
11495 sec_name
= h
->root
.root
.string
+ 7;
11499 if (sec_name
&& *sec_name
!= '\0')
11503 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
11505 sec
= bfd_get_section_by_name (i
, sec_name
);
11507 sec
->flags
|= SEC_KEEP
;
11517 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
11522 /* COOKIE->rel describes a relocation against section SEC, which is
11523 a section we've decided to keep. Return the section that contains
11524 the relocation symbol, or NULL if no section contains it. */
11527 _bfd_elf_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
11528 elf_gc_mark_hook_fn gc_mark_hook
,
11529 struct elf_reloc_cookie
*cookie
)
11531 unsigned long r_symndx
;
11532 struct elf_link_hash_entry
*h
;
11534 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
11535 if (r_symndx
== STN_UNDEF
)
11538 if (r_symndx
>= cookie
->locsymcount
11539 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
11541 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
11542 while (h
->root
.type
== bfd_link_hash_indirect
11543 || h
->root
.type
== bfd_link_hash_warning
)
11544 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11545 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
11548 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
11549 &cookie
->locsyms
[r_symndx
]);
11552 /* COOKIE->rel describes a relocation against section SEC, which is
11553 a section we've decided to keep. Mark the section that contains
11554 the relocation symbol. */
11557 _bfd_elf_gc_mark_reloc (struct bfd_link_info
*info
,
11559 elf_gc_mark_hook_fn gc_mark_hook
,
11560 struct elf_reloc_cookie
*cookie
)
11564 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
11565 if (rsec
&& !rsec
->gc_mark
)
11567 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
)
11569 else if (!_bfd_elf_gc_mark (info
, rsec
, gc_mark_hook
))
11575 /* The mark phase of garbage collection. For a given section, mark
11576 it and any sections in this section's group, and all the sections
11577 which define symbols to which it refers. */
11580 _bfd_elf_gc_mark (struct bfd_link_info
*info
,
11582 elf_gc_mark_hook_fn gc_mark_hook
)
11585 asection
*group_sec
, *eh_frame
;
11589 /* Mark all the sections in the group. */
11590 group_sec
= elf_section_data (sec
)->next_in_group
;
11591 if (group_sec
&& !group_sec
->gc_mark
)
11592 if (!_bfd_elf_gc_mark (info
, group_sec
, gc_mark_hook
))
11595 /* Look through the section relocs. */
11597 eh_frame
= elf_eh_frame_section (sec
->owner
);
11598 if ((sec
->flags
& SEC_RELOC
) != 0
11599 && sec
->reloc_count
> 0
11600 && sec
!= eh_frame
)
11602 struct elf_reloc_cookie cookie
;
11604 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
11608 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
11609 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
11614 fini_reloc_cookie_for_section (&cookie
, sec
);
11618 if (ret
&& eh_frame
&& elf_fde_list (sec
))
11620 struct elf_reloc_cookie cookie
;
11622 if (!init_reloc_cookie_for_section (&cookie
, info
, eh_frame
))
11626 if (!_bfd_elf_gc_mark_fdes (info
, sec
, eh_frame
,
11627 gc_mark_hook
, &cookie
))
11629 fini_reloc_cookie_for_section (&cookie
, eh_frame
);
11636 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
11638 struct elf_gc_sweep_symbol_info
11640 struct bfd_link_info
*info
;
11641 void (*hide_symbol
) (struct bfd_link_info
*, struct elf_link_hash_entry
*,
11646 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *data
)
11648 if ((h
->root
.type
== bfd_link_hash_defined
11649 || h
->root
.type
== bfd_link_hash_defweak
)
11650 && !h
->root
.u
.def
.section
->gc_mark
11651 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
11653 struct elf_gc_sweep_symbol_info
*inf
=
11654 (struct elf_gc_sweep_symbol_info
*) data
;
11655 (*inf
->hide_symbol
) (inf
->info
, h
, TRUE
);
11661 /* The sweep phase of garbage collection. Remove all garbage sections. */
11663 typedef bfd_boolean (*gc_sweep_hook_fn
)
11664 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
11667 elf_gc_sweep (bfd
*abfd
, struct bfd_link_info
*info
)
11670 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11671 gc_sweep_hook_fn gc_sweep_hook
= bed
->gc_sweep_hook
;
11672 unsigned long section_sym_count
;
11673 struct elf_gc_sweep_symbol_info sweep_info
;
11675 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
11679 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
11682 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
11684 /* When any section in a section group is kept, we keep all
11685 sections in the section group. If the first member of
11686 the section group is excluded, we will also exclude the
11688 if (o
->flags
& SEC_GROUP
)
11690 asection
*first
= elf_next_in_group (o
);
11691 o
->gc_mark
= first
->gc_mark
;
11693 else if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
11694 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
11696 /* Keep debug and special sections. */
11703 /* Skip sweeping sections already excluded. */
11704 if (o
->flags
& SEC_EXCLUDE
)
11707 /* Since this is early in the link process, it is simple
11708 to remove a section from the output. */
11709 o
->flags
|= SEC_EXCLUDE
;
11711 if (info
->print_gc_sections
&& o
->size
!= 0)
11712 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub
, o
->name
);
11714 /* But we also have to update some of the relocation
11715 info we collected before. */
11717 && (o
->flags
& SEC_RELOC
) != 0
11718 && o
->reloc_count
> 0
11719 && !bfd_is_abs_section (o
->output_section
))
11721 Elf_Internal_Rela
*internal_relocs
;
11725 = _bfd_elf_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
11726 info
->keep_memory
);
11727 if (internal_relocs
== NULL
)
11730 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
11732 if (elf_section_data (o
)->relocs
!= internal_relocs
)
11733 free (internal_relocs
);
11741 /* Remove the symbols that were in the swept sections from the dynamic
11742 symbol table. GCFIXME: Anyone know how to get them out of the
11743 static symbol table as well? */
11744 sweep_info
.info
= info
;
11745 sweep_info
.hide_symbol
= bed
->elf_backend_hide_symbol
;
11746 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
,
11749 _bfd_elf_link_renumber_dynsyms (abfd
, info
, §ion_sym_count
);
11753 /* Propagate collected vtable information. This is called through
11754 elf_link_hash_traverse. */
11757 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
11759 /* Those that are not vtables. */
11760 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
11763 /* Those vtables that do not have parents, we cannot merge. */
11764 if (h
->vtable
->parent
== (struct elf_link_hash_entry
*) -1)
11767 /* If we've already been done, exit. */
11768 if (h
->vtable
->used
&& h
->vtable
->used
[-1])
11771 /* Make sure the parent's table is up to date. */
11772 elf_gc_propagate_vtable_entries_used (h
->vtable
->parent
, okp
);
11774 if (h
->vtable
->used
== NULL
)
11776 /* None of this table's entries were referenced. Re-use the
11778 h
->vtable
->used
= h
->vtable
->parent
->vtable
->used
;
11779 h
->vtable
->size
= h
->vtable
->parent
->vtable
->size
;
11784 bfd_boolean
*cu
, *pu
;
11786 /* Or the parent's entries into ours. */
11787 cu
= h
->vtable
->used
;
11789 pu
= h
->vtable
->parent
->vtable
->used
;
11792 const struct elf_backend_data
*bed
;
11793 unsigned int log_file_align
;
11795 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
11796 log_file_align
= bed
->s
->log_file_align
;
11797 n
= h
->vtable
->parent
->vtable
->size
>> log_file_align
;
11812 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
, void *okp
)
11815 bfd_vma hstart
, hend
;
11816 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
11817 const struct elf_backend_data
*bed
;
11818 unsigned int log_file_align
;
11820 /* Take care of both those symbols that do not describe vtables as
11821 well as those that are not loaded. */
11822 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
11825 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
11826 || h
->root
.type
== bfd_link_hash_defweak
);
11828 sec
= h
->root
.u
.def
.section
;
11829 hstart
= h
->root
.u
.def
.value
;
11830 hend
= hstart
+ h
->size
;
11832 relstart
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, TRUE
);
11834 return *(bfd_boolean
*) okp
= FALSE
;
11835 bed
= get_elf_backend_data (sec
->owner
);
11836 log_file_align
= bed
->s
->log_file_align
;
11838 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
11840 for (rel
= relstart
; rel
< relend
; ++rel
)
11841 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
11843 /* If the entry is in use, do nothing. */
11844 if (h
->vtable
->used
11845 && (rel
->r_offset
- hstart
) < h
->vtable
->size
)
11847 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
11848 if (h
->vtable
->used
[entry
])
11851 /* Otherwise, kill it. */
11852 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
11858 /* Mark sections containing dynamically referenced symbols. When
11859 building shared libraries, we must assume that any visible symbol is
11863 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry
*h
, void *inf
)
11865 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
11867 if ((h
->root
.type
== bfd_link_hash_defined
11868 || h
->root
.type
== bfd_link_hash_defweak
)
11870 || (!info
->executable
11872 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
11873 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
)))
11874 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
11879 /* Keep all sections containing symbols undefined on the command-line,
11880 and the section containing the entry symbol. */
11883 _bfd_elf_gc_keep (struct bfd_link_info
*info
)
11885 struct bfd_sym_chain
*sym
;
11887 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
11889 struct elf_link_hash_entry
*h
;
11891 h
= elf_link_hash_lookup (elf_hash_table (info
), sym
->name
,
11892 FALSE
, FALSE
, FALSE
);
11895 && (h
->root
.type
== bfd_link_hash_defined
11896 || h
->root
.type
== bfd_link_hash_defweak
)
11897 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
11898 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
11902 /* Do mark and sweep of unused sections. */
11905 bfd_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
11907 bfd_boolean ok
= TRUE
;
11909 elf_gc_mark_hook_fn gc_mark_hook
;
11910 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11912 if (!bed
->can_gc_sections
11913 || !is_elf_hash_table (info
->hash
))
11915 (*_bfd_error_handler
)(_("Warning: gc-sections option ignored"));
11919 bed
->gc_keep (info
);
11921 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
11922 at the .eh_frame section if we can mark the FDEs individually. */
11923 _bfd_elf_begin_eh_frame_parsing (info
);
11924 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
11927 struct elf_reloc_cookie cookie
;
11929 sec
= bfd_get_section_by_name (sub
, ".eh_frame");
11930 if (sec
&& init_reloc_cookie_for_section (&cookie
, info
, sec
))
11932 _bfd_elf_parse_eh_frame (sub
, info
, sec
, &cookie
);
11933 if (elf_section_data (sec
)->sec_info
)
11934 elf_eh_frame_section (sub
) = sec
;
11935 fini_reloc_cookie_for_section (&cookie
, sec
);
11938 _bfd_elf_end_eh_frame_parsing (info
);
11940 /* Apply transitive closure to the vtable entry usage info. */
11941 elf_link_hash_traverse (elf_hash_table (info
),
11942 elf_gc_propagate_vtable_entries_used
,
11947 /* Kill the vtable relocations that were not used. */
11948 elf_link_hash_traverse (elf_hash_table (info
),
11949 elf_gc_smash_unused_vtentry_relocs
,
11954 /* Mark dynamically referenced symbols. */
11955 if (elf_hash_table (info
)->dynamic_sections_created
)
11956 elf_link_hash_traverse (elf_hash_table (info
),
11957 bed
->gc_mark_dynamic_ref
,
11960 /* Grovel through relocs to find out who stays ... */
11961 gc_mark_hook
= bed
->gc_mark_hook
;
11962 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
11966 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
11969 /* Also keep SHT_NOTE sections. */
11970 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
11971 if ((o
->flags
& SEC_EXCLUDE
) == 0
11972 && ((o
->flags
& SEC_KEEP
) != 0
11973 || elf_section_data (o
)->this_hdr
.sh_type
== SHT_NOTE
)
11975 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
11979 /* Allow the backend to mark additional target specific sections. */
11980 if (bed
->gc_mark_extra_sections
)
11981 bed
->gc_mark_extra_sections (info
, gc_mark_hook
);
11983 /* ... and mark SEC_EXCLUDE for those that go. */
11984 return elf_gc_sweep (abfd
, info
);
11987 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
11990 bfd_elf_gc_record_vtinherit (bfd
*abfd
,
11992 struct elf_link_hash_entry
*h
,
11995 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
11996 struct elf_link_hash_entry
**search
, *child
;
11997 bfd_size_type extsymcount
;
11998 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12000 /* The sh_info field of the symtab header tells us where the
12001 external symbols start. We don't care about the local symbols at
12003 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/ bed
->s
->sizeof_sym
;
12004 if (!elf_bad_symtab (abfd
))
12005 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
12007 sym_hashes
= elf_sym_hashes (abfd
);
12008 sym_hashes_end
= sym_hashes
+ extsymcount
;
12010 /* Hunt down the child symbol, which is in this section at the same
12011 offset as the relocation. */
12012 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
12014 if ((child
= *search
) != NULL
12015 && (child
->root
.type
== bfd_link_hash_defined
12016 || child
->root
.type
== bfd_link_hash_defweak
)
12017 && child
->root
.u
.def
.section
== sec
12018 && child
->root
.u
.def
.value
== offset
)
12022 (*_bfd_error_handler
) ("%B: %A+%lu: No symbol found for INHERIT",
12023 abfd
, sec
, (unsigned long) offset
);
12024 bfd_set_error (bfd_error_invalid_operation
);
12028 if (!child
->vtable
)
12030 child
->vtable
= (struct elf_link_virtual_table_entry
*)
12031 bfd_zalloc (abfd
, sizeof (*child
->vtable
));
12032 if (!child
->vtable
)
12037 /* This *should* only be the absolute section. It could potentially
12038 be that someone has defined a non-global vtable though, which
12039 would be bad. It isn't worth paging in the local symbols to be
12040 sure though; that case should simply be handled by the assembler. */
12042 child
->vtable
->parent
= (struct elf_link_hash_entry
*) -1;
12045 child
->vtable
->parent
= h
;
12050 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
12053 bfd_elf_gc_record_vtentry (bfd
*abfd ATTRIBUTE_UNUSED
,
12054 asection
*sec ATTRIBUTE_UNUSED
,
12055 struct elf_link_hash_entry
*h
,
12058 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12059 unsigned int log_file_align
= bed
->s
->log_file_align
;
12063 h
->vtable
= (struct elf_link_virtual_table_entry
*)
12064 bfd_zalloc (abfd
, sizeof (*h
->vtable
));
12069 if (addend
>= h
->vtable
->size
)
12071 size_t size
, bytes
, file_align
;
12072 bfd_boolean
*ptr
= h
->vtable
->used
;
12074 /* While the symbol is undefined, we have to be prepared to handle
12076 file_align
= 1 << log_file_align
;
12077 if (h
->root
.type
== bfd_link_hash_undefined
)
12078 size
= addend
+ file_align
;
12082 if (addend
>= size
)
12084 /* Oops! We've got a reference past the defined end of
12085 the table. This is probably a bug -- shall we warn? */
12086 size
= addend
+ file_align
;
12089 size
= (size
+ file_align
- 1) & -file_align
;
12091 /* Allocate one extra entry for use as a "done" flag for the
12092 consolidation pass. */
12093 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bfd_boolean
);
12097 ptr
= (bfd_boolean
*) bfd_realloc (ptr
- 1, bytes
);
12103 oldbytes
= (((h
->vtable
->size
>> log_file_align
) + 1)
12104 * sizeof (bfd_boolean
));
12105 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
12109 ptr
= (bfd_boolean
*) bfd_zmalloc (bytes
);
12114 /* And arrange for that done flag to be at index -1. */
12115 h
->vtable
->used
= ptr
+ 1;
12116 h
->vtable
->size
= size
;
12119 h
->vtable
->used
[addend
>> log_file_align
] = TRUE
;
12124 struct alloc_got_off_arg
{
12126 struct bfd_link_info
*info
;
12129 /* We need a special top-level link routine to convert got reference counts
12130 to real got offsets. */
12133 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *arg
)
12135 struct alloc_got_off_arg
*gofarg
= (struct alloc_got_off_arg
*) arg
;
12136 bfd
*obfd
= gofarg
->info
->output_bfd
;
12137 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
12139 if (h
->got
.refcount
> 0)
12141 h
->got
.offset
= gofarg
->gotoff
;
12142 gofarg
->gotoff
+= bed
->got_elt_size (obfd
, gofarg
->info
, h
, NULL
, 0);
12145 h
->got
.offset
= (bfd_vma
) -1;
12150 /* And an accompanying bit to work out final got entry offsets once
12151 we're done. Should be called from final_link. */
12154 bfd_elf_gc_common_finalize_got_offsets (bfd
*abfd
,
12155 struct bfd_link_info
*info
)
12158 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12160 struct alloc_got_off_arg gofarg
;
12162 BFD_ASSERT (abfd
== info
->output_bfd
);
12164 if (! is_elf_hash_table (info
->hash
))
12167 /* The GOT offset is relative to the .got section, but the GOT header is
12168 put into the .got.plt section, if the backend uses it. */
12169 if (bed
->want_got_plt
)
12172 gotoff
= bed
->got_header_size
;
12174 /* Do the local .got entries first. */
12175 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
12177 bfd_signed_vma
*local_got
;
12178 bfd_size_type j
, locsymcount
;
12179 Elf_Internal_Shdr
*symtab_hdr
;
12181 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
12184 local_got
= elf_local_got_refcounts (i
);
12188 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
12189 if (elf_bad_symtab (i
))
12190 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
12192 locsymcount
= symtab_hdr
->sh_info
;
12194 for (j
= 0; j
< locsymcount
; ++j
)
12196 if (local_got
[j
] > 0)
12198 local_got
[j
] = gotoff
;
12199 gotoff
+= bed
->got_elt_size (abfd
, info
, NULL
, i
, j
);
12202 local_got
[j
] = (bfd_vma
) -1;
12206 /* Then the global .got entries. .plt refcounts are handled by
12207 adjust_dynamic_symbol */
12208 gofarg
.gotoff
= gotoff
;
12209 gofarg
.info
= info
;
12210 elf_link_hash_traverse (elf_hash_table (info
),
12211 elf_gc_allocate_got_offsets
,
12216 /* Many folk need no more in the way of final link than this, once
12217 got entry reference counting is enabled. */
12220 bfd_elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
12222 if (!bfd_elf_gc_common_finalize_got_offsets (abfd
, info
))
12225 /* Invoke the regular ELF backend linker to do all the work. */
12226 return bfd_elf_final_link (abfd
, info
);
12230 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
12232 struct elf_reloc_cookie
*rcookie
= (struct elf_reloc_cookie
*) cookie
;
12234 if (rcookie
->bad_symtab
)
12235 rcookie
->rel
= rcookie
->rels
;
12237 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
12239 unsigned long r_symndx
;
12241 if (! rcookie
->bad_symtab
)
12242 if (rcookie
->rel
->r_offset
> offset
)
12244 if (rcookie
->rel
->r_offset
!= offset
)
12247 r_symndx
= rcookie
->rel
->r_info
>> rcookie
->r_sym_shift
;
12248 if (r_symndx
== STN_UNDEF
)
12251 if (r_symndx
>= rcookie
->locsymcount
12252 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
12254 struct elf_link_hash_entry
*h
;
12256 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
12258 while (h
->root
.type
== bfd_link_hash_indirect
12259 || h
->root
.type
== bfd_link_hash_warning
)
12260 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
12262 if ((h
->root
.type
== bfd_link_hash_defined
12263 || h
->root
.type
== bfd_link_hash_defweak
)
12264 && elf_discarded_section (h
->root
.u
.def
.section
))
12271 /* It's not a relocation against a global symbol,
12272 but it could be a relocation against a local
12273 symbol for a discarded section. */
12275 Elf_Internal_Sym
*isym
;
12277 /* Need to: get the symbol; get the section. */
12278 isym
= &rcookie
->locsyms
[r_symndx
];
12279 isec
= bfd_section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
12280 if (isec
!= NULL
&& elf_discarded_section (isec
))
12288 /* Discard unneeded references to discarded sections.
12289 Returns TRUE if any section's size was changed. */
12290 /* This function assumes that the relocations are in sorted order,
12291 which is true for all known assemblers. */
12294 bfd_elf_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
12296 struct elf_reloc_cookie cookie
;
12297 asection
*stab
, *eh
;
12298 const struct elf_backend_data
*bed
;
12300 bfd_boolean ret
= FALSE
;
12302 if (info
->traditional_format
12303 || !is_elf_hash_table (info
->hash
))
12306 _bfd_elf_begin_eh_frame_parsing (info
);
12307 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
12309 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
12312 bed
= get_elf_backend_data (abfd
);
12314 if ((abfd
->flags
& DYNAMIC
) != 0)
12318 if (!info
->relocatable
)
12320 eh
= bfd_get_section_by_name (abfd
, ".eh_frame");
12323 || bfd_is_abs_section (eh
->output_section
)))
12327 stab
= bfd_get_section_by_name (abfd
, ".stab");
12329 && (stab
->size
== 0
12330 || bfd_is_abs_section (stab
->output_section
)
12331 || stab
->sec_info_type
!= ELF_INFO_TYPE_STABS
))
12336 && bed
->elf_backend_discard_info
== NULL
)
12339 if (!init_reloc_cookie (&cookie
, info
, abfd
))
12343 && stab
->reloc_count
> 0
12344 && init_reloc_cookie_rels (&cookie
, info
, abfd
, stab
))
12346 if (_bfd_discard_section_stabs (abfd
, stab
,
12347 elf_section_data (stab
)->sec_info
,
12348 bfd_elf_reloc_symbol_deleted_p
,
12351 fini_reloc_cookie_rels (&cookie
, stab
);
12355 && init_reloc_cookie_rels (&cookie
, info
, abfd
, eh
))
12357 _bfd_elf_parse_eh_frame (abfd
, info
, eh
, &cookie
);
12358 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, eh
,
12359 bfd_elf_reloc_symbol_deleted_p
,
12362 fini_reloc_cookie_rels (&cookie
, eh
);
12365 if (bed
->elf_backend_discard_info
!= NULL
12366 && (*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
12369 fini_reloc_cookie (&cookie
, abfd
);
12371 _bfd_elf_end_eh_frame_parsing (info
);
12373 if (info
->eh_frame_hdr
12374 && !info
->relocatable
12375 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
12381 /* For a SHT_GROUP section, return the group signature. For other
12382 sections, return the normal section name. */
12384 static const char *
12385 section_signature (asection
*sec
)
12387 if ((sec
->flags
& SEC_GROUP
) != 0
12388 && elf_next_in_group (sec
) != NULL
12389 && elf_group_name (elf_next_in_group (sec
)) != NULL
)
12390 return elf_group_name (elf_next_in_group (sec
));
12395 _bfd_elf_section_already_linked (bfd
*abfd
, asection
*sec
,
12396 struct bfd_link_info
*info
)
12399 const char *name
, *p
;
12400 struct bfd_section_already_linked
*l
;
12401 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
12403 if (sec
->output_section
== bfd_abs_section_ptr
)
12406 flags
= sec
->flags
;
12408 /* Return if it isn't a linkonce section. A comdat group section
12409 also has SEC_LINK_ONCE set. */
12410 if ((flags
& SEC_LINK_ONCE
) == 0)
12413 /* Don't put group member sections on our list of already linked
12414 sections. They are handled as a group via their group section. */
12415 if (elf_sec_group (sec
) != NULL
)
12418 /* FIXME: When doing a relocatable link, we may have trouble
12419 copying relocations in other sections that refer to local symbols
12420 in the section being discarded. Those relocations will have to
12421 be converted somehow; as of this writing I'm not sure that any of
12422 the backends handle that correctly.
12424 It is tempting to instead not discard link once sections when
12425 doing a relocatable link (technically, they should be discarded
12426 whenever we are building constructors). However, that fails,
12427 because the linker winds up combining all the link once sections
12428 into a single large link once section, which defeats the purpose
12429 of having link once sections in the first place.
12431 Also, not merging link once sections in a relocatable link
12432 causes trouble for MIPS ELF, which relies on link once semantics
12433 to handle the .reginfo section correctly. */
12435 name
= section_signature (sec
);
12437 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
12438 && (p
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
12443 already_linked_list
= bfd_section_already_linked_table_lookup (p
);
12445 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12447 /* We may have 2 different types of sections on the list: group
12448 sections and linkonce sections. Match like sections. */
12449 if ((flags
& SEC_GROUP
) == (l
->sec
->flags
& SEC_GROUP
)
12450 && strcmp (name
, section_signature (l
->sec
)) == 0
12451 && bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
) == NULL
)
12453 /* The section has already been linked. See if we should
12454 issue a warning. */
12455 switch (flags
& SEC_LINK_DUPLICATES
)
12460 case SEC_LINK_DUPLICATES_DISCARD
:
12463 case SEC_LINK_DUPLICATES_ONE_ONLY
:
12464 (*_bfd_error_handler
)
12465 (_("%B: ignoring duplicate section `%A'"),
12469 case SEC_LINK_DUPLICATES_SAME_SIZE
:
12470 if (sec
->size
!= l
->sec
->size
)
12471 (*_bfd_error_handler
)
12472 (_("%B: duplicate section `%A' has different size"),
12476 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
12477 if (sec
->size
!= l
->sec
->size
)
12478 (*_bfd_error_handler
)
12479 (_("%B: duplicate section `%A' has different size"),
12481 else if (sec
->size
!= 0)
12483 bfd_byte
*sec_contents
, *l_sec_contents
;
12485 if (!bfd_malloc_and_get_section (abfd
, sec
, &sec_contents
))
12486 (*_bfd_error_handler
)
12487 (_("%B: warning: could not read contents of section `%A'"),
12489 else if (!bfd_malloc_and_get_section (l
->sec
->owner
, l
->sec
,
12491 (*_bfd_error_handler
)
12492 (_("%B: warning: could not read contents of section `%A'"),
12493 l
->sec
->owner
, l
->sec
);
12494 else if (memcmp (sec_contents
, l_sec_contents
, sec
->size
) != 0)
12495 (*_bfd_error_handler
)
12496 (_("%B: warning: duplicate section `%A' has different contents"),
12500 free (sec_contents
);
12501 if (l_sec_contents
)
12502 free (l_sec_contents
);
12507 /* Set the output_section field so that lang_add_section
12508 does not create a lang_input_section structure for this
12509 section. Since there might be a symbol in the section
12510 being discarded, we must retain a pointer to the section
12511 which we are really going to use. */
12512 sec
->output_section
= bfd_abs_section_ptr
;
12513 sec
->kept_section
= l
->sec
;
12515 if (flags
& SEC_GROUP
)
12517 asection
*first
= elf_next_in_group (sec
);
12518 asection
*s
= first
;
12522 s
->output_section
= bfd_abs_section_ptr
;
12523 /* Record which group discards it. */
12524 s
->kept_section
= l
->sec
;
12525 s
= elf_next_in_group (s
);
12526 /* These lists are circular. */
12536 /* A single member comdat group section may be discarded by a
12537 linkonce section and vice versa. */
12539 if ((flags
& SEC_GROUP
) != 0)
12541 asection
*first
= elf_next_in_group (sec
);
12543 if (first
!= NULL
&& elf_next_in_group (first
) == first
)
12544 /* Check this single member group against linkonce sections. */
12545 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12546 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12547 && bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
) == NULL
12548 && bfd_elf_match_symbols_in_sections (l
->sec
, first
, info
))
12550 first
->output_section
= bfd_abs_section_ptr
;
12551 first
->kept_section
= l
->sec
;
12552 sec
->output_section
= bfd_abs_section_ptr
;
12557 /* Check this linkonce section against single member groups. */
12558 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12559 if (l
->sec
->flags
& SEC_GROUP
)
12561 asection
*first
= elf_next_in_group (l
->sec
);
12564 && elf_next_in_group (first
) == first
12565 && bfd_elf_match_symbols_in_sections (first
, sec
, info
))
12567 sec
->output_section
= bfd_abs_section_ptr
;
12568 sec
->kept_section
= first
;
12573 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12574 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12575 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12576 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
12577 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
12578 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12579 `.gnu.linkonce.t.F' section from a different bfd not requiring any
12580 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
12581 The reverse order cannot happen as there is never a bfd with only the
12582 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
12583 matter as here were are looking only for cross-bfd sections. */
12585 if ((flags
& SEC_GROUP
) == 0 && CONST_STRNEQ (name
, ".gnu.linkonce.r."))
12586 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12587 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12588 && CONST_STRNEQ (l
->sec
->name
, ".gnu.linkonce.t."))
12590 if (abfd
!= l
->sec
->owner
)
12591 sec
->output_section
= bfd_abs_section_ptr
;
12595 /* This is the first section with this name. Record it. */
12596 if (! bfd_section_already_linked_table_insert (already_linked_list
, sec
))
12597 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
12601 _bfd_elf_common_definition (Elf_Internal_Sym
*sym
)
12603 return sym
->st_shndx
== SHN_COMMON
;
12607 _bfd_elf_common_section_index (asection
*sec ATTRIBUTE_UNUSED
)
12613 _bfd_elf_common_section (asection
*sec ATTRIBUTE_UNUSED
)
12615 return bfd_com_section_ptr
;
12619 _bfd_elf_default_got_elt_size (bfd
*abfd
,
12620 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12621 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
12622 bfd
*ibfd ATTRIBUTE_UNUSED
,
12623 unsigned long symndx ATTRIBUTE_UNUSED
)
12625 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12626 return bed
->s
->arch_size
/ 8;
12629 /* Routines to support the creation of dynamic relocs. */
12631 /* Returns the name of the dynamic reloc section associated with SEC. */
12633 static const char *
12634 get_dynamic_reloc_section_name (bfd
* abfd
,
12636 bfd_boolean is_rela
)
12639 const char *old_name
= bfd_get_section_name (NULL
, sec
);
12640 const char *prefix
= is_rela
? ".rela" : ".rel";
12642 if (old_name
== NULL
)
12645 name
= bfd_alloc (abfd
, strlen (prefix
) + strlen (old_name
) + 1);
12646 sprintf (name
, "%s%s", prefix
, old_name
);
12651 /* Returns the dynamic reloc section associated with SEC.
12652 If necessary compute the name of the dynamic reloc section based
12653 on SEC's name (looked up in ABFD's string table) and the setting
12657 _bfd_elf_get_dynamic_reloc_section (bfd
* abfd
,
12659 bfd_boolean is_rela
)
12661 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
12663 if (reloc_sec
== NULL
)
12665 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
12669 reloc_sec
= bfd_get_section_by_name (abfd
, name
);
12671 if (reloc_sec
!= NULL
)
12672 elf_section_data (sec
)->sreloc
= reloc_sec
;
12679 /* Returns the dynamic reloc section associated with SEC. If the
12680 section does not exist it is created and attached to the DYNOBJ
12681 bfd and stored in the SRELOC field of SEC's elf_section_data
12684 ALIGNMENT is the alignment for the newly created section and
12685 IS_RELA defines whether the name should be .rela.<SEC's name>
12686 or .rel.<SEC's name>. The section name is looked up in the
12687 string table associated with ABFD. */
12690 _bfd_elf_make_dynamic_reloc_section (asection
* sec
,
12692 unsigned int alignment
,
12694 bfd_boolean is_rela
)
12696 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
12698 if (reloc_sec
== NULL
)
12700 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
12705 reloc_sec
= bfd_get_section_by_name (dynobj
, name
);
12707 if (reloc_sec
== NULL
)
12711 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
12712 if ((sec
->flags
& SEC_ALLOC
) != 0)
12713 flags
|= SEC_ALLOC
| SEC_LOAD
;
12715 reloc_sec
= bfd_make_section_with_flags (dynobj
, name
, flags
);
12716 if (reloc_sec
!= NULL
)
12718 if (! bfd_set_section_alignment (dynobj
, reloc_sec
, alignment
))
12723 elf_section_data (sec
)->sreloc
= reloc_sec
;
12729 /* Copy the ELF symbol type associated with a linker hash entry. */
12731 _bfd_elf_copy_link_hash_symbol_type (bfd
*abfd ATTRIBUTE_UNUSED
,
12732 struct bfd_link_hash_entry
* hdest
,
12733 struct bfd_link_hash_entry
* hsrc
)
12735 struct elf_link_hash_entry
*ehdest
= (struct elf_link_hash_entry
*)hdest
;
12736 struct elf_link_hash_entry
*ehsrc
= (struct elf_link_hash_entry
*)hsrc
;
12738 ehdest
->type
= ehsrc
->type
;
12739 ehdest
->target_internal
= ehsrc
->target_internal
;
12742 /* Append a RELA relocation REL to section S in BFD. */
12745 elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
12747 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12748 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
12749 BFD_ASSERT (loc
+ bed
->s
->sizeof_rela
<= s
->contents
+ s
->size
);
12750 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
12753 /* Append a REL relocation REL to section S in BFD. */
12756 elf_append_rel (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
12758 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12759 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rel
);
12760 BFD_ASSERT (loc
+ bed
->s
->sizeof_rel
<= s
->contents
+ s
->size
);
12761 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);