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, 2012
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
;
42 /* This structure is used to pass information to
43 _bfd_elf_link_find_version_dependencies. */
45 struct elf_find_verdep_info
47 /* General link information. */
48 struct bfd_link_info
*info
;
49 /* The number of dependencies. */
51 /* Whether we had a failure. */
55 static bfd_boolean _bfd_elf_fix_symbol_flags
56 (struct elf_link_hash_entry
*, struct elf_info_failed
*);
58 /* Define a symbol in a dynamic linkage section. */
60 struct elf_link_hash_entry
*
61 _bfd_elf_define_linkage_sym (bfd
*abfd
,
62 struct bfd_link_info
*info
,
66 struct elf_link_hash_entry
*h
;
67 struct bfd_link_hash_entry
*bh
;
68 const struct elf_backend_data
*bed
;
70 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
73 /* Zap symbol defined in an as-needed lib that wasn't linked.
74 This is a symptom of a larger problem: Absolute symbols
75 defined in shared libraries can't be overridden, because we
76 lose the link to the bfd which is via the symbol section. */
77 h
->root
.type
= bfd_link_hash_new
;
81 if (!_bfd_generic_link_add_one_symbol (info
, abfd
, name
, BSF_GLOBAL
,
83 get_elf_backend_data (abfd
)->collect
,
86 h
= (struct elf_link_hash_entry
*) bh
;
90 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
92 bed
= get_elf_backend_data (abfd
);
93 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
98 _bfd_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
102 struct elf_link_hash_entry
*h
;
103 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
104 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
106 /* This function may be called more than once. */
107 s
= bfd_get_linker_section (abfd
, ".got");
111 flags
= bed
->dynamic_sec_flags
;
113 s
= bfd_make_section_anyway_with_flags (abfd
,
114 (bed
->rela_plts_and_copies_p
115 ? ".rela.got" : ".rel.got"),
116 (bed
->dynamic_sec_flags
119 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
123 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
125 || !bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
129 if (bed
->want_got_plt
)
131 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
133 || !bfd_set_section_alignment (abfd
, s
,
134 bed
->s
->log_file_align
))
139 /* The first bit of the global offset table is the header. */
140 s
->size
+= bed
->got_header_size
;
142 if (bed
->want_got_sym
)
144 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
145 (or .got.plt) section. We don't do this in the linker script
146 because we don't want to define the symbol if we are not creating
147 a global offset table. */
148 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
149 "_GLOBAL_OFFSET_TABLE_");
150 elf_hash_table (info
)->hgot
= h
;
158 /* Create a strtab to hold the dynamic symbol names. */
160 _bfd_elf_link_create_dynstrtab (bfd
*abfd
, struct bfd_link_info
*info
)
162 struct elf_link_hash_table
*hash_table
;
164 hash_table
= elf_hash_table (info
);
165 if (hash_table
->dynobj
== NULL
)
166 hash_table
->dynobj
= abfd
;
168 if (hash_table
->dynstr
== NULL
)
170 hash_table
->dynstr
= _bfd_elf_strtab_init ();
171 if (hash_table
->dynstr
== NULL
)
177 /* Create some sections which will be filled in with dynamic linking
178 information. ABFD is an input file which requires dynamic sections
179 to be created. The dynamic sections take up virtual memory space
180 when the final executable is run, so we need to create them before
181 addresses are assigned to the output sections. We work out the
182 actual contents and size of these sections later. */
185 _bfd_elf_link_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
189 const struct elf_backend_data
*bed
;
191 if (! is_elf_hash_table (info
->hash
))
194 if (elf_hash_table (info
)->dynamic_sections_created
)
197 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
200 abfd
= elf_hash_table (info
)->dynobj
;
201 bed
= get_elf_backend_data (abfd
);
203 flags
= bed
->dynamic_sec_flags
;
205 /* A dynamically linked executable has a .interp section, but a
206 shared library does not. */
207 if (info
->executable
)
209 s
= bfd_make_section_anyway_with_flags (abfd
, ".interp",
210 flags
| SEC_READONLY
);
215 /* Create sections to hold version informations. These are removed
216 if they are not needed. */
217 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_d",
218 flags
| SEC_READONLY
);
220 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
223 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version",
224 flags
| SEC_READONLY
);
226 || ! bfd_set_section_alignment (abfd
, s
, 1))
229 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_r",
230 flags
| SEC_READONLY
);
232 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
235 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynsym",
236 flags
| SEC_READONLY
);
238 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
241 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynstr",
242 flags
| SEC_READONLY
);
246 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic", flags
);
248 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
251 /* The special symbol _DYNAMIC is always set to the start of the
252 .dynamic section. We could set _DYNAMIC in a linker script, but we
253 only want to define it if we are, in fact, creating a .dynamic
254 section. We don't want to define it if there is no .dynamic
255 section, since on some ELF platforms the start up code examines it
256 to decide how to initialize the process. */
257 if (!_bfd_elf_define_linkage_sym (abfd
, info
, s
, "_DYNAMIC"))
262 s
= bfd_make_section_anyway_with_flags (abfd
, ".hash",
263 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_anyway_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_anyway_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_anyway_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_anyway_with_flags (abfd
, ".dynbss",
362 (SEC_ALLOC
| SEC_LINKER_CREATED
));
366 /* The .rel[a].bss section holds copy relocs. This section is not
367 normally needed. We need to create it here, though, so that the
368 linker will map it to an output section. We can't just create it
369 only if we need it, because we will not know whether we need it
370 until we have seen all the input files, and the first time the
371 main linker code calls BFD after examining all the input files
372 (size_dynamic_sections) the input sections have already been
373 mapped to the output sections. If the section turns out not to
374 be needed, we can discard it later. We will never need this
375 section when generating a shared object, since they do not use
379 s
= bfd_make_section_anyway_with_flags (abfd
,
380 (bed
->rela_plts_and_copies_p
381 ? ".rela.bss" : ".rel.bss"),
382 flags
| SEC_READONLY
);
384 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
392 /* Record a new dynamic symbol. We record the dynamic symbols as we
393 read the input files, since we need to have a list of all of them
394 before we can determine the final sizes of the output sections.
395 Note that we may actually call this function even though we are not
396 going to output any dynamic symbols; in some cases we know that a
397 symbol should be in the dynamic symbol table, but only if there is
401 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
402 struct elf_link_hash_entry
*h
)
404 if (h
->dynindx
== -1)
406 struct elf_strtab_hash
*dynstr
;
411 /* XXX: The ABI draft says the linker must turn hidden and
412 internal symbols into STB_LOCAL symbols when producing the
413 DSO. However, if ld.so honors st_other in the dynamic table,
414 this would not be necessary. */
415 switch (ELF_ST_VISIBILITY (h
->other
))
419 if (h
->root
.type
!= bfd_link_hash_undefined
420 && h
->root
.type
!= bfd_link_hash_undefweak
)
423 if (!elf_hash_table (info
)->is_relocatable_executable
)
431 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
432 ++elf_hash_table (info
)->dynsymcount
;
434 dynstr
= elf_hash_table (info
)->dynstr
;
437 /* Create a strtab to hold the dynamic symbol names. */
438 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
443 /* We don't put any version information in the dynamic string
445 name
= h
->root
.root
.string
;
446 p
= strchr (name
, ELF_VER_CHR
);
448 /* We know that the p points into writable memory. In fact,
449 there are only a few symbols that have read-only names, being
450 those like _GLOBAL_OFFSET_TABLE_ that are created specially
451 by the backends. Most symbols will have names pointing into
452 an ELF string table read from a file, or to objalloc memory. */
455 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
460 if (indx
== (bfd_size_type
) -1)
462 h
->dynstr_index
= indx
;
468 /* Mark a symbol dynamic. */
471 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info
*info
,
472 struct elf_link_hash_entry
*h
,
473 Elf_Internal_Sym
*sym
)
475 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
477 /* It may be called more than once on the same H. */
478 if(h
->dynamic
|| info
->relocatable
)
481 if ((info
->dynamic_data
482 && (h
->type
== STT_OBJECT
484 && ELF_ST_TYPE (sym
->st_info
) == STT_OBJECT
)))
486 && h
->root
.type
== bfd_link_hash_new
487 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
491 /* Record an assignment to a symbol made by a linker script. We need
492 this in case some dynamic object refers to this symbol. */
495 bfd_elf_record_link_assignment (bfd
*output_bfd
,
496 struct bfd_link_info
*info
,
501 struct elf_link_hash_entry
*h
, *hv
;
502 struct elf_link_hash_table
*htab
;
503 const struct elf_backend_data
*bed
;
505 if (!is_elf_hash_table (info
->hash
))
508 htab
= elf_hash_table (info
);
509 h
= elf_link_hash_lookup (htab
, name
, !provide
, TRUE
, FALSE
);
513 switch (h
->root
.type
)
515 case bfd_link_hash_defined
:
516 case bfd_link_hash_defweak
:
517 case bfd_link_hash_common
:
519 case bfd_link_hash_undefweak
:
520 case bfd_link_hash_undefined
:
521 /* Since we're defining the symbol, don't let it seem to have not
522 been defined. record_dynamic_symbol and size_dynamic_sections
523 may depend on this. */
524 h
->root
.type
= bfd_link_hash_new
;
525 if (h
->root
.u
.undef
.next
!= NULL
|| htab
->root
.undefs_tail
== &h
->root
)
526 bfd_link_repair_undef_list (&htab
->root
);
528 case bfd_link_hash_new
:
529 bfd_elf_link_mark_dynamic_symbol (info
, h
, NULL
);
532 case bfd_link_hash_indirect
:
533 /* We had a versioned symbol in a dynamic library. We make the
534 the versioned symbol point to this one. */
535 bed
= get_elf_backend_data (output_bfd
);
537 while (hv
->root
.type
== bfd_link_hash_indirect
538 || hv
->root
.type
== bfd_link_hash_warning
)
539 hv
= (struct elf_link_hash_entry
*) hv
->root
.u
.i
.link
;
540 /* We don't need to update h->root.u since linker will set them
542 h
->root
.type
= bfd_link_hash_undefined
;
543 hv
->root
.type
= bfd_link_hash_indirect
;
544 hv
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
545 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hv
);
547 case bfd_link_hash_warning
:
552 /* If this symbol is being provided by the linker script, and it is
553 currently defined by a dynamic object, but not by a regular
554 object, then mark it as undefined so that the generic linker will
555 force the correct value. */
559 h
->root
.type
= bfd_link_hash_undefined
;
561 /* If this symbol is not being provided by the linker script, and it is
562 currently defined by a dynamic object, but not by a regular object,
563 then clear out any version information because the symbol will not be
564 associated with the dynamic object any more. */
568 h
->verinfo
.verdef
= NULL
;
572 if (provide
&& hidden
)
574 bed
= get_elf_backend_data (output_bfd
);
575 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
576 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
579 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
581 if (!info
->relocatable
583 && (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
584 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
))
590 || (info
->executable
&& elf_hash_table (info
)->is_relocatable_executable
))
593 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
596 /* If this is a weak defined symbol, and we know a corresponding
597 real symbol from the same dynamic object, make sure the real
598 symbol is also made into a dynamic symbol. */
599 if (h
->u
.weakdef
!= NULL
600 && h
->u
.weakdef
->dynindx
== -1)
602 if (! bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
610 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
611 success, and 2 on a failure caused by attempting to record a symbol
612 in a discarded section, eg. a discarded link-once section symbol. */
615 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
620 struct elf_link_local_dynamic_entry
*entry
;
621 struct elf_link_hash_table
*eht
;
622 struct elf_strtab_hash
*dynstr
;
623 unsigned long dynstr_index
;
625 Elf_External_Sym_Shndx eshndx
;
626 char esym
[sizeof (Elf64_External_Sym
)];
628 if (! is_elf_hash_table (info
->hash
))
631 /* See if the entry exists already. */
632 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
633 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
636 amt
= sizeof (*entry
);
637 entry
= (struct elf_link_local_dynamic_entry
*) bfd_alloc (input_bfd
, amt
);
641 /* Go find the symbol, so that we can find it's name. */
642 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
643 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
645 bfd_release (input_bfd
, entry
);
649 if (entry
->isym
.st_shndx
!= SHN_UNDEF
650 && entry
->isym
.st_shndx
< SHN_LORESERVE
)
654 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
655 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
657 /* We can still bfd_release here as nothing has done another
658 bfd_alloc. We can't do this later in this function. */
659 bfd_release (input_bfd
, entry
);
664 name
= (bfd_elf_string_from_elf_section
665 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
666 entry
->isym
.st_name
));
668 dynstr
= elf_hash_table (info
)->dynstr
;
671 /* Create a strtab to hold the dynamic symbol names. */
672 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
677 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, FALSE
);
678 if (dynstr_index
== (unsigned long) -1)
680 entry
->isym
.st_name
= dynstr_index
;
682 eht
= elf_hash_table (info
);
684 entry
->next
= eht
->dynlocal
;
685 eht
->dynlocal
= entry
;
686 entry
->input_bfd
= input_bfd
;
687 entry
->input_indx
= input_indx
;
690 /* Whatever binding the symbol had before, it's now local. */
692 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
694 /* The dynindx will be set at the end of size_dynamic_sections. */
699 /* Return the dynindex of a local dynamic symbol. */
702 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
706 struct elf_link_local_dynamic_entry
*e
;
708 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
709 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
714 /* This function is used to renumber the dynamic symbols, if some of
715 them are removed because they are marked as local. This is called
716 via elf_link_hash_traverse. */
719 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
722 size_t *count
= (size_t *) data
;
727 if (h
->dynindx
!= -1)
728 h
->dynindx
= ++(*count
);
734 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
735 STB_LOCAL binding. */
738 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
741 size_t *count
= (size_t *) data
;
743 if (!h
->forced_local
)
746 if (h
->dynindx
!= -1)
747 h
->dynindx
= ++(*count
);
752 /* Return true if the dynamic symbol for a given section should be
753 omitted when creating a shared library. */
755 _bfd_elf_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
756 struct bfd_link_info
*info
,
759 struct elf_link_hash_table
*htab
;
761 switch (elf_section_data (p
)->this_hdr
.sh_type
)
765 /* If sh_type is yet undecided, assume it could be
766 SHT_PROGBITS/SHT_NOBITS. */
768 htab
= elf_hash_table (info
);
769 if (p
== htab
->tls_sec
)
772 if (htab
->text_index_section
!= NULL
)
773 return p
!= htab
->text_index_section
&& p
!= htab
->data_index_section
;
775 if (strcmp (p
->name
, ".got") == 0
776 || strcmp (p
->name
, ".got.plt") == 0
777 || strcmp (p
->name
, ".plt") == 0)
781 if (htab
->dynobj
!= NULL
782 && (ip
= bfd_get_linker_section (htab
->dynobj
, p
->name
)) != NULL
783 && ip
->output_section
== p
)
788 /* There shouldn't be section relative relocations
789 against any other section. */
795 /* Assign dynsym indices. In a shared library we generate a section
796 symbol for each output section, which come first. Next come symbols
797 which have been forced to local binding. Then all of the back-end
798 allocated local dynamic syms, followed by the rest of the global
802 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
,
803 struct bfd_link_info
*info
,
804 unsigned long *section_sym_count
)
806 unsigned long dynsymcount
= 0;
808 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
810 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
812 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
813 if ((p
->flags
& SEC_EXCLUDE
) == 0
814 && (p
->flags
& SEC_ALLOC
) != 0
815 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
816 elf_section_data (p
)->dynindx
= ++dynsymcount
;
818 elf_section_data (p
)->dynindx
= 0;
820 *section_sym_count
= dynsymcount
;
822 elf_link_hash_traverse (elf_hash_table (info
),
823 elf_link_renumber_local_hash_table_dynsyms
,
826 if (elf_hash_table (info
)->dynlocal
)
828 struct elf_link_local_dynamic_entry
*p
;
829 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
830 p
->dynindx
= ++dynsymcount
;
833 elf_link_hash_traverse (elf_hash_table (info
),
834 elf_link_renumber_hash_table_dynsyms
,
837 /* There is an unused NULL entry at the head of the table which
838 we must account for in our count. Unless there weren't any
839 symbols, which means we'll have no table at all. */
840 if (dynsymcount
!= 0)
843 elf_hash_table (info
)->dynsymcount
= dynsymcount
;
847 /* Merge st_other field. */
850 elf_merge_st_other (bfd
*abfd
, struct elf_link_hash_entry
*h
,
851 Elf_Internal_Sym
*isym
, bfd_boolean definition
,
854 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
856 /* If st_other has a processor-specific meaning, specific
857 code might be needed here. We never merge the visibility
858 attribute with the one from a dynamic object. */
859 if (bed
->elf_backend_merge_symbol_attribute
)
860 (*bed
->elf_backend_merge_symbol_attribute
) (h
, isym
, definition
,
863 /* If this symbol has default visibility and the user has requested
864 we not re-export it, then mark it as hidden. */
868 || (abfd
->my_archive
&& abfd
->my_archive
->no_export
))
869 && ELF_ST_VISIBILITY (isym
->st_other
) != STV_INTERNAL
)
870 isym
->st_other
= (STV_HIDDEN
871 | (isym
->st_other
& ~ELF_ST_VISIBILITY (-1)));
873 if (!dynamic
&& ELF_ST_VISIBILITY (isym
->st_other
) != 0)
875 unsigned char hvis
, symvis
, other
, nvis
;
877 /* Only merge the visibility. Leave the remainder of the
878 st_other field to elf_backend_merge_symbol_attribute. */
879 other
= h
->other
& ~ELF_ST_VISIBILITY (-1);
881 /* Combine visibilities, using the most constraining one. */
882 hvis
= ELF_ST_VISIBILITY (h
->other
);
883 symvis
= ELF_ST_VISIBILITY (isym
->st_other
);
889 nvis
= hvis
< symvis
? hvis
: symvis
;
891 h
->other
= other
| nvis
;
895 /* Mark if a symbol has a definition in a dynamic object or is
896 weak in all dynamic objects. */
899 _bfd_elf_mark_dynamic_def_weak (struct elf_link_hash_entry
*h
,
900 asection
*sec
, int bind
)
904 if (!bfd_is_und_section (sec
))
908 /* Check if this symbol is weak in all dynamic objects. If it
909 is the first time we see it in a dynamic object, we mark
910 if it is weak. Otherwise, we clear it. */
913 if (bind
== STB_WEAK
)
916 else if (bind
!= STB_WEAK
)
922 /* This function is called when we want to define a new symbol. It
923 handles the various cases which arise when we find a definition in
924 a dynamic object, or when there is already a definition in a
925 dynamic object. The new symbol is described by NAME, SYM, PSEC,
926 and PVALUE. We set SYM_HASH to the hash table entry. We set
927 OVERRIDE if the old symbol is overriding a new definition. We set
928 TYPE_CHANGE_OK if it is OK for the type to change. We set
929 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
930 change, we mean that we shouldn't warn if the type or size does
931 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic
932 object is overridden by a regular object. */
935 _bfd_elf_merge_symbol (bfd
*abfd
,
936 struct bfd_link_info
*info
,
938 Elf_Internal_Sym
*sym
,
941 unsigned int *pold_alignment
,
942 struct elf_link_hash_entry
**sym_hash
,
944 bfd_boolean
*override
,
945 bfd_boolean
*type_change_ok
,
946 bfd_boolean
*size_change_ok
)
948 asection
*sec
, *oldsec
;
949 struct elf_link_hash_entry
*h
;
950 struct elf_link_hash_entry
*hi
;
951 struct elf_link_hash_entry
*flip
;
954 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
955 bfd_boolean newweak
, oldweak
, newfunc
, oldfunc
;
956 const struct elf_backend_data
*bed
;
962 bind
= ELF_ST_BIND (sym
->st_info
);
964 /* Silently discard TLS symbols from --just-syms. There's no way to
965 combine a static TLS block with a new TLS block for this executable. */
966 if (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
967 && sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
973 if (! bfd_is_und_section (sec
))
974 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
976 h
= ((struct elf_link_hash_entry
*)
977 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
982 bed
= get_elf_backend_data (abfd
);
984 /* This code is for coping with dynamic objects, and is only useful
985 if we are doing an ELF link. */
986 if (!(*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
989 /* For merging, we only care about real symbols. But we need to make
990 sure that indirect symbol dynamic flags are updated. */
992 while (h
->root
.type
== bfd_link_hash_indirect
993 || h
->root
.type
== bfd_link_hash_warning
)
994 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
996 /* We have to check it for every instance since the first few may be
997 refereences and not all compilers emit symbol type for undefined
999 bfd_elf_link_mark_dynamic_symbol (info
, h
, sym
);
1001 /* If we just created the symbol, mark it as being an ELF symbol.
1002 Other than that, there is nothing to do--there is no merge issue
1003 with a newly defined symbol--so we just return. */
1005 if (h
->root
.type
== bfd_link_hash_new
)
1011 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
1014 switch (h
->root
.type
)
1021 case bfd_link_hash_undefined
:
1022 case bfd_link_hash_undefweak
:
1023 oldbfd
= h
->root
.u
.undef
.abfd
;
1027 case bfd_link_hash_defined
:
1028 case bfd_link_hash_defweak
:
1029 oldbfd
= h
->root
.u
.def
.section
->owner
;
1030 oldsec
= h
->root
.u
.def
.section
;
1033 case bfd_link_hash_common
:
1034 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
1035 oldsec
= h
->root
.u
.c
.p
->section
;
1039 /* Differentiate strong and weak symbols. */
1040 newweak
= bind
== STB_WEAK
;
1041 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
1042 || h
->root
.type
== bfd_link_hash_undefweak
);
1044 /* In cases involving weak versioned symbols, we may wind up trying
1045 to merge a symbol with itself. Catch that here, to avoid the
1046 confusion that results if we try to override a symbol with
1047 itself. The additional tests catch cases like
1048 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1049 dynamic object, which we do want to handle here. */
1051 && (newweak
|| oldweak
)
1052 && ((abfd
->flags
& DYNAMIC
) == 0
1053 || !h
->def_regular
))
1056 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1057 respectively, is from a dynamic object. */
1059 newdyn
= (abfd
->flags
& DYNAMIC
) != 0;
1063 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
1064 else if (oldsec
!= NULL
)
1066 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1067 indices used by MIPS ELF. */
1068 olddyn
= (oldsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
1071 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1072 respectively, appear to be a definition rather than reference. */
1074 newdef
= !bfd_is_und_section (sec
) && !bfd_is_com_section (sec
);
1076 olddef
= (h
->root
.type
!= bfd_link_hash_undefined
1077 && h
->root
.type
!= bfd_link_hash_undefweak
1078 && h
->root
.type
!= bfd_link_hash_common
);
1080 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1081 respectively, appear to be a function. */
1083 newfunc
= (ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1084 && bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)));
1086 oldfunc
= (h
->type
!= STT_NOTYPE
1087 && bed
->is_function_type (h
->type
));
1089 /* When we try to create a default indirect symbol from the dynamic
1090 definition with the default version, we skip it if its type and
1091 the type of existing regular definition mismatch. We only do it
1092 if the existing regular definition won't be dynamic. */
1093 if (pold_alignment
== NULL
1095 && !info
->export_dynamic
1100 && (olddef
|| h
->root
.type
== bfd_link_hash_common
)
1101 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1102 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1103 && h
->type
!= STT_NOTYPE
1104 && !(newfunc
&& oldfunc
))
1110 /* Plugin symbol type isn't currently set. Stop bogus errors. */
1111 if (oldbfd
!= NULL
&& (oldbfd
->flags
& BFD_PLUGIN
) != 0)
1112 *type_change_ok
= TRUE
;
1114 /* Check TLS symbol. We don't check undefined symbol introduced by
1116 else if (oldbfd
!= NULL
1117 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1118 && (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
|| h
->type
== STT_TLS
))
1121 bfd_boolean ntdef
, tdef
;
1122 asection
*ntsec
, *tsec
;
1124 if (h
->type
== STT_TLS
)
1144 (*_bfd_error_handler
)
1145 (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1146 tbfd
, tsec
, ntbfd
, ntsec
, h
->root
.root
.string
);
1147 else if (!tdef
&& !ntdef
)
1148 (*_bfd_error_handler
)
1149 (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1150 tbfd
, ntbfd
, h
->root
.root
.string
);
1152 (*_bfd_error_handler
)
1153 (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1154 tbfd
, tsec
, ntbfd
, h
->root
.root
.string
);
1156 (*_bfd_error_handler
)
1157 (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1158 tbfd
, ntbfd
, ntsec
, h
->root
.root
.string
);
1160 bfd_set_error (bfd_error_bad_value
);
1164 /* We need to remember if a symbol has a definition in a dynamic
1165 object or is weak in all dynamic objects. Internal and hidden
1166 visibility will make it unavailable to dynamic objects. */
1169 _bfd_elf_mark_dynamic_def_weak (h
, sec
, bind
);
1171 _bfd_elf_mark_dynamic_def_weak (hi
, sec
, bind
);
1174 /* If the old symbol has non-default visibility, we ignore the new
1175 definition from a dynamic object. */
1177 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1178 && !bfd_is_und_section (sec
))
1181 /* Make sure this symbol is dynamic. */
1183 hi
->ref_dynamic
= 1;
1184 /* A protected symbol has external availability. Make sure it is
1185 recorded as dynamic.
1187 FIXME: Should we check type and size for protected symbol? */
1188 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1189 return bfd_elf_link_record_dynamic_symbol (info
, h
);
1194 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
1197 /* If the new symbol with non-default visibility comes from a
1198 relocatable file and the old definition comes from a dynamic
1199 object, we remove the old definition. */
1200 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1202 /* Handle the case where the old dynamic definition is
1203 default versioned. We need to copy the symbol info from
1204 the symbol with default version to the normal one if it
1205 was referenced before. */
1208 struct elf_link_hash_entry
*vh
= *sym_hash
;
1210 vh
->root
.type
= h
->root
.type
;
1211 h
->root
.type
= bfd_link_hash_indirect
;
1212 (*bed
->elf_backend_copy_indirect_symbol
) (info
, vh
, h
);
1213 /* Protected symbols will override the dynamic definition
1214 with default version. */
1215 if (ELF_ST_VISIBILITY (sym
->st_other
) == STV_PROTECTED
)
1217 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) vh
;
1218 vh
->dynamic_def
= 1;
1219 vh
->ref_dynamic
= 1;
1223 h
->root
.type
= vh
->root
.type
;
1224 vh
->ref_dynamic
= 0;
1225 /* We have to hide it here since it was made dynamic
1226 global with extra bits when the symbol info was
1227 copied from the old dynamic definition. */
1228 (*bed
->elf_backend_hide_symbol
) (info
, vh
, TRUE
);
1236 /* If the old symbol was undefined before, then it will still be
1237 on the undefs list. If the new symbol is undefined or
1238 common, we can't make it bfd_link_hash_new here, because new
1239 undefined or common symbols will be added to the undefs list
1240 by _bfd_generic_link_add_one_symbol. Symbols may not be
1241 added twice to the undefs list. Also, if the new symbol is
1242 undefweak then we don't want to lose the strong undef. */
1243 if (h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1245 h
->root
.type
= bfd_link_hash_undefined
;
1246 h
->root
.u
.undef
.abfd
= abfd
;
1250 h
->root
.type
= bfd_link_hash_new
;
1251 h
->root
.u
.undef
.abfd
= NULL
;
1254 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1256 /* If the new symbol is hidden or internal, completely undo
1257 any dynamic link state. */
1258 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1259 h
->forced_local
= 0;
1266 /* FIXME: Should we check type and size for protected symbol? */
1272 if (bind
== STB_GNU_UNIQUE
)
1273 h
->unique_global
= 1;
1275 /* If a new weak symbol definition comes from a regular file and the
1276 old symbol comes from a dynamic library, we treat the new one as
1277 strong. Similarly, an old weak symbol definition from a regular
1278 file is treated as strong when the new symbol comes from a dynamic
1279 library. Further, an old weak symbol from a dynamic library is
1280 treated as strong if the new symbol is from a dynamic library.
1281 This reflects the way glibc's ld.so works.
1283 Do this before setting *type_change_ok or *size_change_ok so that
1284 we warn properly when dynamic library symbols are overridden. */
1286 if (newdef
&& !newdyn
&& olddyn
)
1288 if (olddef
&& newdyn
)
1291 /* Allow changes between different types of function symbol. */
1292 if (newfunc
&& oldfunc
)
1293 *type_change_ok
= TRUE
;
1295 /* It's OK to change the type if either the existing symbol or the
1296 new symbol is weak. A type change is also OK if the old symbol
1297 is undefined and the new symbol is defined. */
1302 && h
->root
.type
== bfd_link_hash_undefined
))
1303 *type_change_ok
= TRUE
;
1305 /* It's OK to change the size if either the existing symbol or the
1306 new symbol is weak, or if the old symbol is undefined. */
1309 || h
->root
.type
== bfd_link_hash_undefined
)
1310 *size_change_ok
= TRUE
;
1312 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1313 symbol, respectively, appears to be a common symbol in a dynamic
1314 object. If a symbol appears in an uninitialized section, and is
1315 not weak, and is not a function, then it may be a common symbol
1316 which was resolved when the dynamic object was created. We want
1317 to treat such symbols specially, because they raise special
1318 considerations when setting the symbol size: if the symbol
1319 appears as a common symbol in a regular object, and the size in
1320 the regular object is larger, we must make sure that we use the
1321 larger size. This problematic case can always be avoided in C,
1322 but it must be handled correctly when using Fortran shared
1325 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1326 likewise for OLDDYNCOMMON and OLDDEF.
1328 Note that this test is just a heuristic, and that it is quite
1329 possible to have an uninitialized symbol in a shared object which
1330 is really a definition, rather than a common symbol. This could
1331 lead to some minor confusion when the symbol really is a common
1332 symbol in some regular object. However, I think it will be
1338 && (sec
->flags
& SEC_ALLOC
) != 0
1339 && (sec
->flags
& SEC_LOAD
) == 0
1342 newdyncommon
= TRUE
;
1344 newdyncommon
= FALSE
;
1348 && h
->root
.type
== bfd_link_hash_defined
1350 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1351 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
1354 olddyncommon
= TRUE
;
1356 olddyncommon
= FALSE
;
1358 /* We now know everything about the old and new symbols. We ask the
1359 backend to check if we can merge them. */
1360 if (bed
->merge_symbol
1361 && !bed
->merge_symbol (info
, sym_hash
, h
, sym
, psec
, pvalue
,
1362 pold_alignment
, skip
, override
,
1363 type_change_ok
, size_change_ok
,
1364 &newdyn
, &newdef
, &newdyncommon
, &newweak
,
1366 &olddyn
, &olddef
, &olddyncommon
, &oldweak
,
1370 /* If both the old and the new symbols look like common symbols in a
1371 dynamic object, set the size of the symbol to the larger of the
1376 && sym
->st_size
!= h
->size
)
1378 /* Since we think we have two common symbols, issue a multiple
1379 common warning if desired. Note that we only warn if the
1380 size is different. If the size is the same, we simply let
1381 the old symbol override the new one as normally happens with
1382 symbols defined in dynamic objects. */
1384 if (! ((*info
->callbacks
->multiple_common
)
1385 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1388 if (sym
->st_size
> h
->size
)
1389 h
->size
= sym
->st_size
;
1391 *size_change_ok
= TRUE
;
1394 /* If we are looking at a dynamic object, and we have found a
1395 definition, we need to see if the symbol was already defined by
1396 some other object. If so, we want to use the existing
1397 definition, and we do not want to report a multiple symbol
1398 definition error; we do this by clobbering *PSEC to be
1399 bfd_und_section_ptr.
1401 We treat a common symbol as a definition if the symbol in the
1402 shared library is a function, since common symbols always
1403 represent variables; this can cause confusion in principle, but
1404 any such confusion would seem to indicate an erroneous program or
1405 shared library. We also permit a common symbol in a regular
1406 object to override a weak symbol in a shared object. */
1411 || (h
->root
.type
== bfd_link_hash_common
1412 && (newweak
|| newfunc
))))
1416 newdyncommon
= FALSE
;
1418 *psec
= sec
= bfd_und_section_ptr
;
1419 *size_change_ok
= TRUE
;
1421 /* If we get here when the old symbol is a common symbol, then
1422 we are explicitly letting it override a weak symbol or
1423 function in a dynamic object, and we don't want to warn about
1424 a type change. If the old symbol is a defined symbol, a type
1425 change warning may still be appropriate. */
1427 if (h
->root
.type
== bfd_link_hash_common
)
1428 *type_change_ok
= TRUE
;
1431 /* Handle the special case of an old common symbol merging with a
1432 new symbol which looks like a common symbol in a shared object.
1433 We change *PSEC and *PVALUE to make the new symbol look like a
1434 common symbol, and let _bfd_generic_link_add_one_symbol do the
1438 && h
->root
.type
== bfd_link_hash_common
)
1442 newdyncommon
= FALSE
;
1443 *pvalue
= sym
->st_size
;
1444 *psec
= sec
= bed
->common_section (oldsec
);
1445 *size_change_ok
= TRUE
;
1448 /* Skip weak definitions of symbols that are already defined. */
1449 if (newdef
&& olddef
&& newweak
)
1451 /* Don't skip new non-IR weak syms. */
1452 if (!(oldbfd
!= NULL
1453 && (oldbfd
->flags
& BFD_PLUGIN
) != 0
1454 && (abfd
->flags
& BFD_PLUGIN
) == 0))
1457 /* Merge st_other. If the symbol already has a dynamic index,
1458 but visibility says it should not be visible, turn it into a
1460 elf_merge_st_other (abfd
, h
, sym
, newdef
, newdyn
);
1461 if (h
->dynindx
!= -1)
1462 switch (ELF_ST_VISIBILITY (h
->other
))
1466 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1471 /* If the old symbol is from a dynamic object, and the new symbol is
1472 a definition which is not from a dynamic object, then the new
1473 symbol overrides the old symbol. Symbols from regular files
1474 always take precedence over symbols from dynamic objects, even if
1475 they are defined after the dynamic object in the link.
1477 As above, we again permit a common symbol in a regular object to
1478 override a definition in a shared object if the shared object
1479 symbol is a function or is weak. */
1484 || (bfd_is_com_section (sec
)
1485 && (oldweak
|| oldfunc
)))
1490 /* Change the hash table entry to undefined, and let
1491 _bfd_generic_link_add_one_symbol do the right thing with the
1494 h
->root
.type
= bfd_link_hash_undefined
;
1495 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1496 *size_change_ok
= TRUE
;
1499 olddyncommon
= FALSE
;
1501 /* We again permit a type change when a common symbol may be
1502 overriding a function. */
1504 if (bfd_is_com_section (sec
))
1508 /* If a common symbol overrides a function, make sure
1509 that it isn't defined dynamically nor has type
1512 h
->type
= STT_NOTYPE
;
1514 *type_change_ok
= TRUE
;
1517 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1520 /* This union may have been set to be non-NULL when this symbol
1521 was seen in a dynamic object. We must force the union to be
1522 NULL, so that it is correct for a regular symbol. */
1523 h
->verinfo
.vertree
= NULL
;
1526 /* Handle the special case of a new common symbol merging with an
1527 old symbol that looks like it might be a common symbol defined in
1528 a shared object. Note that we have already handled the case in
1529 which a new common symbol should simply override the definition
1530 in the shared library. */
1533 && bfd_is_com_section (sec
)
1536 /* It would be best if we could set the hash table entry to a
1537 common symbol, but we don't know what to use for the section
1538 or the alignment. */
1539 if (! ((*info
->callbacks
->multiple_common
)
1540 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1543 /* If the presumed common symbol in the dynamic object is
1544 larger, pretend that the new symbol has its size. */
1546 if (h
->size
> *pvalue
)
1549 /* We need to remember the alignment required by the symbol
1550 in the dynamic object. */
1551 BFD_ASSERT (pold_alignment
);
1552 *pold_alignment
= h
->root
.u
.def
.section
->alignment_power
;
1555 olddyncommon
= FALSE
;
1557 h
->root
.type
= bfd_link_hash_undefined
;
1558 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1560 *size_change_ok
= TRUE
;
1561 *type_change_ok
= TRUE
;
1563 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1566 h
->verinfo
.vertree
= NULL
;
1571 /* Handle the case where we had a versioned symbol in a dynamic
1572 library and now find a definition in a normal object. In this
1573 case, we make the versioned symbol point to the normal one. */
1574 flip
->root
.type
= h
->root
.type
;
1575 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1576 h
->root
.type
= bfd_link_hash_indirect
;
1577 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1578 (*bed
->elf_backend_copy_indirect_symbol
) (info
, flip
, h
);
1582 flip
->ref_dynamic
= 1;
1589 /* This function is called to create an indirect symbol from the
1590 default for the symbol with the default version if needed. The
1591 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
1592 set DYNSYM if the new indirect symbol is dynamic. */
1595 _bfd_elf_add_default_symbol (bfd
*abfd
,
1596 struct bfd_link_info
*info
,
1597 struct elf_link_hash_entry
*h
,
1599 Elf_Internal_Sym
*sym
,
1602 bfd_boolean
*dynsym
,
1603 bfd_boolean override
)
1605 bfd_boolean type_change_ok
;
1606 bfd_boolean size_change_ok
;
1609 struct elf_link_hash_entry
*hi
;
1610 struct bfd_link_hash_entry
*bh
;
1611 const struct elf_backend_data
*bed
;
1612 bfd_boolean collect
;
1613 bfd_boolean dynamic
;
1615 size_t len
, shortlen
;
1618 /* If this symbol has a version, and it is the default version, we
1619 create an indirect symbol from the default name to the fully
1620 decorated name. This will cause external references which do not
1621 specify a version to be bound to this version of the symbol. */
1622 p
= strchr (name
, ELF_VER_CHR
);
1623 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
1628 /* We are overridden by an old definition. We need to check if we
1629 need to create the indirect symbol from the default name. */
1630 hi
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
,
1632 BFD_ASSERT (hi
!= NULL
);
1635 while (hi
->root
.type
== bfd_link_hash_indirect
1636 || hi
->root
.type
== bfd_link_hash_warning
)
1638 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1644 bed
= get_elf_backend_data (abfd
);
1645 collect
= bed
->collect
;
1646 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1648 shortlen
= p
- name
;
1649 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1650 if (shortname
== NULL
)
1652 memcpy (shortname
, name
, shortlen
);
1653 shortname
[shortlen
] = '\0';
1655 /* We are going to create a new symbol. Merge it with any existing
1656 symbol with this name. For the purposes of the merge, act as
1657 though we were defining the symbol we just defined, although we
1658 actually going to define an indirect symbol. */
1659 type_change_ok
= FALSE
;
1660 size_change_ok
= FALSE
;
1662 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1663 NULL
, &hi
, &skip
, &override
,
1664 &type_change_ok
, &size_change_ok
))
1673 if (! (_bfd_generic_link_add_one_symbol
1674 (info
, abfd
, shortname
, BSF_INDIRECT
, bfd_ind_section_ptr
,
1675 0, name
, FALSE
, collect
, &bh
)))
1677 hi
= (struct elf_link_hash_entry
*) bh
;
1681 /* In this case the symbol named SHORTNAME is overriding the
1682 indirect symbol we want to add. We were planning on making
1683 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1684 is the name without a version. NAME is the fully versioned
1685 name, and it is the default version.
1687 Overriding means that we already saw a definition for the
1688 symbol SHORTNAME in a regular object, and it is overriding
1689 the symbol defined in the dynamic object.
1691 When this happens, we actually want to change NAME, the
1692 symbol we just added, to refer to SHORTNAME. This will cause
1693 references to NAME in the shared object to become references
1694 to SHORTNAME in the regular object. This is what we expect
1695 when we override a function in a shared object: that the
1696 references in the shared object will be mapped to the
1697 definition in the regular object. */
1699 while (hi
->root
.type
== bfd_link_hash_indirect
1700 || hi
->root
.type
== bfd_link_hash_warning
)
1701 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1703 h
->root
.type
= bfd_link_hash_indirect
;
1704 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1708 hi
->ref_dynamic
= 1;
1712 if (! bfd_elf_link_record_dynamic_symbol (info
, hi
))
1717 /* Now set HI to H, so that the following code will set the
1718 other fields correctly. */
1722 /* Check if HI is a warning symbol. */
1723 if (hi
->root
.type
== bfd_link_hash_warning
)
1724 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1726 /* If there is a duplicate definition somewhere, then HI may not
1727 point to an indirect symbol. We will have reported an error to
1728 the user in that case. */
1730 if (hi
->root
.type
== bfd_link_hash_indirect
)
1732 struct elf_link_hash_entry
*ht
;
1734 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1735 (*bed
->elf_backend_copy_indirect_symbol
) (info
, ht
, hi
);
1737 /* See if the new flags lead us to realize that the symbol must
1743 if (! info
->executable
1750 if (hi
->ref_regular
)
1756 /* We also need to define an indirection from the nondefault version
1760 len
= strlen (name
);
1761 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, len
);
1762 if (shortname
== NULL
)
1764 memcpy (shortname
, name
, shortlen
);
1765 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1767 /* Once again, merge with any existing symbol. */
1768 type_change_ok
= FALSE
;
1769 size_change_ok
= FALSE
;
1771 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1772 NULL
, &hi
, &skip
, &override
,
1773 &type_change_ok
, &size_change_ok
))
1781 /* Here SHORTNAME is a versioned name, so we don't expect to see
1782 the type of override we do in the case above unless it is
1783 overridden by a versioned definition. */
1784 if (hi
->root
.type
!= bfd_link_hash_defined
1785 && hi
->root
.type
!= bfd_link_hash_defweak
)
1786 (*_bfd_error_handler
)
1787 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1793 if (! (_bfd_generic_link_add_one_symbol
1794 (info
, abfd
, shortname
, BSF_INDIRECT
,
1795 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
1797 hi
= (struct elf_link_hash_entry
*) bh
;
1799 /* If there is a duplicate definition somewhere, then HI may not
1800 point to an indirect symbol. We will have reported an error
1801 to the user in that case. */
1803 if (hi
->root
.type
== bfd_link_hash_indirect
)
1805 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
1807 /* See if the new flags lead us to realize that the symbol
1813 if (! info
->executable
1819 if (hi
->ref_regular
)
1829 /* This routine is used to export all defined symbols into the dynamic
1830 symbol table. It is called via elf_link_hash_traverse. */
1833 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
1835 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1837 /* Ignore indirect symbols. These are added by the versioning code. */
1838 if (h
->root
.type
== bfd_link_hash_indirect
)
1841 /* Ignore this if we won't export it. */
1842 if (!eif
->info
->export_dynamic
&& !h
->dynamic
)
1845 if (h
->dynindx
== -1
1846 && (h
->def_regular
|| h
->ref_regular
)
1847 && ! bfd_hide_sym_by_version (eif
->info
->version_info
,
1848 h
->root
.root
.string
))
1850 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1860 /* Look through the symbols which are defined in other shared
1861 libraries and referenced here. Update the list of version
1862 dependencies. This will be put into the .gnu.version_r section.
1863 This function is called via elf_link_hash_traverse. */
1866 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1869 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
1870 Elf_Internal_Verneed
*t
;
1871 Elf_Internal_Vernaux
*a
;
1874 /* We only care about symbols defined in shared objects with version
1879 || h
->verinfo
.verdef
== NULL
)
1882 /* See if we already know about this version. */
1883 for (t
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1887 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1890 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1891 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1897 /* This is a new version. Add it to tree we are building. */
1902 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1905 rinfo
->failed
= TRUE
;
1909 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1910 t
->vn_nextref
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1911 elf_tdata (rinfo
->info
->output_bfd
)->verref
= t
;
1915 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1918 rinfo
->failed
= TRUE
;
1922 /* Note that we are copying a string pointer here, and testing it
1923 above. If bfd_elf_string_from_elf_section is ever changed to
1924 discard the string data when low in memory, this will have to be
1926 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1928 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1929 a
->vna_nextptr
= t
->vn_auxptr
;
1931 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1934 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1941 /* Figure out appropriate versions for all the symbols. We may not
1942 have the version number script until we have read all of the input
1943 files, so until that point we don't know which symbols should be
1944 local. This function is called via elf_link_hash_traverse. */
1947 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1949 struct elf_info_failed
*sinfo
;
1950 struct bfd_link_info
*info
;
1951 const struct elf_backend_data
*bed
;
1952 struct elf_info_failed eif
;
1956 sinfo
= (struct elf_info_failed
*) data
;
1959 /* Fix the symbol flags. */
1962 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1965 sinfo
->failed
= TRUE
;
1969 /* We only need version numbers for symbols defined in regular
1971 if (!h
->def_regular
)
1974 bed
= get_elf_backend_data (info
->output_bfd
);
1975 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1976 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1978 struct bfd_elf_version_tree
*t
;
1983 /* There are two consecutive ELF_VER_CHR characters if this is
1984 not a hidden symbol. */
1986 if (*p
== ELF_VER_CHR
)
1992 /* If there is no version string, we can just return out. */
2000 /* Look for the version. If we find it, it is no longer weak. */
2001 for (t
= sinfo
->info
->version_info
; t
!= NULL
; t
= t
->next
)
2003 if (strcmp (t
->name
, p
) == 0)
2007 struct bfd_elf_version_expr
*d
;
2009 len
= p
- h
->root
.root
.string
;
2010 alc
= (char *) bfd_malloc (len
);
2013 sinfo
->failed
= TRUE
;
2016 memcpy (alc
, h
->root
.root
.string
, len
- 1);
2017 alc
[len
- 1] = '\0';
2018 if (alc
[len
- 2] == ELF_VER_CHR
)
2019 alc
[len
- 2] = '\0';
2021 h
->verinfo
.vertree
= t
;
2025 if (t
->globals
.list
!= NULL
)
2026 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
2028 /* See if there is anything to force this symbol to
2030 if (d
== NULL
&& t
->locals
.list
!= NULL
)
2032 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
2035 && ! info
->export_dynamic
)
2036 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2044 /* If we are building an application, we need to create a
2045 version node for this version. */
2046 if (t
== NULL
&& info
->executable
)
2048 struct bfd_elf_version_tree
**pp
;
2051 /* If we aren't going to export this symbol, we don't need
2052 to worry about it. */
2053 if (h
->dynindx
== -1)
2057 t
= (struct bfd_elf_version_tree
*) bfd_zalloc (info
->output_bfd
, amt
);
2060 sinfo
->failed
= TRUE
;
2065 t
->name_indx
= (unsigned int) -1;
2069 /* Don't count anonymous version tag. */
2070 if (sinfo
->info
->version_info
!= NULL
2071 && sinfo
->info
->version_info
->vernum
== 0)
2073 for (pp
= &sinfo
->info
->version_info
;
2077 t
->vernum
= version_index
;
2081 h
->verinfo
.vertree
= t
;
2085 /* We could not find the version for a symbol when
2086 generating a shared archive. Return an error. */
2087 (*_bfd_error_handler
)
2088 (_("%B: version node not found for symbol %s"),
2089 info
->output_bfd
, h
->root
.root
.string
);
2090 bfd_set_error (bfd_error_bad_value
);
2091 sinfo
->failed
= TRUE
;
2099 /* If we don't have a version for this symbol, see if we can find
2101 if (h
->verinfo
.vertree
== NULL
&& sinfo
->info
->version_info
!= NULL
)
2106 = bfd_find_version_for_sym (sinfo
->info
->version_info
,
2107 h
->root
.root
.string
, &hide
);
2108 if (h
->verinfo
.vertree
!= NULL
&& hide
)
2109 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2115 /* Read and swap the relocs from the section indicated by SHDR. This
2116 may be either a REL or a RELA section. The relocations are
2117 translated into RELA relocations and stored in INTERNAL_RELOCS,
2118 which should have already been allocated to contain enough space.
2119 The EXTERNAL_RELOCS are a buffer where the external form of the
2120 relocations should be stored.
2122 Returns FALSE if something goes wrong. */
2125 elf_link_read_relocs_from_section (bfd
*abfd
,
2127 Elf_Internal_Shdr
*shdr
,
2128 void *external_relocs
,
2129 Elf_Internal_Rela
*internal_relocs
)
2131 const struct elf_backend_data
*bed
;
2132 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2133 const bfd_byte
*erela
;
2134 const bfd_byte
*erelaend
;
2135 Elf_Internal_Rela
*irela
;
2136 Elf_Internal_Shdr
*symtab_hdr
;
2139 /* Position ourselves at the start of the section. */
2140 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2143 /* Read the relocations. */
2144 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
2147 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2148 nsyms
= NUM_SHDR_ENTRIES (symtab_hdr
);
2150 bed
= get_elf_backend_data (abfd
);
2152 /* Convert the external relocations to the internal format. */
2153 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2154 swap_in
= bed
->s
->swap_reloc_in
;
2155 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2156 swap_in
= bed
->s
->swap_reloca_in
;
2159 bfd_set_error (bfd_error_wrong_format
);
2163 erela
= (const bfd_byte
*) external_relocs
;
2164 erelaend
= erela
+ shdr
->sh_size
;
2165 irela
= internal_relocs
;
2166 while (erela
< erelaend
)
2170 (*swap_in
) (abfd
, erela
, irela
);
2171 r_symndx
= ELF32_R_SYM (irela
->r_info
);
2172 if (bed
->s
->arch_size
== 64)
2176 if ((size_t) r_symndx
>= nsyms
)
2178 (*_bfd_error_handler
)
2179 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2180 " for offset 0x%lx in section `%A'"),
2182 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2183 bfd_set_error (bfd_error_bad_value
);
2187 else if (r_symndx
!= STN_UNDEF
)
2189 (*_bfd_error_handler
)
2190 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2191 " when the object file has no symbol table"),
2193 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2194 bfd_set_error (bfd_error_bad_value
);
2197 irela
+= bed
->s
->int_rels_per_ext_rel
;
2198 erela
+= shdr
->sh_entsize
;
2204 /* Read and swap the relocs for a section O. They may have been
2205 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2206 not NULL, they are used as buffers to read into. They are known to
2207 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2208 the return value is allocated using either malloc or bfd_alloc,
2209 according to the KEEP_MEMORY argument. If O has two relocation
2210 sections (both REL and RELA relocations), then the REL_HDR
2211 relocations will appear first in INTERNAL_RELOCS, followed by the
2212 RELA_HDR relocations. */
2215 _bfd_elf_link_read_relocs (bfd
*abfd
,
2217 void *external_relocs
,
2218 Elf_Internal_Rela
*internal_relocs
,
2219 bfd_boolean keep_memory
)
2221 void *alloc1
= NULL
;
2222 Elf_Internal_Rela
*alloc2
= NULL
;
2223 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2224 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
2225 Elf_Internal_Rela
*internal_rela_relocs
;
2227 if (esdo
->relocs
!= NULL
)
2228 return esdo
->relocs
;
2230 if (o
->reloc_count
== 0)
2233 if (internal_relocs
== NULL
)
2237 size
= o
->reloc_count
;
2238 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
2240 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2242 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2243 if (internal_relocs
== NULL
)
2247 if (external_relocs
== NULL
)
2249 bfd_size_type size
= 0;
2252 size
+= esdo
->rel
.hdr
->sh_size
;
2254 size
+= esdo
->rela
.hdr
->sh_size
;
2256 alloc1
= bfd_malloc (size
);
2259 external_relocs
= alloc1
;
2262 internal_rela_relocs
= internal_relocs
;
2265 if (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rel
.hdr
,
2269 external_relocs
= (((bfd_byte
*) external_relocs
)
2270 + esdo
->rel
.hdr
->sh_size
);
2271 internal_rela_relocs
+= (NUM_SHDR_ENTRIES (esdo
->rel
.hdr
)
2272 * bed
->s
->int_rels_per_ext_rel
);
2276 && (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rela
.hdr
,
2278 internal_rela_relocs
)))
2281 /* Cache the results for next time, if we can. */
2283 esdo
->relocs
= internal_relocs
;
2288 /* Don't free alloc2, since if it was allocated we are passing it
2289 back (under the name of internal_relocs). */
2291 return internal_relocs
;
2299 bfd_release (abfd
, alloc2
);
2306 /* Compute the size of, and allocate space for, REL_HDR which is the
2307 section header for a section containing relocations for O. */
2310 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2311 struct bfd_elf_section_reloc_data
*reldata
)
2313 Elf_Internal_Shdr
*rel_hdr
= reldata
->hdr
;
2315 /* That allows us to calculate the size of the section. */
2316 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reldata
->count
;
2318 /* The contents field must last into write_object_contents, so we
2319 allocate it with bfd_alloc rather than malloc. Also since we
2320 cannot be sure that the contents will actually be filled in,
2321 we zero the allocated space. */
2322 rel_hdr
->contents
= (unsigned char *) bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2323 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2326 if (reldata
->hashes
== NULL
&& reldata
->count
)
2328 struct elf_link_hash_entry
**p
;
2330 p
= (struct elf_link_hash_entry
**)
2331 bfd_zmalloc (reldata
->count
* sizeof (struct elf_link_hash_entry
*));
2335 reldata
->hashes
= p
;
2341 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2342 originated from the section given by INPUT_REL_HDR) to the
2346 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2347 asection
*input_section
,
2348 Elf_Internal_Shdr
*input_rel_hdr
,
2349 Elf_Internal_Rela
*internal_relocs
,
2350 struct elf_link_hash_entry
**rel_hash
2353 Elf_Internal_Rela
*irela
;
2354 Elf_Internal_Rela
*irelaend
;
2356 struct bfd_elf_section_reloc_data
*output_reldata
;
2357 asection
*output_section
;
2358 const struct elf_backend_data
*bed
;
2359 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2360 struct bfd_elf_section_data
*esdo
;
2362 output_section
= input_section
->output_section
;
2364 bed
= get_elf_backend_data (output_bfd
);
2365 esdo
= elf_section_data (output_section
);
2366 if (esdo
->rel
.hdr
&& esdo
->rel
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2368 output_reldata
= &esdo
->rel
;
2369 swap_out
= bed
->s
->swap_reloc_out
;
2371 else if (esdo
->rela
.hdr
2372 && esdo
->rela
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2374 output_reldata
= &esdo
->rela
;
2375 swap_out
= bed
->s
->swap_reloca_out
;
2379 (*_bfd_error_handler
)
2380 (_("%B: relocation size mismatch in %B section %A"),
2381 output_bfd
, input_section
->owner
, input_section
);
2382 bfd_set_error (bfd_error_wrong_format
);
2386 erel
= output_reldata
->hdr
->contents
;
2387 erel
+= output_reldata
->count
* input_rel_hdr
->sh_entsize
;
2388 irela
= internal_relocs
;
2389 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2390 * bed
->s
->int_rels_per_ext_rel
);
2391 while (irela
< irelaend
)
2393 (*swap_out
) (output_bfd
, irela
, erel
);
2394 irela
+= bed
->s
->int_rels_per_ext_rel
;
2395 erel
+= input_rel_hdr
->sh_entsize
;
2398 /* Bump the counter, so that we know where to add the next set of
2400 output_reldata
->count
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2405 /* Make weak undefined symbols in PIE dynamic. */
2408 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info
*info
,
2409 struct elf_link_hash_entry
*h
)
2413 && h
->root
.type
== bfd_link_hash_undefweak
)
2414 return bfd_elf_link_record_dynamic_symbol (info
, h
);
2419 /* Fix up the flags for a symbol. This handles various cases which
2420 can only be fixed after all the input files are seen. This is
2421 currently called by both adjust_dynamic_symbol and
2422 assign_sym_version, which is unnecessary but perhaps more robust in
2423 the face of future changes. */
2426 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2427 struct elf_info_failed
*eif
)
2429 const struct elf_backend_data
*bed
;
2431 /* If this symbol was mentioned in a non-ELF file, try to set
2432 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2433 permit a non-ELF file to correctly refer to a symbol defined in
2434 an ELF dynamic object. */
2437 while (h
->root
.type
== bfd_link_hash_indirect
)
2438 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2440 if (h
->root
.type
!= bfd_link_hash_defined
2441 && h
->root
.type
!= bfd_link_hash_defweak
)
2444 h
->ref_regular_nonweak
= 1;
2448 if (h
->root
.u
.def
.section
->owner
!= NULL
2449 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2450 == bfd_target_elf_flavour
))
2453 h
->ref_regular_nonweak
= 1;
2459 if (h
->dynindx
== -1
2463 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2472 /* Unfortunately, NON_ELF is only correct if the symbol
2473 was first seen in a non-ELF file. Fortunately, if the symbol
2474 was first seen in an ELF file, we're probably OK unless the
2475 symbol was defined in a non-ELF file. Catch that case here.
2476 FIXME: We're still in trouble if the symbol was first seen in
2477 a dynamic object, and then later in a non-ELF regular object. */
2478 if ((h
->root
.type
== bfd_link_hash_defined
2479 || h
->root
.type
== bfd_link_hash_defweak
)
2481 && (h
->root
.u
.def
.section
->owner
!= NULL
2482 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2483 != bfd_target_elf_flavour
)
2484 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2485 && !h
->def_dynamic
)))
2489 /* Backend specific symbol fixup. */
2490 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2491 if (bed
->elf_backend_fixup_symbol
2492 && !(*bed
->elf_backend_fixup_symbol
) (eif
->info
, h
))
2495 /* If this is a final link, and the symbol was defined as a common
2496 symbol in a regular object file, and there was no definition in
2497 any dynamic object, then the linker will have allocated space for
2498 the symbol in a common section but the DEF_REGULAR
2499 flag will not have been set. */
2500 if (h
->root
.type
== bfd_link_hash_defined
2504 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2507 /* If -Bsymbolic was used (which means to bind references to global
2508 symbols to the definition within the shared object), and this
2509 symbol was defined in a regular object, then it actually doesn't
2510 need a PLT entry. Likewise, if the symbol has non-default
2511 visibility. If the symbol has hidden or internal visibility, we
2512 will force it local. */
2514 && eif
->info
->shared
2515 && is_elf_hash_table (eif
->info
->hash
)
2516 && (SYMBOLIC_BIND (eif
->info
, h
)
2517 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2520 bfd_boolean force_local
;
2522 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2523 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2524 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2527 /* If a weak undefined symbol has non-default visibility, we also
2528 hide it from the dynamic linker. */
2529 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2530 && h
->root
.type
== bfd_link_hash_undefweak
)
2531 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2533 /* If this is a weak defined symbol in a dynamic object, and we know
2534 the real definition in the dynamic object, copy interesting flags
2535 over to the real definition. */
2536 if (h
->u
.weakdef
!= NULL
)
2538 /* If the real definition is defined by a regular object file,
2539 don't do anything special. See the longer description in
2540 _bfd_elf_adjust_dynamic_symbol, below. */
2541 if (h
->u
.weakdef
->def_regular
)
2542 h
->u
.weakdef
= NULL
;
2545 struct elf_link_hash_entry
*weakdef
= h
->u
.weakdef
;
2547 while (h
->root
.type
== bfd_link_hash_indirect
)
2548 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2550 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2551 || h
->root
.type
== bfd_link_hash_defweak
);
2552 BFD_ASSERT (weakdef
->def_dynamic
);
2553 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2554 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2555 (*bed
->elf_backend_copy_indirect_symbol
) (eif
->info
, weakdef
, h
);
2562 /* Make the backend pick a good value for a dynamic symbol. This is
2563 called via elf_link_hash_traverse, and also calls itself
2567 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2569 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2571 const struct elf_backend_data
*bed
;
2573 if (! is_elf_hash_table (eif
->info
->hash
))
2576 /* Ignore indirect symbols. These are added by the versioning code. */
2577 if (h
->root
.type
== bfd_link_hash_indirect
)
2580 /* Fix the symbol flags. */
2581 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2584 /* If this symbol does not require a PLT entry, and it is not
2585 defined by a dynamic object, or is not referenced by a regular
2586 object, ignore it. We do have to handle a weak defined symbol,
2587 even if no regular object refers to it, if we decided to add it
2588 to the dynamic symbol table. FIXME: Do we normally need to worry
2589 about symbols which are defined by one dynamic object and
2590 referenced by another one? */
2592 && h
->type
!= STT_GNU_IFUNC
2596 && (h
->u
.weakdef
== NULL
|| h
->u
.weakdef
->dynindx
== -1))))
2598 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
2602 /* If we've already adjusted this symbol, don't do it again. This
2603 can happen via a recursive call. */
2604 if (h
->dynamic_adjusted
)
2607 /* Don't look at this symbol again. Note that we must set this
2608 after checking the above conditions, because we may look at a
2609 symbol once, decide not to do anything, and then get called
2610 recursively later after REF_REGULAR is set below. */
2611 h
->dynamic_adjusted
= 1;
2613 /* If this is a weak definition, and we know a real definition, and
2614 the real symbol is not itself defined by a regular object file,
2615 then get a good value for the real definition. We handle the
2616 real symbol first, for the convenience of the backend routine.
2618 Note that there is a confusing case here. If the real definition
2619 is defined by a regular object file, we don't get the real symbol
2620 from the dynamic object, but we do get the weak symbol. If the
2621 processor backend uses a COPY reloc, then if some routine in the
2622 dynamic object changes the real symbol, we will not see that
2623 change in the corresponding weak symbol. This is the way other
2624 ELF linkers work as well, and seems to be a result of the shared
2627 I will clarify this issue. Most SVR4 shared libraries define the
2628 variable _timezone and define timezone as a weak synonym. The
2629 tzset call changes _timezone. If you write
2630 extern int timezone;
2632 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2633 you might expect that, since timezone is a synonym for _timezone,
2634 the same number will print both times. However, if the processor
2635 backend uses a COPY reloc, then actually timezone will be copied
2636 into your process image, and, since you define _timezone
2637 yourself, _timezone will not. Thus timezone and _timezone will
2638 wind up at different memory locations. The tzset call will set
2639 _timezone, leaving timezone unchanged. */
2641 if (h
->u
.weakdef
!= NULL
)
2643 /* If we get to this point, there is an implicit reference to
2644 H->U.WEAKDEF by a regular object file via the weak symbol H. */
2645 h
->u
.weakdef
->ref_regular
= 1;
2647 /* Ensure that the backend adjust_dynamic_symbol function sees
2648 H->U.WEAKDEF before H by recursively calling ourselves. */
2649 if (! _bfd_elf_adjust_dynamic_symbol (h
->u
.weakdef
, eif
))
2653 /* If a symbol has no type and no size and does not require a PLT
2654 entry, then we are probably about to do the wrong thing here: we
2655 are probably going to create a COPY reloc for an empty object.
2656 This case can arise when a shared object is built with assembly
2657 code, and the assembly code fails to set the symbol type. */
2659 && h
->type
== STT_NOTYPE
2661 (*_bfd_error_handler
)
2662 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2663 h
->root
.root
.string
);
2665 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2666 bed
= get_elf_backend_data (dynobj
);
2668 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2677 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2681 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry
*h
,
2684 unsigned int power_of_two
;
2686 asection
*sec
= h
->root
.u
.def
.section
;
2688 /* The section aligment of definition is the maximum alignment
2689 requirement of symbols defined in the section. Since we don't
2690 know the symbol alignment requirement, we start with the
2691 maximum alignment and check low bits of the symbol address
2692 for the minimum alignment. */
2693 power_of_two
= bfd_get_section_alignment (sec
->owner
, sec
);
2694 mask
= ((bfd_vma
) 1 << power_of_two
) - 1;
2695 while ((h
->root
.u
.def
.value
& mask
) != 0)
2701 if (power_of_two
> bfd_get_section_alignment (dynbss
->owner
,
2704 /* Adjust the section alignment if needed. */
2705 if (! bfd_set_section_alignment (dynbss
->owner
, dynbss
,
2710 /* We make sure that the symbol will be aligned properly. */
2711 dynbss
->size
= BFD_ALIGN (dynbss
->size
, mask
+ 1);
2713 /* Define the symbol as being at this point in DYNBSS. */
2714 h
->root
.u
.def
.section
= dynbss
;
2715 h
->root
.u
.def
.value
= dynbss
->size
;
2717 /* Increment the size of DYNBSS to make room for the symbol. */
2718 dynbss
->size
+= h
->size
;
2723 /* Adjust all external symbols pointing into SEC_MERGE sections
2724 to reflect the object merging within the sections. */
2727 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2731 if ((h
->root
.type
== bfd_link_hash_defined
2732 || h
->root
.type
== bfd_link_hash_defweak
)
2733 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2734 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
2736 bfd
*output_bfd
= (bfd
*) data
;
2738 h
->root
.u
.def
.value
=
2739 _bfd_merged_section_offset (output_bfd
,
2740 &h
->root
.u
.def
.section
,
2741 elf_section_data (sec
)->sec_info
,
2742 h
->root
.u
.def
.value
);
2748 /* Returns false if the symbol referred to by H should be considered
2749 to resolve local to the current module, and true if it should be
2750 considered to bind dynamically. */
2753 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2754 struct bfd_link_info
*info
,
2755 bfd_boolean not_local_protected
)
2757 bfd_boolean binding_stays_local_p
;
2758 const struct elf_backend_data
*bed
;
2759 struct elf_link_hash_table
*hash_table
;
2764 while (h
->root
.type
== bfd_link_hash_indirect
2765 || h
->root
.type
== bfd_link_hash_warning
)
2766 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2768 /* If it was forced local, then clearly it's not dynamic. */
2769 if (h
->dynindx
== -1)
2771 if (h
->forced_local
)
2774 /* Identify the cases where name binding rules say that a
2775 visible symbol resolves locally. */
2776 binding_stays_local_p
= info
->executable
|| SYMBOLIC_BIND (info
, h
);
2778 switch (ELF_ST_VISIBILITY (h
->other
))
2785 hash_table
= elf_hash_table (info
);
2786 if (!is_elf_hash_table (hash_table
))
2789 bed
= get_elf_backend_data (hash_table
->dynobj
);
2791 /* Proper resolution for function pointer equality may require
2792 that these symbols perhaps be resolved dynamically, even though
2793 we should be resolving them to the current module. */
2794 if (!not_local_protected
|| !bed
->is_function_type (h
->type
))
2795 binding_stays_local_p
= TRUE
;
2802 /* If it isn't defined locally, then clearly it's dynamic. */
2803 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
2806 /* Otherwise, the symbol is dynamic if binding rules don't tell
2807 us that it remains local. */
2808 return !binding_stays_local_p
;
2811 /* Return true if the symbol referred to by H should be considered
2812 to resolve local to the current module, and false otherwise. Differs
2813 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2814 undefined symbols. The two functions are virtually identical except
2815 for the place where forced_local and dynindx == -1 are tested. If
2816 either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2817 the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2818 the symbol is local only for defined symbols.
2819 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2820 !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2821 treatment of undefined weak symbols. For those that do not make
2822 undefined weak symbols dynamic, both functions may return false. */
2825 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2826 struct bfd_link_info
*info
,
2827 bfd_boolean local_protected
)
2829 const struct elf_backend_data
*bed
;
2830 struct elf_link_hash_table
*hash_table
;
2832 /* If it's a local sym, of course we resolve locally. */
2836 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
2837 if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
2838 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
2841 /* Common symbols that become definitions don't get the DEF_REGULAR
2842 flag set, so test it first, and don't bail out. */
2843 if (ELF_COMMON_DEF_P (h
))
2845 /* If we don't have a definition in a regular file, then we can't
2846 resolve locally. The sym is either undefined or dynamic. */
2847 else if (!h
->def_regular
)
2850 /* Forced local symbols resolve locally. */
2851 if (h
->forced_local
)
2854 /* As do non-dynamic symbols. */
2855 if (h
->dynindx
== -1)
2858 /* At this point, we know the symbol is defined and dynamic. In an
2859 executable it must resolve locally, likewise when building symbolic
2860 shared libraries. */
2861 if (info
->executable
|| SYMBOLIC_BIND (info
, h
))
2864 /* Now deal with defined dynamic symbols in shared libraries. Ones
2865 with default visibility might not resolve locally. */
2866 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2869 hash_table
= elf_hash_table (info
);
2870 if (!is_elf_hash_table (hash_table
))
2873 bed
= get_elf_backend_data (hash_table
->dynobj
);
2875 /* STV_PROTECTED non-function symbols are local. */
2876 if (!bed
->is_function_type (h
->type
))
2879 /* Function pointer equality tests may require that STV_PROTECTED
2880 symbols be treated as dynamic symbols. If the address of a
2881 function not defined in an executable is set to that function's
2882 plt entry in the executable, then the address of the function in
2883 a shared library must also be the plt entry in the executable. */
2884 return local_protected
;
2887 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2888 aligned. Returns the first TLS output section. */
2890 struct bfd_section
*
2891 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
2893 struct bfd_section
*sec
, *tls
;
2894 unsigned int align
= 0;
2896 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2897 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
2901 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
2902 if (sec
->alignment_power
> align
)
2903 align
= sec
->alignment_power
;
2905 elf_hash_table (info
)->tls_sec
= tls
;
2907 /* Ensure the alignment of the first section is the largest alignment,
2908 so that the tls segment starts aligned. */
2910 tls
->alignment_power
= align
;
2915 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2917 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
2918 Elf_Internal_Sym
*sym
)
2920 const struct elf_backend_data
*bed
;
2922 /* Local symbols do not count, but target specific ones might. */
2923 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
2924 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
2927 bed
= get_elf_backend_data (abfd
);
2928 /* Function symbols do not count. */
2929 if (bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)))
2932 /* If the section is undefined, then so is the symbol. */
2933 if (sym
->st_shndx
== SHN_UNDEF
)
2936 /* If the symbol is defined in the common section, then
2937 it is a common definition and so does not count. */
2938 if (bed
->common_definition (sym
))
2941 /* If the symbol is in a target specific section then we
2942 must rely upon the backend to tell us what it is. */
2943 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
2944 /* FIXME - this function is not coded yet:
2946 return _bfd_is_global_symbol_definition (abfd, sym);
2948 Instead for now assume that the definition is not global,
2949 Even if this is wrong, at least the linker will behave
2950 in the same way that it used to do. */
2956 /* Search the symbol table of the archive element of the archive ABFD
2957 whose archive map contains a mention of SYMDEF, and determine if
2958 the symbol is defined in this element. */
2960 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
2962 Elf_Internal_Shdr
* hdr
;
2963 bfd_size_type symcount
;
2964 bfd_size_type extsymcount
;
2965 bfd_size_type extsymoff
;
2966 Elf_Internal_Sym
*isymbuf
;
2967 Elf_Internal_Sym
*isym
;
2968 Elf_Internal_Sym
*isymend
;
2971 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
2975 if (! bfd_check_format (abfd
, bfd_object
))
2978 /* If we have already included the element containing this symbol in the
2979 link then we do not need to include it again. Just claim that any symbol
2980 it contains is not a definition, so that our caller will not decide to
2981 (re)include this element. */
2982 if (abfd
->archive_pass
)
2985 /* Select the appropriate symbol table. */
2986 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
2987 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2989 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2991 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2993 /* The sh_info field of the symtab header tells us where the
2994 external symbols start. We don't care about the local symbols. */
2995 if (elf_bad_symtab (abfd
))
2997 extsymcount
= symcount
;
3002 extsymcount
= symcount
- hdr
->sh_info
;
3003 extsymoff
= hdr
->sh_info
;
3006 if (extsymcount
== 0)
3009 /* Read in the symbol table. */
3010 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3012 if (isymbuf
== NULL
)
3015 /* Scan the symbol table looking for SYMDEF. */
3017 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
3021 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3026 if (strcmp (name
, symdef
->name
) == 0)
3028 result
= is_global_data_symbol_definition (abfd
, isym
);
3038 /* Add an entry to the .dynamic table. */
3041 _bfd_elf_add_dynamic_entry (struct bfd_link_info
*info
,
3045 struct elf_link_hash_table
*hash_table
;
3046 const struct elf_backend_data
*bed
;
3048 bfd_size_type newsize
;
3049 bfd_byte
*newcontents
;
3050 Elf_Internal_Dyn dyn
;
3052 hash_table
= elf_hash_table (info
);
3053 if (! is_elf_hash_table (hash_table
))
3056 bed
= get_elf_backend_data (hash_table
->dynobj
);
3057 s
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3058 BFD_ASSERT (s
!= NULL
);
3060 newsize
= s
->size
+ bed
->s
->sizeof_dyn
;
3061 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
3062 if (newcontents
== NULL
)
3066 dyn
.d_un
.d_val
= val
;
3067 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
, newcontents
+ s
->size
);
3070 s
->contents
= newcontents
;
3075 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3076 otherwise just check whether one already exists. Returns -1 on error,
3077 1 if a DT_NEEDED tag already exists, and 0 on success. */
3080 elf_add_dt_needed_tag (bfd
*abfd
,
3081 struct bfd_link_info
*info
,
3085 struct elf_link_hash_table
*hash_table
;
3086 bfd_size_type oldsize
;
3087 bfd_size_type strindex
;
3089 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
3092 hash_table
= elf_hash_table (info
);
3093 oldsize
= _bfd_elf_strtab_size (hash_table
->dynstr
);
3094 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, soname
, FALSE
);
3095 if (strindex
== (bfd_size_type
) -1)
3098 if (oldsize
== _bfd_elf_strtab_size (hash_table
->dynstr
))
3101 const struct elf_backend_data
*bed
;
3104 bed
= get_elf_backend_data (hash_table
->dynobj
);
3105 sdyn
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3107 for (extdyn
= sdyn
->contents
;
3108 extdyn
< sdyn
->contents
+ sdyn
->size
;
3109 extdyn
+= bed
->s
->sizeof_dyn
)
3111 Elf_Internal_Dyn dyn
;
3113 bed
->s
->swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
3114 if (dyn
.d_tag
== DT_NEEDED
3115 && dyn
.d_un
.d_val
== strindex
)
3117 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3125 if (!_bfd_elf_link_create_dynamic_sections (hash_table
->dynobj
, info
))
3128 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
3132 /* We were just checking for existence of the tag. */
3133 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3139 on_needed_list (const char *soname
, struct bfd_link_needed_list
*needed
)
3141 for (; needed
!= NULL
; needed
= needed
->next
)
3142 if (strcmp (soname
, needed
->name
) == 0)
3148 /* Sort symbol by value and section. */
3150 elf_sort_symbol (const void *arg1
, const void *arg2
)
3152 const struct elf_link_hash_entry
*h1
;
3153 const struct elf_link_hash_entry
*h2
;
3154 bfd_signed_vma vdiff
;
3156 h1
= *(const struct elf_link_hash_entry
**) arg1
;
3157 h2
= *(const struct elf_link_hash_entry
**) arg2
;
3158 vdiff
= h1
->root
.u
.def
.value
- h2
->root
.u
.def
.value
;
3160 return vdiff
> 0 ? 1 : -1;
3163 long sdiff
= h1
->root
.u
.def
.section
->id
- h2
->root
.u
.def
.section
->id
;
3165 return sdiff
> 0 ? 1 : -1;
3170 /* This function is used to adjust offsets into .dynstr for
3171 dynamic symbols. This is called via elf_link_hash_traverse. */
3174 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
3176 struct elf_strtab_hash
*dynstr
= (struct elf_strtab_hash
*) data
;
3178 if (h
->dynindx
!= -1)
3179 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
3183 /* Assign string offsets in .dynstr, update all structures referencing
3187 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
3189 struct elf_link_hash_table
*hash_table
= elf_hash_table (info
);
3190 struct elf_link_local_dynamic_entry
*entry
;
3191 struct elf_strtab_hash
*dynstr
= hash_table
->dynstr
;
3192 bfd
*dynobj
= hash_table
->dynobj
;
3195 const struct elf_backend_data
*bed
;
3198 _bfd_elf_strtab_finalize (dynstr
);
3199 size
= _bfd_elf_strtab_size (dynstr
);
3201 bed
= get_elf_backend_data (dynobj
);
3202 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3203 BFD_ASSERT (sdyn
!= NULL
);
3205 /* Update all .dynamic entries referencing .dynstr strings. */
3206 for (extdyn
= sdyn
->contents
;
3207 extdyn
< sdyn
->contents
+ sdyn
->size
;
3208 extdyn
+= bed
->s
->sizeof_dyn
)
3210 Elf_Internal_Dyn dyn
;
3212 bed
->s
->swap_dyn_in (dynobj
, extdyn
, &dyn
);
3216 dyn
.d_un
.d_val
= size
;
3226 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
3231 bed
->s
->swap_dyn_out (dynobj
, &dyn
, extdyn
);
3234 /* Now update local dynamic symbols. */
3235 for (entry
= hash_table
->dynlocal
; entry
; entry
= entry
->next
)
3236 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
3237 entry
->isym
.st_name
);
3239 /* And the rest of dynamic symbols. */
3240 elf_link_hash_traverse (hash_table
, elf_adjust_dynstr_offsets
, dynstr
);
3242 /* Adjust version definitions. */
3243 if (elf_tdata (output_bfd
)->cverdefs
)
3248 Elf_Internal_Verdef def
;
3249 Elf_Internal_Verdaux defaux
;
3251 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
3255 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
3257 p
+= sizeof (Elf_External_Verdef
);
3258 if (def
.vd_aux
!= sizeof (Elf_External_Verdef
))
3260 for (i
= 0; i
< def
.vd_cnt
; ++i
)
3262 _bfd_elf_swap_verdaux_in (output_bfd
,
3263 (Elf_External_Verdaux
*) p
, &defaux
);
3264 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
3266 _bfd_elf_swap_verdaux_out (output_bfd
,
3267 &defaux
, (Elf_External_Verdaux
*) p
);
3268 p
+= sizeof (Elf_External_Verdaux
);
3271 while (def
.vd_next
);
3274 /* Adjust version references. */
3275 if (elf_tdata (output_bfd
)->verref
)
3280 Elf_Internal_Verneed need
;
3281 Elf_Internal_Vernaux needaux
;
3283 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
3287 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
3289 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
3290 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
3291 (Elf_External_Verneed
*) p
);
3292 p
+= sizeof (Elf_External_Verneed
);
3293 for (i
= 0; i
< need
.vn_cnt
; ++i
)
3295 _bfd_elf_swap_vernaux_in (output_bfd
,
3296 (Elf_External_Vernaux
*) p
, &needaux
);
3297 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
3299 _bfd_elf_swap_vernaux_out (output_bfd
,
3301 (Elf_External_Vernaux
*) p
);
3302 p
+= sizeof (Elf_External_Vernaux
);
3305 while (need
.vn_next
);
3311 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3312 The default is to only match when the INPUT and OUTPUT are exactly
3316 _bfd_elf_default_relocs_compatible (const bfd_target
*input
,
3317 const bfd_target
*output
)
3319 return input
== output
;
3322 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3323 This version is used when different targets for the same architecture
3324 are virtually identical. */
3327 _bfd_elf_relocs_compatible (const bfd_target
*input
,
3328 const bfd_target
*output
)
3330 const struct elf_backend_data
*obed
, *ibed
;
3332 if (input
== output
)
3335 ibed
= xvec_get_elf_backend_data (input
);
3336 obed
= xvec_get_elf_backend_data (output
);
3338 if (ibed
->arch
!= obed
->arch
)
3341 /* If both backends are using this function, deem them compatible. */
3342 return ibed
->relocs_compatible
== obed
->relocs_compatible
;
3345 /* Add symbols from an ELF object file to the linker hash table. */
3348 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3350 Elf_Internal_Ehdr
*ehdr
;
3351 Elf_Internal_Shdr
*hdr
;
3352 bfd_size_type symcount
;
3353 bfd_size_type extsymcount
;
3354 bfd_size_type extsymoff
;
3355 struct elf_link_hash_entry
**sym_hash
;
3356 bfd_boolean dynamic
;
3357 Elf_External_Versym
*extversym
= NULL
;
3358 Elf_External_Versym
*ever
;
3359 struct elf_link_hash_entry
*weaks
;
3360 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
3361 bfd_size_type nondeflt_vers_cnt
= 0;
3362 Elf_Internal_Sym
*isymbuf
= NULL
;
3363 Elf_Internal_Sym
*isym
;
3364 Elf_Internal_Sym
*isymend
;
3365 const struct elf_backend_data
*bed
;
3366 bfd_boolean add_needed
;
3367 struct elf_link_hash_table
*htab
;
3369 void *alloc_mark
= NULL
;
3370 struct bfd_hash_entry
**old_table
= NULL
;
3371 unsigned int old_size
= 0;
3372 unsigned int old_count
= 0;
3373 void *old_tab
= NULL
;
3376 struct bfd_link_hash_entry
*old_undefs
= NULL
;
3377 struct bfd_link_hash_entry
*old_undefs_tail
= NULL
;
3378 long old_dynsymcount
= 0;
3380 size_t hashsize
= 0;
3382 htab
= elf_hash_table (info
);
3383 bed
= get_elf_backend_data (abfd
);
3385 if ((abfd
->flags
& DYNAMIC
) == 0)
3391 /* You can't use -r against a dynamic object. Also, there's no
3392 hope of using a dynamic object which does not exactly match
3393 the format of the output file. */
3394 if (info
->relocatable
3395 || !is_elf_hash_table (htab
)
3396 || info
->output_bfd
->xvec
!= abfd
->xvec
)
3398 if (info
->relocatable
)
3399 bfd_set_error (bfd_error_invalid_operation
);
3401 bfd_set_error (bfd_error_wrong_format
);
3406 ehdr
= elf_elfheader (abfd
);
3407 if (info
->warn_alternate_em
3408 && bed
->elf_machine_code
!= ehdr
->e_machine
3409 && ((bed
->elf_machine_alt1
!= 0
3410 && ehdr
->e_machine
== bed
->elf_machine_alt1
)
3411 || (bed
->elf_machine_alt2
!= 0
3412 && ehdr
->e_machine
== bed
->elf_machine_alt2
)))
3413 info
->callbacks
->einfo
3414 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3415 ehdr
->e_machine
, abfd
, bed
->elf_machine_code
);
3417 /* As a GNU extension, any input sections which are named
3418 .gnu.warning.SYMBOL are treated as warning symbols for the given
3419 symbol. This differs from .gnu.warning sections, which generate
3420 warnings when they are included in an output file. */
3421 /* PR 12761: Also generate this warning when building shared libraries. */
3422 if (info
->executable
|| info
->shared
)
3426 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3430 name
= bfd_get_section_name (abfd
, s
);
3431 if (CONST_STRNEQ (name
, ".gnu.warning."))
3436 name
+= sizeof ".gnu.warning." - 1;
3438 /* If this is a shared object, then look up the symbol
3439 in the hash table. If it is there, and it is already
3440 been defined, then we will not be using the entry
3441 from this shared object, so we don't need to warn.
3442 FIXME: If we see the definition in a regular object
3443 later on, we will warn, but we shouldn't. The only
3444 fix is to keep track of what warnings we are supposed
3445 to emit, and then handle them all at the end of the
3449 struct elf_link_hash_entry
*h
;
3451 h
= elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
3453 /* FIXME: What about bfd_link_hash_common? */
3455 && (h
->root
.type
== bfd_link_hash_defined
3456 || h
->root
.type
== bfd_link_hash_defweak
))
3458 /* We don't want to issue this warning. Clobber
3459 the section size so that the warning does not
3460 get copied into the output file. */
3467 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
3471 if (! bfd_get_section_contents (abfd
, s
, msg
, 0, sz
))
3476 if (! (_bfd_generic_link_add_one_symbol
3477 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
3478 FALSE
, bed
->collect
, NULL
)))
3481 if (! info
->relocatable
)
3483 /* Clobber the section size so that the warning does
3484 not get copied into the output file. */
3487 /* Also set SEC_EXCLUDE, so that symbols defined in
3488 the warning section don't get copied to the output. */
3489 s
->flags
|= SEC_EXCLUDE
;
3498 /* If we are creating a shared library, create all the dynamic
3499 sections immediately. We need to attach them to something,
3500 so we attach them to this BFD, provided it is the right
3501 format. FIXME: If there are no input BFD's of the same
3502 format as the output, we can't make a shared library. */
3504 && is_elf_hash_table (htab
)
3505 && info
->output_bfd
->xvec
== abfd
->xvec
3506 && !htab
->dynamic_sections_created
)
3508 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
3512 else if (!is_elf_hash_table (htab
))
3517 const char *soname
= NULL
;
3519 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
3522 /* ld --just-symbols and dynamic objects don't mix very well.
3523 ld shouldn't allow it. */
3524 if ((s
= abfd
->sections
) != NULL
3525 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
3528 /* If this dynamic lib was specified on the command line with
3529 --as-needed in effect, then we don't want to add a DT_NEEDED
3530 tag unless the lib is actually used. Similary for libs brought
3531 in by another lib's DT_NEEDED. When --no-add-needed is used
3532 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3533 any dynamic library in DT_NEEDED tags in the dynamic lib at
3535 add_needed
= (elf_dyn_lib_class (abfd
)
3536 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
3537 | DYN_NO_NEEDED
)) == 0;
3539 s
= bfd_get_section_by_name (abfd
, ".dynamic");
3544 unsigned int elfsec
;
3545 unsigned long shlink
;
3547 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
3554 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
3555 if (elfsec
== SHN_BAD
)
3556 goto error_free_dyn
;
3557 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
3559 for (extdyn
= dynbuf
;
3560 extdyn
< dynbuf
+ s
->size
;
3561 extdyn
+= bed
->s
->sizeof_dyn
)
3563 Elf_Internal_Dyn dyn
;
3565 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
3566 if (dyn
.d_tag
== DT_SONAME
)
3568 unsigned int tagv
= dyn
.d_un
.d_val
;
3569 soname
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3571 goto error_free_dyn
;
3573 if (dyn
.d_tag
== DT_NEEDED
)
3575 struct bfd_link_needed_list
*n
, **pn
;
3577 unsigned int tagv
= dyn
.d_un
.d_val
;
3579 amt
= sizeof (struct bfd_link_needed_list
);
3580 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3581 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3582 if (n
== NULL
|| fnm
== NULL
)
3583 goto error_free_dyn
;
3584 amt
= strlen (fnm
) + 1;
3585 anm
= (char *) bfd_alloc (abfd
, amt
);
3587 goto error_free_dyn
;
3588 memcpy (anm
, fnm
, amt
);
3592 for (pn
= &htab
->needed
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3596 if (dyn
.d_tag
== DT_RUNPATH
)
3598 struct bfd_link_needed_list
*n
, **pn
;
3600 unsigned int tagv
= dyn
.d_un
.d_val
;
3602 amt
= sizeof (struct bfd_link_needed_list
);
3603 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3604 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3605 if (n
== NULL
|| fnm
== NULL
)
3606 goto error_free_dyn
;
3607 amt
= strlen (fnm
) + 1;
3608 anm
= (char *) bfd_alloc (abfd
, amt
);
3610 goto error_free_dyn
;
3611 memcpy (anm
, fnm
, amt
);
3615 for (pn
= & runpath
;
3621 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3622 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
3624 struct bfd_link_needed_list
*n
, **pn
;
3626 unsigned int tagv
= dyn
.d_un
.d_val
;
3628 amt
= sizeof (struct bfd_link_needed_list
);
3629 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3630 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3631 if (n
== NULL
|| fnm
== NULL
)
3632 goto error_free_dyn
;
3633 amt
= strlen (fnm
) + 1;
3634 anm
= (char *) bfd_alloc (abfd
, amt
);
3636 goto error_free_dyn
;
3637 memcpy (anm
, fnm
, amt
);
3647 if (dyn
.d_tag
== DT_AUDIT
)
3649 unsigned int tagv
= dyn
.d_un
.d_val
;
3650 audit
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3657 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3658 frees all more recently bfd_alloc'd blocks as well. */
3664 struct bfd_link_needed_list
**pn
;
3665 for (pn
= &htab
->runpath
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3670 /* We do not want to include any of the sections in a dynamic
3671 object in the output file. We hack by simply clobbering the
3672 list of sections in the BFD. This could be handled more
3673 cleanly by, say, a new section flag; the existing
3674 SEC_NEVER_LOAD flag is not the one we want, because that one
3675 still implies that the section takes up space in the output
3677 bfd_section_list_clear (abfd
);
3679 /* Find the name to use in a DT_NEEDED entry that refers to this
3680 object. If the object has a DT_SONAME entry, we use it.
3681 Otherwise, if the generic linker stuck something in
3682 elf_dt_name, we use that. Otherwise, we just use the file
3684 if (soname
== NULL
|| *soname
== '\0')
3686 soname
= elf_dt_name (abfd
);
3687 if (soname
== NULL
|| *soname
== '\0')
3688 soname
= bfd_get_filename (abfd
);
3691 /* Save the SONAME because sometimes the linker emulation code
3692 will need to know it. */
3693 elf_dt_name (abfd
) = soname
;
3695 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
3699 /* If we have already included this dynamic object in the
3700 link, just ignore it. There is no reason to include a
3701 particular dynamic object more than once. */
3705 /* Save the DT_AUDIT entry for the linker emulation code. */
3706 elf_dt_audit (abfd
) = audit
;
3709 /* If this is a dynamic object, we always link against the .dynsym
3710 symbol table, not the .symtab symbol table. The dynamic linker
3711 will only see the .dynsym symbol table, so there is no reason to
3712 look at .symtab for a dynamic object. */
3714 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
3715 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3717 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3719 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
3721 /* The sh_info field of the symtab header tells us where the
3722 external symbols start. We don't care about the local symbols at
3724 if (elf_bad_symtab (abfd
))
3726 extsymcount
= symcount
;
3731 extsymcount
= symcount
- hdr
->sh_info
;
3732 extsymoff
= hdr
->sh_info
;
3736 if (extsymcount
!= 0)
3738 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3740 if (isymbuf
== NULL
)
3743 /* We store a pointer to the hash table entry for each external
3745 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3746 sym_hash
= (struct elf_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3747 if (sym_hash
== NULL
)
3748 goto error_free_sym
;
3749 elf_sym_hashes (abfd
) = sym_hash
;
3754 /* Read in any version definitions. */
3755 if (!_bfd_elf_slurp_version_tables (abfd
,
3756 info
->default_imported_symver
))
3757 goto error_free_sym
;
3759 /* Read in the symbol versions, but don't bother to convert them
3760 to internal format. */
3761 if (elf_dynversym (abfd
) != 0)
3763 Elf_Internal_Shdr
*versymhdr
;
3765 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
3766 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
3767 if (extversym
== NULL
)
3768 goto error_free_sym
;
3769 amt
= versymhdr
->sh_size
;
3770 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
3771 || bfd_bread (extversym
, amt
, abfd
) != amt
)
3772 goto error_free_vers
;
3776 /* If we are loading an as-needed shared lib, save the symbol table
3777 state before we start adding symbols. If the lib turns out
3778 to be unneeded, restore the state. */
3779 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
3784 for (entsize
= 0, i
= 0; i
< htab
->root
.table
.size
; i
++)
3786 struct bfd_hash_entry
*p
;
3787 struct elf_link_hash_entry
*h
;
3789 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3791 h
= (struct elf_link_hash_entry
*) p
;
3792 entsize
+= htab
->root
.table
.entsize
;
3793 if (h
->root
.type
== bfd_link_hash_warning
)
3794 entsize
+= htab
->root
.table
.entsize
;
3798 tabsize
= htab
->root
.table
.size
* sizeof (struct bfd_hash_entry
*);
3799 hashsize
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3800 old_tab
= bfd_malloc (tabsize
+ entsize
+ hashsize
);
3801 if (old_tab
== NULL
)
3802 goto error_free_vers
;
3804 /* Remember the current objalloc pointer, so that all mem for
3805 symbols added can later be reclaimed. */
3806 alloc_mark
= bfd_hash_allocate (&htab
->root
.table
, 1);
3807 if (alloc_mark
== NULL
)
3808 goto error_free_vers
;
3810 /* Make a special call to the linker "notice" function to
3811 tell it that we are about to handle an as-needed lib. */
3812 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
3813 notice_as_needed
, 0, NULL
))
3814 goto error_free_vers
;
3816 /* Clone the symbol table and sym hashes. Remember some
3817 pointers into the symbol table, and dynamic symbol count. */
3818 old_hash
= (char *) old_tab
+ tabsize
;
3819 old_ent
= (char *) old_hash
+ hashsize
;
3820 memcpy (old_tab
, htab
->root
.table
.table
, tabsize
);
3821 memcpy (old_hash
, sym_hash
, hashsize
);
3822 old_undefs
= htab
->root
.undefs
;
3823 old_undefs_tail
= htab
->root
.undefs_tail
;
3824 old_table
= htab
->root
.table
.table
;
3825 old_size
= htab
->root
.table
.size
;
3826 old_count
= htab
->root
.table
.count
;
3827 old_dynsymcount
= htab
->dynsymcount
;
3829 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
3831 struct bfd_hash_entry
*p
;
3832 struct elf_link_hash_entry
*h
;
3834 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3836 memcpy (old_ent
, p
, htab
->root
.table
.entsize
);
3837 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3838 h
= (struct elf_link_hash_entry
*) p
;
3839 if (h
->root
.type
== bfd_link_hash_warning
)
3841 memcpy (old_ent
, h
->root
.u
.i
.link
, htab
->root
.table
.entsize
);
3842 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3849 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
3850 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
3852 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
3856 asection
*sec
, *new_sec
;
3859 struct elf_link_hash_entry
*h
;
3860 struct elf_link_hash_entry
*hi
;
3861 bfd_boolean definition
;
3862 bfd_boolean size_change_ok
;
3863 bfd_boolean type_change_ok
;
3864 bfd_boolean new_weakdef
;
3865 bfd_boolean override
;
3867 unsigned int old_alignment
;
3869 bfd
* undef_bfd
= NULL
;
3873 flags
= BSF_NO_FLAGS
;
3875 value
= isym
->st_value
;
3877 common
= bed
->common_definition (isym
);
3879 bind
= ELF_ST_BIND (isym
->st_info
);
3883 /* This should be impossible, since ELF requires that all
3884 global symbols follow all local symbols, and that sh_info
3885 point to the first global symbol. Unfortunately, Irix 5
3890 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
3898 case STB_GNU_UNIQUE
:
3899 flags
= BSF_GNU_UNIQUE
;
3903 /* Leave it up to the processor backend. */
3907 if (isym
->st_shndx
== SHN_UNDEF
)
3908 sec
= bfd_und_section_ptr
;
3909 else if (isym
->st_shndx
== SHN_ABS
)
3910 sec
= bfd_abs_section_ptr
;
3911 else if (isym
->st_shndx
== SHN_COMMON
)
3913 sec
= bfd_com_section_ptr
;
3914 /* What ELF calls the size we call the value. What ELF
3915 calls the value we call the alignment. */
3916 value
= isym
->st_size
;
3920 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3922 sec
= bfd_abs_section_ptr
;
3923 else if (discarded_section (sec
))
3925 /* Symbols from discarded section are undefined. We keep
3927 sec
= bfd_und_section_ptr
;
3928 isym
->st_shndx
= SHN_UNDEF
;
3930 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
3934 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3937 goto error_free_vers
;
3939 if (isym
->st_shndx
== SHN_COMMON
3940 && (abfd
->flags
& BFD_PLUGIN
) != 0)
3942 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
3946 flagword sflags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
3948 xc
= bfd_make_section_with_flags (abfd
, "COMMON", sflags
);
3950 goto error_free_vers
;
3954 else if (isym
->st_shndx
== SHN_COMMON
3955 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
3956 && !info
->relocatable
)
3958 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
3962 flagword sflags
= (SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_IS_COMMON
3963 | SEC_LINKER_CREATED
);
3964 tcomm
= bfd_make_section_with_flags (abfd
, ".tcommon", sflags
);
3966 goto error_free_vers
;
3970 else if (bed
->elf_add_symbol_hook
)
3972 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
3974 goto error_free_vers
;
3976 /* The hook function sets the name to NULL if this symbol
3977 should be skipped for some reason. */
3982 /* Sanity check that all possibilities were handled. */
3985 bfd_set_error (bfd_error_bad_value
);
3986 goto error_free_vers
;
3989 if (bfd_is_und_section (sec
)
3990 || bfd_is_com_section (sec
))
3995 size_change_ok
= FALSE
;
3996 type_change_ok
= bed
->type_change_ok
;
4001 if (is_elf_hash_table (htab
))
4003 Elf_Internal_Versym iver
;
4004 unsigned int vernum
= 0;
4007 /* If this is a definition of a symbol which was previously
4008 referenced in a non-weak manner then make a note of the bfd
4009 that contained the reference. This is used if we need to
4010 refer to the source of the reference later on. */
4011 if (! bfd_is_und_section (sec
))
4013 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
4016 && h
->root
.type
== bfd_link_hash_undefined
4017 && h
->root
.u
.undef
.abfd
)
4018 undef_bfd
= h
->root
.u
.undef
.abfd
;
4023 if (info
->default_imported_symver
)
4024 /* Use the default symbol version created earlier. */
4025 iver
.vs_vers
= elf_tdata (abfd
)->cverdefs
;
4030 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
4032 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
4034 /* If this is a hidden symbol, or if it is not version
4035 1, we append the version name to the symbol name.
4036 However, we do not modify a non-hidden absolute symbol
4037 if it is not a function, because it might be the version
4038 symbol itself. FIXME: What if it isn't? */
4039 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
4041 && (!bfd_is_abs_section (sec
)
4042 || bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
)))))
4045 size_t namelen
, verlen
, newlen
;
4048 if (isym
->st_shndx
!= SHN_UNDEF
)
4050 if (vernum
> elf_tdata (abfd
)->cverdefs
)
4052 else if (vernum
> 1)
4054 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
4060 (*_bfd_error_handler
)
4061 (_("%B: %s: invalid version %u (max %d)"),
4063 elf_tdata (abfd
)->cverdefs
);
4064 bfd_set_error (bfd_error_bad_value
);
4065 goto error_free_vers
;
4070 /* We cannot simply test for the number of
4071 entries in the VERNEED section since the
4072 numbers for the needed versions do not start
4074 Elf_Internal_Verneed
*t
;
4077 for (t
= elf_tdata (abfd
)->verref
;
4081 Elf_Internal_Vernaux
*a
;
4083 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
4085 if (a
->vna_other
== vernum
)
4087 verstr
= a
->vna_nodename
;
4096 (*_bfd_error_handler
)
4097 (_("%B: %s: invalid needed version %d"),
4098 abfd
, name
, vernum
);
4099 bfd_set_error (bfd_error_bad_value
);
4100 goto error_free_vers
;
4104 namelen
= strlen (name
);
4105 verlen
= strlen (verstr
);
4106 newlen
= namelen
+ verlen
+ 2;
4107 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4108 && isym
->st_shndx
!= SHN_UNDEF
)
4111 newname
= (char *) bfd_hash_allocate (&htab
->root
.table
, newlen
);
4112 if (newname
== NULL
)
4113 goto error_free_vers
;
4114 memcpy (newname
, name
, namelen
);
4115 p
= newname
+ namelen
;
4117 /* If this is a defined non-hidden version symbol,
4118 we add another @ to the name. This indicates the
4119 default version of the symbol. */
4120 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4121 && isym
->st_shndx
!= SHN_UNDEF
)
4123 memcpy (p
, verstr
, verlen
+ 1);
4128 /* If necessary, make a second attempt to locate the bfd
4129 containing an unresolved, non-weak reference to the
4131 if (! bfd_is_und_section (sec
) && undef_bfd
== NULL
)
4133 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
4136 && h
->root
.type
== bfd_link_hash_undefined
4137 && h
->root
.u
.undef
.abfd
)
4138 undef_bfd
= h
->root
.u
.undef
.abfd
;
4141 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
,
4142 &value
, &old_alignment
,
4143 sym_hash
, &skip
, &override
,
4144 &type_change_ok
, &size_change_ok
))
4145 goto error_free_vers
;
4154 while (h
->root
.type
== bfd_link_hash_indirect
4155 || h
->root
.type
== bfd_link_hash_warning
)
4156 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4158 /* Remember the old alignment if this is a common symbol, so
4159 that we don't reduce the alignment later on. We can't
4160 check later, because _bfd_generic_link_add_one_symbol
4161 will set a default for the alignment which we want to
4162 override. We also remember the old bfd where the existing
4163 definition comes from. */
4164 switch (h
->root
.type
)
4169 case bfd_link_hash_defined
:
4170 case bfd_link_hash_defweak
:
4171 old_bfd
= h
->root
.u
.def
.section
->owner
;
4174 case bfd_link_hash_common
:
4175 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
4176 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
4180 if (elf_tdata (abfd
)->verdef
!= NULL
4184 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
4187 if (! (_bfd_generic_link_add_one_symbol
4188 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
4189 (struct bfd_link_hash_entry
**) sym_hash
)))
4190 goto error_free_vers
;
4193 /* We need to make sure that indirect symbol dynamic flags are
4196 while (h
->root
.type
== bfd_link_hash_indirect
4197 || h
->root
.type
== bfd_link_hash_warning
)
4198 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4201 if (is_elf_hash_table (htab
))
4202 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
4204 new_weakdef
= FALSE
;
4207 && (flags
& BSF_WEAK
) != 0
4208 && !bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
))
4209 && is_elf_hash_table (htab
)
4210 && h
->u
.weakdef
== NULL
)
4212 /* Keep a list of all weak defined non function symbols from
4213 a dynamic object, using the weakdef field. Later in this
4214 function we will set the weakdef field to the correct
4215 value. We only put non-function symbols from dynamic
4216 objects on this list, because that happens to be the only
4217 time we need to know the normal symbol corresponding to a
4218 weak symbol, and the information is time consuming to
4219 figure out. If the weakdef field is not already NULL,
4220 then this symbol was already defined by some previous
4221 dynamic object, and we will be using that previous
4222 definition anyhow. */
4224 h
->u
.weakdef
= weaks
;
4229 /* Set the alignment of a common symbol. */
4230 if ((common
|| bfd_is_com_section (sec
))
4231 && h
->root
.type
== bfd_link_hash_common
)
4236 align
= bfd_log2 (isym
->st_value
);
4239 /* The new symbol is a common symbol in a shared object.
4240 We need to get the alignment from the section. */
4241 align
= new_sec
->alignment_power
;
4243 if (align
> old_alignment
)
4244 h
->root
.u
.c
.p
->alignment_power
= align
;
4246 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
4249 if (is_elf_hash_table (htab
))
4253 /* Check the alignment when a common symbol is involved. This
4254 can change when a common symbol is overridden by a normal
4255 definition or a common symbol is ignored due to the old
4256 normal definition. We need to make sure the maximum
4257 alignment is maintained. */
4258 if ((old_alignment
|| common
)
4259 && h
->root
.type
!= bfd_link_hash_common
)
4261 unsigned int common_align
;
4262 unsigned int normal_align
;
4263 unsigned int symbol_align
;
4267 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
4268 if (h
->root
.u
.def
.section
->owner
!= NULL
4269 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
4271 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
4272 if (normal_align
> symbol_align
)
4273 normal_align
= symbol_align
;
4276 normal_align
= symbol_align
;
4280 common_align
= old_alignment
;
4281 common_bfd
= old_bfd
;
4286 common_align
= bfd_log2 (isym
->st_value
);
4288 normal_bfd
= old_bfd
;
4291 if (normal_align
< common_align
)
4293 /* PR binutils/2735 */
4294 if (normal_bfd
== NULL
)
4295 (*_bfd_error_handler
)
4296 (_("Warning: alignment %u of common symbol `%s' in %B"
4297 " is greater than the alignment (%u) of its section %A"),
4298 common_bfd
, h
->root
.u
.def
.section
,
4299 1 << common_align
, name
, 1 << normal_align
);
4301 (*_bfd_error_handler
)
4302 (_("Warning: alignment %u of symbol `%s' in %B"
4303 " is smaller than %u in %B"),
4304 normal_bfd
, common_bfd
,
4305 1 << normal_align
, name
, 1 << common_align
);
4309 /* Remember the symbol size if it isn't undefined. */
4310 if ((isym
->st_size
!= 0 && isym
->st_shndx
!= SHN_UNDEF
)
4311 && (definition
|| h
->size
== 0))
4314 && h
->size
!= isym
->st_size
4315 && ! size_change_ok
)
4316 (*_bfd_error_handler
)
4317 (_("Warning: size of symbol `%s' changed"
4318 " from %lu in %B to %lu in %B"),
4320 name
, (unsigned long) h
->size
,
4321 (unsigned long) isym
->st_size
);
4323 h
->size
= isym
->st_size
;
4326 /* If this is a common symbol, then we always want H->SIZE
4327 to be the size of the common symbol. The code just above
4328 won't fix the size if a common symbol becomes larger. We
4329 don't warn about a size change here, because that is
4330 covered by --warn-common. Allow changed between different
4332 if (h
->root
.type
== bfd_link_hash_common
)
4333 h
->size
= h
->root
.u
.c
.size
;
4335 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
4336 && (definition
|| h
->type
== STT_NOTYPE
))
4338 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
4340 /* Turn an IFUNC symbol from a DSO into a normal FUNC
4342 if (type
== STT_GNU_IFUNC
4343 && (abfd
->flags
& DYNAMIC
) != 0)
4346 if (h
->type
!= type
)
4348 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
4349 (*_bfd_error_handler
)
4350 (_("Warning: type of symbol `%s' changed"
4351 " from %d to %d in %B"),
4352 abfd
, name
, h
->type
, type
);
4358 /* Merge st_other field. */
4359 elf_merge_st_other (abfd
, h
, isym
, definition
, dynamic
);
4361 /* Set a flag in the hash table entry indicating the type of
4362 reference or definition we just found. Keep a count of
4363 the number of dynamic symbols we find. A dynamic symbol
4364 is one which is referenced or defined by both a regular
4365 object and a shared object. */
4372 if (bind
!= STB_WEAK
)
4373 h
->ref_regular_nonweak
= 1;
4385 /* If the indirect symbol has been forced local, don't
4386 make the real symbol dynamic. */
4387 if ((h
== hi
|| !hi
->forced_local
)
4388 && (! info
->executable
4398 hi
->ref_dynamic
= 1;
4404 hi
->def_dynamic
= 1;
4405 hi
->dynamic_def
= 1;
4408 /* If the indirect symbol has been forced local, don't
4409 make the real symbol dynamic. */
4410 if ((h
== hi
|| !hi
->forced_local
)
4413 || (h
->u
.weakdef
!= NULL
4415 && h
->u
.weakdef
->dynindx
!= -1)))
4419 /* We don't want to make debug symbol dynamic. */
4420 if (definition
&& (sec
->flags
& SEC_DEBUGGING
) && !info
->relocatable
)
4423 /* Nor should we make plugin symbols dynamic. */
4424 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
4428 h
->target_internal
= isym
->st_target_internal
;
4430 /* Check to see if we need to add an indirect symbol for
4431 the default name. */
4432 if (definition
|| h
->root
.type
== bfd_link_hash_common
)
4433 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
4434 &sec
, &value
, &dynsym
,
4436 goto error_free_vers
;
4438 if (definition
&& !dynamic
)
4440 char *p
= strchr (name
, ELF_VER_CHR
);
4441 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
4443 /* Queue non-default versions so that .symver x, x@FOO
4444 aliases can be checked. */
4447 amt
= ((isymend
- isym
+ 1)
4448 * sizeof (struct elf_link_hash_entry
*));
4450 (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4452 goto error_free_vers
;
4454 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
4458 if (dynsym
&& h
->dynindx
== -1)
4460 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4461 goto error_free_vers
;
4462 if (h
->u
.weakdef
!= NULL
4464 && h
->u
.weakdef
->dynindx
== -1)
4466 if (!bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
4467 goto error_free_vers
;
4470 else if (dynsym
&& h
->dynindx
!= -1)
4471 /* If the symbol already has a dynamic index, but
4472 visibility says it should not be visible, turn it into
4474 switch (ELF_ST_VISIBILITY (h
->other
))
4478 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
4488 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0
4489 && !on_needed_list (elf_dt_name (abfd
), htab
->needed
))))
4492 const char *soname
= elf_dt_name (abfd
);
4494 /* A symbol from a library loaded via DT_NEEDED of some
4495 other library is referenced by a regular object.
4496 Add a DT_NEEDED entry for it. Issue an error if
4497 --no-add-needed is used and the reference was not
4499 if (undef_bfd
!= NULL
4500 && (elf_dyn_lib_class (abfd
) & DYN_NO_NEEDED
) != 0)
4502 (*_bfd_error_handler
)
4503 (_("%B: undefined reference to symbol '%s'"),
4505 (*_bfd_error_handler
)
4506 (_("note: '%s' is defined in DSO %B so try adding it to the linker command line"),
4508 bfd_set_error (bfd_error_invalid_operation
);
4509 goto error_free_vers
;
4512 elf_dyn_lib_class (abfd
) = (enum dynamic_lib_link_class
)
4513 (elf_dyn_lib_class (abfd
) & ~DYN_AS_NEEDED
);
4516 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
4518 goto error_free_vers
;
4520 BFD_ASSERT (ret
== 0);
4525 if (extversym
!= NULL
)
4531 if (isymbuf
!= NULL
)
4537 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4541 /* Restore the symbol table. */
4542 if (bed
->as_needed_cleanup
)
4543 (*bed
->as_needed_cleanup
) (abfd
, info
);
4544 old_hash
= (char *) old_tab
+ tabsize
;
4545 old_ent
= (char *) old_hash
+ hashsize
;
4546 sym_hash
= elf_sym_hashes (abfd
);
4547 htab
->root
.table
.table
= old_table
;
4548 htab
->root
.table
.size
= old_size
;
4549 htab
->root
.table
.count
= old_count
;
4550 memcpy (htab
->root
.table
.table
, old_tab
, tabsize
);
4551 memcpy (sym_hash
, old_hash
, hashsize
);
4552 htab
->root
.undefs
= old_undefs
;
4553 htab
->root
.undefs_tail
= old_undefs_tail
;
4554 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4556 struct bfd_hash_entry
*p
;
4557 struct elf_link_hash_entry
*h
;
4559 unsigned int alignment_power
;
4561 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4563 h
= (struct elf_link_hash_entry
*) p
;
4564 if (h
->root
.type
== bfd_link_hash_warning
)
4565 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4566 if (h
->dynindx
>= old_dynsymcount
)
4567 _bfd_elf_strtab_delref (htab
->dynstr
, h
->dynstr_index
);
4569 /* Preserve the maximum alignment and size for common
4570 symbols even if this dynamic lib isn't on DT_NEEDED
4571 since it can still be loaded at the run-time by another
4573 if (h
->root
.type
== bfd_link_hash_common
)
4575 size
= h
->root
.u
.c
.size
;
4576 alignment_power
= h
->root
.u
.c
.p
->alignment_power
;
4581 alignment_power
= 0;
4583 memcpy (p
, old_ent
, htab
->root
.table
.entsize
);
4584 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4585 h
= (struct elf_link_hash_entry
*) p
;
4586 if (h
->root
.type
== bfd_link_hash_warning
)
4588 memcpy (h
->root
.u
.i
.link
, old_ent
, htab
->root
.table
.entsize
);
4589 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4591 else if (h
->root
.type
== bfd_link_hash_common
)
4593 if (size
> h
->root
.u
.c
.size
)
4594 h
->root
.u
.c
.size
= size
;
4595 if (alignment_power
> h
->root
.u
.c
.p
->alignment_power
)
4596 h
->root
.u
.c
.p
->alignment_power
= alignment_power
;
4601 /* Make a special call to the linker "notice" function to
4602 tell it that symbols added for crefs may need to be removed. */
4603 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4604 notice_not_needed
, 0, NULL
))
4605 goto error_free_vers
;
4608 objalloc_free_block ((struct objalloc
*) htab
->root
.table
.memory
,
4610 if (nondeflt_vers
!= NULL
)
4611 free (nondeflt_vers
);
4615 if (old_tab
!= NULL
)
4617 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4618 notice_needed
, 0, NULL
))
4619 goto error_free_vers
;
4624 /* Now that all the symbols from this input file are created, handle
4625 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4626 if (nondeflt_vers
!= NULL
)
4628 bfd_size_type cnt
, symidx
;
4630 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
4632 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
4633 char *shortname
, *p
;
4635 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
4637 || (h
->root
.type
!= bfd_link_hash_defined
4638 && h
->root
.type
!= bfd_link_hash_defweak
))
4641 amt
= p
- h
->root
.root
.string
;
4642 shortname
= (char *) bfd_malloc (amt
+ 1);
4644 goto error_free_vers
;
4645 memcpy (shortname
, h
->root
.root
.string
, amt
);
4646 shortname
[amt
] = '\0';
4648 hi
= (struct elf_link_hash_entry
*)
4649 bfd_link_hash_lookup (&htab
->root
, shortname
,
4650 FALSE
, FALSE
, FALSE
);
4652 && hi
->root
.type
== h
->root
.type
4653 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
4654 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
4656 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
4657 hi
->root
.type
= bfd_link_hash_indirect
;
4658 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
4659 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
4660 sym_hash
= elf_sym_hashes (abfd
);
4662 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
4663 if (sym_hash
[symidx
] == hi
)
4665 sym_hash
[symidx
] = h
;
4671 free (nondeflt_vers
);
4672 nondeflt_vers
= NULL
;
4675 /* Now set the weakdefs field correctly for all the weak defined
4676 symbols we found. The only way to do this is to search all the
4677 symbols. Since we only need the information for non functions in
4678 dynamic objects, that's the only time we actually put anything on
4679 the list WEAKS. We need this information so that if a regular
4680 object refers to a symbol defined weakly in a dynamic object, the
4681 real symbol in the dynamic object is also put in the dynamic
4682 symbols; we also must arrange for both symbols to point to the
4683 same memory location. We could handle the general case of symbol
4684 aliasing, but a general symbol alias can only be generated in
4685 assembler code, handling it correctly would be very time
4686 consuming, and other ELF linkers don't handle general aliasing
4690 struct elf_link_hash_entry
**hpp
;
4691 struct elf_link_hash_entry
**hppend
;
4692 struct elf_link_hash_entry
**sorted_sym_hash
;
4693 struct elf_link_hash_entry
*h
;
4696 /* Since we have to search the whole symbol list for each weak
4697 defined symbol, search time for N weak defined symbols will be
4698 O(N^2). Binary search will cut it down to O(NlogN). */
4699 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4700 sorted_sym_hash
= (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4701 if (sorted_sym_hash
== NULL
)
4703 sym_hash
= sorted_sym_hash
;
4704 hpp
= elf_sym_hashes (abfd
);
4705 hppend
= hpp
+ extsymcount
;
4707 for (; hpp
< hppend
; hpp
++)
4711 && h
->root
.type
== bfd_link_hash_defined
4712 && !bed
->is_function_type (h
->type
))
4720 qsort (sorted_sym_hash
, sym_count
,
4721 sizeof (struct elf_link_hash_entry
*),
4724 while (weaks
!= NULL
)
4726 struct elf_link_hash_entry
*hlook
;
4733 weaks
= hlook
->u
.weakdef
;
4734 hlook
->u
.weakdef
= NULL
;
4736 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4737 || hlook
->root
.type
== bfd_link_hash_defweak
4738 || hlook
->root
.type
== bfd_link_hash_common
4739 || hlook
->root
.type
== bfd_link_hash_indirect
);
4740 slook
= hlook
->root
.u
.def
.section
;
4741 vlook
= hlook
->root
.u
.def
.value
;
4748 bfd_signed_vma vdiff
;
4750 h
= sorted_sym_hash
[idx
];
4751 vdiff
= vlook
- h
->root
.u
.def
.value
;
4758 long sdiff
= slook
->id
- h
->root
.u
.def
.section
->id
;
4771 /* We didn't find a value/section match. */
4775 for (i
= ilook
; i
< sym_count
; i
++)
4777 h
= sorted_sym_hash
[i
];
4779 /* Stop if value or section doesn't match. */
4780 if (h
->root
.u
.def
.value
!= vlook
4781 || h
->root
.u
.def
.section
!= slook
)
4783 else if (h
!= hlook
)
4785 hlook
->u
.weakdef
= h
;
4787 /* If the weak definition is in the list of dynamic
4788 symbols, make sure the real definition is put
4790 if (hlook
->dynindx
!= -1 && h
->dynindx
== -1)
4792 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4795 free (sorted_sym_hash
);
4800 /* If the real definition is in the list of dynamic
4801 symbols, make sure the weak definition is put
4802 there as well. If we don't do this, then the
4803 dynamic loader might not merge the entries for the
4804 real definition and the weak definition. */
4805 if (h
->dynindx
!= -1 && hlook
->dynindx
== -1)
4807 if (! bfd_elf_link_record_dynamic_symbol (info
, hlook
))
4808 goto err_free_sym_hash
;
4815 free (sorted_sym_hash
);
4818 if (bed
->check_directives
4819 && !(*bed
->check_directives
) (abfd
, info
))
4822 /* If this object is the same format as the output object, and it is
4823 not a shared library, then let the backend look through the
4826 This is required to build global offset table entries and to
4827 arrange for dynamic relocs. It is not required for the
4828 particular common case of linking non PIC code, even when linking
4829 against shared libraries, but unfortunately there is no way of
4830 knowing whether an object file has been compiled PIC or not.
4831 Looking through the relocs is not particularly time consuming.
4832 The problem is that we must either (1) keep the relocs in memory,
4833 which causes the linker to require additional runtime memory or
4834 (2) read the relocs twice from the input file, which wastes time.
4835 This would be a good case for using mmap.
4837 I have no idea how to handle linking PIC code into a file of a
4838 different format. It probably can't be done. */
4840 && is_elf_hash_table (htab
)
4841 && bed
->check_relocs
!= NULL
4842 && elf_object_id (abfd
) == elf_hash_table_id (htab
)
4843 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
4847 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4849 Elf_Internal_Rela
*internal_relocs
;
4852 if ((o
->flags
& SEC_RELOC
) == 0
4853 || o
->reloc_count
== 0
4854 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
4855 && (o
->flags
& SEC_DEBUGGING
) != 0)
4856 || bfd_is_abs_section (o
->output_section
))
4859 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
4861 if (internal_relocs
== NULL
)
4864 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
4866 if (elf_section_data (o
)->relocs
!= internal_relocs
)
4867 free (internal_relocs
);
4874 /* If this is a non-traditional link, try to optimize the handling
4875 of the .stab/.stabstr sections. */
4877 && ! info
->traditional_format
4878 && is_elf_hash_table (htab
)
4879 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
4883 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
4884 if (stabstr
!= NULL
)
4886 bfd_size_type string_offset
= 0;
4889 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
4890 if (CONST_STRNEQ (stab
->name
, ".stab")
4891 && (!stab
->name
[5] ||
4892 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
4893 && (stab
->flags
& SEC_MERGE
) == 0
4894 && !bfd_is_abs_section (stab
->output_section
))
4896 struct bfd_elf_section_data
*secdata
;
4898 secdata
= elf_section_data (stab
);
4899 if (! _bfd_link_section_stabs (abfd
, &htab
->stab_info
, stab
,
4900 stabstr
, &secdata
->sec_info
,
4903 if (secdata
->sec_info
)
4904 stab
->sec_info_type
= SEC_INFO_TYPE_STABS
;
4909 if (is_elf_hash_table (htab
) && add_needed
)
4911 /* Add this bfd to the loaded list. */
4912 struct elf_link_loaded_list
*n
;
4914 n
= (struct elf_link_loaded_list
*)
4915 bfd_alloc (abfd
, sizeof (struct elf_link_loaded_list
));
4919 n
->next
= htab
->loaded
;
4926 if (old_tab
!= NULL
)
4928 if (nondeflt_vers
!= NULL
)
4929 free (nondeflt_vers
);
4930 if (extversym
!= NULL
)
4933 if (isymbuf
!= NULL
)
4939 /* Return the linker hash table entry of a symbol that might be
4940 satisfied by an archive symbol. Return -1 on error. */
4942 struct elf_link_hash_entry
*
4943 _bfd_elf_archive_symbol_lookup (bfd
*abfd
,
4944 struct bfd_link_info
*info
,
4947 struct elf_link_hash_entry
*h
;
4951 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, TRUE
);
4955 /* If this is a default version (the name contains @@), look up the
4956 symbol again with only one `@' as well as without the version.
4957 The effect is that references to the symbol with and without the
4958 version will be matched by the default symbol in the archive. */
4960 p
= strchr (name
, ELF_VER_CHR
);
4961 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
4964 /* First check with only one `@'. */
4965 len
= strlen (name
);
4966 copy
= (char *) bfd_alloc (abfd
, len
);
4968 return (struct elf_link_hash_entry
*) 0 - 1;
4970 first
= p
- name
+ 1;
4971 memcpy (copy
, name
, first
);
4972 memcpy (copy
+ first
, name
+ first
+ 1, len
- first
);
4974 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
, FALSE
, FALSE
, TRUE
);
4977 /* We also need to check references to the symbol without the
4979 copy
[first
- 1] = '\0';
4980 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
4981 FALSE
, FALSE
, TRUE
);
4984 bfd_release (abfd
, copy
);
4988 /* Add symbols from an ELF archive file to the linker hash table. We
4989 don't use _bfd_generic_link_add_archive_symbols because of a
4990 problem which arises on UnixWare. The UnixWare libc.so is an
4991 archive which includes an entry libc.so.1 which defines a bunch of
4992 symbols. The libc.so archive also includes a number of other
4993 object files, which also define symbols, some of which are the same
4994 as those defined in libc.so.1. Correct linking requires that we
4995 consider each object file in turn, and include it if it defines any
4996 symbols we need. _bfd_generic_link_add_archive_symbols does not do
4997 this; it looks through the list of undefined symbols, and includes
4998 any object file which defines them. When this algorithm is used on
4999 UnixWare, it winds up pulling in libc.so.1 early and defining a
5000 bunch of symbols. This means that some of the other objects in the
5001 archive are not included in the link, which is incorrect since they
5002 precede libc.so.1 in the archive.
5004 Fortunately, ELF archive handling is simpler than that done by
5005 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
5006 oddities. In ELF, if we find a symbol in the archive map, and the
5007 symbol is currently undefined, we know that we must pull in that
5010 Unfortunately, we do have to make multiple passes over the symbol
5011 table until nothing further is resolved. */
5014 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5017 bfd_boolean
*defined
= NULL
;
5018 bfd_boolean
*included
= NULL
;
5022 const struct elf_backend_data
*bed
;
5023 struct elf_link_hash_entry
* (*archive_symbol_lookup
)
5024 (bfd
*, struct bfd_link_info
*, const char *);
5026 if (! bfd_has_map (abfd
))
5028 /* An empty archive is a special case. */
5029 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
5031 bfd_set_error (bfd_error_no_armap
);
5035 /* Keep track of all symbols we know to be already defined, and all
5036 files we know to be already included. This is to speed up the
5037 second and subsequent passes. */
5038 c
= bfd_ardata (abfd
)->symdef_count
;
5042 amt
*= sizeof (bfd_boolean
);
5043 defined
= (bfd_boolean
*) bfd_zmalloc (amt
);
5044 included
= (bfd_boolean
*) bfd_zmalloc (amt
);
5045 if (defined
== NULL
|| included
== NULL
)
5048 symdefs
= bfd_ardata (abfd
)->symdefs
;
5049 bed
= get_elf_backend_data (abfd
);
5050 archive_symbol_lookup
= bed
->elf_backend_archive_symbol_lookup
;
5063 symdefend
= symdef
+ c
;
5064 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
5066 struct elf_link_hash_entry
*h
;
5068 struct bfd_link_hash_entry
*undefs_tail
;
5071 if (defined
[i
] || included
[i
])
5073 if (symdef
->file_offset
== last
)
5079 h
= archive_symbol_lookup (abfd
, info
, symdef
->name
);
5080 if (h
== (struct elf_link_hash_entry
*) 0 - 1)
5086 if (h
->root
.type
== bfd_link_hash_common
)
5088 /* We currently have a common symbol. The archive map contains
5089 a reference to this symbol, so we may want to include it. We
5090 only want to include it however, if this archive element
5091 contains a definition of the symbol, not just another common
5094 Unfortunately some archivers (including GNU ar) will put
5095 declarations of common symbols into their archive maps, as
5096 well as real definitions, so we cannot just go by the archive
5097 map alone. Instead we must read in the element's symbol
5098 table and check that to see what kind of symbol definition
5100 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
5103 else if (h
->root
.type
!= bfd_link_hash_undefined
)
5105 if (h
->root
.type
!= bfd_link_hash_undefweak
)
5110 /* We need to include this archive member. */
5111 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
5112 if (element
== NULL
)
5115 if (! bfd_check_format (element
, bfd_object
))
5118 /* Doublecheck that we have not included this object
5119 already--it should be impossible, but there may be
5120 something wrong with the archive. */
5121 if (element
->archive_pass
!= 0)
5123 bfd_set_error (bfd_error_bad_value
);
5126 element
->archive_pass
= 1;
5128 undefs_tail
= info
->hash
->undefs_tail
;
5130 if (!(*info
->callbacks
5131 ->add_archive_element
) (info
, element
, symdef
->name
, &element
))
5133 if (!bfd_link_add_symbols (element
, info
))
5136 /* If there are any new undefined symbols, we need to make
5137 another pass through the archive in order to see whether
5138 they can be defined. FIXME: This isn't perfect, because
5139 common symbols wind up on undefs_tail and because an
5140 undefined symbol which is defined later on in this pass
5141 does not require another pass. This isn't a bug, but it
5142 does make the code less efficient than it could be. */
5143 if (undefs_tail
!= info
->hash
->undefs_tail
)
5146 /* Look backward to mark all symbols from this object file
5147 which we have already seen in this pass. */
5151 included
[mark
] = TRUE
;
5156 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
5158 /* We mark subsequent symbols from this object file as we go
5159 on through the loop. */
5160 last
= symdef
->file_offset
;
5171 if (defined
!= NULL
)
5173 if (included
!= NULL
)
5178 /* Given an ELF BFD, add symbols to the global hash table as
5182 bfd_elf_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5184 switch (bfd_get_format (abfd
))
5187 return elf_link_add_object_symbols (abfd
, info
);
5189 return elf_link_add_archive_symbols (abfd
, info
);
5191 bfd_set_error (bfd_error_wrong_format
);
5196 struct hash_codes_info
5198 unsigned long *hashcodes
;
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_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5208 struct hash_codes_info
*inf
= (struct hash_codes_info
*) data
;
5214 /* Ignore indirect symbols. These are added by the versioning code. */
5215 if (h
->dynindx
== -1)
5218 name
= h
->root
.root
.string
;
5219 p
= strchr (name
, ELF_VER_CHR
);
5222 alc
= (char *) bfd_malloc (p
- name
+ 1);
5228 memcpy (alc
, name
, p
- name
);
5229 alc
[p
- name
] = '\0';
5233 /* Compute the hash value. */
5234 ha
= bfd_elf_hash (name
);
5236 /* Store the found hash value in the array given as the argument. */
5237 *(inf
->hashcodes
)++ = ha
;
5239 /* And store it in the struct so that we can put it in the hash table
5241 h
->u
.elf_hash_value
= ha
;
5249 struct collect_gnu_hash_codes
5252 const struct elf_backend_data
*bed
;
5253 unsigned long int nsyms
;
5254 unsigned long int maskbits
;
5255 unsigned long int *hashcodes
;
5256 unsigned long int *hashval
;
5257 unsigned long int *indx
;
5258 unsigned long int *counts
;
5261 long int min_dynindx
;
5262 unsigned long int bucketcount
;
5263 unsigned long int symindx
;
5264 long int local_indx
;
5265 long int shift1
, shift2
;
5266 unsigned long int mask
;
5270 /* This function will be called though elf_link_hash_traverse to store
5271 all hash value of the exported symbols in an array. */
5274 elf_collect_gnu_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5276 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5282 /* Ignore indirect symbols. These are added by the versioning code. */
5283 if (h
->dynindx
== -1)
5286 /* Ignore also local symbols and undefined symbols. */
5287 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5290 name
= h
->root
.root
.string
;
5291 p
= strchr (name
, ELF_VER_CHR
);
5294 alc
= (char *) bfd_malloc (p
- name
+ 1);
5300 memcpy (alc
, name
, p
- name
);
5301 alc
[p
- name
] = '\0';
5305 /* Compute the hash value. */
5306 ha
= bfd_elf_gnu_hash (name
);
5308 /* Store the found hash value in the array for compute_bucket_count,
5309 and also for .dynsym reordering purposes. */
5310 s
->hashcodes
[s
->nsyms
] = ha
;
5311 s
->hashval
[h
->dynindx
] = ha
;
5313 if (s
->min_dynindx
< 0 || s
->min_dynindx
> h
->dynindx
)
5314 s
->min_dynindx
= h
->dynindx
;
5322 /* This function will be called though elf_link_hash_traverse to do
5323 final dynaminc symbol renumbering. */
5326 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry
*h
, void *data
)
5328 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5329 unsigned long int bucket
;
5330 unsigned long int val
;
5332 /* Ignore indirect symbols. */
5333 if (h
->dynindx
== -1)
5336 /* Ignore also local symbols and undefined symbols. */
5337 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5339 if (h
->dynindx
>= s
->min_dynindx
)
5340 h
->dynindx
= s
->local_indx
++;
5344 bucket
= s
->hashval
[h
->dynindx
] % s
->bucketcount
;
5345 val
= (s
->hashval
[h
->dynindx
] >> s
->shift1
)
5346 & ((s
->maskbits
>> s
->shift1
) - 1);
5347 s
->bitmask
[val
] |= ((bfd_vma
) 1) << (s
->hashval
[h
->dynindx
] & s
->mask
);
5349 |= ((bfd_vma
) 1) << ((s
->hashval
[h
->dynindx
] >> s
->shift2
) & s
->mask
);
5350 val
= s
->hashval
[h
->dynindx
] & ~(unsigned long int) 1;
5351 if (s
->counts
[bucket
] == 1)
5352 /* Last element terminates the chain. */
5354 bfd_put_32 (s
->output_bfd
, val
,
5355 s
->contents
+ (s
->indx
[bucket
] - s
->symindx
) * 4);
5356 --s
->counts
[bucket
];
5357 h
->dynindx
= s
->indx
[bucket
]++;
5361 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5364 _bfd_elf_hash_symbol (struct elf_link_hash_entry
*h
)
5366 return !(h
->forced_local
5367 || h
->root
.type
== bfd_link_hash_undefined
5368 || h
->root
.type
== bfd_link_hash_undefweak
5369 || ((h
->root
.type
== bfd_link_hash_defined
5370 || h
->root
.type
== bfd_link_hash_defweak
)
5371 && h
->root
.u
.def
.section
->output_section
== NULL
));
5374 /* Array used to determine the number of hash table buckets to use
5375 based on the number of symbols there are. If there are fewer than
5376 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5377 fewer than 37 we use 17 buckets, and so forth. We never use more
5378 than 32771 buckets. */
5380 static const size_t elf_buckets
[] =
5382 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5386 /* Compute bucket count for hashing table. We do not use a static set
5387 of possible tables sizes anymore. Instead we determine for all
5388 possible reasonable sizes of the table the outcome (i.e., the
5389 number of collisions etc) and choose the best solution. The
5390 weighting functions are not too simple to allow the table to grow
5391 without bounds. Instead one of the weighting factors is the size.
5392 Therefore the result is always a good payoff between few collisions
5393 (= short chain lengths) and table size. */
5395 compute_bucket_count (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5396 unsigned long int *hashcodes ATTRIBUTE_UNUSED
,
5397 unsigned long int nsyms
,
5400 size_t best_size
= 0;
5401 unsigned long int i
;
5403 /* We have a problem here. The following code to optimize the table
5404 size requires an integer type with more the 32 bits. If
5405 BFD_HOST_U_64_BIT is set we know about such a type. */
5406 #ifdef BFD_HOST_U_64_BIT
5411 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
5412 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
5413 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5414 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
5415 unsigned long int *counts
;
5417 unsigned int no_improvement_count
= 0;
5419 /* Possible optimization parameters: if we have NSYMS symbols we say
5420 that the hashing table must at least have NSYMS/4 and at most
5422 minsize
= nsyms
/ 4;
5425 best_size
= maxsize
= nsyms
* 2;
5430 if ((best_size
& 31) == 0)
5434 /* Create array where we count the collisions in. We must use bfd_malloc
5435 since the size could be large. */
5437 amt
*= sizeof (unsigned long int);
5438 counts
= (unsigned long int *) bfd_malloc (amt
);
5442 /* Compute the "optimal" size for the hash table. The criteria is a
5443 minimal chain length. The minor criteria is (of course) the size
5445 for (i
= minsize
; i
< maxsize
; ++i
)
5447 /* Walk through the array of hashcodes and count the collisions. */
5448 BFD_HOST_U_64_BIT max
;
5449 unsigned long int j
;
5450 unsigned long int fact
;
5452 if (gnu_hash
&& (i
& 31) == 0)
5455 memset (counts
, '\0', i
* sizeof (unsigned long int));
5457 /* Determine how often each hash bucket is used. */
5458 for (j
= 0; j
< nsyms
; ++j
)
5459 ++counts
[hashcodes
[j
] % i
];
5461 /* For the weight function we need some information about the
5462 pagesize on the target. This is information need not be 100%
5463 accurate. Since this information is not available (so far) we
5464 define it here to a reasonable default value. If it is crucial
5465 to have a better value some day simply define this value. */
5466 # ifndef BFD_TARGET_PAGESIZE
5467 # define BFD_TARGET_PAGESIZE (4096)
5470 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5472 max
= (2 + dynsymcount
) * bed
->s
->sizeof_hash_entry
;
5475 /* Variant 1: optimize for short chains. We add the squares
5476 of all the chain lengths (which favors many small chain
5477 over a few long chains). */
5478 for (j
= 0; j
< i
; ++j
)
5479 max
+= counts
[j
] * counts
[j
];
5481 /* This adds penalties for the overall size of the table. */
5482 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5485 /* Variant 2: Optimize a lot more for small table. Here we
5486 also add squares of the size but we also add penalties for
5487 empty slots (the +1 term). */
5488 for (j
= 0; j
< i
; ++j
)
5489 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
5491 /* The overall size of the table is considered, but not as
5492 strong as in variant 1, where it is squared. */
5493 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5497 /* Compare with current best results. */
5498 if (max
< best_chlen
)
5502 no_improvement_count
= 0;
5504 /* PR 11843: Avoid futile long searches for the best bucket size
5505 when there are a large number of symbols. */
5506 else if (++no_improvement_count
== 100)
5513 #endif /* defined (BFD_HOST_U_64_BIT) */
5515 /* This is the fallback solution if no 64bit type is available or if we
5516 are not supposed to spend much time on optimizations. We select the
5517 bucket count using a fixed set of numbers. */
5518 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5520 best_size
= elf_buckets
[i
];
5521 if (nsyms
< elf_buckets
[i
+ 1])
5524 if (gnu_hash
&& best_size
< 2)
5531 /* Size any SHT_GROUP section for ld -r. */
5534 _bfd_elf_size_group_sections (struct bfd_link_info
*info
)
5538 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
5539 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
5540 && !_bfd_elf_fixup_group_sections (ibfd
, bfd_abs_section_ptr
))
5545 /* Set up the sizes and contents of the ELF dynamic sections. This is
5546 called by the ELF linker emulation before_allocation routine. We
5547 must set the sizes of the sections before the linker sets the
5548 addresses of the various sections. */
5551 bfd_elf_size_dynamic_sections (bfd
*output_bfd
,
5554 const char *filter_shlib
,
5556 const char *depaudit
,
5557 const char * const *auxiliary_filters
,
5558 struct bfd_link_info
*info
,
5559 asection
**sinterpptr
)
5561 bfd_size_type soname_indx
;
5563 const struct elf_backend_data
*bed
;
5564 struct elf_info_failed asvinfo
;
5568 soname_indx
= (bfd_size_type
) -1;
5570 if (!is_elf_hash_table (info
->hash
))
5573 bed
= get_elf_backend_data (output_bfd
);
5574 if (info
->execstack
)
5575 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
5576 else if (info
->noexecstack
)
5577 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
;
5581 asection
*notesec
= NULL
;
5584 for (inputobj
= info
->input_bfds
;
5586 inputobj
= inputobj
->link_next
)
5591 & (DYNAMIC
| EXEC_P
| BFD_PLUGIN
| BFD_LINKER_CREATED
))
5593 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
5596 if (s
->flags
& SEC_CODE
)
5600 else if (bed
->default_execstack
)
5605 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| exec
;
5606 if (exec
&& info
->relocatable
5607 && notesec
->output_section
!= bfd_abs_section_ptr
)
5608 notesec
->output_section
->flags
|= SEC_CODE
;
5612 /* Any syms created from now on start with -1 in
5613 got.refcount/offset and plt.refcount/offset. */
5614 elf_hash_table (info
)->init_got_refcount
5615 = elf_hash_table (info
)->init_got_offset
;
5616 elf_hash_table (info
)->init_plt_refcount
5617 = elf_hash_table (info
)->init_plt_offset
;
5619 if (info
->relocatable
5620 && !_bfd_elf_size_group_sections (info
))
5623 /* The backend may have to create some sections regardless of whether
5624 we're dynamic or not. */
5625 if (bed
->elf_backend_always_size_sections
5626 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
5629 dynobj
= elf_hash_table (info
)->dynobj
;
5631 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
5633 struct elf_info_failed eif
;
5634 struct elf_link_hash_entry
*h
;
5636 struct bfd_elf_version_tree
*t
;
5637 struct bfd_elf_version_expr
*d
;
5639 bfd_boolean all_defined
;
5641 *sinterpptr
= bfd_get_linker_section (dynobj
, ".interp");
5642 BFD_ASSERT (*sinterpptr
!= NULL
|| !info
->executable
);
5646 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5648 if (soname_indx
== (bfd_size_type
) -1
5649 || !_bfd_elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
5655 if (!_bfd_elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
5657 info
->flags
|= DF_SYMBOLIC
;
5664 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5666 if (indx
== (bfd_size_type
) -1
5667 || !_bfd_elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5670 if (info
->new_dtags
)
5672 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
, indx
);
5673 if (!_bfd_elf_add_dynamic_entry (info
, DT_RUNPATH
, indx
))
5678 if (filter_shlib
!= NULL
)
5682 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5683 filter_shlib
, TRUE
);
5684 if (indx
== (bfd_size_type
) -1
5685 || !_bfd_elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
5689 if (auxiliary_filters
!= NULL
)
5691 const char * const *p
;
5693 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
5697 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5699 if (indx
== (bfd_size_type
) -1
5700 || !_bfd_elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
5709 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, audit
,
5711 if (indx
== (bfd_size_type
) -1
5712 || !_bfd_elf_add_dynamic_entry (info
, DT_AUDIT
, indx
))
5716 if (depaudit
!= NULL
)
5720 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, depaudit
,
5722 if (indx
== (bfd_size_type
) -1
5723 || !_bfd_elf_add_dynamic_entry (info
, DT_DEPAUDIT
, indx
))
5730 /* If we are supposed to export all symbols into the dynamic symbol
5731 table (this is not the normal case), then do so. */
5732 if (info
->export_dynamic
5733 || (info
->executable
&& info
->dynamic
))
5735 elf_link_hash_traverse (elf_hash_table (info
),
5736 _bfd_elf_export_symbol
,
5742 /* Make all global versions with definition. */
5743 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
5744 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5745 if (!d
->symver
&& d
->literal
)
5747 const char *verstr
, *name
;
5748 size_t namelen
, verlen
, newlen
;
5749 char *newname
, *p
, leading_char
;
5750 struct elf_link_hash_entry
*newh
;
5752 leading_char
= bfd_get_symbol_leading_char (output_bfd
);
5754 namelen
= strlen (name
) + (leading_char
!= '\0');
5756 verlen
= strlen (verstr
);
5757 newlen
= namelen
+ verlen
+ 3;
5759 newname
= (char *) bfd_malloc (newlen
);
5760 if (newname
== NULL
)
5762 newname
[0] = leading_char
;
5763 memcpy (newname
+ (leading_char
!= '\0'), name
, namelen
);
5765 /* Check the hidden versioned definition. */
5766 p
= newname
+ namelen
;
5768 memcpy (p
, verstr
, verlen
+ 1);
5769 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5770 newname
, FALSE
, FALSE
,
5773 || (newh
->root
.type
!= bfd_link_hash_defined
5774 && newh
->root
.type
!= bfd_link_hash_defweak
))
5776 /* Check the default versioned definition. */
5778 memcpy (p
, verstr
, verlen
+ 1);
5779 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5780 newname
, FALSE
, FALSE
,
5785 /* Mark this version if there is a definition and it is
5786 not defined in a shared object. */
5788 && !newh
->def_dynamic
5789 && (newh
->root
.type
== bfd_link_hash_defined
5790 || newh
->root
.type
== bfd_link_hash_defweak
))
5794 /* Attach all the symbols to their version information. */
5795 asvinfo
.info
= info
;
5796 asvinfo
.failed
= FALSE
;
5798 elf_link_hash_traverse (elf_hash_table (info
),
5799 _bfd_elf_link_assign_sym_version
,
5804 if (!info
->allow_undefined_version
)
5806 /* Check if all global versions have a definition. */
5808 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
5809 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5810 if (d
->literal
&& !d
->symver
&& !d
->script
)
5812 (*_bfd_error_handler
)
5813 (_("%s: undefined version: %s"),
5814 d
->pattern
, t
->name
);
5815 all_defined
= FALSE
;
5820 bfd_set_error (bfd_error_bad_value
);
5825 /* Find all symbols which were defined in a dynamic object and make
5826 the backend pick a reasonable value for them. */
5827 elf_link_hash_traverse (elf_hash_table (info
),
5828 _bfd_elf_adjust_dynamic_symbol
,
5833 /* Add some entries to the .dynamic section. We fill in some of the
5834 values later, in bfd_elf_final_link, but we must add the entries
5835 now so that we know the final size of the .dynamic section. */
5837 /* If there are initialization and/or finalization functions to
5838 call then add the corresponding DT_INIT/DT_FINI entries. */
5839 h
= (info
->init_function
5840 ? elf_link_hash_lookup (elf_hash_table (info
),
5841 info
->init_function
, FALSE
,
5848 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT
, 0))
5851 h
= (info
->fini_function
5852 ? elf_link_hash_lookup (elf_hash_table (info
),
5853 info
->fini_function
, FALSE
,
5860 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI
, 0))
5864 s
= bfd_get_section_by_name (output_bfd
, ".preinit_array");
5865 if (s
!= NULL
&& s
->linker_has_input
)
5867 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5868 if (! info
->executable
)
5873 for (sub
= info
->input_bfds
; sub
!= NULL
;
5874 sub
= sub
->link_next
)
5875 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
)
5876 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5877 if (elf_section_data (o
)->this_hdr
.sh_type
5878 == SHT_PREINIT_ARRAY
)
5880 (*_bfd_error_handler
)
5881 (_("%B: .preinit_array section is not allowed in DSO"),
5886 bfd_set_error (bfd_error_nonrepresentable_section
);
5890 if (!_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
5891 || !_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
5894 s
= bfd_get_section_by_name (output_bfd
, ".init_array");
5895 if (s
!= NULL
&& s
->linker_has_input
)
5897 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
5898 || !_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
5901 s
= bfd_get_section_by_name (output_bfd
, ".fini_array");
5902 if (s
!= NULL
&& s
->linker_has_input
)
5904 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
5905 || !_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
5909 dynstr
= bfd_get_linker_section (dynobj
, ".dynstr");
5910 /* If .dynstr is excluded from the link, we don't want any of
5911 these tags. Strictly, we should be checking each section
5912 individually; This quick check covers for the case where
5913 someone does a /DISCARD/ : { *(*) }. */
5914 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
5916 bfd_size_type strsize
;
5918 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
5919 if ((info
->emit_hash
5920 && !_bfd_elf_add_dynamic_entry (info
, DT_HASH
, 0))
5921 || (info
->emit_gnu_hash
5922 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_HASH
, 0))
5923 || !_bfd_elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5924 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5925 || !_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5926 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMENT
,
5927 bed
->s
->sizeof_sym
))
5932 /* The backend must work out the sizes of all the other dynamic
5935 && bed
->elf_backend_size_dynamic_sections
!= NULL
5936 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5939 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
5942 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
5944 unsigned long section_sym_count
;
5945 struct bfd_elf_version_tree
*verdefs
;
5948 /* Set up the version definition section. */
5949 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
5950 BFD_ASSERT (s
!= NULL
);
5952 /* We may have created additional version definitions if we are
5953 just linking a regular application. */
5954 verdefs
= info
->version_info
;
5956 /* Skip anonymous version tag. */
5957 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
5958 verdefs
= verdefs
->next
;
5960 if (verdefs
== NULL
&& !info
->create_default_symver
)
5961 s
->flags
|= SEC_EXCLUDE
;
5966 struct bfd_elf_version_tree
*t
;
5968 Elf_Internal_Verdef def
;
5969 Elf_Internal_Verdaux defaux
;
5970 struct bfd_link_hash_entry
*bh
;
5971 struct elf_link_hash_entry
*h
;
5977 /* Make space for the base version. */
5978 size
+= sizeof (Elf_External_Verdef
);
5979 size
+= sizeof (Elf_External_Verdaux
);
5982 /* Make space for the default version. */
5983 if (info
->create_default_symver
)
5985 size
+= sizeof (Elf_External_Verdef
);
5989 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5991 struct bfd_elf_version_deps
*n
;
5993 /* Don't emit base version twice. */
5997 size
+= sizeof (Elf_External_Verdef
);
5998 size
+= sizeof (Elf_External_Verdaux
);
6001 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6002 size
+= sizeof (Elf_External_Verdaux
);
6006 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6007 if (s
->contents
== NULL
&& s
->size
!= 0)
6010 /* Fill in the version definition section. */
6014 def
.vd_version
= VER_DEF_CURRENT
;
6015 def
.vd_flags
= VER_FLG_BASE
;
6018 if (info
->create_default_symver
)
6020 def
.vd_aux
= 2 * sizeof (Elf_External_Verdef
);
6021 def
.vd_next
= sizeof (Elf_External_Verdef
);
6025 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6026 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6027 + sizeof (Elf_External_Verdaux
));
6030 if (soname_indx
!= (bfd_size_type
) -1)
6032 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6034 def
.vd_hash
= bfd_elf_hash (soname
);
6035 defaux
.vda_name
= soname_indx
;
6042 name
= lbasename (output_bfd
->filename
);
6043 def
.vd_hash
= bfd_elf_hash (name
);
6044 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6046 if (indx
== (bfd_size_type
) -1)
6048 defaux
.vda_name
= indx
;
6050 defaux
.vda_next
= 0;
6052 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6053 (Elf_External_Verdef
*) p
);
6054 p
+= sizeof (Elf_External_Verdef
);
6055 if (info
->create_default_symver
)
6057 /* Add a symbol representing this version. */
6059 if (! (_bfd_generic_link_add_one_symbol
6060 (info
, dynobj
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6062 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6064 h
= (struct elf_link_hash_entry
*) bh
;
6067 h
->type
= STT_OBJECT
;
6068 h
->verinfo
.vertree
= NULL
;
6070 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6073 /* Create a duplicate of the base version with the same
6074 aux block, but different flags. */
6077 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6079 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6080 + sizeof (Elf_External_Verdaux
));
6083 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6084 (Elf_External_Verdef
*) p
);
6085 p
+= sizeof (Elf_External_Verdef
);
6087 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6088 (Elf_External_Verdaux
*) p
);
6089 p
+= sizeof (Elf_External_Verdaux
);
6091 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6094 struct bfd_elf_version_deps
*n
;
6096 /* Don't emit the base version twice. */
6101 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6104 /* Add a symbol representing this version. */
6106 if (! (_bfd_generic_link_add_one_symbol
6107 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6109 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6111 h
= (struct elf_link_hash_entry
*) bh
;
6114 h
->type
= STT_OBJECT
;
6115 h
->verinfo
.vertree
= t
;
6117 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6120 def
.vd_version
= VER_DEF_CURRENT
;
6122 if (t
->globals
.list
== NULL
6123 && t
->locals
.list
== NULL
6125 def
.vd_flags
|= VER_FLG_WEAK
;
6126 def
.vd_ndx
= t
->vernum
+ (info
->create_default_symver
? 2 : 1);
6127 def
.vd_cnt
= cdeps
+ 1;
6128 def
.vd_hash
= bfd_elf_hash (t
->name
);
6129 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6132 /* If a basever node is next, it *must* be the last node in
6133 the chain, otherwise Verdef construction breaks. */
6134 if (t
->next
!= NULL
&& t
->next
->vernum
== 0)
6135 BFD_ASSERT (t
->next
->next
== NULL
);
6137 if (t
->next
!= NULL
&& t
->next
->vernum
!= 0)
6138 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6139 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
6141 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6142 (Elf_External_Verdef
*) p
);
6143 p
+= sizeof (Elf_External_Verdef
);
6145 defaux
.vda_name
= h
->dynstr_index
;
6146 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6148 defaux
.vda_next
= 0;
6149 if (t
->deps
!= NULL
)
6150 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6151 t
->name_indx
= defaux
.vda_name
;
6153 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6154 (Elf_External_Verdaux
*) p
);
6155 p
+= sizeof (Elf_External_Verdaux
);
6157 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6159 if (n
->version_needed
== NULL
)
6161 /* This can happen if there was an error in the
6163 defaux
.vda_name
= 0;
6167 defaux
.vda_name
= n
->version_needed
->name_indx
;
6168 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6171 if (n
->next
== NULL
)
6172 defaux
.vda_next
= 0;
6174 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6176 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6177 (Elf_External_Verdaux
*) p
);
6178 p
+= sizeof (Elf_External_Verdaux
);
6182 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
6183 || !_bfd_elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
6186 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
6189 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
6191 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
6194 else if (info
->flags
& DF_BIND_NOW
)
6196 if (!_bfd_elf_add_dynamic_entry (info
, DT_BIND_NOW
, 0))
6202 if (info
->executable
)
6203 info
->flags_1
&= ~ (DF_1_INITFIRST
6206 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
6210 /* Work out the size of the version reference section. */
6212 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
6213 BFD_ASSERT (s
!= NULL
);
6215 struct elf_find_verdep_info sinfo
;
6218 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
6219 if (sinfo
.vers
== 0)
6221 sinfo
.failed
= FALSE
;
6223 elf_link_hash_traverse (elf_hash_table (info
),
6224 _bfd_elf_link_find_version_dependencies
,
6229 if (elf_tdata (output_bfd
)->verref
== NULL
)
6230 s
->flags
|= SEC_EXCLUDE
;
6233 Elf_Internal_Verneed
*t
;
6238 /* Build the version dependency section. */
6241 for (t
= elf_tdata (output_bfd
)->verref
;
6245 Elf_Internal_Vernaux
*a
;
6247 size
+= sizeof (Elf_External_Verneed
);
6249 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6250 size
+= sizeof (Elf_External_Vernaux
);
6254 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6255 if (s
->contents
== NULL
)
6259 for (t
= elf_tdata (output_bfd
)->verref
;
6264 Elf_Internal_Vernaux
*a
;
6268 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6271 t
->vn_version
= VER_NEED_CURRENT
;
6273 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6274 elf_dt_name (t
->vn_bfd
) != NULL
6275 ? elf_dt_name (t
->vn_bfd
)
6276 : lbasename (t
->vn_bfd
->filename
),
6278 if (indx
== (bfd_size_type
) -1)
6281 t
->vn_aux
= sizeof (Elf_External_Verneed
);
6282 if (t
->vn_nextref
== NULL
)
6285 t
->vn_next
= (sizeof (Elf_External_Verneed
)
6286 + caux
* sizeof (Elf_External_Vernaux
));
6288 _bfd_elf_swap_verneed_out (output_bfd
, t
,
6289 (Elf_External_Verneed
*) p
);
6290 p
+= sizeof (Elf_External_Verneed
);
6292 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6294 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
6295 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6296 a
->vna_nodename
, FALSE
);
6297 if (indx
== (bfd_size_type
) -1)
6300 if (a
->vna_nextptr
== NULL
)
6303 a
->vna_next
= sizeof (Elf_External_Vernaux
);
6305 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
6306 (Elf_External_Vernaux
*) p
);
6307 p
+= sizeof (Elf_External_Vernaux
);
6311 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
6312 || !_bfd_elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
6315 elf_tdata (output_bfd
)->cverrefs
= crefs
;
6319 if ((elf_tdata (output_bfd
)->cverrefs
== 0
6320 && elf_tdata (output_bfd
)->cverdefs
== 0)
6321 || _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6322 §ion_sym_count
) == 0)
6324 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6325 s
->flags
|= SEC_EXCLUDE
;
6331 /* Find the first non-excluded output section. We'll use its
6332 section symbol for some emitted relocs. */
6334 _bfd_elf_init_1_index_section (bfd
*output_bfd
, struct bfd_link_info
*info
)
6338 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6339 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
6340 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6342 elf_hash_table (info
)->text_index_section
= s
;
6347 /* Find two non-excluded output sections, one for code, one for data.
6348 We'll use their section symbols for some emitted relocs. */
6350 _bfd_elf_init_2_index_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6354 /* Data first, since setting text_index_section changes
6355 _bfd_elf_link_omit_section_dynsym. */
6356 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6357 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
)) == SEC_ALLOC
)
6358 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6360 elf_hash_table (info
)->data_index_section
= s
;
6364 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6365 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
))
6366 == (SEC_ALLOC
| SEC_READONLY
))
6367 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6369 elf_hash_table (info
)->text_index_section
= s
;
6373 if (elf_hash_table (info
)->text_index_section
== NULL
)
6374 elf_hash_table (info
)->text_index_section
6375 = elf_hash_table (info
)->data_index_section
;
6379 bfd_elf_size_dynsym_hash_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
6381 const struct elf_backend_data
*bed
;
6383 if (!is_elf_hash_table (info
->hash
))
6386 bed
= get_elf_backend_data (output_bfd
);
6387 (*bed
->elf_backend_init_index_section
) (output_bfd
, info
);
6389 if (elf_hash_table (info
)->dynamic_sections_created
)
6393 bfd_size_type dynsymcount
;
6394 unsigned long section_sym_count
;
6395 unsigned int dtagcount
;
6397 dynobj
= elf_hash_table (info
)->dynobj
;
6399 /* Assign dynsym indicies. In a shared library we generate a
6400 section symbol for each output section, which come first.
6401 Next come all of the back-end allocated local dynamic syms,
6402 followed by the rest of the global symbols. */
6404 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6405 §ion_sym_count
);
6407 /* Work out the size of the symbol version section. */
6408 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6409 BFD_ASSERT (s
!= NULL
);
6410 if (dynsymcount
!= 0
6411 && (s
->flags
& SEC_EXCLUDE
) == 0)
6413 s
->size
= dynsymcount
* sizeof (Elf_External_Versym
);
6414 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6415 if (s
->contents
== NULL
)
6418 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
6422 /* Set the size of the .dynsym and .hash sections. We counted
6423 the number of dynamic symbols in elf_link_add_object_symbols.
6424 We will build the contents of .dynsym and .hash when we build
6425 the final symbol table, because until then we do not know the
6426 correct value to give the symbols. We built the .dynstr
6427 section as we went along in elf_link_add_object_symbols. */
6428 s
= bfd_get_linker_section (dynobj
, ".dynsym");
6429 BFD_ASSERT (s
!= NULL
);
6430 s
->size
= dynsymcount
* bed
->s
->sizeof_sym
;
6432 if (dynsymcount
!= 0)
6434 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6435 if (s
->contents
== NULL
)
6438 /* The first entry in .dynsym is a dummy symbol.
6439 Clear all the section syms, in case we don't output them all. */
6440 ++section_sym_count
;
6441 memset (s
->contents
, 0, section_sym_count
* bed
->s
->sizeof_sym
);
6444 elf_hash_table (info
)->bucketcount
= 0;
6446 /* Compute the size of the hashing table. As a side effect this
6447 computes the hash values for all the names we export. */
6448 if (info
->emit_hash
)
6450 unsigned long int *hashcodes
;
6451 struct hash_codes_info hashinf
;
6453 unsigned long int nsyms
;
6455 size_t hash_entry_size
;
6457 /* Compute the hash values for all exported symbols. At the same
6458 time store the values in an array so that we could use them for
6460 amt
= dynsymcount
* sizeof (unsigned long int);
6461 hashcodes
= (unsigned long int *) bfd_malloc (amt
);
6462 if (hashcodes
== NULL
)
6464 hashinf
.hashcodes
= hashcodes
;
6465 hashinf
.error
= FALSE
;
6467 /* Put all hash values in HASHCODES. */
6468 elf_link_hash_traverse (elf_hash_table (info
),
6469 elf_collect_hash_codes
, &hashinf
);
6476 nsyms
= hashinf
.hashcodes
- hashcodes
;
6478 = compute_bucket_count (info
, hashcodes
, nsyms
, 0);
6481 if (bucketcount
== 0)
6484 elf_hash_table (info
)->bucketcount
= bucketcount
;
6486 s
= bfd_get_linker_section (dynobj
, ".hash");
6487 BFD_ASSERT (s
!= NULL
);
6488 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
6489 s
->size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
6490 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6491 if (s
->contents
== NULL
)
6494 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
6495 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
6496 s
->contents
+ hash_entry_size
);
6499 if (info
->emit_gnu_hash
)
6502 unsigned char *contents
;
6503 struct collect_gnu_hash_codes cinfo
;
6507 memset (&cinfo
, 0, sizeof (cinfo
));
6509 /* Compute the hash values for all exported symbols. At the same
6510 time store the values in an array so that we could use them for
6512 amt
= dynsymcount
* 2 * sizeof (unsigned long int);
6513 cinfo
.hashcodes
= (long unsigned int *) bfd_malloc (amt
);
6514 if (cinfo
.hashcodes
== NULL
)
6517 cinfo
.hashval
= cinfo
.hashcodes
+ dynsymcount
;
6518 cinfo
.min_dynindx
= -1;
6519 cinfo
.output_bfd
= output_bfd
;
6522 /* Put all hash values in HASHCODES. */
6523 elf_link_hash_traverse (elf_hash_table (info
),
6524 elf_collect_gnu_hash_codes
, &cinfo
);
6527 free (cinfo
.hashcodes
);
6532 = compute_bucket_count (info
, cinfo
.hashcodes
, cinfo
.nsyms
, 1);
6534 if (bucketcount
== 0)
6536 free (cinfo
.hashcodes
);
6540 s
= bfd_get_linker_section (dynobj
, ".gnu.hash");
6541 BFD_ASSERT (s
!= NULL
);
6543 if (cinfo
.nsyms
== 0)
6545 /* Empty .gnu.hash section is special. */
6546 BFD_ASSERT (cinfo
.min_dynindx
== -1);
6547 free (cinfo
.hashcodes
);
6548 s
->size
= 5 * 4 + bed
->s
->arch_size
/ 8;
6549 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6550 if (contents
== NULL
)
6552 s
->contents
= contents
;
6553 /* 1 empty bucket. */
6554 bfd_put_32 (output_bfd
, 1, contents
);
6555 /* SYMIDX above the special symbol 0. */
6556 bfd_put_32 (output_bfd
, 1, contents
+ 4);
6557 /* Just one word for bitmask. */
6558 bfd_put_32 (output_bfd
, 1, contents
+ 8);
6559 /* Only hash fn bloom filter. */
6560 bfd_put_32 (output_bfd
, 0, contents
+ 12);
6561 /* No hashes are valid - empty bitmask. */
6562 bfd_put (bed
->s
->arch_size
, output_bfd
, 0, contents
+ 16);
6563 /* No hashes in the only bucket. */
6564 bfd_put_32 (output_bfd
, 0,
6565 contents
+ 16 + bed
->s
->arch_size
/ 8);
6569 unsigned long int maskwords
, maskbitslog2
, x
;
6570 BFD_ASSERT (cinfo
.min_dynindx
!= -1);
6574 while ((x
>>= 1) != 0)
6576 if (maskbitslog2
< 3)
6578 else if ((1 << (maskbitslog2
- 2)) & cinfo
.nsyms
)
6579 maskbitslog2
= maskbitslog2
+ 3;
6581 maskbitslog2
= maskbitslog2
+ 2;
6582 if (bed
->s
->arch_size
== 64)
6584 if (maskbitslog2
== 5)
6590 cinfo
.mask
= (1 << cinfo
.shift1
) - 1;
6591 cinfo
.shift2
= maskbitslog2
;
6592 cinfo
.maskbits
= 1 << maskbitslog2
;
6593 maskwords
= 1 << (maskbitslog2
- cinfo
.shift1
);
6594 amt
= bucketcount
* sizeof (unsigned long int) * 2;
6595 amt
+= maskwords
* sizeof (bfd_vma
);
6596 cinfo
.bitmask
= (bfd_vma
*) bfd_malloc (amt
);
6597 if (cinfo
.bitmask
== NULL
)
6599 free (cinfo
.hashcodes
);
6603 cinfo
.counts
= (long unsigned int *) (cinfo
.bitmask
+ maskwords
);
6604 cinfo
.indx
= cinfo
.counts
+ bucketcount
;
6605 cinfo
.symindx
= dynsymcount
- cinfo
.nsyms
;
6606 memset (cinfo
.bitmask
, 0, maskwords
* sizeof (bfd_vma
));
6608 /* Determine how often each hash bucket is used. */
6609 memset (cinfo
.counts
, 0, bucketcount
* sizeof (cinfo
.counts
[0]));
6610 for (i
= 0; i
< cinfo
.nsyms
; ++i
)
6611 ++cinfo
.counts
[cinfo
.hashcodes
[i
] % bucketcount
];
6613 for (i
= 0, cnt
= cinfo
.symindx
; i
< bucketcount
; ++i
)
6614 if (cinfo
.counts
[i
] != 0)
6616 cinfo
.indx
[i
] = cnt
;
6617 cnt
+= cinfo
.counts
[i
];
6619 BFD_ASSERT (cnt
== dynsymcount
);
6620 cinfo
.bucketcount
= bucketcount
;
6621 cinfo
.local_indx
= cinfo
.min_dynindx
;
6623 s
->size
= (4 + bucketcount
+ cinfo
.nsyms
) * 4;
6624 s
->size
+= cinfo
.maskbits
/ 8;
6625 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6626 if (contents
== NULL
)
6628 free (cinfo
.bitmask
);
6629 free (cinfo
.hashcodes
);
6633 s
->contents
= contents
;
6634 bfd_put_32 (output_bfd
, bucketcount
, contents
);
6635 bfd_put_32 (output_bfd
, cinfo
.symindx
, contents
+ 4);
6636 bfd_put_32 (output_bfd
, maskwords
, contents
+ 8);
6637 bfd_put_32 (output_bfd
, cinfo
.shift2
, contents
+ 12);
6638 contents
+= 16 + cinfo
.maskbits
/ 8;
6640 for (i
= 0; i
< bucketcount
; ++i
)
6642 if (cinfo
.counts
[i
] == 0)
6643 bfd_put_32 (output_bfd
, 0, contents
);
6645 bfd_put_32 (output_bfd
, cinfo
.indx
[i
], contents
);
6649 cinfo
.contents
= contents
;
6651 /* Renumber dynamic symbols, populate .gnu.hash section. */
6652 elf_link_hash_traverse (elf_hash_table (info
),
6653 elf_renumber_gnu_hash_syms
, &cinfo
);
6655 contents
= s
->contents
+ 16;
6656 for (i
= 0; i
< maskwords
; ++i
)
6658 bfd_put (bed
->s
->arch_size
, output_bfd
, cinfo
.bitmask
[i
],
6660 contents
+= bed
->s
->arch_size
/ 8;
6663 free (cinfo
.bitmask
);
6664 free (cinfo
.hashcodes
);
6668 s
= bfd_get_linker_section (dynobj
, ".dynstr");
6669 BFD_ASSERT (s
!= NULL
);
6671 elf_finalize_dynstr (output_bfd
, info
);
6673 s
->size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6675 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
6676 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0))
6683 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
6686 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
6689 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
);
6690 sec
->sec_info_type
= SEC_INFO_TYPE_NONE
;
6693 /* Finish SHF_MERGE section merging. */
6696 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6701 if (!is_elf_hash_table (info
->hash
))
6704 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
6705 if ((ibfd
->flags
& DYNAMIC
) == 0)
6706 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6707 if ((sec
->flags
& SEC_MERGE
) != 0
6708 && !bfd_is_abs_section (sec
->output_section
))
6710 struct bfd_elf_section_data
*secdata
;
6712 secdata
= elf_section_data (sec
);
6713 if (! _bfd_add_merge_section (abfd
,
6714 &elf_hash_table (info
)->merge_info
,
6715 sec
, &secdata
->sec_info
))
6717 else if (secdata
->sec_info
)
6718 sec
->sec_info_type
= SEC_INFO_TYPE_MERGE
;
6721 if (elf_hash_table (info
)->merge_info
!= NULL
)
6722 _bfd_merge_sections (abfd
, info
, elf_hash_table (info
)->merge_info
,
6723 merge_sections_remove_hook
);
6727 /* Create an entry in an ELF linker hash table. */
6729 struct bfd_hash_entry
*
6730 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
6731 struct bfd_hash_table
*table
,
6734 /* Allocate the structure if it has not already been allocated by a
6738 entry
= (struct bfd_hash_entry
*)
6739 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
6744 /* Call the allocation method of the superclass. */
6745 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
6748 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
6749 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
6751 /* Set local fields. */
6754 ret
->got
= htab
->init_got_refcount
;
6755 ret
->plt
= htab
->init_plt_refcount
;
6756 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
6757 - offsetof (struct elf_link_hash_entry
, size
)));
6758 /* Assume that we have been called by a non-ELF symbol reader.
6759 This flag is then reset by the code which reads an ELF input
6760 file. This ensures that a symbol created by a non-ELF symbol
6761 reader will have the flag set correctly. */
6768 /* Copy data from an indirect symbol to its direct symbol, hiding the
6769 old indirect symbol. Also used for copying flags to a weakdef. */
6772 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info
*info
,
6773 struct elf_link_hash_entry
*dir
,
6774 struct elf_link_hash_entry
*ind
)
6776 struct elf_link_hash_table
*htab
;
6778 /* Copy down any references that we may have already seen to the
6779 symbol which just became indirect. */
6781 dir
->ref_dynamic
|= ind
->ref_dynamic
;
6782 dir
->ref_regular
|= ind
->ref_regular
;
6783 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
6784 dir
->non_got_ref
|= ind
->non_got_ref
;
6785 dir
->needs_plt
|= ind
->needs_plt
;
6786 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
6788 if (ind
->root
.type
!= bfd_link_hash_indirect
)
6791 /* Copy over the global and procedure linkage table refcount entries.
6792 These may have been already set up by a check_relocs routine. */
6793 htab
= elf_hash_table (info
);
6794 if (ind
->got
.refcount
> htab
->init_got_refcount
.refcount
)
6796 if (dir
->got
.refcount
< 0)
6797 dir
->got
.refcount
= 0;
6798 dir
->got
.refcount
+= ind
->got
.refcount
;
6799 ind
->got
.refcount
= htab
->init_got_refcount
.refcount
;
6802 if (ind
->plt
.refcount
> htab
->init_plt_refcount
.refcount
)
6804 if (dir
->plt
.refcount
< 0)
6805 dir
->plt
.refcount
= 0;
6806 dir
->plt
.refcount
+= ind
->plt
.refcount
;
6807 ind
->plt
.refcount
= htab
->init_plt_refcount
.refcount
;
6810 if (ind
->dynindx
!= -1)
6812 if (dir
->dynindx
!= -1)
6813 _bfd_elf_strtab_delref (htab
->dynstr
, dir
->dynstr_index
);
6814 dir
->dynindx
= ind
->dynindx
;
6815 dir
->dynstr_index
= ind
->dynstr_index
;
6817 ind
->dynstr_index
= 0;
6822 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
6823 struct elf_link_hash_entry
*h
,
6824 bfd_boolean force_local
)
6826 /* STT_GNU_IFUNC symbol must go through PLT. */
6827 if (h
->type
!= STT_GNU_IFUNC
)
6829 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
6834 h
->forced_local
= 1;
6835 if (h
->dynindx
!= -1)
6838 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
6844 /* Initialize an ELF linker hash table. */
6847 _bfd_elf_link_hash_table_init
6848 (struct elf_link_hash_table
*table
,
6850 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
6851 struct bfd_hash_table
*,
6853 unsigned int entsize
,
6854 enum elf_target_id target_id
)
6857 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
6859 memset (table
, 0, sizeof * table
);
6860 table
->init_got_refcount
.refcount
= can_refcount
- 1;
6861 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
6862 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
6863 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
6864 /* The first dynamic symbol is a dummy. */
6865 table
->dynsymcount
= 1;
6867 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
6869 table
->root
.type
= bfd_link_elf_hash_table
;
6870 table
->hash_table_id
= target_id
;
6875 /* Create an ELF linker hash table. */
6877 struct bfd_link_hash_table
*
6878 _bfd_elf_link_hash_table_create (bfd
*abfd
)
6880 struct elf_link_hash_table
*ret
;
6881 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
6883 ret
= (struct elf_link_hash_table
*) bfd_malloc (amt
);
6887 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
,
6888 sizeof (struct elf_link_hash_entry
),
6898 /* This is a hook for the ELF emulation code in the generic linker to
6899 tell the backend linker what file name to use for the DT_NEEDED
6900 entry for a dynamic object. */
6903 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
6905 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6906 && bfd_get_format (abfd
) == bfd_object
)
6907 elf_dt_name (abfd
) = name
;
6911 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
6914 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6915 && bfd_get_format (abfd
) == bfd_object
)
6916 lib_class
= elf_dyn_lib_class (abfd
);
6923 bfd_elf_set_dyn_lib_class (bfd
*abfd
, enum dynamic_lib_link_class lib_class
)
6925 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6926 && bfd_get_format (abfd
) == bfd_object
)
6927 elf_dyn_lib_class (abfd
) = lib_class
;
6930 /* Get the list of DT_NEEDED entries for a link. This is a hook for
6931 the linker ELF emulation code. */
6933 struct bfd_link_needed_list
*
6934 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
6935 struct bfd_link_info
*info
)
6937 if (! is_elf_hash_table (info
->hash
))
6939 return elf_hash_table (info
)->needed
;
6942 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
6943 hook for the linker ELF emulation code. */
6945 struct bfd_link_needed_list
*
6946 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
6947 struct bfd_link_info
*info
)
6949 if (! is_elf_hash_table (info
->hash
))
6951 return elf_hash_table (info
)->runpath
;
6954 /* Get the name actually used for a dynamic object for a link. This
6955 is the SONAME entry if there is one. Otherwise, it is the string
6956 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
6959 bfd_elf_get_dt_soname (bfd
*abfd
)
6961 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6962 && bfd_get_format (abfd
) == bfd_object
)
6963 return elf_dt_name (abfd
);
6967 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
6968 the ELF linker emulation code. */
6971 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
6972 struct bfd_link_needed_list
**pneeded
)
6975 bfd_byte
*dynbuf
= NULL
;
6976 unsigned int elfsec
;
6977 unsigned long shlink
;
6978 bfd_byte
*extdyn
, *extdynend
;
6980 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
6984 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
6985 || bfd_get_format (abfd
) != bfd_object
)
6988 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6989 if (s
== NULL
|| s
->size
== 0)
6992 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
6995 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
6996 if (elfsec
== SHN_BAD
)
6999 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
7001 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
7002 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
7005 extdynend
= extdyn
+ s
->size
;
7006 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
7008 Elf_Internal_Dyn dyn
;
7010 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
7012 if (dyn
.d_tag
== DT_NULL
)
7015 if (dyn
.d_tag
== DT_NEEDED
)
7018 struct bfd_link_needed_list
*l
;
7019 unsigned int tagv
= dyn
.d_un
.d_val
;
7022 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
7027 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
7048 struct elf_symbuf_symbol
7050 unsigned long st_name
; /* Symbol name, index in string tbl */
7051 unsigned char st_info
; /* Type and binding attributes */
7052 unsigned char st_other
; /* Visibilty, and target specific */
7055 struct elf_symbuf_head
7057 struct elf_symbuf_symbol
*ssym
;
7058 bfd_size_type count
;
7059 unsigned int st_shndx
;
7066 Elf_Internal_Sym
*isym
;
7067 struct elf_symbuf_symbol
*ssym
;
7072 /* Sort references to symbols by ascending section number. */
7075 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
7077 const Elf_Internal_Sym
*s1
= *(const Elf_Internal_Sym
**) arg1
;
7078 const Elf_Internal_Sym
*s2
= *(const Elf_Internal_Sym
**) arg2
;
7080 return s1
->st_shndx
- s2
->st_shndx
;
7084 elf_sym_name_compare (const void *arg1
, const void *arg2
)
7086 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
7087 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
7088 return strcmp (s1
->name
, s2
->name
);
7091 static struct elf_symbuf_head
*
7092 elf_create_symbuf (bfd_size_type symcount
, Elf_Internal_Sym
*isymbuf
)
7094 Elf_Internal_Sym
**ind
, **indbufend
, **indbuf
;
7095 struct elf_symbuf_symbol
*ssym
;
7096 struct elf_symbuf_head
*ssymbuf
, *ssymhead
;
7097 bfd_size_type i
, shndx_count
, total_size
;
7099 indbuf
= (Elf_Internal_Sym
**) bfd_malloc2 (symcount
, sizeof (*indbuf
));
7103 for (ind
= indbuf
, i
= 0; i
< symcount
; i
++)
7104 if (isymbuf
[i
].st_shndx
!= SHN_UNDEF
)
7105 *ind
++ = &isymbuf
[i
];
7108 qsort (indbuf
, indbufend
- indbuf
, sizeof (Elf_Internal_Sym
*),
7109 elf_sort_elf_symbol
);
7112 if (indbufend
> indbuf
)
7113 for (ind
= indbuf
, shndx_count
++; ind
< indbufend
- 1; ind
++)
7114 if (ind
[0]->st_shndx
!= ind
[1]->st_shndx
)
7117 total_size
= ((shndx_count
+ 1) * sizeof (*ssymbuf
)
7118 + (indbufend
- indbuf
) * sizeof (*ssym
));
7119 ssymbuf
= (struct elf_symbuf_head
*) bfd_malloc (total_size
);
7120 if (ssymbuf
== NULL
)
7126 ssym
= (struct elf_symbuf_symbol
*) (ssymbuf
+ shndx_count
+ 1);
7127 ssymbuf
->ssym
= NULL
;
7128 ssymbuf
->count
= shndx_count
;
7129 ssymbuf
->st_shndx
= 0;
7130 for (ssymhead
= ssymbuf
, ind
= indbuf
; ind
< indbufend
; ssym
++, ind
++)
7132 if (ind
== indbuf
|| ssymhead
->st_shndx
!= (*ind
)->st_shndx
)
7135 ssymhead
->ssym
= ssym
;
7136 ssymhead
->count
= 0;
7137 ssymhead
->st_shndx
= (*ind
)->st_shndx
;
7139 ssym
->st_name
= (*ind
)->st_name
;
7140 ssym
->st_info
= (*ind
)->st_info
;
7141 ssym
->st_other
= (*ind
)->st_other
;
7144 BFD_ASSERT ((bfd_size_type
) (ssymhead
- ssymbuf
) == shndx_count
7145 && (((bfd_hostptr_t
) ssym
- (bfd_hostptr_t
) ssymbuf
)
7152 /* Check if 2 sections define the same set of local and global
7156 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
,
7157 struct bfd_link_info
*info
)
7160 const struct elf_backend_data
*bed1
, *bed2
;
7161 Elf_Internal_Shdr
*hdr1
, *hdr2
;
7162 bfd_size_type symcount1
, symcount2
;
7163 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
7164 struct elf_symbuf_head
*ssymbuf1
, *ssymbuf2
;
7165 Elf_Internal_Sym
*isym
, *isymend
;
7166 struct elf_symbol
*symtable1
= NULL
, *symtable2
= NULL
;
7167 bfd_size_type count1
, count2
, i
;
7168 unsigned int shndx1
, shndx2
;
7174 /* Both sections have to be in ELF. */
7175 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
7176 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
7179 if (elf_section_type (sec1
) != elf_section_type (sec2
))
7182 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
7183 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
7184 if (shndx1
== SHN_BAD
|| shndx2
== SHN_BAD
)
7187 bed1
= get_elf_backend_data (bfd1
);
7188 bed2
= get_elf_backend_data (bfd2
);
7189 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
7190 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
7191 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
7192 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
7194 if (symcount1
== 0 || symcount2
== 0)
7200 ssymbuf1
= (struct elf_symbuf_head
*) elf_tdata (bfd1
)->symbuf
;
7201 ssymbuf2
= (struct elf_symbuf_head
*) elf_tdata (bfd2
)->symbuf
;
7203 if (ssymbuf1
== NULL
)
7205 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
7207 if (isymbuf1
== NULL
)
7210 if (!info
->reduce_memory_overheads
)
7211 elf_tdata (bfd1
)->symbuf
= ssymbuf1
7212 = elf_create_symbuf (symcount1
, isymbuf1
);
7215 if (ssymbuf1
== NULL
|| ssymbuf2
== NULL
)
7217 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
7219 if (isymbuf2
== NULL
)
7222 if (ssymbuf1
!= NULL
&& !info
->reduce_memory_overheads
)
7223 elf_tdata (bfd2
)->symbuf
= ssymbuf2
7224 = elf_create_symbuf (symcount2
, isymbuf2
);
7227 if (ssymbuf1
!= NULL
&& ssymbuf2
!= NULL
)
7229 /* Optimized faster version. */
7230 bfd_size_type lo
, hi
, mid
;
7231 struct elf_symbol
*symp
;
7232 struct elf_symbuf_symbol
*ssym
, *ssymend
;
7235 hi
= ssymbuf1
->count
;
7240 mid
= (lo
+ hi
) / 2;
7241 if (shndx1
< ssymbuf1
[mid
].st_shndx
)
7243 else if (shndx1
> ssymbuf1
[mid
].st_shndx
)
7247 count1
= ssymbuf1
[mid
].count
;
7254 hi
= ssymbuf2
->count
;
7259 mid
= (lo
+ hi
) / 2;
7260 if (shndx2
< ssymbuf2
[mid
].st_shndx
)
7262 else if (shndx2
> ssymbuf2
[mid
].st_shndx
)
7266 count2
= ssymbuf2
[mid
].count
;
7272 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7275 symtable1
= (struct elf_symbol
*)
7276 bfd_malloc (count1
* sizeof (struct elf_symbol
));
7277 symtable2
= (struct elf_symbol
*)
7278 bfd_malloc (count2
* sizeof (struct elf_symbol
));
7279 if (symtable1
== NULL
|| symtable2
== NULL
)
7283 for (ssym
= ssymbuf1
->ssym
, ssymend
= ssym
+ count1
;
7284 ssym
< ssymend
; ssym
++, symp
++)
7286 symp
->u
.ssym
= ssym
;
7287 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
7293 for (ssym
= ssymbuf2
->ssym
, ssymend
= ssym
+ count2
;
7294 ssym
< ssymend
; ssym
++, symp
++)
7296 symp
->u
.ssym
= ssym
;
7297 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
7302 /* Sort symbol by name. */
7303 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7304 elf_sym_name_compare
);
7305 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7306 elf_sym_name_compare
);
7308 for (i
= 0; i
< count1
; i
++)
7309 /* Two symbols must have the same binding, type and name. */
7310 if (symtable1
[i
].u
.ssym
->st_info
!= symtable2
[i
].u
.ssym
->st_info
7311 || symtable1
[i
].u
.ssym
->st_other
!= symtable2
[i
].u
.ssym
->st_other
7312 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7319 symtable1
= (struct elf_symbol
*)
7320 bfd_malloc (symcount1
* sizeof (struct elf_symbol
));
7321 symtable2
= (struct elf_symbol
*)
7322 bfd_malloc (symcount2
* sizeof (struct elf_symbol
));
7323 if (symtable1
== NULL
|| symtable2
== NULL
)
7326 /* Count definitions in the section. */
7328 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
; isym
< isymend
; isym
++)
7329 if (isym
->st_shndx
== shndx1
)
7330 symtable1
[count1
++].u
.isym
= isym
;
7333 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
; isym
< isymend
; isym
++)
7334 if (isym
->st_shndx
== shndx2
)
7335 symtable2
[count2
++].u
.isym
= isym
;
7337 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7340 for (i
= 0; i
< count1
; i
++)
7342 = bfd_elf_string_from_elf_section (bfd1
, hdr1
->sh_link
,
7343 symtable1
[i
].u
.isym
->st_name
);
7345 for (i
= 0; i
< count2
; i
++)
7347 = bfd_elf_string_from_elf_section (bfd2
, hdr2
->sh_link
,
7348 symtable2
[i
].u
.isym
->st_name
);
7350 /* Sort symbol by name. */
7351 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7352 elf_sym_name_compare
);
7353 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7354 elf_sym_name_compare
);
7356 for (i
= 0; i
< count1
; i
++)
7357 /* Two symbols must have the same binding, type and name. */
7358 if (symtable1
[i
].u
.isym
->st_info
!= symtable2
[i
].u
.isym
->st_info
7359 || symtable1
[i
].u
.isym
->st_other
!= symtable2
[i
].u
.isym
->st_other
7360 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7378 /* Return TRUE if 2 section types are compatible. */
7381 _bfd_elf_match_sections_by_type (bfd
*abfd
, const asection
*asec
,
7382 bfd
*bbfd
, const asection
*bsec
)
7386 || abfd
->xvec
->flavour
!= bfd_target_elf_flavour
7387 || bbfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7390 return elf_section_type (asec
) == elf_section_type (bsec
);
7393 /* Final phase of ELF linker. */
7395 /* A structure we use to avoid passing large numbers of arguments. */
7397 struct elf_final_link_info
7399 /* General link information. */
7400 struct bfd_link_info
*info
;
7403 /* Symbol string table. */
7404 struct bfd_strtab_hash
*symstrtab
;
7405 /* .dynsym section. */
7406 asection
*dynsym_sec
;
7407 /* .hash section. */
7409 /* symbol version section (.gnu.version). */
7410 asection
*symver_sec
;
7411 /* Buffer large enough to hold contents of any section. */
7413 /* Buffer large enough to hold external relocs of any section. */
7414 void *external_relocs
;
7415 /* Buffer large enough to hold internal relocs of any section. */
7416 Elf_Internal_Rela
*internal_relocs
;
7417 /* Buffer large enough to hold external local symbols of any input
7419 bfd_byte
*external_syms
;
7420 /* And a buffer for symbol section indices. */
7421 Elf_External_Sym_Shndx
*locsym_shndx
;
7422 /* Buffer large enough to hold internal local symbols of any input
7424 Elf_Internal_Sym
*internal_syms
;
7425 /* Array large enough to hold a symbol index for each local symbol
7426 of any input BFD. */
7428 /* Array large enough to hold a section pointer for each local
7429 symbol of any input BFD. */
7430 asection
**sections
;
7431 /* Buffer to hold swapped out symbols. */
7433 /* And one for symbol section indices. */
7434 Elf_External_Sym_Shndx
*symshndxbuf
;
7435 /* Number of swapped out symbols in buffer. */
7436 size_t symbuf_count
;
7437 /* Number of symbols which fit in symbuf. */
7439 /* And same for symshndxbuf. */
7440 size_t shndxbuf_size
;
7441 /* Number of STT_FILE syms seen. */
7442 size_t filesym_count
;
7445 /* This struct is used to pass information to elf_link_output_extsym. */
7447 struct elf_outext_info
7450 bfd_boolean localsyms
;
7451 bfd_boolean need_second_pass
;
7452 bfd_boolean second_pass
;
7453 struct elf_final_link_info
*flinfo
;
7457 /* Support for evaluating a complex relocation.
7459 Complex relocations are generalized, self-describing relocations. The
7460 implementation of them consists of two parts: complex symbols, and the
7461 relocations themselves.
7463 The relocations are use a reserved elf-wide relocation type code (R_RELC
7464 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7465 information (start bit, end bit, word width, etc) into the addend. This
7466 information is extracted from CGEN-generated operand tables within gas.
7468 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7469 internal) representing prefix-notation expressions, including but not
7470 limited to those sorts of expressions normally encoded as addends in the
7471 addend field. The symbol mangling format is:
7474 | <unary-operator> ':' <node>
7475 | <binary-operator> ':' <node> ':' <node>
7478 <literal> := 's' <digits=N> ':' <N character symbol name>
7479 | 'S' <digits=N> ':' <N character section name>
7483 <binary-operator> := as in C
7484 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7487 set_symbol_value (bfd
*bfd_with_globals
,
7488 Elf_Internal_Sym
*isymbuf
,
7493 struct elf_link_hash_entry
**sym_hashes
;
7494 struct elf_link_hash_entry
*h
;
7495 size_t extsymoff
= locsymcount
;
7497 if (symidx
< locsymcount
)
7499 Elf_Internal_Sym
*sym
;
7501 sym
= isymbuf
+ symidx
;
7502 if (ELF_ST_BIND (sym
->st_info
) == STB_LOCAL
)
7504 /* It is a local symbol: move it to the
7505 "absolute" section and give it a value. */
7506 sym
->st_shndx
= SHN_ABS
;
7507 sym
->st_value
= val
;
7510 BFD_ASSERT (elf_bad_symtab (bfd_with_globals
));
7514 /* It is a global symbol: set its link type
7515 to "defined" and give it a value. */
7517 sym_hashes
= elf_sym_hashes (bfd_with_globals
);
7518 h
= sym_hashes
[symidx
- extsymoff
];
7519 while (h
->root
.type
== bfd_link_hash_indirect
7520 || h
->root
.type
== bfd_link_hash_warning
)
7521 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7522 h
->root
.type
= bfd_link_hash_defined
;
7523 h
->root
.u
.def
.value
= val
;
7524 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
7528 resolve_symbol (const char *name
,
7530 struct elf_final_link_info
*flinfo
,
7532 Elf_Internal_Sym
*isymbuf
,
7535 Elf_Internal_Sym
*sym
;
7536 struct bfd_link_hash_entry
*global_entry
;
7537 const char *candidate
= NULL
;
7538 Elf_Internal_Shdr
*symtab_hdr
;
7541 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
7543 for (i
= 0; i
< locsymcount
; ++ i
)
7547 if (ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7550 candidate
= bfd_elf_string_from_elf_section (input_bfd
,
7551 symtab_hdr
->sh_link
,
7554 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7555 name
, candidate
, (unsigned long) sym
->st_value
);
7557 if (candidate
&& strcmp (candidate
, name
) == 0)
7559 asection
*sec
= flinfo
->sections
[i
];
7561 *result
= _bfd_elf_rel_local_sym (input_bfd
, sym
, &sec
, 0);
7562 *result
+= sec
->output_offset
+ sec
->output_section
->vma
;
7564 printf ("Found symbol with value %8.8lx\n",
7565 (unsigned long) *result
);
7571 /* Hmm, haven't found it yet. perhaps it is a global. */
7572 global_entry
= bfd_link_hash_lookup (flinfo
->info
->hash
, name
,
7573 FALSE
, FALSE
, TRUE
);
7577 if (global_entry
->type
== bfd_link_hash_defined
7578 || global_entry
->type
== bfd_link_hash_defweak
)
7580 *result
= (global_entry
->u
.def
.value
7581 + global_entry
->u
.def
.section
->output_section
->vma
7582 + global_entry
->u
.def
.section
->output_offset
);
7584 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7585 global_entry
->root
.string
, (unsigned long) *result
);
7594 resolve_section (const char *name
,
7601 for (curr
= sections
; curr
; curr
= curr
->next
)
7602 if (strcmp (curr
->name
, name
) == 0)
7604 *result
= curr
->vma
;
7608 /* Hmm. still haven't found it. try pseudo-section names. */
7609 for (curr
= sections
; curr
; curr
= curr
->next
)
7611 len
= strlen (curr
->name
);
7612 if (len
> strlen (name
))
7615 if (strncmp (curr
->name
, name
, len
) == 0)
7617 if (strncmp (".end", name
+ len
, 4) == 0)
7619 *result
= curr
->vma
+ curr
->size
;
7623 /* Insert more pseudo-section names here, if you like. */
7631 undefined_reference (const char *reftype
, const char *name
)
7633 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7638 eval_symbol (bfd_vma
*result
,
7641 struct elf_final_link_info
*flinfo
,
7643 Elf_Internal_Sym
*isymbuf
,
7652 const char *sym
= *symp
;
7654 bfd_boolean symbol_is_section
= FALSE
;
7659 if (len
< 1 || len
> sizeof (symbuf
))
7661 bfd_set_error (bfd_error_invalid_operation
);
7674 *result
= strtoul (sym
, (char **) symp
, 16);
7678 symbol_is_section
= TRUE
;
7681 symlen
= strtol (sym
, (char **) symp
, 10);
7682 sym
= *symp
+ 1; /* Skip the trailing ':'. */
7684 if (symend
< sym
|| symlen
+ 1 > sizeof (symbuf
))
7686 bfd_set_error (bfd_error_invalid_operation
);
7690 memcpy (symbuf
, sym
, symlen
);
7691 symbuf
[symlen
] = '\0';
7692 *symp
= sym
+ symlen
;
7694 /* Is it always possible, with complex symbols, that gas "mis-guessed"
7695 the symbol as a section, or vice-versa. so we're pretty liberal in our
7696 interpretation here; section means "try section first", not "must be a
7697 section", and likewise with symbol. */
7699 if (symbol_is_section
)
7701 if (!resolve_section (symbuf
, flinfo
->output_bfd
->sections
, result
)
7702 && !resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
7703 isymbuf
, locsymcount
))
7705 undefined_reference ("section", symbuf
);
7711 if (!resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
7712 isymbuf
, locsymcount
)
7713 && !resolve_section (symbuf
, flinfo
->output_bfd
->sections
,
7716 undefined_reference ("symbol", symbuf
);
7723 /* All that remains are operators. */
7725 #define UNARY_OP(op) \
7726 if (strncmp (sym, #op, strlen (#op)) == 0) \
7728 sym += strlen (#op); \
7732 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7733 isymbuf, locsymcount, signed_p)) \
7736 *result = op ((bfd_signed_vma) a); \
7742 #define BINARY_OP(op) \
7743 if (strncmp (sym, #op, strlen (#op)) == 0) \
7745 sym += strlen (#op); \
7749 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7750 isymbuf, locsymcount, signed_p)) \
7753 if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
7754 isymbuf, locsymcount, signed_p)) \
7757 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7787 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym
);
7788 bfd_set_error (bfd_error_invalid_operation
);
7794 put_value (bfd_vma size
,
7795 unsigned long chunksz
,
7800 location
+= (size
- chunksz
);
7802 for (; size
; size
-= chunksz
, location
-= chunksz
, x
>>= (chunksz
* 8))
7810 bfd_put_8 (input_bfd
, x
, location
);
7813 bfd_put_16 (input_bfd
, x
, location
);
7816 bfd_put_32 (input_bfd
, x
, location
);
7820 bfd_put_64 (input_bfd
, x
, location
);
7830 get_value (bfd_vma size
,
7831 unsigned long chunksz
,
7837 for (; size
; size
-= chunksz
, location
+= chunksz
)
7845 x
= (x
<< (8 * chunksz
)) | bfd_get_8 (input_bfd
, location
);
7848 x
= (x
<< (8 * chunksz
)) | bfd_get_16 (input_bfd
, location
);
7851 x
= (x
<< (8 * chunksz
)) | bfd_get_32 (input_bfd
, location
);
7855 x
= (x
<< (8 * chunksz
)) | bfd_get_64 (input_bfd
, location
);
7866 decode_complex_addend (unsigned long *start
, /* in bits */
7867 unsigned long *oplen
, /* in bits */
7868 unsigned long *len
, /* in bits */
7869 unsigned long *wordsz
, /* in bytes */
7870 unsigned long *chunksz
, /* in bytes */
7871 unsigned long *lsb0_p
,
7872 unsigned long *signed_p
,
7873 unsigned long *trunc_p
,
7874 unsigned long encoded
)
7876 * start
= encoded
& 0x3F;
7877 * len
= (encoded
>> 6) & 0x3F;
7878 * oplen
= (encoded
>> 12) & 0x3F;
7879 * wordsz
= (encoded
>> 18) & 0xF;
7880 * chunksz
= (encoded
>> 22) & 0xF;
7881 * lsb0_p
= (encoded
>> 27) & 1;
7882 * signed_p
= (encoded
>> 28) & 1;
7883 * trunc_p
= (encoded
>> 29) & 1;
7886 bfd_reloc_status_type
7887 bfd_elf_perform_complex_relocation (bfd
*input_bfd
,
7888 asection
*input_section ATTRIBUTE_UNUSED
,
7890 Elf_Internal_Rela
*rel
,
7893 bfd_vma shift
, x
, mask
;
7894 unsigned long start
, oplen
, len
, wordsz
, chunksz
, lsb0_p
, signed_p
, trunc_p
;
7895 bfd_reloc_status_type r
;
7897 /* Perform this reloc, since it is complex.
7898 (this is not to say that it necessarily refers to a complex
7899 symbol; merely that it is a self-describing CGEN based reloc.
7900 i.e. the addend has the complete reloc information (bit start, end,
7901 word size, etc) encoded within it.). */
7903 decode_complex_addend (&start
, &oplen
, &len
, &wordsz
,
7904 &chunksz
, &lsb0_p
, &signed_p
,
7905 &trunc_p
, rel
->r_addend
);
7907 mask
= (((1L << (len
- 1)) - 1) << 1) | 1;
7910 shift
= (start
+ 1) - len
;
7912 shift
= (8 * wordsz
) - (start
+ len
);
7914 /* FIXME: octets_per_byte. */
7915 x
= get_value (wordsz
, chunksz
, input_bfd
, contents
+ rel
->r_offset
);
7918 printf ("Doing complex reloc: "
7919 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7920 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7921 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7922 lsb0_p
, signed_p
, trunc_p
, wordsz
, chunksz
, start
, len
,
7923 oplen
, (unsigned long) x
, (unsigned long) mask
,
7924 (unsigned long) relocation
);
7929 /* Now do an overflow check. */
7930 r
= bfd_check_overflow ((signed_p
7931 ? complain_overflow_signed
7932 : complain_overflow_unsigned
),
7933 len
, 0, (8 * wordsz
),
7937 x
= (x
& ~(mask
<< shift
)) | ((relocation
& mask
) << shift
);
7940 printf (" relocation: %8.8lx\n"
7941 " shifted mask: %8.8lx\n"
7942 " shifted/masked reloc: %8.8lx\n"
7943 " result: %8.8lx\n",
7944 (unsigned long) relocation
, (unsigned long) (mask
<< shift
),
7945 (unsigned long) ((relocation
& mask
) << shift
), (unsigned long) x
);
7947 /* FIXME: octets_per_byte. */
7948 put_value (wordsz
, chunksz
, input_bfd
, x
, contents
+ rel
->r_offset
);
7952 /* When performing a relocatable link, the input relocations are
7953 preserved. But, if they reference global symbols, the indices
7954 referenced must be updated. Update all the relocations found in
7958 elf_link_adjust_relocs (bfd
*abfd
,
7959 struct bfd_elf_section_reloc_data
*reldata
)
7962 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7964 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
7965 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
7966 bfd_vma r_type_mask
;
7968 unsigned int count
= reldata
->count
;
7969 struct elf_link_hash_entry
**rel_hash
= reldata
->hashes
;
7971 if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
7973 swap_in
= bed
->s
->swap_reloc_in
;
7974 swap_out
= bed
->s
->swap_reloc_out
;
7976 else if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
7978 swap_in
= bed
->s
->swap_reloca_in
;
7979 swap_out
= bed
->s
->swap_reloca_out
;
7984 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
7987 if (bed
->s
->arch_size
== 32)
7994 r_type_mask
= 0xffffffff;
7998 erela
= reldata
->hdr
->contents
;
7999 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= reldata
->hdr
->sh_entsize
)
8001 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
8004 if (*rel_hash
== NULL
)
8007 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
8009 (*swap_in
) (abfd
, erela
, irela
);
8010 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
8011 irela
[j
].r_info
= ((bfd_vma
) (*rel_hash
)->indx
<< r_sym_shift
8012 | (irela
[j
].r_info
& r_type_mask
));
8013 (*swap_out
) (abfd
, irela
, erela
);
8017 struct elf_link_sort_rela
8023 enum elf_reloc_type_class type
;
8024 /* We use this as an array of size int_rels_per_ext_rel. */
8025 Elf_Internal_Rela rela
[1];
8029 elf_link_sort_cmp1 (const void *A
, const void *B
)
8031 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8032 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8033 int relativea
, relativeb
;
8035 relativea
= a
->type
== reloc_class_relative
;
8036 relativeb
= b
->type
== reloc_class_relative
;
8038 if (relativea
< relativeb
)
8040 if (relativea
> relativeb
)
8042 if ((a
->rela
->r_info
& a
->u
.sym_mask
) < (b
->rela
->r_info
& b
->u
.sym_mask
))
8044 if ((a
->rela
->r_info
& a
->u
.sym_mask
) > (b
->rela
->r_info
& b
->u
.sym_mask
))
8046 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8048 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8054 elf_link_sort_cmp2 (const void *A
, const void *B
)
8056 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8057 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8060 if (a
->u
.offset
< b
->u
.offset
)
8062 if (a
->u
.offset
> b
->u
.offset
)
8064 copya
= (a
->type
== reloc_class_copy
) * 2 + (a
->type
== reloc_class_plt
);
8065 copyb
= (b
->type
== reloc_class_copy
) * 2 + (b
->type
== reloc_class_plt
);
8070 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8072 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8078 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
8080 asection
*dynamic_relocs
;
8083 bfd_size_type count
, size
;
8084 size_t i
, ret
, sort_elt
, ext_size
;
8085 bfd_byte
*sort
, *s_non_relative
, *p
;
8086 struct elf_link_sort_rela
*sq
;
8087 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8088 int i2e
= bed
->s
->int_rels_per_ext_rel
;
8089 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8090 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8091 struct bfd_link_order
*lo
;
8093 bfd_boolean use_rela
;
8095 /* Find a dynamic reloc section. */
8096 rela_dyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
8097 rel_dyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
8098 if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0
8099 && rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8101 bfd_boolean use_rela_initialised
= FALSE
;
8103 /* This is just here to stop gcc from complaining.
8104 It's initialization checking code is not perfect. */
8107 /* Both sections are present. Examine the sizes
8108 of the indirect sections to help us choose. */
8109 for (lo
= rela_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8110 if (lo
->type
== bfd_indirect_link_order
)
8112 asection
*o
= lo
->u
.indirect
.section
;
8114 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8116 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8117 /* Section size is divisible by both rel and rela sizes.
8118 It is of no help to us. */
8122 /* Section size is only divisible by rela. */
8123 if (use_rela_initialised
&& (use_rela
== FALSE
))
8126 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8127 bfd_set_error (bfd_error_invalid_operation
);
8133 use_rela_initialised
= TRUE
;
8137 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8139 /* Section size is only divisible by rel. */
8140 if (use_rela_initialised
&& (use_rela
== TRUE
))
8143 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8144 bfd_set_error (bfd_error_invalid_operation
);
8150 use_rela_initialised
= TRUE
;
8155 /* The section size is not divisible by either - something is wrong. */
8157 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8158 bfd_set_error (bfd_error_invalid_operation
);
8163 for (lo
= rel_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8164 if (lo
->type
== bfd_indirect_link_order
)
8166 asection
*o
= lo
->u
.indirect
.section
;
8168 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8170 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8171 /* Section size is divisible by both rel and rela sizes.
8172 It is of no help to us. */
8176 /* Section size is only divisible by rela. */
8177 if (use_rela_initialised
&& (use_rela
== FALSE
))
8180 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8181 bfd_set_error (bfd_error_invalid_operation
);
8187 use_rela_initialised
= TRUE
;
8191 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8193 /* Section size is only divisible by rel. */
8194 if (use_rela_initialised
&& (use_rela
== TRUE
))
8197 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8198 bfd_set_error (bfd_error_invalid_operation
);
8204 use_rela_initialised
= TRUE
;
8209 /* The section size is not divisible by either - something is wrong. */
8211 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8212 bfd_set_error (bfd_error_invalid_operation
);
8217 if (! use_rela_initialised
)
8221 else if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0)
8223 else if (rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8230 dynamic_relocs
= rela_dyn
;
8231 ext_size
= bed
->s
->sizeof_rela
;
8232 swap_in
= bed
->s
->swap_reloca_in
;
8233 swap_out
= bed
->s
->swap_reloca_out
;
8237 dynamic_relocs
= rel_dyn
;
8238 ext_size
= bed
->s
->sizeof_rel
;
8239 swap_in
= bed
->s
->swap_reloc_in
;
8240 swap_out
= bed
->s
->swap_reloc_out
;
8244 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8245 if (lo
->type
== bfd_indirect_link_order
)
8246 size
+= lo
->u
.indirect
.section
->size
;
8248 if (size
!= dynamic_relocs
->size
)
8251 sort_elt
= (sizeof (struct elf_link_sort_rela
)
8252 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
8254 count
= dynamic_relocs
->size
/ ext_size
;
8257 sort
= (bfd_byte
*) bfd_zmalloc (sort_elt
* count
);
8261 (*info
->callbacks
->warning
)
8262 (info
, _("Not enough memory to sort relocations"), 0, abfd
, 0, 0);
8266 if (bed
->s
->arch_size
== 32)
8267 r_sym_mask
= ~(bfd_vma
) 0xff;
8269 r_sym_mask
= ~(bfd_vma
) 0xffffffff;
8271 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8272 if (lo
->type
== bfd_indirect_link_order
)
8274 bfd_byte
*erel
, *erelend
;
8275 asection
*o
= lo
->u
.indirect
.section
;
8277 if (o
->contents
== NULL
&& o
->size
!= 0)
8279 /* This is a reloc section that is being handled as a normal
8280 section. See bfd_section_from_shdr. We can't combine
8281 relocs in this case. */
8286 erelend
= o
->contents
+ o
->size
;
8287 /* FIXME: octets_per_byte. */
8288 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8290 while (erel
< erelend
)
8292 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8294 (*swap_in
) (abfd
, erel
, s
->rela
);
8295 s
->type
= (*bed
->elf_backend_reloc_type_class
) (s
->rela
);
8296 s
->u
.sym_mask
= r_sym_mask
;
8302 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
8304 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
8306 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8307 if (s
->type
!= reloc_class_relative
)
8313 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
8314 for (; i
< count
; i
++, p
+= sort_elt
)
8316 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
8317 if (((sp
->rela
->r_info
^ sq
->rela
->r_info
) & r_sym_mask
) != 0)
8319 sp
->u
.offset
= sq
->rela
->r_offset
;
8322 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
8324 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8325 if (lo
->type
== bfd_indirect_link_order
)
8327 bfd_byte
*erel
, *erelend
;
8328 asection
*o
= lo
->u
.indirect
.section
;
8331 erelend
= o
->contents
+ o
->size
;
8332 /* FIXME: octets_per_byte. */
8333 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8334 while (erel
< erelend
)
8336 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8337 (*swap_out
) (abfd
, s
->rela
, erel
);
8344 *psec
= dynamic_relocs
;
8348 /* Flush the output symbols to the file. */
8351 elf_link_flush_output_syms (struct elf_final_link_info
*flinfo
,
8352 const struct elf_backend_data
*bed
)
8354 if (flinfo
->symbuf_count
> 0)
8356 Elf_Internal_Shdr
*hdr
;
8360 hdr
= &elf_tdata (flinfo
->output_bfd
)->symtab_hdr
;
8361 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
8362 amt
= flinfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8363 if (bfd_seek (flinfo
->output_bfd
, pos
, SEEK_SET
) != 0
8364 || bfd_bwrite (flinfo
->symbuf
, amt
, flinfo
->output_bfd
) != amt
)
8367 hdr
->sh_size
+= amt
;
8368 flinfo
->symbuf_count
= 0;
8374 /* Add a symbol to the output symbol table. */
8377 elf_link_output_sym (struct elf_final_link_info
*flinfo
,
8379 Elf_Internal_Sym
*elfsym
,
8380 asection
*input_sec
,
8381 struct elf_link_hash_entry
*h
)
8384 Elf_External_Sym_Shndx
*destshndx
;
8385 int (*output_symbol_hook
)
8386 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*, asection
*,
8387 struct elf_link_hash_entry
*);
8388 const struct elf_backend_data
*bed
;
8390 bed
= get_elf_backend_data (flinfo
->output_bfd
);
8391 output_symbol_hook
= bed
->elf_backend_link_output_symbol_hook
;
8392 if (output_symbol_hook
!= NULL
)
8394 int ret
= (*output_symbol_hook
) (flinfo
->info
, name
, elfsym
, input_sec
, h
);
8399 if (name
== NULL
|| *name
== '\0')
8400 elfsym
->st_name
= 0;
8401 else if (input_sec
->flags
& SEC_EXCLUDE
)
8402 elfsym
->st_name
= 0;
8405 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (flinfo
->symstrtab
,
8407 if (elfsym
->st_name
== (unsigned long) -1)
8411 if (flinfo
->symbuf_count
>= flinfo
->symbuf_size
)
8413 if (! elf_link_flush_output_syms (flinfo
, bed
))
8417 dest
= flinfo
->symbuf
+ flinfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8418 destshndx
= flinfo
->symshndxbuf
;
8419 if (destshndx
!= NULL
)
8421 if (bfd_get_symcount (flinfo
->output_bfd
) >= flinfo
->shndxbuf_size
)
8425 amt
= flinfo
->shndxbuf_size
* sizeof (Elf_External_Sym_Shndx
);
8426 destshndx
= (Elf_External_Sym_Shndx
*) bfd_realloc (destshndx
,
8428 if (destshndx
== NULL
)
8430 flinfo
->symshndxbuf
= destshndx
;
8431 memset ((char *) destshndx
+ amt
, 0, amt
);
8432 flinfo
->shndxbuf_size
*= 2;
8434 destshndx
+= bfd_get_symcount (flinfo
->output_bfd
);
8437 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, elfsym
, dest
, destshndx
);
8438 flinfo
->symbuf_count
+= 1;
8439 bfd_get_symcount (flinfo
->output_bfd
) += 1;
8444 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8447 check_dynsym (bfd
*abfd
, Elf_Internal_Sym
*sym
)
8449 if (sym
->st_shndx
>= (SHN_LORESERVE
& 0xffff)
8450 && sym
->st_shndx
< SHN_LORESERVE
)
8452 /* The gABI doesn't support dynamic symbols in output sections
8454 (*_bfd_error_handler
)
8455 (_("%B: Too many sections: %d (>= %d)"),
8456 abfd
, bfd_count_sections (abfd
), SHN_LORESERVE
& 0xffff);
8457 bfd_set_error (bfd_error_nonrepresentable_section
);
8463 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8464 allowing an unsatisfied unversioned symbol in the DSO to match a
8465 versioned symbol that would normally require an explicit version.
8466 We also handle the case that a DSO references a hidden symbol
8467 which may be satisfied by a versioned symbol in another DSO. */
8470 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
8471 const struct elf_backend_data
*bed
,
8472 struct elf_link_hash_entry
*h
)
8475 struct elf_link_loaded_list
*loaded
;
8477 if (!is_elf_hash_table (info
->hash
))
8480 /* Check indirect symbol. */
8481 while (h
->root
.type
== bfd_link_hash_indirect
)
8482 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8484 switch (h
->root
.type
)
8490 case bfd_link_hash_undefined
:
8491 case bfd_link_hash_undefweak
:
8492 abfd
= h
->root
.u
.undef
.abfd
;
8493 if ((abfd
->flags
& DYNAMIC
) == 0
8494 || (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) == 0)
8498 case bfd_link_hash_defined
:
8499 case bfd_link_hash_defweak
:
8500 abfd
= h
->root
.u
.def
.section
->owner
;
8503 case bfd_link_hash_common
:
8504 abfd
= h
->root
.u
.c
.p
->section
->owner
;
8507 BFD_ASSERT (abfd
!= NULL
);
8509 for (loaded
= elf_hash_table (info
)->loaded
;
8511 loaded
= loaded
->next
)
8514 Elf_Internal_Shdr
*hdr
;
8515 bfd_size_type symcount
;
8516 bfd_size_type extsymcount
;
8517 bfd_size_type extsymoff
;
8518 Elf_Internal_Shdr
*versymhdr
;
8519 Elf_Internal_Sym
*isym
;
8520 Elf_Internal_Sym
*isymend
;
8521 Elf_Internal_Sym
*isymbuf
;
8522 Elf_External_Versym
*ever
;
8523 Elf_External_Versym
*extversym
;
8525 input
= loaded
->abfd
;
8527 /* We check each DSO for a possible hidden versioned definition. */
8529 || (input
->flags
& DYNAMIC
) == 0
8530 || elf_dynversym (input
) == 0)
8533 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
8535 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
8536 if (elf_bad_symtab (input
))
8538 extsymcount
= symcount
;
8543 extsymcount
= symcount
- hdr
->sh_info
;
8544 extsymoff
= hdr
->sh_info
;
8547 if (extsymcount
== 0)
8550 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
8552 if (isymbuf
== NULL
)
8555 /* Read in any version definitions. */
8556 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
8557 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
8558 if (extversym
== NULL
)
8561 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
8562 || (bfd_bread (extversym
, versymhdr
->sh_size
, input
)
8563 != versymhdr
->sh_size
))
8571 ever
= extversym
+ extsymoff
;
8572 isymend
= isymbuf
+ extsymcount
;
8573 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
8576 Elf_Internal_Versym iver
;
8577 unsigned short version_index
;
8579 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
8580 || isym
->st_shndx
== SHN_UNDEF
)
8583 name
= bfd_elf_string_from_elf_section (input
,
8586 if (strcmp (name
, h
->root
.root
.string
) != 0)
8589 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
8591 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
8593 && h
->forced_local
))
8595 /* If we have a non-hidden versioned sym, then it should
8596 have provided a definition for the undefined sym unless
8597 it is defined in a non-shared object and forced local.
8602 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
8603 if (version_index
== 1 || version_index
== 2)
8605 /* This is the base or first version. We can use it. */
8619 /* Add an external symbol to the symbol table. This is called from
8620 the hash table traversal routine. When generating a shared object,
8621 we go through the symbol table twice. The first time we output
8622 anything that might have been forced to local scope in a version
8623 script. The second time we output the symbols that are still
8627 elf_link_output_extsym (struct bfd_hash_entry
*bh
, void *data
)
8629 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
8630 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
8631 struct elf_final_link_info
*flinfo
= eoinfo
->flinfo
;
8633 Elf_Internal_Sym sym
;
8634 asection
*input_sec
;
8635 const struct elf_backend_data
*bed
;
8639 if (h
->root
.type
== bfd_link_hash_warning
)
8641 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8642 if (h
->root
.type
== bfd_link_hash_new
)
8646 /* Decide whether to output this symbol in this pass. */
8647 if (eoinfo
->localsyms
)
8649 if (!h
->forced_local
)
8651 if (eoinfo
->second_pass
8652 && !((h
->root
.type
== bfd_link_hash_defined
8653 || h
->root
.type
== bfd_link_hash_defweak
)
8654 && h
->root
.u
.def
.section
->output_section
!= NULL
))
8659 if (h
->forced_local
)
8663 bed
= get_elf_backend_data (flinfo
->output_bfd
);
8665 if (h
->root
.type
== bfd_link_hash_undefined
)
8667 /* If we have an undefined symbol reference here then it must have
8668 come from a shared library that is being linked in. (Undefined
8669 references in regular files have already been handled unless
8670 they are in unreferenced sections which are removed by garbage
8672 bfd_boolean ignore_undef
= FALSE
;
8674 /* Some symbols may be special in that the fact that they're
8675 undefined can be safely ignored - let backend determine that. */
8676 if (bed
->elf_backend_ignore_undef_symbol
)
8677 ignore_undef
= bed
->elf_backend_ignore_undef_symbol (h
);
8679 /* If we are reporting errors for this situation then do so now. */
8682 && (!h
->ref_regular
|| flinfo
->info
->gc_sections
)
8683 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
)
8684 && flinfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
8686 if (!(flinfo
->info
->callbacks
->undefined_symbol
8687 (flinfo
->info
, h
->root
.root
.string
,
8688 h
->ref_regular
? NULL
: h
->root
.u
.undef
.abfd
,
8690 (flinfo
->info
->unresolved_syms_in_shared_libs
8691 == RM_GENERATE_ERROR
))))
8693 bfd_set_error (bfd_error_bad_value
);
8694 eoinfo
->failed
= TRUE
;
8700 /* We should also warn if a forced local symbol is referenced from
8701 shared libraries. */
8702 if (!flinfo
->info
->relocatable
8703 && flinfo
->info
->executable
8709 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
))
8713 struct elf_link_hash_entry
*hi
= h
;
8715 /* Check indirect symbol. */
8716 while (hi
->root
.type
== bfd_link_hash_indirect
)
8717 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
8719 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
8720 msg
= _("%B: internal symbol `%s' in %B is referenced by DSO");
8721 else if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
8722 msg
= _("%B: hidden symbol `%s' in %B is referenced by DSO");
8724 msg
= _("%B: local symbol `%s' in %B is referenced by DSO");
8725 def_bfd
= flinfo
->output_bfd
;
8726 if (hi
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
8727 def_bfd
= hi
->root
.u
.def
.section
->owner
;
8728 (*_bfd_error_handler
) (msg
, flinfo
->output_bfd
, def_bfd
,
8729 h
->root
.root
.string
);
8730 bfd_set_error (bfd_error_bad_value
);
8731 eoinfo
->failed
= TRUE
;
8735 /* We don't want to output symbols that have never been mentioned by
8736 a regular file, or that we have been told to strip. However, if
8737 h->indx is set to -2, the symbol is used by a reloc and we must
8741 else if ((h
->def_dynamic
8743 || h
->root
.type
== bfd_link_hash_new
)
8747 else if (flinfo
->info
->strip
== strip_all
)
8749 else if (flinfo
->info
->strip
== strip_some
8750 && bfd_hash_lookup (flinfo
->info
->keep_hash
,
8751 h
->root
.root
.string
, FALSE
, FALSE
) == NULL
)
8753 else if ((h
->root
.type
== bfd_link_hash_defined
8754 || h
->root
.type
== bfd_link_hash_defweak
)
8755 && ((flinfo
->info
->strip_discarded
8756 && discarded_section (h
->root
.u
.def
.section
))
8757 || (h
->root
.u
.def
.section
->owner
!= NULL
8758 && (h
->root
.u
.def
.section
->owner
->flags
& BFD_PLUGIN
) != 0)))
8760 else if ((h
->root
.type
== bfd_link_hash_undefined
8761 || h
->root
.type
== bfd_link_hash_undefweak
)
8762 && h
->root
.u
.undef
.abfd
!= NULL
8763 && (h
->root
.u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0)
8768 /* If we're stripping it, and it's not a dynamic symbol, there's
8769 nothing else to do unless it is a forced local symbol or a
8770 STT_GNU_IFUNC symbol. */
8773 && h
->type
!= STT_GNU_IFUNC
8774 && !h
->forced_local
)
8778 sym
.st_size
= h
->size
;
8779 sym
.st_other
= h
->other
;
8780 if (h
->forced_local
)
8782 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
8783 /* Turn off visibility on local symbol. */
8784 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
8786 else if (h
->unique_global
)
8787 sym
.st_info
= ELF_ST_INFO (STB_GNU_UNIQUE
, h
->type
);
8788 else if (h
->root
.type
== bfd_link_hash_undefweak
8789 || h
->root
.type
== bfd_link_hash_defweak
)
8790 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
8792 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
8793 sym
.st_target_internal
= h
->target_internal
;
8795 switch (h
->root
.type
)
8798 case bfd_link_hash_new
:
8799 case bfd_link_hash_warning
:
8803 case bfd_link_hash_undefined
:
8804 case bfd_link_hash_undefweak
:
8805 input_sec
= bfd_und_section_ptr
;
8806 sym
.st_shndx
= SHN_UNDEF
;
8809 case bfd_link_hash_defined
:
8810 case bfd_link_hash_defweak
:
8812 input_sec
= h
->root
.u
.def
.section
;
8813 if (input_sec
->output_section
!= NULL
)
8815 if (eoinfo
->localsyms
&& flinfo
->filesym_count
== 1)
8817 bfd_boolean second_pass_sym
8818 = (input_sec
->owner
== flinfo
->output_bfd
8819 || input_sec
->owner
== NULL
8820 || (input_sec
->flags
& SEC_LINKER_CREATED
) != 0
8821 || (input_sec
->owner
->flags
& BFD_LINKER_CREATED
) != 0);
8823 eoinfo
->need_second_pass
|= second_pass_sym
;
8824 if (eoinfo
->second_pass
!= second_pass_sym
)
8829 _bfd_elf_section_from_bfd_section (flinfo
->output_bfd
,
8830 input_sec
->output_section
);
8831 if (sym
.st_shndx
== SHN_BAD
)
8833 (*_bfd_error_handler
)
8834 (_("%B: could not find output section %A for input section %A"),
8835 flinfo
->output_bfd
, input_sec
->output_section
, input_sec
);
8836 bfd_set_error (bfd_error_nonrepresentable_section
);
8837 eoinfo
->failed
= TRUE
;
8841 /* ELF symbols in relocatable files are section relative,
8842 but in nonrelocatable files they are virtual
8844 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
8845 if (!flinfo
->info
->relocatable
)
8847 sym
.st_value
+= input_sec
->output_section
->vma
;
8848 if (h
->type
== STT_TLS
)
8850 asection
*tls_sec
= elf_hash_table (flinfo
->info
)->tls_sec
;
8851 if (tls_sec
!= NULL
)
8852 sym
.st_value
-= tls_sec
->vma
;
8855 /* The TLS section may have been garbage collected. */
8856 BFD_ASSERT (flinfo
->info
->gc_sections
8857 && !input_sec
->gc_mark
);
8864 BFD_ASSERT (input_sec
->owner
== NULL
8865 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
8866 sym
.st_shndx
= SHN_UNDEF
;
8867 input_sec
= bfd_und_section_ptr
;
8872 case bfd_link_hash_common
:
8873 input_sec
= h
->root
.u
.c
.p
->section
;
8874 sym
.st_shndx
= bed
->common_section_index (input_sec
);
8875 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
8878 case bfd_link_hash_indirect
:
8879 /* These symbols are created by symbol versioning. They point
8880 to the decorated version of the name. For example, if the
8881 symbol foo@@GNU_1.2 is the default, which should be used when
8882 foo is used with no version, then we add an indirect symbol
8883 foo which points to foo@@GNU_1.2. We ignore these symbols,
8884 since the indirected symbol is already in the hash table. */
8888 /* Give the processor backend a chance to tweak the symbol value,
8889 and also to finish up anything that needs to be done for this
8890 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
8891 forced local syms when non-shared is due to a historical quirk.
8892 STT_GNU_IFUNC symbol must go through PLT. */
8893 if ((h
->type
== STT_GNU_IFUNC
8895 && !flinfo
->info
->relocatable
)
8896 || ((h
->dynindx
!= -1
8898 && ((flinfo
->info
->shared
8899 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
8900 || h
->root
.type
!= bfd_link_hash_undefweak
))
8901 || !h
->forced_local
)
8902 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
))
8904 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
8905 (flinfo
->output_bfd
, flinfo
->info
, h
, &sym
)))
8907 eoinfo
->failed
= TRUE
;
8912 /* If we are marking the symbol as undefined, and there are no
8913 non-weak references to this symbol from a regular object, then
8914 mark the symbol as weak undefined; if there are non-weak
8915 references, mark the symbol as strong. We can't do this earlier,
8916 because it might not be marked as undefined until the
8917 finish_dynamic_symbol routine gets through with it. */
8918 if (sym
.st_shndx
== SHN_UNDEF
8920 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
8921 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
8924 unsigned int type
= ELF_ST_TYPE (sym
.st_info
);
8926 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
8927 if (type
== STT_GNU_IFUNC
)
8930 if (h
->ref_regular_nonweak
)
8931 bindtype
= STB_GLOBAL
;
8933 bindtype
= STB_WEAK
;
8934 sym
.st_info
= ELF_ST_INFO (bindtype
, type
);
8937 /* If this is a symbol defined in a dynamic library, don't use the
8938 symbol size from the dynamic library. Relinking an executable
8939 against a new library may introduce gratuitous changes in the
8940 executable's symbols if we keep the size. */
8941 if (sym
.st_shndx
== SHN_UNDEF
8946 /* If a non-weak symbol with non-default visibility is not defined
8947 locally, it is a fatal error. */
8948 if (!flinfo
->info
->relocatable
8949 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
8950 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
8951 && h
->root
.type
== bfd_link_hash_undefined
8956 if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
)
8957 msg
= _("%B: protected symbol `%s' isn't defined");
8958 else if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
)
8959 msg
= _("%B: internal symbol `%s' isn't defined");
8961 msg
= _("%B: hidden symbol `%s' isn't defined");
8962 (*_bfd_error_handler
) (msg
, flinfo
->output_bfd
, h
->root
.root
.string
);
8963 bfd_set_error (bfd_error_bad_value
);
8964 eoinfo
->failed
= TRUE
;
8968 /* If this symbol should be put in the .dynsym section, then put it
8969 there now. We already know the symbol index. We also fill in
8970 the entry in the .hash section. */
8971 if (flinfo
->dynsym_sec
!= NULL
8973 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
)
8977 /* Since there is no version information in the dynamic string,
8978 if there is no version info in symbol version section, we will
8979 have a run-time problem. */
8980 if (h
->verinfo
.verdef
== NULL
)
8982 char *p
= strrchr (h
->root
.root
.string
, ELF_VER_CHR
);
8984 if (p
&& p
[1] != '\0')
8986 (*_bfd_error_handler
)
8987 (_("%B: No symbol version section for versioned symbol `%s'"),
8988 flinfo
->output_bfd
, h
->root
.root
.string
);
8989 eoinfo
->failed
= TRUE
;
8994 sym
.st_name
= h
->dynstr_index
;
8995 esym
= flinfo
->dynsym_sec
->contents
+ h
->dynindx
* bed
->s
->sizeof_sym
;
8996 if (!check_dynsym (flinfo
->output_bfd
, &sym
))
8998 eoinfo
->failed
= TRUE
;
9001 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, &sym
, esym
, 0);
9003 if (flinfo
->hash_sec
!= NULL
)
9005 size_t hash_entry_size
;
9006 bfd_byte
*bucketpos
;
9011 bucketcount
= elf_hash_table (flinfo
->info
)->bucketcount
;
9012 bucket
= h
->u
.elf_hash_value
% bucketcount
;
9015 = elf_section_data (flinfo
->hash_sec
)->this_hdr
.sh_entsize
;
9016 bucketpos
= ((bfd_byte
*) flinfo
->hash_sec
->contents
9017 + (bucket
+ 2) * hash_entry_size
);
9018 chain
= bfd_get (8 * hash_entry_size
, flinfo
->output_bfd
, bucketpos
);
9019 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, h
->dynindx
,
9021 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, chain
,
9022 ((bfd_byte
*) flinfo
->hash_sec
->contents
9023 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
9026 if (flinfo
->symver_sec
!= NULL
&& flinfo
->symver_sec
->contents
!= NULL
)
9028 Elf_Internal_Versym iversym
;
9029 Elf_External_Versym
*eversym
;
9031 if (!h
->def_regular
)
9033 if (h
->verinfo
.verdef
== NULL
)
9034 iversym
.vs_vers
= 0;
9036 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
9040 if (h
->verinfo
.vertree
== NULL
)
9041 iversym
.vs_vers
= 1;
9043 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
9044 if (flinfo
->info
->create_default_symver
)
9049 iversym
.vs_vers
|= VERSYM_HIDDEN
;
9051 eversym
= (Elf_External_Versym
*) flinfo
->symver_sec
->contents
;
9052 eversym
+= h
->dynindx
;
9053 _bfd_elf_swap_versym_out (flinfo
->output_bfd
, &iversym
, eversym
);
9057 /* If we're stripping it, then it was just a dynamic symbol, and
9058 there's nothing else to do. */
9059 if (strip
|| (input_sec
->flags
& SEC_EXCLUDE
) != 0)
9062 indx
= bfd_get_symcount (flinfo
->output_bfd
);
9063 ret
= elf_link_output_sym (flinfo
, h
->root
.root
.string
, &sym
, input_sec
, h
);
9066 eoinfo
->failed
= TRUE
;
9071 else if (h
->indx
== -2)
9077 /* Return TRUE if special handling is done for relocs in SEC against
9078 symbols defined in discarded sections. */
9081 elf_section_ignore_discarded_relocs (asection
*sec
)
9083 const struct elf_backend_data
*bed
;
9085 switch (sec
->sec_info_type
)
9087 case SEC_INFO_TYPE_STABS
:
9088 case SEC_INFO_TYPE_EH_FRAME
:
9094 bed
= get_elf_backend_data (sec
->owner
);
9095 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
9096 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))
9102 /* Return a mask saying how ld should treat relocations in SEC against
9103 symbols defined in discarded sections. If this function returns
9104 COMPLAIN set, ld will issue a warning message. If this function
9105 returns PRETEND set, and the discarded section was link-once and the
9106 same size as the kept link-once section, ld will pretend that the
9107 symbol was actually defined in the kept section. Otherwise ld will
9108 zero the reloc (at least that is the intent, but some cooperation by
9109 the target dependent code is needed, particularly for REL targets). */
9112 _bfd_elf_default_action_discarded (asection
*sec
)
9114 if (sec
->flags
& SEC_DEBUGGING
)
9117 if (strcmp (".eh_frame", sec
->name
) == 0)
9120 if (strcmp (".gcc_except_table", sec
->name
) == 0)
9123 return COMPLAIN
| PRETEND
;
9126 /* Find a match between a section and a member of a section group. */
9129 match_group_member (asection
*sec
, asection
*group
,
9130 struct bfd_link_info
*info
)
9132 asection
*first
= elf_next_in_group (group
);
9133 asection
*s
= first
;
9137 if (bfd_elf_match_symbols_in_sections (s
, sec
, info
))
9140 s
= elf_next_in_group (s
);
9148 /* Check if the kept section of a discarded section SEC can be used
9149 to replace it. Return the replacement if it is OK. Otherwise return
9153 _bfd_elf_check_kept_section (asection
*sec
, struct bfd_link_info
*info
)
9157 kept
= sec
->kept_section
;
9160 if ((kept
->flags
& SEC_GROUP
) != 0)
9161 kept
= match_group_member (sec
, kept
, info
);
9163 && ((sec
->rawsize
!= 0 ? sec
->rawsize
: sec
->size
)
9164 != (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9166 sec
->kept_section
= kept
;
9171 /* Link an input file into the linker output file. This function
9172 handles all the sections and relocations of the input file at once.
9173 This is so that we only have to read the local symbols once, and
9174 don't have to keep them in memory. */
9177 elf_link_input_bfd (struct elf_final_link_info
*flinfo
, bfd
*input_bfd
)
9179 int (*relocate_section
)
9180 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
9181 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
9183 Elf_Internal_Shdr
*symtab_hdr
;
9186 Elf_Internal_Sym
*isymbuf
;
9187 Elf_Internal_Sym
*isym
;
9188 Elf_Internal_Sym
*isymend
;
9190 asection
**ppsection
;
9192 const struct elf_backend_data
*bed
;
9193 struct elf_link_hash_entry
**sym_hashes
;
9194 bfd_size_type address_size
;
9195 bfd_vma r_type_mask
;
9197 bfd_boolean have_file_sym
= FALSE
;
9199 output_bfd
= flinfo
->output_bfd
;
9200 bed
= get_elf_backend_data (output_bfd
);
9201 relocate_section
= bed
->elf_backend_relocate_section
;
9203 /* If this is a dynamic object, we don't want to do anything here:
9204 we don't want the local symbols, and we don't want the section
9206 if ((input_bfd
->flags
& DYNAMIC
) != 0)
9209 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
9210 if (elf_bad_symtab (input_bfd
))
9212 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
9217 locsymcount
= symtab_hdr
->sh_info
;
9218 extsymoff
= symtab_hdr
->sh_info
;
9221 /* Read the local symbols. */
9222 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
9223 if (isymbuf
== NULL
&& locsymcount
!= 0)
9225 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
9226 flinfo
->internal_syms
,
9227 flinfo
->external_syms
,
9228 flinfo
->locsym_shndx
);
9229 if (isymbuf
== NULL
)
9233 /* Find local symbol sections and adjust values of symbols in
9234 SEC_MERGE sections. Write out those local symbols we know are
9235 going into the output file. */
9236 isymend
= isymbuf
+ locsymcount
;
9237 for (isym
= isymbuf
, pindex
= flinfo
->indices
, ppsection
= flinfo
->sections
;
9239 isym
++, pindex
++, ppsection
++)
9243 Elf_Internal_Sym osym
;
9249 if (elf_bad_symtab (input_bfd
))
9251 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
9258 if (isym
->st_shndx
== SHN_UNDEF
)
9259 isec
= bfd_und_section_ptr
;
9260 else if (isym
->st_shndx
== SHN_ABS
)
9261 isec
= bfd_abs_section_ptr
;
9262 else if (isym
->st_shndx
== SHN_COMMON
)
9263 isec
= bfd_com_section_ptr
;
9266 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
9269 /* Don't attempt to output symbols with st_shnx in the
9270 reserved range other than SHN_ABS and SHN_COMMON. */
9274 else if (isec
->sec_info_type
== SEC_INFO_TYPE_MERGE
9275 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
9277 _bfd_merged_section_offset (output_bfd
, &isec
,
9278 elf_section_data (isec
)->sec_info
,
9284 /* Don't output the first, undefined, symbol. */
9285 if (ppsection
== flinfo
->sections
)
9288 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
9290 /* We never output section symbols. Instead, we use the
9291 section symbol of the corresponding section in the output
9296 /* If we are stripping all symbols, we don't want to output this
9298 if (flinfo
->info
->strip
== strip_all
)
9301 /* If we are discarding all local symbols, we don't want to
9302 output this one. If we are generating a relocatable output
9303 file, then some of the local symbols may be required by
9304 relocs; we output them below as we discover that they are
9306 if (flinfo
->info
->discard
== discard_all
)
9309 /* If this symbol is defined in a section which we are
9310 discarding, we don't need to keep it. */
9311 if (isym
->st_shndx
!= SHN_UNDEF
9312 && isym
->st_shndx
< SHN_LORESERVE
9313 && bfd_section_removed_from_list (output_bfd
,
9314 isec
->output_section
))
9317 /* Get the name of the symbol. */
9318 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
9323 /* See if we are discarding symbols with this name. */
9324 if ((flinfo
->info
->strip
== strip_some
9325 && (bfd_hash_lookup (flinfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
9327 || (((flinfo
->info
->discard
== discard_sec_merge
9328 && (isec
->flags
& SEC_MERGE
) && !flinfo
->info
->relocatable
)
9329 || flinfo
->info
->discard
== discard_l
)
9330 && bfd_is_local_label_name (input_bfd
, name
)))
9333 if (ELF_ST_TYPE (isym
->st_info
) == STT_FILE
)
9335 have_file_sym
= TRUE
;
9336 flinfo
->filesym_count
+= 1;
9340 /* In the absence of debug info, bfd_find_nearest_line uses
9341 FILE symbols to determine the source file for local
9342 function symbols. Provide a FILE symbol here if input
9343 files lack such, so that their symbols won't be
9344 associated with a previous input file. It's not the
9345 source file, but the best we can do. */
9346 have_file_sym
= TRUE
;
9347 flinfo
->filesym_count
+= 1;
9348 memset (&osym
, 0, sizeof (osym
));
9349 osym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
9350 osym
.st_shndx
= SHN_ABS
;
9351 if (!elf_link_output_sym (flinfo
, input_bfd
->filename
, &osym
,
9352 bfd_abs_section_ptr
, NULL
))
9358 /* Adjust the section index for the output file. */
9359 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9360 isec
->output_section
);
9361 if (osym
.st_shndx
== SHN_BAD
)
9364 /* ELF symbols in relocatable files are section relative, but
9365 in executable files they are virtual addresses. Note that
9366 this code assumes that all ELF sections have an associated
9367 BFD section with a reasonable value for output_offset; below
9368 we assume that they also have a reasonable value for
9369 output_section. Any special sections must be set up to meet
9370 these requirements. */
9371 osym
.st_value
+= isec
->output_offset
;
9372 if (!flinfo
->info
->relocatable
)
9374 osym
.st_value
+= isec
->output_section
->vma
;
9375 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
9377 /* STT_TLS symbols are relative to PT_TLS segment base. */
9378 BFD_ASSERT (elf_hash_table (flinfo
->info
)->tls_sec
!= NULL
);
9379 osym
.st_value
-= elf_hash_table (flinfo
->info
)->tls_sec
->vma
;
9383 indx
= bfd_get_symcount (output_bfd
);
9384 ret
= elf_link_output_sym (flinfo
, name
, &osym
, isec
, NULL
);
9391 if (bed
->s
->arch_size
== 32)
9399 r_type_mask
= 0xffffffff;
9404 /* Relocate the contents of each section. */
9405 sym_hashes
= elf_sym_hashes (input_bfd
);
9406 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
9410 if (! o
->linker_mark
)
9412 /* This section was omitted from the link. */
9416 if (flinfo
->info
->relocatable
9417 && (o
->flags
& (SEC_LINKER_CREATED
| SEC_GROUP
)) == SEC_GROUP
)
9419 /* Deal with the group signature symbol. */
9420 struct bfd_elf_section_data
*sec_data
= elf_section_data (o
);
9421 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
9422 asection
*osec
= o
->output_section
;
9424 if (symndx
>= locsymcount
9425 || (elf_bad_symtab (input_bfd
)
9426 && flinfo
->sections
[symndx
] == NULL
))
9428 struct elf_link_hash_entry
*h
= sym_hashes
[symndx
- extsymoff
];
9429 while (h
->root
.type
== bfd_link_hash_indirect
9430 || h
->root
.type
== bfd_link_hash_warning
)
9431 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9432 /* Arrange for symbol to be output. */
9434 elf_section_data (osec
)->this_hdr
.sh_info
= -2;
9436 else if (ELF_ST_TYPE (isymbuf
[symndx
].st_info
) == STT_SECTION
)
9438 /* We'll use the output section target_index. */
9439 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
9440 elf_section_data (osec
)->this_hdr
.sh_info
= sec
->target_index
;
9444 if (flinfo
->indices
[symndx
] == -1)
9446 /* Otherwise output the local symbol now. */
9447 Elf_Internal_Sym sym
= isymbuf
[symndx
];
9448 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
9453 name
= bfd_elf_string_from_elf_section (input_bfd
,
9454 symtab_hdr
->sh_link
,
9459 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9461 if (sym
.st_shndx
== SHN_BAD
)
9464 sym
.st_value
+= o
->output_offset
;
9466 indx
= bfd_get_symcount (output_bfd
);
9467 ret
= elf_link_output_sym (flinfo
, name
, &sym
, o
, NULL
);
9471 flinfo
->indices
[symndx
] = indx
;
9475 elf_section_data (osec
)->this_hdr
.sh_info
9476 = flinfo
->indices
[symndx
];
9480 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
9481 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
9484 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
9486 /* Section was created by _bfd_elf_link_create_dynamic_sections
9491 /* Get the contents of the section. They have been cached by a
9492 relaxation routine. Note that o is a section in an input
9493 file, so the contents field will not have been set by any of
9494 the routines which work on output files. */
9495 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
9496 contents
= elf_section_data (o
)->this_hdr
.contents
;
9499 contents
= flinfo
->contents
;
9500 if (! bfd_get_full_section_contents (input_bfd
, o
, &contents
))
9504 if ((o
->flags
& SEC_RELOC
) != 0)
9506 Elf_Internal_Rela
*internal_relocs
;
9507 Elf_Internal_Rela
*rel
, *relend
;
9508 int action_discarded
;
9511 /* Get the swapped relocs. */
9513 = _bfd_elf_link_read_relocs (input_bfd
, o
, flinfo
->external_relocs
,
9514 flinfo
->internal_relocs
, FALSE
);
9515 if (internal_relocs
== NULL
9516 && o
->reloc_count
> 0)
9519 /* We need to reverse-copy input .ctors/.dtors sections if
9520 they are placed in .init_array/.finit_array for output. */
9521 if (o
->size
> address_size
9522 && ((strncmp (o
->name
, ".ctors", 6) == 0
9523 && strcmp (o
->output_section
->name
,
9524 ".init_array") == 0)
9525 || (strncmp (o
->name
, ".dtors", 6) == 0
9526 && strcmp (o
->output_section
->name
,
9527 ".fini_array") == 0))
9528 && (o
->name
[6] == 0 || o
->name
[6] == '.'))
9530 if (o
->size
!= o
->reloc_count
* address_size
)
9532 (*_bfd_error_handler
)
9533 (_("error: %B: size of section %A is not "
9534 "multiple of address size"),
9536 bfd_set_error (bfd_error_on_input
);
9539 o
->flags
|= SEC_ELF_REVERSE_COPY
;
9542 action_discarded
= -1;
9543 if (!elf_section_ignore_discarded_relocs (o
))
9544 action_discarded
= (*bed
->action_discarded
) (o
);
9546 /* Run through the relocs evaluating complex reloc symbols and
9547 looking for relocs against symbols from discarded sections
9548 or section symbols from removed link-once sections.
9549 Complain about relocs against discarded sections. Zero
9550 relocs against removed link-once sections. */
9552 rel
= internal_relocs
;
9553 relend
= rel
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9554 for ( ; rel
< relend
; rel
++)
9556 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
9557 unsigned int s_type
;
9558 asection
**ps
, *sec
;
9559 struct elf_link_hash_entry
*h
= NULL
;
9560 const char *sym_name
;
9562 if (r_symndx
== STN_UNDEF
)
9565 if (r_symndx
>= locsymcount
9566 || (elf_bad_symtab (input_bfd
)
9567 && flinfo
->sections
[r_symndx
] == NULL
))
9569 h
= sym_hashes
[r_symndx
- extsymoff
];
9571 /* Badly formatted input files can contain relocs that
9572 reference non-existant symbols. Check here so that
9573 we do not seg fault. */
9578 sprintf_vma (buffer
, rel
->r_info
);
9579 (*_bfd_error_handler
)
9580 (_("error: %B contains a reloc (0x%s) for section %A "
9581 "that references a non-existent global symbol"),
9582 input_bfd
, o
, buffer
);
9583 bfd_set_error (bfd_error_bad_value
);
9587 while (h
->root
.type
== bfd_link_hash_indirect
9588 || h
->root
.type
== bfd_link_hash_warning
)
9589 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9594 if (h
->root
.type
== bfd_link_hash_defined
9595 || h
->root
.type
== bfd_link_hash_defweak
)
9596 ps
= &h
->root
.u
.def
.section
;
9598 sym_name
= h
->root
.root
.string
;
9602 Elf_Internal_Sym
*sym
= isymbuf
+ r_symndx
;
9604 s_type
= ELF_ST_TYPE (sym
->st_info
);
9605 ps
= &flinfo
->sections
[r_symndx
];
9606 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
9610 if ((s_type
== STT_RELC
|| s_type
== STT_SRELC
)
9611 && !flinfo
->info
->relocatable
)
9614 bfd_vma dot
= (rel
->r_offset
9615 + o
->output_offset
+ o
->output_section
->vma
);
9617 printf ("Encountered a complex symbol!");
9618 printf (" (input_bfd %s, section %s, reloc %ld\n",
9619 input_bfd
->filename
, o
->name
,
9620 (long) (rel
- internal_relocs
));
9621 printf (" symbol: idx %8.8lx, name %s\n",
9622 r_symndx
, sym_name
);
9623 printf (" reloc : info %8.8lx, addr %8.8lx\n",
9624 (unsigned long) rel
->r_info
,
9625 (unsigned long) rel
->r_offset
);
9627 if (!eval_symbol (&val
, &sym_name
, input_bfd
, flinfo
, dot
,
9628 isymbuf
, locsymcount
, s_type
== STT_SRELC
))
9631 /* Symbol evaluated OK. Update to absolute value. */
9632 set_symbol_value (input_bfd
, isymbuf
, locsymcount
,
9637 if (action_discarded
!= -1 && ps
!= NULL
)
9639 /* Complain if the definition comes from a
9640 discarded section. */
9641 if ((sec
= *ps
) != NULL
&& discarded_section (sec
))
9643 BFD_ASSERT (r_symndx
!= STN_UNDEF
);
9644 if (action_discarded
& COMPLAIN
)
9645 (*flinfo
->info
->callbacks
->einfo
)
9646 (_("%X`%s' referenced in section `%A' of %B: "
9647 "defined in discarded section `%A' of %B\n"),
9648 sym_name
, o
, input_bfd
, sec
, sec
->owner
);
9650 /* Try to do the best we can to support buggy old
9651 versions of gcc. Pretend that the symbol is
9652 really defined in the kept linkonce section.
9653 FIXME: This is quite broken. Modifying the
9654 symbol here means we will be changing all later
9655 uses of the symbol, not just in this section. */
9656 if (action_discarded
& PRETEND
)
9660 kept
= _bfd_elf_check_kept_section (sec
,
9672 /* Relocate the section by invoking a back end routine.
9674 The back end routine is responsible for adjusting the
9675 section contents as necessary, and (if using Rela relocs
9676 and generating a relocatable output file) adjusting the
9677 reloc addend as necessary.
9679 The back end routine does not have to worry about setting
9680 the reloc address or the reloc symbol index.
9682 The back end routine is given a pointer to the swapped in
9683 internal symbols, and can access the hash table entries
9684 for the external symbols via elf_sym_hashes (input_bfd).
9686 When generating relocatable output, the back end routine
9687 must handle STB_LOCAL/STT_SECTION symbols specially. The
9688 output symbol is going to be a section symbol
9689 corresponding to the output section, which will require
9690 the addend to be adjusted. */
9692 ret
= (*relocate_section
) (output_bfd
, flinfo
->info
,
9693 input_bfd
, o
, contents
,
9701 || flinfo
->info
->relocatable
9702 || flinfo
->info
->emitrelocations
)
9704 Elf_Internal_Rela
*irela
;
9705 Elf_Internal_Rela
*irelaend
, *irelamid
;
9706 bfd_vma last_offset
;
9707 struct elf_link_hash_entry
**rel_hash
;
9708 struct elf_link_hash_entry
**rel_hash_list
, **rela_hash_list
;
9709 Elf_Internal_Shdr
*input_rel_hdr
, *input_rela_hdr
;
9710 unsigned int next_erel
;
9711 bfd_boolean rela_normal
;
9712 struct bfd_elf_section_data
*esdi
, *esdo
;
9714 esdi
= elf_section_data (o
);
9715 esdo
= elf_section_data (o
->output_section
);
9716 rela_normal
= FALSE
;
9718 /* Adjust the reloc addresses and symbol indices. */
9720 irela
= internal_relocs
;
9721 irelaend
= irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9722 rel_hash
= esdo
->rel
.hashes
+ esdo
->rel
.count
;
9723 /* We start processing the REL relocs, if any. When we reach
9724 IRELAMID in the loop, we switch to the RELA relocs. */
9726 if (esdi
->rel
.hdr
!= NULL
)
9727 irelamid
+= (NUM_SHDR_ENTRIES (esdi
->rel
.hdr
)
9728 * bed
->s
->int_rels_per_ext_rel
);
9729 rel_hash_list
= rel_hash
;
9730 rela_hash_list
= NULL
;
9731 last_offset
= o
->output_offset
;
9732 if (!flinfo
->info
->relocatable
)
9733 last_offset
+= o
->output_section
->vma
;
9734 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
9736 unsigned long r_symndx
;
9738 Elf_Internal_Sym sym
;
9740 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
9746 if (irela
== irelamid
)
9748 rel_hash
= esdo
->rela
.hashes
+ esdo
->rela
.count
;
9749 rela_hash_list
= rel_hash
;
9750 rela_normal
= bed
->rela_normal
;
9753 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
9756 if (irela
->r_offset
>= (bfd_vma
) -2)
9758 /* This is a reloc for a deleted entry or somesuch.
9759 Turn it into an R_*_NONE reloc, at the same
9760 offset as the last reloc. elf_eh_frame.c and
9761 bfd_elf_discard_info rely on reloc offsets
9763 irela
->r_offset
= last_offset
;
9765 irela
->r_addend
= 0;
9769 irela
->r_offset
+= o
->output_offset
;
9771 /* Relocs in an executable have to be virtual addresses. */
9772 if (!flinfo
->info
->relocatable
)
9773 irela
->r_offset
+= o
->output_section
->vma
;
9775 last_offset
= irela
->r_offset
;
9777 r_symndx
= irela
->r_info
>> r_sym_shift
;
9778 if (r_symndx
== STN_UNDEF
)
9781 if (r_symndx
>= locsymcount
9782 || (elf_bad_symtab (input_bfd
)
9783 && flinfo
->sections
[r_symndx
] == NULL
))
9785 struct elf_link_hash_entry
*rh
;
9788 /* This is a reloc against a global symbol. We
9789 have not yet output all the local symbols, so
9790 we do not know the symbol index of any global
9791 symbol. We set the rel_hash entry for this
9792 reloc to point to the global hash table entry
9793 for this symbol. The symbol index is then
9794 set at the end of bfd_elf_final_link. */
9795 indx
= r_symndx
- extsymoff
;
9796 rh
= elf_sym_hashes (input_bfd
)[indx
];
9797 while (rh
->root
.type
== bfd_link_hash_indirect
9798 || rh
->root
.type
== bfd_link_hash_warning
)
9799 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
9801 /* Setting the index to -2 tells
9802 elf_link_output_extsym that this symbol is
9804 BFD_ASSERT (rh
->indx
< 0);
9812 /* This is a reloc against a local symbol. */
9815 sym
= isymbuf
[r_symndx
];
9816 sec
= flinfo
->sections
[r_symndx
];
9817 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
9819 /* I suppose the backend ought to fill in the
9820 section of any STT_SECTION symbol against a
9821 processor specific section. */
9822 r_symndx
= STN_UNDEF
;
9823 if (bfd_is_abs_section (sec
))
9825 else if (sec
== NULL
|| sec
->owner
== NULL
)
9827 bfd_set_error (bfd_error_bad_value
);
9832 asection
*osec
= sec
->output_section
;
9834 /* If we have discarded a section, the output
9835 section will be the absolute section. In
9836 case of discarded SEC_MERGE sections, use
9837 the kept section. relocate_section should
9838 have already handled discarded linkonce
9840 if (bfd_is_abs_section (osec
)
9841 && sec
->kept_section
!= NULL
9842 && sec
->kept_section
->output_section
!= NULL
)
9844 osec
= sec
->kept_section
->output_section
;
9845 irela
->r_addend
-= osec
->vma
;
9848 if (!bfd_is_abs_section (osec
))
9850 r_symndx
= osec
->target_index
;
9851 if (r_symndx
== STN_UNDEF
)
9853 irela
->r_addend
+= osec
->vma
;
9854 osec
= _bfd_nearby_section (output_bfd
, osec
,
9856 irela
->r_addend
-= osec
->vma
;
9857 r_symndx
= osec
->target_index
;
9862 /* Adjust the addend according to where the
9863 section winds up in the output section. */
9865 irela
->r_addend
+= sec
->output_offset
;
9869 if (flinfo
->indices
[r_symndx
] == -1)
9871 unsigned long shlink
;
9876 if (flinfo
->info
->strip
== strip_all
)
9878 /* You can't do ld -r -s. */
9879 bfd_set_error (bfd_error_invalid_operation
);
9883 /* This symbol was skipped earlier, but
9884 since it is needed by a reloc, we
9885 must output it now. */
9886 shlink
= symtab_hdr
->sh_link
;
9887 name
= (bfd_elf_string_from_elf_section
9888 (input_bfd
, shlink
, sym
.st_name
));
9892 osec
= sec
->output_section
;
9894 _bfd_elf_section_from_bfd_section (output_bfd
,
9896 if (sym
.st_shndx
== SHN_BAD
)
9899 sym
.st_value
+= sec
->output_offset
;
9900 if (!flinfo
->info
->relocatable
)
9902 sym
.st_value
+= osec
->vma
;
9903 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
9905 /* STT_TLS symbols are relative to PT_TLS
9907 BFD_ASSERT (elf_hash_table (flinfo
->info
)
9909 sym
.st_value
-= (elf_hash_table (flinfo
->info
)
9914 indx
= bfd_get_symcount (output_bfd
);
9915 ret
= elf_link_output_sym (flinfo
, name
, &sym
, sec
,
9920 flinfo
->indices
[r_symndx
] = indx
;
9925 r_symndx
= flinfo
->indices
[r_symndx
];
9928 irela
->r_info
= ((bfd_vma
) r_symndx
<< r_sym_shift
9929 | (irela
->r_info
& r_type_mask
));
9932 /* Swap out the relocs. */
9933 input_rel_hdr
= esdi
->rel
.hdr
;
9934 if (input_rel_hdr
&& input_rel_hdr
->sh_size
!= 0)
9936 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
9941 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
9942 * bed
->s
->int_rels_per_ext_rel
);
9943 rel_hash_list
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
9946 input_rela_hdr
= esdi
->rela
.hdr
;
9947 if (input_rela_hdr
&& input_rela_hdr
->sh_size
!= 0)
9949 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
9958 /* Write out the modified section contents. */
9959 if (bed
->elf_backend_write_section
9960 && (*bed
->elf_backend_write_section
) (output_bfd
, flinfo
->info
, o
,
9963 /* Section written out. */
9965 else switch (o
->sec_info_type
)
9967 case SEC_INFO_TYPE_STABS
:
9968 if (! (_bfd_write_section_stabs
9970 &elf_hash_table (flinfo
->info
)->stab_info
,
9971 o
, &elf_section_data (o
)->sec_info
, contents
)))
9974 case SEC_INFO_TYPE_MERGE
:
9975 if (! _bfd_write_merged_section (output_bfd
, o
,
9976 elf_section_data (o
)->sec_info
))
9979 case SEC_INFO_TYPE_EH_FRAME
:
9981 if (! _bfd_elf_write_section_eh_frame (output_bfd
, flinfo
->info
,
9988 /* FIXME: octets_per_byte. */
9989 if (! (o
->flags
& SEC_EXCLUDE
))
9991 file_ptr offset
= (file_ptr
) o
->output_offset
;
9992 bfd_size_type todo
= o
->size
;
9993 if ((o
->flags
& SEC_ELF_REVERSE_COPY
))
9995 /* Reverse-copy input section to output. */
9998 todo
-= address_size
;
9999 if (! bfd_set_section_contents (output_bfd
,
10007 offset
+= address_size
;
10011 else if (! bfd_set_section_contents (output_bfd
,
10025 /* Generate a reloc when linking an ELF file. This is a reloc
10026 requested by the linker, and does not come from any input file. This
10027 is used to build constructor and destructor tables when linking
10031 elf_reloc_link_order (bfd
*output_bfd
,
10032 struct bfd_link_info
*info
,
10033 asection
*output_section
,
10034 struct bfd_link_order
*link_order
)
10036 reloc_howto_type
*howto
;
10040 struct bfd_elf_section_reloc_data
*reldata
;
10041 struct elf_link_hash_entry
**rel_hash_ptr
;
10042 Elf_Internal_Shdr
*rel_hdr
;
10043 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
10044 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
10047 struct bfd_elf_section_data
*esdo
= elf_section_data (output_section
);
10049 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
10052 bfd_set_error (bfd_error_bad_value
);
10056 addend
= link_order
->u
.reloc
.p
->addend
;
10059 reldata
= &esdo
->rel
;
10060 else if (esdo
->rela
.hdr
)
10061 reldata
= &esdo
->rela
;
10068 /* Figure out the symbol index. */
10069 rel_hash_ptr
= reldata
->hashes
+ reldata
->count
;
10070 if (link_order
->type
== bfd_section_reloc_link_order
)
10072 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
10073 BFD_ASSERT (indx
!= 0);
10074 *rel_hash_ptr
= NULL
;
10078 struct elf_link_hash_entry
*h
;
10080 /* Treat a reloc against a defined symbol as though it were
10081 actually against the section. */
10082 h
= ((struct elf_link_hash_entry
*)
10083 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
10084 link_order
->u
.reloc
.p
->u
.name
,
10085 FALSE
, FALSE
, TRUE
));
10087 && (h
->root
.type
== bfd_link_hash_defined
10088 || h
->root
.type
== bfd_link_hash_defweak
))
10092 section
= h
->root
.u
.def
.section
;
10093 indx
= section
->output_section
->target_index
;
10094 *rel_hash_ptr
= NULL
;
10095 /* It seems that we ought to add the symbol value to the
10096 addend here, but in practice it has already been added
10097 because it was passed to constructor_callback. */
10098 addend
+= section
->output_section
->vma
+ section
->output_offset
;
10100 else if (h
!= NULL
)
10102 /* Setting the index to -2 tells elf_link_output_extsym that
10103 this symbol is used by a reloc. */
10110 if (! ((*info
->callbacks
->unattached_reloc
)
10111 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0)))
10117 /* If this is an inplace reloc, we must write the addend into the
10119 if (howto
->partial_inplace
&& addend
!= 0)
10121 bfd_size_type size
;
10122 bfd_reloc_status_type rstat
;
10125 const char *sym_name
;
10127 size
= (bfd_size_type
) bfd_get_reloc_size (howto
);
10128 buf
= (bfd_byte
*) bfd_zmalloc (size
);
10131 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
10138 case bfd_reloc_outofrange
:
10141 case bfd_reloc_overflow
:
10142 if (link_order
->type
== bfd_section_reloc_link_order
)
10143 sym_name
= bfd_section_name (output_bfd
,
10144 link_order
->u
.reloc
.p
->u
.section
);
10146 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
10147 if (! ((*info
->callbacks
->reloc_overflow
)
10148 (info
, NULL
, sym_name
, howto
->name
, addend
, NULL
,
10149 NULL
, (bfd_vma
) 0)))
10156 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
10157 link_order
->offset
, size
);
10163 /* The address of a reloc is relative to the section in a
10164 relocatable file, and is a virtual address in an executable
10166 offset
= link_order
->offset
;
10167 if (! info
->relocatable
)
10168 offset
+= output_section
->vma
;
10170 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
10172 irel
[i
].r_offset
= offset
;
10173 irel
[i
].r_info
= 0;
10174 irel
[i
].r_addend
= 0;
10176 if (bed
->s
->arch_size
== 32)
10177 irel
[0].r_info
= ELF32_R_INFO (indx
, howto
->type
);
10179 irel
[0].r_info
= ELF64_R_INFO (indx
, howto
->type
);
10181 rel_hdr
= reldata
->hdr
;
10182 erel
= rel_hdr
->contents
;
10183 if (rel_hdr
->sh_type
== SHT_REL
)
10185 erel
+= reldata
->count
* bed
->s
->sizeof_rel
;
10186 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
10190 irel
[0].r_addend
= addend
;
10191 erel
+= reldata
->count
* bed
->s
->sizeof_rela
;
10192 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
10201 /* Get the output vma of the section pointed to by the sh_link field. */
10204 elf_get_linked_section_vma (struct bfd_link_order
*p
)
10206 Elf_Internal_Shdr
**elf_shdrp
;
10210 s
= p
->u
.indirect
.section
;
10211 elf_shdrp
= elf_elfsections (s
->owner
);
10212 elfsec
= _bfd_elf_section_from_bfd_section (s
->owner
, s
);
10213 elfsec
= elf_shdrp
[elfsec
]->sh_link
;
10215 The Intel C compiler generates SHT_IA_64_UNWIND with
10216 SHF_LINK_ORDER. But it doesn't set the sh_link or
10217 sh_info fields. Hence we could get the situation
10218 where elfsec is 0. */
10221 const struct elf_backend_data
*bed
10222 = get_elf_backend_data (s
->owner
);
10223 if (bed
->link_order_error_handler
)
10224 bed
->link_order_error_handler
10225 (_("%B: warning: sh_link not set for section `%A'"), s
->owner
, s
);
10230 s
= elf_shdrp
[elfsec
]->bfd_section
;
10231 return s
->output_section
->vma
+ s
->output_offset
;
10236 /* Compare two sections based on the locations of the sections they are
10237 linked to. Used by elf_fixup_link_order. */
10240 compare_link_order (const void * a
, const void * b
)
10245 apos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)a
);
10246 bpos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)b
);
10249 return apos
> bpos
;
10253 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
10254 order as their linked sections. Returns false if this could not be done
10255 because an output section includes both ordered and unordered
10256 sections. Ideally we'd do this in the linker proper. */
10259 elf_fixup_link_order (bfd
*abfd
, asection
*o
)
10261 int seen_linkorder
;
10264 struct bfd_link_order
*p
;
10266 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10268 struct bfd_link_order
**sections
;
10269 asection
*s
, *other_sec
, *linkorder_sec
;
10273 linkorder_sec
= NULL
;
10275 seen_linkorder
= 0;
10276 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10278 if (p
->type
== bfd_indirect_link_order
)
10280 s
= p
->u
.indirect
.section
;
10282 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
10283 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
10284 && (elfsec
= _bfd_elf_section_from_bfd_section (sub
, s
))
10285 && elfsec
< elf_numsections (sub
)
10286 && elf_elfsections (sub
)[elfsec
]->sh_flags
& SHF_LINK_ORDER
10287 && elf_elfsections (sub
)[elfsec
]->sh_link
< elf_numsections (sub
))
10301 if (seen_other
&& seen_linkorder
)
10303 if (other_sec
&& linkorder_sec
)
10304 (*_bfd_error_handler
) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10306 linkorder_sec
->owner
, other_sec
,
10309 (*_bfd_error_handler
) (_("%A has both ordered and unordered sections"),
10311 bfd_set_error (bfd_error_bad_value
);
10316 if (!seen_linkorder
)
10319 sections
= (struct bfd_link_order
**)
10320 bfd_malloc (seen_linkorder
* sizeof (struct bfd_link_order
*));
10321 if (sections
== NULL
)
10323 seen_linkorder
= 0;
10325 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10327 sections
[seen_linkorder
++] = p
;
10329 /* Sort the input sections in the order of their linked section. */
10330 qsort (sections
, seen_linkorder
, sizeof (struct bfd_link_order
*),
10331 compare_link_order
);
10333 /* Change the offsets of the sections. */
10335 for (n
= 0; n
< seen_linkorder
; n
++)
10337 s
= sections
[n
]->u
.indirect
.section
;
10338 offset
&= ~(bfd_vma
) 0 << s
->alignment_power
;
10339 s
->output_offset
= offset
;
10340 sections
[n
]->offset
= offset
;
10341 /* FIXME: octets_per_byte. */
10342 offset
+= sections
[n
]->size
;
10350 /* Do the final step of an ELF link. */
10353 bfd_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10355 bfd_boolean dynamic
;
10356 bfd_boolean emit_relocs
;
10358 struct elf_final_link_info flinfo
;
10360 struct bfd_link_order
*p
;
10362 bfd_size_type max_contents_size
;
10363 bfd_size_type max_external_reloc_size
;
10364 bfd_size_type max_internal_reloc_count
;
10365 bfd_size_type max_sym_count
;
10366 bfd_size_type max_sym_shndx_count
;
10368 Elf_Internal_Sym elfsym
;
10370 Elf_Internal_Shdr
*symtab_hdr
;
10371 Elf_Internal_Shdr
*symtab_shndx_hdr
;
10372 Elf_Internal_Shdr
*symstrtab_hdr
;
10373 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10374 struct elf_outext_info eoinfo
;
10375 bfd_boolean merged
;
10376 size_t relativecount
= 0;
10377 asection
*reldyn
= 0;
10379 asection
*attr_section
= NULL
;
10380 bfd_vma attr_size
= 0;
10381 const char *std_attrs_section
;
10383 if (! is_elf_hash_table (info
->hash
))
10387 abfd
->flags
|= DYNAMIC
;
10389 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
10390 dynobj
= elf_hash_table (info
)->dynobj
;
10392 emit_relocs
= (info
->relocatable
10393 || info
->emitrelocations
);
10395 flinfo
.info
= info
;
10396 flinfo
.output_bfd
= abfd
;
10397 flinfo
.symstrtab
= _bfd_elf_stringtab_init ();
10398 if (flinfo
.symstrtab
== NULL
)
10403 flinfo
.dynsym_sec
= NULL
;
10404 flinfo
.hash_sec
= NULL
;
10405 flinfo
.symver_sec
= NULL
;
10409 flinfo
.dynsym_sec
= bfd_get_linker_section (dynobj
, ".dynsym");
10410 flinfo
.hash_sec
= bfd_get_linker_section (dynobj
, ".hash");
10411 /* Note that dynsym_sec can be NULL (on VMS). */
10412 flinfo
.symver_sec
= bfd_get_linker_section (dynobj
, ".gnu.version");
10413 /* Note that it is OK if symver_sec is NULL. */
10416 flinfo
.contents
= NULL
;
10417 flinfo
.external_relocs
= NULL
;
10418 flinfo
.internal_relocs
= NULL
;
10419 flinfo
.external_syms
= NULL
;
10420 flinfo
.locsym_shndx
= NULL
;
10421 flinfo
.internal_syms
= NULL
;
10422 flinfo
.indices
= NULL
;
10423 flinfo
.sections
= NULL
;
10424 flinfo
.symbuf
= NULL
;
10425 flinfo
.symshndxbuf
= NULL
;
10426 flinfo
.symbuf_count
= 0;
10427 flinfo
.shndxbuf_size
= 0;
10428 flinfo
.filesym_count
= 0;
10430 /* The object attributes have been merged. Remove the input
10431 sections from the link, and set the contents of the output
10433 std_attrs_section
= get_elf_backend_data (abfd
)->obj_attrs_section
;
10434 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10436 if ((std_attrs_section
&& strcmp (o
->name
, std_attrs_section
) == 0)
10437 || strcmp (o
->name
, ".gnu.attributes") == 0)
10439 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10441 asection
*input_section
;
10443 if (p
->type
!= bfd_indirect_link_order
)
10445 input_section
= p
->u
.indirect
.section
;
10446 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10447 elf_link_input_bfd ignores this section. */
10448 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10451 attr_size
= bfd_elf_obj_attr_size (abfd
);
10454 bfd_set_section_size (abfd
, o
, attr_size
);
10456 /* Skip this section later on. */
10457 o
->map_head
.link_order
= NULL
;
10460 o
->flags
|= SEC_EXCLUDE
;
10464 /* Count up the number of relocations we will output for each output
10465 section, so that we know the sizes of the reloc sections. We
10466 also figure out some maximum sizes. */
10467 max_contents_size
= 0;
10468 max_external_reloc_size
= 0;
10469 max_internal_reloc_count
= 0;
10471 max_sym_shndx_count
= 0;
10473 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10475 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10476 o
->reloc_count
= 0;
10478 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10480 unsigned int reloc_count
= 0;
10481 struct bfd_elf_section_data
*esdi
= NULL
;
10483 if (p
->type
== bfd_section_reloc_link_order
10484 || p
->type
== bfd_symbol_reloc_link_order
)
10486 else if (p
->type
== bfd_indirect_link_order
)
10490 sec
= p
->u
.indirect
.section
;
10491 esdi
= elf_section_data (sec
);
10493 /* Mark all sections which are to be included in the
10494 link. This will normally be every section. We need
10495 to do this so that we can identify any sections which
10496 the linker has decided to not include. */
10497 sec
->linker_mark
= TRUE
;
10499 if (sec
->flags
& SEC_MERGE
)
10502 if (esdo
->this_hdr
.sh_type
== SHT_REL
10503 || esdo
->this_hdr
.sh_type
== SHT_RELA
)
10504 /* Some backends use reloc_count in relocation sections
10505 to count particular types of relocs. Of course,
10506 reloc sections themselves can't have relocations. */
10508 else if (info
->relocatable
|| info
->emitrelocations
)
10509 reloc_count
= sec
->reloc_count
;
10510 else if (bed
->elf_backend_count_relocs
)
10511 reloc_count
= (*bed
->elf_backend_count_relocs
) (info
, sec
);
10513 if (sec
->rawsize
> max_contents_size
)
10514 max_contents_size
= sec
->rawsize
;
10515 if (sec
->size
> max_contents_size
)
10516 max_contents_size
= sec
->size
;
10518 /* We are interested in just local symbols, not all
10520 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
10521 && (sec
->owner
->flags
& DYNAMIC
) == 0)
10525 if (elf_bad_symtab (sec
->owner
))
10526 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
10527 / bed
->s
->sizeof_sym
);
10529 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
10531 if (sym_count
> max_sym_count
)
10532 max_sym_count
= sym_count
;
10534 if (sym_count
> max_sym_shndx_count
10535 && elf_symtab_shndx (sec
->owner
) != 0)
10536 max_sym_shndx_count
= sym_count
;
10538 if ((sec
->flags
& SEC_RELOC
) != 0)
10540 size_t ext_size
= 0;
10542 if (esdi
->rel
.hdr
!= NULL
)
10543 ext_size
= esdi
->rel
.hdr
->sh_size
;
10544 if (esdi
->rela
.hdr
!= NULL
)
10545 ext_size
+= esdi
->rela
.hdr
->sh_size
;
10547 if (ext_size
> max_external_reloc_size
)
10548 max_external_reloc_size
= ext_size
;
10549 if (sec
->reloc_count
> max_internal_reloc_count
)
10550 max_internal_reloc_count
= sec
->reloc_count
;
10555 if (reloc_count
== 0)
10558 o
->reloc_count
+= reloc_count
;
10560 if (p
->type
== bfd_indirect_link_order
10561 && (info
->relocatable
|| info
->emitrelocations
))
10564 esdo
->rel
.count
+= NUM_SHDR_ENTRIES (esdi
->rel
.hdr
);
10565 if (esdi
->rela
.hdr
)
10566 esdo
->rela
.count
+= NUM_SHDR_ENTRIES (esdi
->rela
.hdr
);
10571 esdo
->rela
.count
+= reloc_count
;
10573 esdo
->rel
.count
+= reloc_count
;
10577 if (o
->reloc_count
> 0)
10578 o
->flags
|= SEC_RELOC
;
10581 /* Explicitly clear the SEC_RELOC flag. The linker tends to
10582 set it (this is probably a bug) and if it is set
10583 assign_section_numbers will create a reloc section. */
10584 o
->flags
&=~ SEC_RELOC
;
10587 /* If the SEC_ALLOC flag is not set, force the section VMA to
10588 zero. This is done in elf_fake_sections as well, but forcing
10589 the VMA to 0 here will ensure that relocs against these
10590 sections are handled correctly. */
10591 if ((o
->flags
& SEC_ALLOC
) == 0
10592 && ! o
->user_set_vma
)
10596 if (! info
->relocatable
&& merged
)
10597 elf_link_hash_traverse (elf_hash_table (info
),
10598 _bfd_elf_link_sec_merge_syms
, abfd
);
10600 /* Figure out the file positions for everything but the symbol table
10601 and the relocs. We set symcount to force assign_section_numbers
10602 to create a symbol table. */
10603 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
10604 BFD_ASSERT (! abfd
->output_has_begun
);
10605 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
10608 /* Set sizes, and assign file positions for reloc sections. */
10609 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10611 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10612 if ((o
->flags
& SEC_RELOC
) != 0)
10615 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rel
)))
10619 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rela
)))
10623 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10624 to count upwards while actually outputting the relocations. */
10625 esdo
->rel
.count
= 0;
10626 esdo
->rela
.count
= 0;
10629 _bfd_elf_assign_file_positions_for_relocs (abfd
);
10631 /* We have now assigned file positions for all the sections except
10632 .symtab and .strtab. We start the .symtab section at the current
10633 file position, and write directly to it. We build the .strtab
10634 section in memory. */
10635 bfd_get_symcount (abfd
) = 0;
10636 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10637 /* sh_name is set in prep_headers. */
10638 symtab_hdr
->sh_type
= SHT_SYMTAB
;
10639 /* sh_flags, sh_addr and sh_size all start off zero. */
10640 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
10641 /* sh_link is set in assign_section_numbers. */
10642 /* sh_info is set below. */
10643 /* sh_offset is set just below. */
10644 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
10646 off
= elf_tdata (abfd
)->next_file_pos
;
10647 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, TRUE
);
10649 /* Note that at this point elf_tdata (abfd)->next_file_pos is
10650 incorrect. We do not yet know the size of the .symtab section.
10651 We correct next_file_pos below, after we do know the size. */
10653 /* Allocate a buffer to hold swapped out symbols. This is to avoid
10654 continuously seeking to the right position in the file. */
10655 if (! info
->keep_memory
|| max_sym_count
< 20)
10656 flinfo
.symbuf_size
= 20;
10658 flinfo
.symbuf_size
= max_sym_count
;
10659 amt
= flinfo
.symbuf_size
;
10660 amt
*= bed
->s
->sizeof_sym
;
10661 flinfo
.symbuf
= (bfd_byte
*) bfd_malloc (amt
);
10662 if (flinfo
.symbuf
== NULL
)
10664 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
10666 /* Wild guess at number of output symbols. realloc'd as needed. */
10667 amt
= 2 * max_sym_count
+ elf_numsections (abfd
) + 1000;
10668 flinfo
.shndxbuf_size
= amt
;
10669 amt
*= sizeof (Elf_External_Sym_Shndx
);
10670 flinfo
.symshndxbuf
= (Elf_External_Sym_Shndx
*) bfd_zmalloc (amt
);
10671 if (flinfo
.symshndxbuf
== NULL
)
10675 /* Start writing out the symbol table. The first symbol is always a
10677 if (info
->strip
!= strip_all
10680 elfsym
.st_value
= 0;
10681 elfsym
.st_size
= 0;
10682 elfsym
.st_info
= 0;
10683 elfsym
.st_other
= 0;
10684 elfsym
.st_shndx
= SHN_UNDEF
;
10685 elfsym
.st_target_internal
= 0;
10686 if (elf_link_output_sym (&flinfo
, NULL
, &elfsym
, bfd_und_section_ptr
,
10691 /* Output a symbol for each section. We output these even if we are
10692 discarding local symbols, since they are used for relocs. These
10693 symbols have no names. We store the index of each one in the
10694 index field of the section, so that we can find it again when
10695 outputting relocs. */
10696 if (info
->strip
!= strip_all
10699 elfsym
.st_size
= 0;
10700 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
10701 elfsym
.st_other
= 0;
10702 elfsym
.st_value
= 0;
10703 elfsym
.st_target_internal
= 0;
10704 for (i
= 1; i
< elf_numsections (abfd
); i
++)
10706 o
= bfd_section_from_elf_index (abfd
, i
);
10709 o
->target_index
= bfd_get_symcount (abfd
);
10710 elfsym
.st_shndx
= i
;
10711 if (!info
->relocatable
)
10712 elfsym
.st_value
= o
->vma
;
10713 if (elf_link_output_sym (&flinfo
, NULL
, &elfsym
, o
, NULL
) != 1)
10719 /* Allocate some memory to hold information read in from the input
10721 if (max_contents_size
!= 0)
10723 flinfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
10724 if (flinfo
.contents
== NULL
)
10728 if (max_external_reloc_size
!= 0)
10730 flinfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
10731 if (flinfo
.external_relocs
== NULL
)
10735 if (max_internal_reloc_count
!= 0)
10737 amt
= max_internal_reloc_count
* bed
->s
->int_rels_per_ext_rel
;
10738 amt
*= sizeof (Elf_Internal_Rela
);
10739 flinfo
.internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
10740 if (flinfo
.internal_relocs
== NULL
)
10744 if (max_sym_count
!= 0)
10746 amt
= max_sym_count
* bed
->s
->sizeof_sym
;
10747 flinfo
.external_syms
= (bfd_byte
*) bfd_malloc (amt
);
10748 if (flinfo
.external_syms
== NULL
)
10751 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
10752 flinfo
.internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
10753 if (flinfo
.internal_syms
== NULL
)
10756 amt
= max_sym_count
* sizeof (long);
10757 flinfo
.indices
= (long int *) bfd_malloc (amt
);
10758 if (flinfo
.indices
== NULL
)
10761 amt
= max_sym_count
* sizeof (asection
*);
10762 flinfo
.sections
= (asection
**) bfd_malloc (amt
);
10763 if (flinfo
.sections
== NULL
)
10767 if (max_sym_shndx_count
!= 0)
10769 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
10770 flinfo
.locsym_shndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
10771 if (flinfo
.locsym_shndx
== NULL
)
10775 if (elf_hash_table (info
)->tls_sec
)
10777 bfd_vma base
, end
= 0;
10780 for (sec
= elf_hash_table (info
)->tls_sec
;
10781 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
10784 bfd_size_type size
= sec
->size
;
10787 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
10789 struct bfd_link_order
*ord
= sec
->map_tail
.link_order
;
10792 size
= ord
->offset
+ ord
->size
;
10794 end
= sec
->vma
+ size
;
10796 base
= elf_hash_table (info
)->tls_sec
->vma
;
10797 /* Only align end of TLS section if static TLS doesn't have special
10798 alignment requirements. */
10799 if (bed
->static_tls_alignment
== 1)
10800 end
= align_power (end
,
10801 elf_hash_table (info
)->tls_sec
->alignment_power
);
10802 elf_hash_table (info
)->tls_size
= end
- base
;
10805 /* Reorder SHF_LINK_ORDER sections. */
10806 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10808 if (!elf_fixup_link_order (abfd
, o
))
10812 /* Since ELF permits relocations to be against local symbols, we
10813 must have the local symbols available when we do the relocations.
10814 Since we would rather only read the local symbols once, and we
10815 would rather not keep them in memory, we handle all the
10816 relocations for a single input file at the same time.
10818 Unfortunately, there is no way to know the total number of local
10819 symbols until we have seen all of them, and the local symbol
10820 indices precede the global symbol indices. This means that when
10821 we are generating relocatable output, and we see a reloc against
10822 a global symbol, we can not know the symbol index until we have
10823 finished examining all the local symbols to see which ones we are
10824 going to output. To deal with this, we keep the relocations in
10825 memory, and don't output them until the end of the link. This is
10826 an unfortunate waste of memory, but I don't see a good way around
10827 it. Fortunately, it only happens when performing a relocatable
10828 link, which is not the common case. FIXME: If keep_memory is set
10829 we could write the relocs out and then read them again; I don't
10830 know how bad the memory loss will be. */
10832 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
10833 sub
->output_has_begun
= FALSE
;
10834 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10836 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10838 if (p
->type
== bfd_indirect_link_order
10839 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
10840 == bfd_target_elf_flavour
)
10841 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
10843 if (! sub
->output_has_begun
)
10845 if (! elf_link_input_bfd (&flinfo
, sub
))
10847 sub
->output_has_begun
= TRUE
;
10850 else if (p
->type
== bfd_section_reloc_link_order
10851 || p
->type
== bfd_symbol_reloc_link_order
)
10853 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
10858 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
10860 if (p
->type
== bfd_indirect_link_order
10861 && (bfd_get_flavour (sub
)
10862 == bfd_target_elf_flavour
)
10863 && (elf_elfheader (sub
)->e_ident
[EI_CLASS
]
10864 != bed
->s
->elfclass
))
10866 const char *iclass
, *oclass
;
10868 if (bed
->s
->elfclass
== ELFCLASS64
)
10870 iclass
= "ELFCLASS32";
10871 oclass
= "ELFCLASS64";
10875 iclass
= "ELFCLASS64";
10876 oclass
= "ELFCLASS32";
10879 bfd_set_error (bfd_error_wrong_format
);
10880 (*_bfd_error_handler
)
10881 (_("%B: file class %s incompatible with %s"),
10882 sub
, iclass
, oclass
);
10891 /* Free symbol buffer if needed. */
10892 if (!info
->reduce_memory_overheads
)
10894 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
10895 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
10896 && elf_tdata (sub
)->symbuf
)
10898 free (elf_tdata (sub
)->symbuf
);
10899 elf_tdata (sub
)->symbuf
= NULL
;
10903 /* Output a FILE symbol so that following locals are not associated
10904 with the wrong input file. */
10905 memset (&elfsym
, 0, sizeof (elfsym
));
10906 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
10907 elfsym
.st_shndx
= SHN_ABS
;
10909 if (flinfo
.filesym_count
> 1
10910 && !elf_link_output_sym (&flinfo
, NULL
, &elfsym
,
10911 bfd_und_section_ptr
, NULL
))
10914 /* Output any global symbols that got converted to local in a
10915 version script or due to symbol visibility. We do this in a
10916 separate step since ELF requires all local symbols to appear
10917 prior to any global symbols. FIXME: We should only do this if
10918 some global symbols were, in fact, converted to become local.
10919 FIXME: Will this work correctly with the Irix 5 linker? */
10920 eoinfo
.failed
= FALSE
;
10921 eoinfo
.flinfo
= &flinfo
;
10922 eoinfo
.localsyms
= TRUE
;
10923 eoinfo
.need_second_pass
= FALSE
;
10924 eoinfo
.second_pass
= FALSE
;
10925 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
10929 if (flinfo
.filesym_count
== 1
10930 && !elf_link_output_sym (&flinfo
, NULL
, &elfsym
,
10931 bfd_und_section_ptr
, NULL
))
10934 if (eoinfo
.need_second_pass
)
10936 eoinfo
.second_pass
= TRUE
;
10937 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
10942 /* If backend needs to output some local symbols not present in the hash
10943 table, do it now. */
10944 if (bed
->elf_backend_output_arch_local_syms
)
10946 typedef int (*out_sym_func
)
10947 (void *, const char *, Elf_Internal_Sym
*, asection
*,
10948 struct elf_link_hash_entry
*);
10950 if (! ((*bed
->elf_backend_output_arch_local_syms
)
10951 (abfd
, info
, &flinfo
, (out_sym_func
) elf_link_output_sym
)))
10955 /* That wrote out all the local symbols. Finish up the symbol table
10956 with the global symbols. Even if we want to strip everything we
10957 can, we still need to deal with those global symbols that got
10958 converted to local in a version script. */
10960 /* The sh_info field records the index of the first non local symbol. */
10961 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
10964 && flinfo
.dynsym_sec
!= NULL
10965 && flinfo
.dynsym_sec
->output_section
!= bfd_abs_section_ptr
)
10967 Elf_Internal_Sym sym
;
10968 bfd_byte
*dynsym
= flinfo
.dynsym_sec
->contents
;
10969 long last_local
= 0;
10971 /* Write out the section symbols for the output sections. */
10972 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
10978 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
10980 sym
.st_target_internal
= 0;
10982 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
10988 dynindx
= elf_section_data (s
)->dynindx
;
10991 indx
= elf_section_data (s
)->this_idx
;
10992 BFD_ASSERT (indx
> 0);
10993 sym
.st_shndx
= indx
;
10994 if (! check_dynsym (abfd
, &sym
))
10996 sym
.st_value
= s
->vma
;
10997 dest
= dynsym
+ dynindx
* bed
->s
->sizeof_sym
;
10998 if (last_local
< dynindx
)
10999 last_local
= dynindx
;
11000 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
11004 /* Write out the local dynsyms. */
11005 if (elf_hash_table (info
)->dynlocal
)
11007 struct elf_link_local_dynamic_entry
*e
;
11008 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
11013 /* Copy the internal symbol and turn off visibility.
11014 Note that we saved a word of storage and overwrote
11015 the original st_name with the dynstr_index. */
11017 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
11019 s
= bfd_section_from_elf_index (e
->input_bfd
,
11024 elf_section_data (s
->output_section
)->this_idx
;
11025 if (! check_dynsym (abfd
, &sym
))
11027 sym
.st_value
= (s
->output_section
->vma
11029 + e
->isym
.st_value
);
11032 if (last_local
< e
->dynindx
)
11033 last_local
= e
->dynindx
;
11035 dest
= dynsym
+ e
->dynindx
* bed
->s
->sizeof_sym
;
11036 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
11040 elf_section_data (flinfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
=
11044 /* We get the global symbols from the hash table. */
11045 eoinfo
.failed
= FALSE
;
11046 eoinfo
.localsyms
= FALSE
;
11047 eoinfo
.flinfo
= &flinfo
;
11048 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11052 /* If backend needs to output some symbols not present in the hash
11053 table, do it now. */
11054 if (bed
->elf_backend_output_arch_syms
)
11056 typedef int (*out_sym_func
)
11057 (void *, const char *, Elf_Internal_Sym
*, asection
*,
11058 struct elf_link_hash_entry
*);
11060 if (! ((*bed
->elf_backend_output_arch_syms
)
11061 (abfd
, info
, &flinfo
, (out_sym_func
) elf_link_output_sym
)))
11065 /* Flush all symbols to the file. */
11066 if (! elf_link_flush_output_syms (&flinfo
, bed
))
11069 /* Now we know the size of the symtab section. */
11070 off
+= symtab_hdr
->sh_size
;
11072 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
11073 if (symtab_shndx_hdr
->sh_name
!= 0)
11075 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
11076 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
11077 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
11078 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
11079 symtab_shndx_hdr
->sh_size
= amt
;
11081 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
11084 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
11085 || (bfd_bwrite (flinfo
.symshndxbuf
, amt
, abfd
) != amt
))
11090 /* Finish up and write out the symbol string table (.strtab)
11092 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
11093 /* sh_name was set in prep_headers. */
11094 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
11095 symstrtab_hdr
->sh_flags
= 0;
11096 symstrtab_hdr
->sh_addr
= 0;
11097 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (flinfo
.symstrtab
);
11098 symstrtab_hdr
->sh_entsize
= 0;
11099 symstrtab_hdr
->sh_link
= 0;
11100 symstrtab_hdr
->sh_info
= 0;
11101 /* sh_offset is set just below. */
11102 symstrtab_hdr
->sh_addralign
= 1;
11104 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, TRUE
);
11105 elf_tdata (abfd
)->next_file_pos
= off
;
11107 if (bfd_get_symcount (abfd
) > 0)
11109 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
11110 || ! _bfd_stringtab_emit (abfd
, flinfo
.symstrtab
))
11114 /* Adjust the relocs to have the correct symbol indices. */
11115 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11117 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11118 if ((o
->flags
& SEC_RELOC
) == 0)
11121 if (esdo
->rel
.hdr
!= NULL
)
11122 elf_link_adjust_relocs (abfd
, &esdo
->rel
);
11123 if (esdo
->rela
.hdr
!= NULL
)
11124 elf_link_adjust_relocs (abfd
, &esdo
->rela
);
11126 /* Set the reloc_count field to 0 to prevent write_relocs from
11127 trying to swap the relocs out itself. */
11128 o
->reloc_count
= 0;
11131 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
11132 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
11134 /* If we are linking against a dynamic object, or generating a
11135 shared library, finish up the dynamic linking information. */
11138 bfd_byte
*dyncon
, *dynconend
;
11140 /* Fix up .dynamic entries. */
11141 o
= bfd_get_linker_section (dynobj
, ".dynamic");
11142 BFD_ASSERT (o
!= NULL
);
11144 dyncon
= o
->contents
;
11145 dynconend
= o
->contents
+ o
->size
;
11146 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
11148 Elf_Internal_Dyn dyn
;
11152 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11159 if (relativecount
> 0 && dyncon
+ bed
->s
->sizeof_dyn
< dynconend
)
11161 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
11163 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
11164 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
11167 dyn
.d_un
.d_val
= relativecount
;
11174 name
= info
->init_function
;
11177 name
= info
->fini_function
;
11180 struct elf_link_hash_entry
*h
;
11182 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
11183 FALSE
, FALSE
, TRUE
);
11185 && (h
->root
.type
== bfd_link_hash_defined
11186 || h
->root
.type
== bfd_link_hash_defweak
))
11188 dyn
.d_un
.d_ptr
= h
->root
.u
.def
.value
;
11189 o
= h
->root
.u
.def
.section
;
11190 if (o
->output_section
!= NULL
)
11191 dyn
.d_un
.d_ptr
+= (o
->output_section
->vma
11192 + o
->output_offset
);
11195 /* The symbol is imported from another shared
11196 library and does not apply to this one. */
11197 dyn
.d_un
.d_ptr
= 0;
11204 case DT_PREINIT_ARRAYSZ
:
11205 name
= ".preinit_array";
11207 case DT_INIT_ARRAYSZ
:
11208 name
= ".init_array";
11210 case DT_FINI_ARRAYSZ
:
11211 name
= ".fini_array";
11213 o
= bfd_get_section_by_name (abfd
, name
);
11216 (*_bfd_error_handler
)
11217 (_("%B: could not find output section %s"), abfd
, name
);
11221 (*_bfd_error_handler
)
11222 (_("warning: %s section has zero size"), name
);
11223 dyn
.d_un
.d_val
= o
->size
;
11226 case DT_PREINIT_ARRAY
:
11227 name
= ".preinit_array";
11229 case DT_INIT_ARRAY
:
11230 name
= ".init_array";
11232 case DT_FINI_ARRAY
:
11233 name
= ".fini_array";
11240 name
= ".gnu.hash";
11249 name
= ".gnu.version_d";
11252 name
= ".gnu.version_r";
11255 name
= ".gnu.version";
11257 o
= bfd_get_section_by_name (abfd
, name
);
11260 (*_bfd_error_handler
)
11261 (_("%B: could not find output section %s"), abfd
, name
);
11264 if (elf_section_data (o
->output_section
)->this_hdr
.sh_type
== SHT_NOTE
)
11266 (*_bfd_error_handler
)
11267 (_("warning: section '%s' is being made into a note"), name
);
11268 bfd_set_error (bfd_error_nonrepresentable_section
);
11271 dyn
.d_un
.d_ptr
= o
->vma
;
11278 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
11282 dyn
.d_un
.d_val
= 0;
11283 dyn
.d_un
.d_ptr
= 0;
11284 for (i
= 1; i
< elf_numsections (abfd
); i
++)
11286 Elf_Internal_Shdr
*hdr
;
11288 hdr
= elf_elfsections (abfd
)[i
];
11289 if (hdr
->sh_type
== type
11290 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
11292 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
11293 dyn
.d_un
.d_val
+= hdr
->sh_size
;
11296 if (dyn
.d_un
.d_ptr
== 0
11297 || hdr
->sh_addr
< dyn
.d_un
.d_ptr
)
11298 dyn
.d_un
.d_ptr
= hdr
->sh_addr
;
11304 bed
->s
->swap_dyn_out (dynobj
, &dyn
, dyncon
);
11308 /* If we have created any dynamic sections, then output them. */
11309 if (dynobj
!= NULL
)
11311 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
11314 /* Check for DT_TEXTREL (late, in case the backend removes it). */
11315 if (((info
->warn_shared_textrel
&& info
->shared
)
11316 || info
->error_textrel
)
11317 && (o
= bfd_get_linker_section (dynobj
, ".dynamic")) != NULL
)
11319 bfd_byte
*dyncon
, *dynconend
;
11321 dyncon
= o
->contents
;
11322 dynconend
= o
->contents
+ o
->size
;
11323 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
11325 Elf_Internal_Dyn dyn
;
11327 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11329 if (dyn
.d_tag
== DT_TEXTREL
)
11331 if (info
->error_textrel
)
11332 info
->callbacks
->einfo
11333 (_("%P%X: read-only segment has dynamic relocations.\n"));
11335 info
->callbacks
->einfo
11336 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11342 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
11344 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
11346 || o
->output_section
== bfd_abs_section_ptr
)
11348 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
11350 /* At this point, we are only interested in sections
11351 created by _bfd_elf_link_create_dynamic_sections. */
11354 if (elf_hash_table (info
)->stab_info
.stabstr
== o
)
11356 if (elf_hash_table (info
)->eh_info
.hdr_sec
== o
)
11358 if (strcmp (o
->name
, ".dynstr") != 0)
11360 /* FIXME: octets_per_byte. */
11361 if (! bfd_set_section_contents (abfd
, o
->output_section
,
11363 (file_ptr
) o
->output_offset
,
11369 /* The contents of the .dynstr section are actually in a
11371 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
11372 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
11373 || ! _bfd_elf_strtab_emit (abfd
,
11374 elf_hash_table (info
)->dynstr
))
11380 if (info
->relocatable
)
11382 bfd_boolean failed
= FALSE
;
11384 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
11389 /* If we have optimized stabs strings, output them. */
11390 if (elf_hash_table (info
)->stab_info
.stabstr
!= NULL
)
11392 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
11396 if (info
->eh_frame_hdr
)
11398 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
11402 if (flinfo
.symstrtab
!= NULL
)
11403 _bfd_stringtab_free (flinfo
.symstrtab
);
11404 if (flinfo
.contents
!= NULL
)
11405 free (flinfo
.contents
);
11406 if (flinfo
.external_relocs
!= NULL
)
11407 free (flinfo
.external_relocs
);
11408 if (flinfo
.internal_relocs
!= NULL
)
11409 free (flinfo
.internal_relocs
);
11410 if (flinfo
.external_syms
!= NULL
)
11411 free (flinfo
.external_syms
);
11412 if (flinfo
.locsym_shndx
!= NULL
)
11413 free (flinfo
.locsym_shndx
);
11414 if (flinfo
.internal_syms
!= NULL
)
11415 free (flinfo
.internal_syms
);
11416 if (flinfo
.indices
!= NULL
)
11417 free (flinfo
.indices
);
11418 if (flinfo
.sections
!= NULL
)
11419 free (flinfo
.sections
);
11420 if (flinfo
.symbuf
!= NULL
)
11421 free (flinfo
.symbuf
);
11422 if (flinfo
.symshndxbuf
!= NULL
)
11423 free (flinfo
.symshndxbuf
);
11424 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11426 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11427 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
11428 free (esdo
->rel
.hashes
);
11429 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
11430 free (esdo
->rela
.hashes
);
11433 elf_tdata (abfd
)->linker
= TRUE
;
11437 bfd_byte
*contents
= (bfd_byte
*) bfd_malloc (attr_size
);
11438 if (contents
== NULL
)
11439 return FALSE
; /* Bail out and fail. */
11440 bfd_elf_set_obj_attr_contents (abfd
, contents
, attr_size
);
11441 bfd_set_section_contents (abfd
, attr_section
, contents
, 0, attr_size
);
11448 if (flinfo
.symstrtab
!= NULL
)
11449 _bfd_stringtab_free (flinfo
.symstrtab
);
11450 if (flinfo
.contents
!= NULL
)
11451 free (flinfo
.contents
);
11452 if (flinfo
.external_relocs
!= NULL
)
11453 free (flinfo
.external_relocs
);
11454 if (flinfo
.internal_relocs
!= NULL
)
11455 free (flinfo
.internal_relocs
);
11456 if (flinfo
.external_syms
!= NULL
)
11457 free (flinfo
.external_syms
);
11458 if (flinfo
.locsym_shndx
!= NULL
)
11459 free (flinfo
.locsym_shndx
);
11460 if (flinfo
.internal_syms
!= NULL
)
11461 free (flinfo
.internal_syms
);
11462 if (flinfo
.indices
!= NULL
)
11463 free (flinfo
.indices
);
11464 if (flinfo
.sections
!= NULL
)
11465 free (flinfo
.sections
);
11466 if (flinfo
.symbuf
!= NULL
)
11467 free (flinfo
.symbuf
);
11468 if (flinfo
.symshndxbuf
!= NULL
)
11469 free (flinfo
.symshndxbuf
);
11470 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11472 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11473 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
11474 free (esdo
->rel
.hashes
);
11475 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
11476 free (esdo
->rela
.hashes
);
11482 /* Initialize COOKIE for input bfd ABFD. */
11485 init_reloc_cookie (struct elf_reloc_cookie
*cookie
,
11486 struct bfd_link_info
*info
, bfd
*abfd
)
11488 Elf_Internal_Shdr
*symtab_hdr
;
11489 const struct elf_backend_data
*bed
;
11491 bed
= get_elf_backend_data (abfd
);
11492 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11494 cookie
->abfd
= abfd
;
11495 cookie
->sym_hashes
= elf_sym_hashes (abfd
);
11496 cookie
->bad_symtab
= elf_bad_symtab (abfd
);
11497 if (cookie
->bad_symtab
)
11499 cookie
->locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
11500 cookie
->extsymoff
= 0;
11504 cookie
->locsymcount
= symtab_hdr
->sh_info
;
11505 cookie
->extsymoff
= symtab_hdr
->sh_info
;
11508 if (bed
->s
->arch_size
== 32)
11509 cookie
->r_sym_shift
= 8;
11511 cookie
->r_sym_shift
= 32;
11513 cookie
->locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
11514 if (cookie
->locsyms
== NULL
&& cookie
->locsymcount
!= 0)
11516 cookie
->locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
11517 cookie
->locsymcount
, 0,
11519 if (cookie
->locsyms
== NULL
)
11521 info
->callbacks
->einfo (_("%P%X: can not read symbols: %E\n"));
11524 if (info
->keep_memory
)
11525 symtab_hdr
->contents
= (bfd_byte
*) cookie
->locsyms
;
11530 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
11533 fini_reloc_cookie (struct elf_reloc_cookie
*cookie
, bfd
*abfd
)
11535 Elf_Internal_Shdr
*symtab_hdr
;
11537 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11538 if (cookie
->locsyms
!= NULL
11539 && symtab_hdr
->contents
!= (unsigned char *) cookie
->locsyms
)
11540 free (cookie
->locsyms
);
11543 /* Initialize the relocation information in COOKIE for input section SEC
11544 of input bfd ABFD. */
11547 init_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11548 struct bfd_link_info
*info
, bfd
*abfd
,
11551 const struct elf_backend_data
*bed
;
11553 if (sec
->reloc_count
== 0)
11555 cookie
->rels
= NULL
;
11556 cookie
->relend
= NULL
;
11560 bed
= get_elf_backend_data (abfd
);
11562 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
11563 info
->keep_memory
);
11564 if (cookie
->rels
== NULL
)
11566 cookie
->rel
= cookie
->rels
;
11567 cookie
->relend
= (cookie
->rels
11568 + sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
);
11570 cookie
->rel
= cookie
->rels
;
11574 /* Free the memory allocated by init_reloc_cookie_rels,
11578 fini_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11581 if (cookie
->rels
&& elf_section_data (sec
)->relocs
!= cookie
->rels
)
11582 free (cookie
->rels
);
11585 /* Initialize the whole of COOKIE for input section SEC. */
11588 init_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11589 struct bfd_link_info
*info
,
11592 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
11594 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
11599 fini_reloc_cookie (cookie
, sec
->owner
);
11604 /* Free the memory allocated by init_reloc_cookie_for_section,
11608 fini_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11611 fini_reloc_cookie_rels (cookie
, sec
);
11612 fini_reloc_cookie (cookie
, sec
->owner
);
11615 /* Garbage collect unused sections. */
11617 /* Default gc_mark_hook. */
11620 _bfd_elf_gc_mark_hook (asection
*sec
,
11621 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11622 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
11623 struct elf_link_hash_entry
*h
,
11624 Elf_Internal_Sym
*sym
)
11626 const char *sec_name
;
11630 switch (h
->root
.type
)
11632 case bfd_link_hash_defined
:
11633 case bfd_link_hash_defweak
:
11634 return h
->root
.u
.def
.section
;
11636 case bfd_link_hash_common
:
11637 return h
->root
.u
.c
.p
->section
;
11639 case bfd_link_hash_undefined
:
11640 case bfd_link_hash_undefweak
:
11641 /* To work around a glibc bug, keep all XXX input sections
11642 when there is an as yet undefined reference to __start_XXX
11643 or __stop_XXX symbols. The linker will later define such
11644 symbols for orphan input sections that have a name
11645 representable as a C identifier. */
11646 if (strncmp (h
->root
.root
.string
, "__start_", 8) == 0)
11647 sec_name
= h
->root
.root
.string
+ 8;
11648 else if (strncmp (h
->root
.root
.string
, "__stop_", 7) == 0)
11649 sec_name
= h
->root
.root
.string
+ 7;
11653 if (sec_name
&& *sec_name
!= '\0')
11657 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
11659 sec
= bfd_get_section_by_name (i
, sec_name
);
11661 sec
->flags
|= SEC_KEEP
;
11671 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
11676 /* COOKIE->rel describes a relocation against section SEC, which is
11677 a section we've decided to keep. Return the section that contains
11678 the relocation symbol, or NULL if no section contains it. */
11681 _bfd_elf_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
11682 elf_gc_mark_hook_fn gc_mark_hook
,
11683 struct elf_reloc_cookie
*cookie
)
11685 unsigned long r_symndx
;
11686 struct elf_link_hash_entry
*h
;
11688 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
11689 if (r_symndx
== STN_UNDEF
)
11692 if (r_symndx
>= cookie
->locsymcount
11693 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
11695 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
11696 while (h
->root
.type
== bfd_link_hash_indirect
11697 || h
->root
.type
== bfd_link_hash_warning
)
11698 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11700 /* If this symbol is weak and there is a non-weak definition, we
11701 keep the non-weak definition because many backends put
11702 dynamic reloc info on the non-weak definition for code
11703 handling copy relocs. */
11704 if (h
->u
.weakdef
!= NULL
)
11705 h
->u
.weakdef
->mark
= 1;
11706 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
11709 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
11710 &cookie
->locsyms
[r_symndx
]);
11713 /* COOKIE->rel describes a relocation against section SEC, which is
11714 a section we've decided to keep. Mark the section that contains
11715 the relocation symbol. */
11718 _bfd_elf_gc_mark_reloc (struct bfd_link_info
*info
,
11720 elf_gc_mark_hook_fn gc_mark_hook
,
11721 struct elf_reloc_cookie
*cookie
)
11725 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
11726 if (rsec
&& !rsec
->gc_mark
)
11728 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
11729 || (rsec
->owner
->flags
& DYNAMIC
) != 0)
11731 else if (!_bfd_elf_gc_mark (info
, rsec
, gc_mark_hook
))
11737 /* The mark phase of garbage collection. For a given section, mark
11738 it and any sections in this section's group, and all the sections
11739 which define symbols to which it refers. */
11742 _bfd_elf_gc_mark (struct bfd_link_info
*info
,
11744 elf_gc_mark_hook_fn gc_mark_hook
)
11747 asection
*group_sec
, *eh_frame
;
11751 /* Mark all the sections in the group. */
11752 group_sec
= elf_section_data (sec
)->next_in_group
;
11753 if (group_sec
&& !group_sec
->gc_mark
)
11754 if (!_bfd_elf_gc_mark (info
, group_sec
, gc_mark_hook
))
11757 /* Look through the section relocs. */
11759 eh_frame
= elf_eh_frame_section (sec
->owner
);
11760 if ((sec
->flags
& SEC_RELOC
) != 0
11761 && sec
->reloc_count
> 0
11762 && sec
!= eh_frame
)
11764 struct elf_reloc_cookie cookie
;
11766 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
11770 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
11771 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
11776 fini_reloc_cookie_for_section (&cookie
, sec
);
11780 if (ret
&& eh_frame
&& elf_fde_list (sec
))
11782 struct elf_reloc_cookie cookie
;
11784 if (!init_reloc_cookie_for_section (&cookie
, info
, eh_frame
))
11788 if (!_bfd_elf_gc_mark_fdes (info
, sec
, eh_frame
,
11789 gc_mark_hook
, &cookie
))
11791 fini_reloc_cookie_for_section (&cookie
, eh_frame
);
11798 /* Keep debug and special sections. */
11801 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
11802 elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
11806 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
11809 bfd_boolean some_kept
;
11811 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
11814 /* Ensure all linker created sections are kept, and see whether
11815 any other section is already marked. */
11817 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
11819 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
11821 else if (isec
->gc_mark
)
11825 /* If no section in this file will be kept, then we can
11826 toss out debug sections. */
11830 /* Keep debug and special sections like .comment when they are
11831 not part of a group, or when we have single-member groups. */
11832 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
11833 if ((elf_next_in_group (isec
) == NULL
11834 || elf_next_in_group (isec
) == isec
)
11835 && ((isec
->flags
& SEC_DEBUGGING
) != 0
11836 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0))
11842 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
11844 struct elf_gc_sweep_symbol_info
11846 struct bfd_link_info
*info
;
11847 void (*hide_symbol
) (struct bfd_link_info
*, struct elf_link_hash_entry
*,
11852 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *data
)
11855 && (((h
->root
.type
== bfd_link_hash_defined
11856 || h
->root
.type
== bfd_link_hash_defweak
)
11857 && !(h
->def_regular
11858 && h
->root
.u
.def
.section
->gc_mark
))
11859 || h
->root
.type
== bfd_link_hash_undefined
11860 || h
->root
.type
== bfd_link_hash_undefweak
))
11862 struct elf_gc_sweep_symbol_info
*inf
;
11864 inf
= (struct elf_gc_sweep_symbol_info
*) data
;
11865 (*inf
->hide_symbol
) (inf
->info
, h
, TRUE
);
11866 h
->def_regular
= 0;
11867 h
->ref_regular
= 0;
11868 h
->ref_regular_nonweak
= 0;
11874 /* The sweep phase of garbage collection. Remove all garbage sections. */
11876 typedef bfd_boolean (*gc_sweep_hook_fn
)
11877 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
11880 elf_gc_sweep (bfd
*abfd
, struct bfd_link_info
*info
)
11883 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11884 gc_sweep_hook_fn gc_sweep_hook
= bed
->gc_sweep_hook
;
11885 unsigned long section_sym_count
;
11886 struct elf_gc_sweep_symbol_info sweep_info
;
11888 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
11892 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
11895 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
11897 /* When any section in a section group is kept, we keep all
11898 sections in the section group. If the first member of
11899 the section group is excluded, we will also exclude the
11901 if (o
->flags
& SEC_GROUP
)
11903 asection
*first
= elf_next_in_group (o
);
11904 o
->gc_mark
= first
->gc_mark
;
11910 /* Skip sweeping sections already excluded. */
11911 if (o
->flags
& SEC_EXCLUDE
)
11914 /* Since this is early in the link process, it is simple
11915 to remove a section from the output. */
11916 o
->flags
|= SEC_EXCLUDE
;
11918 if (info
->print_gc_sections
&& o
->size
!= 0)
11919 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub
, o
->name
);
11921 /* But we also have to update some of the relocation
11922 info we collected before. */
11924 && (o
->flags
& SEC_RELOC
) != 0
11925 && o
->reloc_count
> 0
11926 && !bfd_is_abs_section (o
->output_section
))
11928 Elf_Internal_Rela
*internal_relocs
;
11932 = _bfd_elf_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
11933 info
->keep_memory
);
11934 if (internal_relocs
== NULL
)
11937 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
11939 if (elf_section_data (o
)->relocs
!= internal_relocs
)
11940 free (internal_relocs
);
11948 /* Remove the symbols that were in the swept sections from the dynamic
11949 symbol table. GCFIXME: Anyone know how to get them out of the
11950 static symbol table as well? */
11951 sweep_info
.info
= info
;
11952 sweep_info
.hide_symbol
= bed
->elf_backend_hide_symbol
;
11953 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
,
11956 _bfd_elf_link_renumber_dynsyms (abfd
, info
, §ion_sym_count
);
11960 /* Propagate collected vtable information. This is called through
11961 elf_link_hash_traverse. */
11964 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
11966 /* Those that are not vtables. */
11967 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
11970 /* Those vtables that do not have parents, we cannot merge. */
11971 if (h
->vtable
->parent
== (struct elf_link_hash_entry
*) -1)
11974 /* If we've already been done, exit. */
11975 if (h
->vtable
->used
&& h
->vtable
->used
[-1])
11978 /* Make sure the parent's table is up to date. */
11979 elf_gc_propagate_vtable_entries_used (h
->vtable
->parent
, okp
);
11981 if (h
->vtable
->used
== NULL
)
11983 /* None of this table's entries were referenced. Re-use the
11985 h
->vtable
->used
= h
->vtable
->parent
->vtable
->used
;
11986 h
->vtable
->size
= h
->vtable
->parent
->vtable
->size
;
11991 bfd_boolean
*cu
, *pu
;
11993 /* Or the parent's entries into ours. */
11994 cu
= h
->vtable
->used
;
11996 pu
= h
->vtable
->parent
->vtable
->used
;
11999 const struct elf_backend_data
*bed
;
12000 unsigned int log_file_align
;
12002 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
12003 log_file_align
= bed
->s
->log_file_align
;
12004 n
= h
->vtable
->parent
->vtable
->size
>> log_file_align
;
12019 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
, void *okp
)
12022 bfd_vma hstart
, hend
;
12023 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
12024 const struct elf_backend_data
*bed
;
12025 unsigned int log_file_align
;
12027 /* Take care of both those symbols that do not describe vtables as
12028 well as those that are not loaded. */
12029 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
12032 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
12033 || h
->root
.type
== bfd_link_hash_defweak
);
12035 sec
= h
->root
.u
.def
.section
;
12036 hstart
= h
->root
.u
.def
.value
;
12037 hend
= hstart
+ h
->size
;
12039 relstart
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, TRUE
);
12041 return *(bfd_boolean
*) okp
= FALSE
;
12042 bed
= get_elf_backend_data (sec
->owner
);
12043 log_file_align
= bed
->s
->log_file_align
;
12045 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
12047 for (rel
= relstart
; rel
< relend
; ++rel
)
12048 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
12050 /* If the entry is in use, do nothing. */
12051 if (h
->vtable
->used
12052 && (rel
->r_offset
- hstart
) < h
->vtable
->size
)
12054 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
12055 if (h
->vtable
->used
[entry
])
12058 /* Otherwise, kill it. */
12059 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
12065 /* Mark sections containing dynamically referenced symbols. When
12066 building shared libraries, we must assume that any visible symbol is
12070 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry
*h
, void *inf
)
12072 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
12074 if ((h
->root
.type
== bfd_link_hash_defined
12075 || h
->root
.type
== bfd_link_hash_defweak
)
12077 || ((!info
->executable
|| info
->export_dynamic
)
12079 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
12080 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
12081 && (strchr (h
->root
.root
.string
, ELF_VER_CHR
) != NULL
12082 || !bfd_hide_sym_by_version (info
->version_info
,
12083 h
->root
.root
.string
)))))
12084 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
12089 /* Keep all sections containing symbols undefined on the command-line,
12090 and the section containing the entry symbol. */
12093 _bfd_elf_gc_keep (struct bfd_link_info
*info
)
12095 struct bfd_sym_chain
*sym
;
12097 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
12099 struct elf_link_hash_entry
*h
;
12101 h
= elf_link_hash_lookup (elf_hash_table (info
), sym
->name
,
12102 FALSE
, FALSE
, FALSE
);
12105 && (h
->root
.type
== bfd_link_hash_defined
12106 || h
->root
.type
== bfd_link_hash_defweak
)
12107 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
12108 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
12112 /* Do mark and sweep of unused sections. */
12115 bfd_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
12117 bfd_boolean ok
= TRUE
;
12119 elf_gc_mark_hook_fn gc_mark_hook
;
12120 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12122 if (!bed
->can_gc_sections
12123 || !is_elf_hash_table (info
->hash
))
12125 (*_bfd_error_handler
)(_("Warning: gc-sections option ignored"));
12129 bed
->gc_keep (info
);
12131 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
12132 at the .eh_frame section if we can mark the FDEs individually. */
12133 _bfd_elf_begin_eh_frame_parsing (info
);
12134 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
12137 struct elf_reloc_cookie cookie
;
12139 sec
= bfd_get_section_by_name (sub
, ".eh_frame");
12140 while (sec
&& init_reloc_cookie_for_section (&cookie
, info
, sec
))
12142 _bfd_elf_parse_eh_frame (sub
, info
, sec
, &cookie
);
12143 if (elf_section_data (sec
)->sec_info
12144 && (sec
->flags
& SEC_LINKER_CREATED
) == 0)
12145 elf_eh_frame_section (sub
) = sec
;
12146 fini_reloc_cookie_for_section (&cookie
, sec
);
12147 sec
= bfd_get_next_section_by_name (sec
);
12150 _bfd_elf_end_eh_frame_parsing (info
);
12152 /* Apply transitive closure to the vtable entry usage info. */
12153 elf_link_hash_traverse (elf_hash_table (info
),
12154 elf_gc_propagate_vtable_entries_used
,
12159 /* Kill the vtable relocations that were not used. */
12160 elf_link_hash_traverse (elf_hash_table (info
),
12161 elf_gc_smash_unused_vtentry_relocs
,
12166 /* Mark dynamically referenced symbols. */
12167 if (elf_hash_table (info
)->dynamic_sections_created
)
12168 elf_link_hash_traverse (elf_hash_table (info
),
12169 bed
->gc_mark_dynamic_ref
,
12172 /* Grovel through relocs to find out who stays ... */
12173 gc_mark_hook
= bed
->gc_mark_hook
;
12174 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
12178 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
12181 /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12182 Also treat note sections as a root, if the section is not part
12184 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
12186 && (o
->flags
& SEC_EXCLUDE
) == 0
12187 && ((o
->flags
& SEC_KEEP
) != 0
12188 || (elf_section_data (o
)->this_hdr
.sh_type
== SHT_NOTE
12189 && elf_next_in_group (o
) == NULL
)))
12191 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
12196 /* Allow the backend to mark additional target specific sections. */
12197 bed
->gc_mark_extra_sections (info
, gc_mark_hook
);
12199 /* ... and mark SEC_EXCLUDE for those that go. */
12200 return elf_gc_sweep (abfd
, info
);
12203 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
12206 bfd_elf_gc_record_vtinherit (bfd
*abfd
,
12208 struct elf_link_hash_entry
*h
,
12211 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
12212 struct elf_link_hash_entry
**search
, *child
;
12213 bfd_size_type extsymcount
;
12214 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12216 /* The sh_info field of the symtab header tells us where the
12217 external symbols start. We don't care about the local symbols at
12219 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/ bed
->s
->sizeof_sym
;
12220 if (!elf_bad_symtab (abfd
))
12221 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
12223 sym_hashes
= elf_sym_hashes (abfd
);
12224 sym_hashes_end
= sym_hashes
+ extsymcount
;
12226 /* Hunt down the child symbol, which is in this section at the same
12227 offset as the relocation. */
12228 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
12230 if ((child
= *search
) != NULL
12231 && (child
->root
.type
== bfd_link_hash_defined
12232 || child
->root
.type
== bfd_link_hash_defweak
)
12233 && child
->root
.u
.def
.section
== sec
12234 && child
->root
.u
.def
.value
== offset
)
12238 (*_bfd_error_handler
) ("%B: %A+%lu: No symbol found for INHERIT",
12239 abfd
, sec
, (unsigned long) offset
);
12240 bfd_set_error (bfd_error_invalid_operation
);
12244 if (!child
->vtable
)
12246 child
->vtable
= (struct elf_link_virtual_table_entry
*)
12247 bfd_zalloc (abfd
, sizeof (*child
->vtable
));
12248 if (!child
->vtable
)
12253 /* This *should* only be the absolute section. It could potentially
12254 be that someone has defined a non-global vtable though, which
12255 would be bad. It isn't worth paging in the local symbols to be
12256 sure though; that case should simply be handled by the assembler. */
12258 child
->vtable
->parent
= (struct elf_link_hash_entry
*) -1;
12261 child
->vtable
->parent
= h
;
12266 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
12269 bfd_elf_gc_record_vtentry (bfd
*abfd ATTRIBUTE_UNUSED
,
12270 asection
*sec ATTRIBUTE_UNUSED
,
12271 struct elf_link_hash_entry
*h
,
12274 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12275 unsigned int log_file_align
= bed
->s
->log_file_align
;
12279 h
->vtable
= (struct elf_link_virtual_table_entry
*)
12280 bfd_zalloc (abfd
, sizeof (*h
->vtable
));
12285 if (addend
>= h
->vtable
->size
)
12287 size_t size
, bytes
, file_align
;
12288 bfd_boolean
*ptr
= h
->vtable
->used
;
12290 /* While the symbol is undefined, we have to be prepared to handle
12292 file_align
= 1 << log_file_align
;
12293 if (h
->root
.type
== bfd_link_hash_undefined
)
12294 size
= addend
+ file_align
;
12298 if (addend
>= size
)
12300 /* Oops! We've got a reference past the defined end of
12301 the table. This is probably a bug -- shall we warn? */
12302 size
= addend
+ file_align
;
12305 size
= (size
+ file_align
- 1) & -file_align
;
12307 /* Allocate one extra entry for use as a "done" flag for the
12308 consolidation pass. */
12309 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bfd_boolean
);
12313 ptr
= (bfd_boolean
*) bfd_realloc (ptr
- 1, bytes
);
12319 oldbytes
= (((h
->vtable
->size
>> log_file_align
) + 1)
12320 * sizeof (bfd_boolean
));
12321 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
12325 ptr
= (bfd_boolean
*) bfd_zmalloc (bytes
);
12330 /* And arrange for that done flag to be at index -1. */
12331 h
->vtable
->used
= ptr
+ 1;
12332 h
->vtable
->size
= size
;
12335 h
->vtable
->used
[addend
>> log_file_align
] = TRUE
;
12340 /* Map an ELF section header flag to its corresponding string. */
12344 flagword flag_value
;
12345 } elf_flags_to_name_table
;
12347 static elf_flags_to_name_table elf_flags_to_names
[] =
12349 { "SHF_WRITE", SHF_WRITE
},
12350 { "SHF_ALLOC", SHF_ALLOC
},
12351 { "SHF_EXECINSTR", SHF_EXECINSTR
},
12352 { "SHF_MERGE", SHF_MERGE
},
12353 { "SHF_STRINGS", SHF_STRINGS
},
12354 { "SHF_INFO_LINK", SHF_INFO_LINK
},
12355 { "SHF_LINK_ORDER", SHF_LINK_ORDER
},
12356 { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING
},
12357 { "SHF_GROUP", SHF_GROUP
},
12358 { "SHF_TLS", SHF_TLS
},
12359 { "SHF_MASKOS", SHF_MASKOS
},
12360 { "SHF_EXCLUDE", SHF_EXCLUDE
},
12363 /* Returns TRUE if the section is to be included, otherwise FALSE. */
12365 bfd_elf_lookup_section_flags (struct bfd_link_info
*info
,
12366 struct flag_info
*flaginfo
,
12369 const bfd_vma sh_flags
= elf_section_flags (section
);
12371 if (!flaginfo
->flags_initialized
)
12373 bfd
*obfd
= info
->output_bfd
;
12374 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
12375 struct flag_info_list
*tf
= flaginfo
->flag_list
;
12377 int without_hex
= 0;
12379 for (tf
= flaginfo
->flag_list
; tf
!= NULL
; tf
= tf
->next
)
12382 flagword (*lookup
) (char *);
12384 lookup
= bed
->elf_backend_lookup_section_flags_hook
;
12385 if (lookup
!= NULL
)
12387 flagword hexval
= (*lookup
) ((char *) tf
->name
);
12391 if (tf
->with
== with_flags
)
12392 with_hex
|= hexval
;
12393 else if (tf
->with
== without_flags
)
12394 without_hex
|= hexval
;
12399 for (i
= 0; i
< ARRAY_SIZE (elf_flags_to_names
); ++i
)
12401 if (strcmp (tf
->name
, elf_flags_to_names
[i
].flag_name
) == 0)
12403 if (tf
->with
== with_flags
)
12404 with_hex
|= elf_flags_to_names
[i
].flag_value
;
12405 else if (tf
->with
== without_flags
)
12406 without_hex
|= elf_flags_to_names
[i
].flag_value
;
12413 info
->callbacks
->einfo
12414 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf
->name
);
12418 flaginfo
->flags_initialized
= TRUE
;
12419 flaginfo
->only_with_flags
|= with_hex
;
12420 flaginfo
->not_with_flags
|= without_hex
;
12423 if ((flaginfo
->only_with_flags
& sh_flags
) != flaginfo
->only_with_flags
)
12426 if ((flaginfo
->not_with_flags
& sh_flags
) != 0)
12432 struct alloc_got_off_arg
{
12434 struct bfd_link_info
*info
;
12437 /* We need a special top-level link routine to convert got reference counts
12438 to real got offsets. */
12441 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *arg
)
12443 struct alloc_got_off_arg
*gofarg
= (struct alloc_got_off_arg
*) arg
;
12444 bfd
*obfd
= gofarg
->info
->output_bfd
;
12445 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
12447 if (h
->got
.refcount
> 0)
12449 h
->got
.offset
= gofarg
->gotoff
;
12450 gofarg
->gotoff
+= bed
->got_elt_size (obfd
, gofarg
->info
, h
, NULL
, 0);
12453 h
->got
.offset
= (bfd_vma
) -1;
12458 /* And an accompanying bit to work out final got entry offsets once
12459 we're done. Should be called from final_link. */
12462 bfd_elf_gc_common_finalize_got_offsets (bfd
*abfd
,
12463 struct bfd_link_info
*info
)
12466 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12468 struct alloc_got_off_arg gofarg
;
12470 BFD_ASSERT (abfd
== info
->output_bfd
);
12472 if (! is_elf_hash_table (info
->hash
))
12475 /* The GOT offset is relative to the .got section, but the GOT header is
12476 put into the .got.plt section, if the backend uses it. */
12477 if (bed
->want_got_plt
)
12480 gotoff
= bed
->got_header_size
;
12482 /* Do the local .got entries first. */
12483 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
12485 bfd_signed_vma
*local_got
;
12486 bfd_size_type j
, locsymcount
;
12487 Elf_Internal_Shdr
*symtab_hdr
;
12489 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
12492 local_got
= elf_local_got_refcounts (i
);
12496 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
12497 if (elf_bad_symtab (i
))
12498 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
12500 locsymcount
= symtab_hdr
->sh_info
;
12502 for (j
= 0; j
< locsymcount
; ++j
)
12504 if (local_got
[j
] > 0)
12506 local_got
[j
] = gotoff
;
12507 gotoff
+= bed
->got_elt_size (abfd
, info
, NULL
, i
, j
);
12510 local_got
[j
] = (bfd_vma
) -1;
12514 /* Then the global .got entries. .plt refcounts are handled by
12515 adjust_dynamic_symbol */
12516 gofarg
.gotoff
= gotoff
;
12517 gofarg
.info
= info
;
12518 elf_link_hash_traverse (elf_hash_table (info
),
12519 elf_gc_allocate_got_offsets
,
12524 /* Many folk need no more in the way of final link than this, once
12525 got entry reference counting is enabled. */
12528 bfd_elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
12530 if (!bfd_elf_gc_common_finalize_got_offsets (abfd
, info
))
12533 /* Invoke the regular ELF backend linker to do all the work. */
12534 return bfd_elf_final_link (abfd
, info
);
12538 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
12540 struct elf_reloc_cookie
*rcookie
= (struct elf_reloc_cookie
*) cookie
;
12542 if (rcookie
->bad_symtab
)
12543 rcookie
->rel
= rcookie
->rels
;
12545 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
12547 unsigned long r_symndx
;
12549 if (! rcookie
->bad_symtab
)
12550 if (rcookie
->rel
->r_offset
> offset
)
12552 if (rcookie
->rel
->r_offset
!= offset
)
12555 r_symndx
= rcookie
->rel
->r_info
>> rcookie
->r_sym_shift
;
12556 if (r_symndx
== STN_UNDEF
)
12559 if (r_symndx
>= rcookie
->locsymcount
12560 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
12562 struct elf_link_hash_entry
*h
;
12564 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
12566 while (h
->root
.type
== bfd_link_hash_indirect
12567 || h
->root
.type
== bfd_link_hash_warning
)
12568 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
12570 if ((h
->root
.type
== bfd_link_hash_defined
12571 || h
->root
.type
== bfd_link_hash_defweak
)
12572 && discarded_section (h
->root
.u
.def
.section
))
12579 /* It's not a relocation against a global symbol,
12580 but it could be a relocation against a local
12581 symbol for a discarded section. */
12583 Elf_Internal_Sym
*isym
;
12585 /* Need to: get the symbol; get the section. */
12586 isym
= &rcookie
->locsyms
[r_symndx
];
12587 isec
= bfd_section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
12588 if (isec
!= NULL
&& discarded_section (isec
))
12596 /* Discard unneeded references to discarded sections.
12597 Returns TRUE if any section's size was changed. */
12598 /* This function assumes that the relocations are in sorted order,
12599 which is true for all known assemblers. */
12602 bfd_elf_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
12604 struct elf_reloc_cookie cookie
;
12605 asection
*stab
, *eh
;
12606 const struct elf_backend_data
*bed
;
12608 bfd_boolean ret
= FALSE
;
12610 if (info
->traditional_format
12611 || !is_elf_hash_table (info
->hash
))
12614 _bfd_elf_begin_eh_frame_parsing (info
);
12615 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
12617 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
12620 bed
= get_elf_backend_data (abfd
);
12623 if (!info
->relocatable
)
12625 eh
= bfd_get_section_by_name (abfd
, ".eh_frame");
12628 || bfd_is_abs_section (eh
->output_section
)))
12629 eh
= bfd_get_next_section_by_name (eh
);
12632 stab
= bfd_get_section_by_name (abfd
, ".stab");
12634 && (stab
->size
== 0
12635 || bfd_is_abs_section (stab
->output_section
)
12636 || stab
->sec_info_type
!= SEC_INFO_TYPE_STABS
))
12641 && bed
->elf_backend_discard_info
== NULL
)
12644 if (!init_reloc_cookie (&cookie
, info
, abfd
))
12648 && stab
->reloc_count
> 0
12649 && init_reloc_cookie_rels (&cookie
, info
, abfd
, stab
))
12651 if (_bfd_discard_section_stabs (abfd
, stab
,
12652 elf_section_data (stab
)->sec_info
,
12653 bfd_elf_reloc_symbol_deleted_p
,
12656 fini_reloc_cookie_rels (&cookie
, stab
);
12660 && init_reloc_cookie_rels (&cookie
, info
, abfd
, eh
))
12662 _bfd_elf_parse_eh_frame (abfd
, info
, eh
, &cookie
);
12663 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, eh
,
12664 bfd_elf_reloc_symbol_deleted_p
,
12667 fini_reloc_cookie_rels (&cookie
, eh
);
12668 eh
= bfd_get_next_section_by_name (eh
);
12671 if (bed
->elf_backend_discard_info
!= NULL
12672 && (*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
12675 fini_reloc_cookie (&cookie
, abfd
);
12677 _bfd_elf_end_eh_frame_parsing (info
);
12679 if (info
->eh_frame_hdr
12680 && !info
->relocatable
12681 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
12688 _bfd_elf_section_already_linked (bfd
*abfd
,
12690 struct bfd_link_info
*info
)
12693 const char *name
, *key
;
12694 struct bfd_section_already_linked
*l
;
12695 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
12697 if (sec
->output_section
== bfd_abs_section_ptr
)
12700 flags
= sec
->flags
;
12702 /* Return if it isn't a linkonce section. A comdat group section
12703 also has SEC_LINK_ONCE set. */
12704 if ((flags
& SEC_LINK_ONCE
) == 0)
12707 /* Don't put group member sections on our list of already linked
12708 sections. They are handled as a group via their group section. */
12709 if (elf_sec_group (sec
) != NULL
)
12712 /* For a SHT_GROUP section, use the group signature as the key. */
12714 if ((flags
& SEC_GROUP
) != 0
12715 && elf_next_in_group (sec
) != NULL
12716 && elf_group_name (elf_next_in_group (sec
)) != NULL
)
12717 key
= elf_group_name (elf_next_in_group (sec
));
12720 /* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */
12721 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
12722 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
12725 /* Must be a user linkonce section that doesn't follow gcc's
12726 naming convention. In this case we won't be matching
12727 single member groups. */
12731 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
12733 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12735 /* We may have 2 different types of sections on the list: group
12736 sections with a signature of <key> (<key> is some string),
12737 and linkonce sections named .gnu.linkonce.<type>.<key>.
12738 Match like sections. LTO plugin sections are an exception.
12739 They are always named .gnu.linkonce.t.<key> and match either
12740 type of section. */
12741 if (((flags
& SEC_GROUP
) == (l
->sec
->flags
& SEC_GROUP
)
12742 && ((flags
& SEC_GROUP
) != 0
12743 || strcmp (name
, l
->sec
->name
) == 0))
12744 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
12746 /* The section has already been linked. See if we should
12747 issue a warning. */
12748 if (!_bfd_handle_already_linked (sec
, l
, info
))
12751 if (flags
& SEC_GROUP
)
12753 asection
*first
= elf_next_in_group (sec
);
12754 asection
*s
= first
;
12758 s
->output_section
= bfd_abs_section_ptr
;
12759 /* Record which group discards it. */
12760 s
->kept_section
= l
->sec
;
12761 s
= elf_next_in_group (s
);
12762 /* These lists are circular. */
12772 /* A single member comdat group section may be discarded by a
12773 linkonce section and vice versa. */
12774 if ((flags
& SEC_GROUP
) != 0)
12776 asection
*first
= elf_next_in_group (sec
);
12778 if (first
!= NULL
&& elf_next_in_group (first
) == first
)
12779 /* Check this single member group against linkonce sections. */
12780 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12781 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12782 && bfd_elf_match_symbols_in_sections (l
->sec
, first
, info
))
12784 first
->output_section
= bfd_abs_section_ptr
;
12785 first
->kept_section
= l
->sec
;
12786 sec
->output_section
= bfd_abs_section_ptr
;
12791 /* Check this linkonce section against single member groups. */
12792 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12793 if (l
->sec
->flags
& SEC_GROUP
)
12795 asection
*first
= elf_next_in_group (l
->sec
);
12798 && elf_next_in_group (first
) == first
12799 && bfd_elf_match_symbols_in_sections (first
, sec
, info
))
12801 sec
->output_section
= bfd_abs_section_ptr
;
12802 sec
->kept_section
= first
;
12807 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12808 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12809 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12810 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
12811 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
12812 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12813 `.gnu.linkonce.t.F' section from a different bfd not requiring any
12814 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
12815 The reverse order cannot happen as there is never a bfd with only the
12816 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
12817 matter as here were are looking only for cross-bfd sections. */
12819 if ((flags
& SEC_GROUP
) == 0 && CONST_STRNEQ (name
, ".gnu.linkonce.r."))
12820 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12821 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12822 && CONST_STRNEQ (l
->sec
->name
, ".gnu.linkonce.t."))
12824 if (abfd
!= l
->sec
->owner
)
12825 sec
->output_section
= bfd_abs_section_ptr
;
12829 /* This is the first section with this name. Record it. */
12830 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
12831 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
12832 return sec
->output_section
== bfd_abs_section_ptr
;
12836 _bfd_elf_common_definition (Elf_Internal_Sym
*sym
)
12838 return sym
->st_shndx
== SHN_COMMON
;
12842 _bfd_elf_common_section_index (asection
*sec ATTRIBUTE_UNUSED
)
12848 _bfd_elf_common_section (asection
*sec ATTRIBUTE_UNUSED
)
12850 return bfd_com_section_ptr
;
12854 _bfd_elf_default_got_elt_size (bfd
*abfd
,
12855 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12856 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
12857 bfd
*ibfd ATTRIBUTE_UNUSED
,
12858 unsigned long symndx ATTRIBUTE_UNUSED
)
12860 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12861 return bed
->s
->arch_size
/ 8;
12864 /* Routines to support the creation of dynamic relocs. */
12866 /* Returns the name of the dynamic reloc section associated with SEC. */
12868 static const char *
12869 get_dynamic_reloc_section_name (bfd
* abfd
,
12871 bfd_boolean is_rela
)
12874 const char *old_name
= bfd_get_section_name (NULL
, sec
);
12875 const char *prefix
= is_rela
? ".rela" : ".rel";
12877 if (old_name
== NULL
)
12880 name
= bfd_alloc (abfd
, strlen (prefix
) + strlen (old_name
) + 1);
12881 sprintf (name
, "%s%s", prefix
, old_name
);
12886 /* Returns the dynamic reloc section associated with SEC.
12887 If necessary compute the name of the dynamic reloc section based
12888 on SEC's name (looked up in ABFD's string table) and the setting
12892 _bfd_elf_get_dynamic_reloc_section (bfd
* abfd
,
12894 bfd_boolean is_rela
)
12896 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
12898 if (reloc_sec
== NULL
)
12900 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
12904 reloc_sec
= bfd_get_linker_section (abfd
, name
);
12906 if (reloc_sec
!= NULL
)
12907 elf_section_data (sec
)->sreloc
= reloc_sec
;
12914 /* Returns the dynamic reloc section associated with SEC. If the
12915 section does not exist it is created and attached to the DYNOBJ
12916 bfd and stored in the SRELOC field of SEC's elf_section_data
12919 ALIGNMENT is the alignment for the newly created section and
12920 IS_RELA defines whether the name should be .rela.<SEC's name>
12921 or .rel.<SEC's name>. The section name is looked up in the
12922 string table associated with ABFD. */
12925 _bfd_elf_make_dynamic_reloc_section (asection
* sec
,
12927 unsigned int alignment
,
12929 bfd_boolean is_rela
)
12931 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
12933 if (reloc_sec
== NULL
)
12935 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
12940 reloc_sec
= bfd_get_linker_section (dynobj
, name
);
12942 if (reloc_sec
== NULL
)
12944 flagword flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
12945 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
12946 if ((sec
->flags
& SEC_ALLOC
) != 0)
12947 flags
|= SEC_ALLOC
| SEC_LOAD
;
12949 reloc_sec
= bfd_make_section_anyway_with_flags (dynobj
, name
, flags
);
12950 if (reloc_sec
!= NULL
)
12952 if (! bfd_set_section_alignment (dynobj
, reloc_sec
, alignment
))
12957 elf_section_data (sec
)->sreloc
= reloc_sec
;
12963 /* Copy the ELF symbol type associated with a linker hash entry. */
12965 _bfd_elf_copy_link_hash_symbol_type (bfd
*abfd ATTRIBUTE_UNUSED
,
12966 struct bfd_link_hash_entry
* hdest
,
12967 struct bfd_link_hash_entry
* hsrc
)
12969 struct elf_link_hash_entry
*ehdest
= (struct elf_link_hash_entry
*)hdest
;
12970 struct elf_link_hash_entry
*ehsrc
= (struct elf_link_hash_entry
*)hsrc
;
12972 ehdest
->type
= ehsrc
->type
;
12973 ehdest
->target_internal
= ehsrc
->target_internal
;
12976 /* Append a RELA relocation REL to section S in BFD. */
12979 elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
12981 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12982 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
12983 BFD_ASSERT (loc
+ bed
->s
->sizeof_rela
<= s
->contents
+ s
->size
);
12984 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
12987 /* Append a REL relocation REL to section S in BFD. */
12990 elf_append_rel (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
12992 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12993 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rel
);
12994 BFD_ASSERT (loc
+ bed
->s
->sizeof_rel
<= s
->contents
+ s
->size
);
12995 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);