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, 2013
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
;
190 struct elf_link_hash_entry
*h
;
192 if (! is_elf_hash_table (info
->hash
))
195 if (elf_hash_table (info
)->dynamic_sections_created
)
198 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
201 abfd
= elf_hash_table (info
)->dynobj
;
202 bed
= get_elf_backend_data (abfd
);
204 flags
= bed
->dynamic_sec_flags
;
206 /* A dynamically linked executable has a .interp section, but a
207 shared library does not. */
208 if (info
->executable
)
210 s
= bfd_make_section_anyway_with_flags (abfd
, ".interp",
211 flags
| SEC_READONLY
);
216 /* Create sections to hold version informations. These are removed
217 if they are not needed. */
218 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_d",
219 flags
| SEC_READONLY
);
221 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
224 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version",
225 flags
| SEC_READONLY
);
227 || ! bfd_set_section_alignment (abfd
, s
, 1))
230 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_r",
231 flags
| SEC_READONLY
);
233 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
236 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynsym",
237 flags
| SEC_READONLY
);
239 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
242 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynstr",
243 flags
| SEC_READONLY
);
247 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic", flags
);
249 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
252 /* The special symbol _DYNAMIC is always set to the start of the
253 .dynamic section. We could set _DYNAMIC in a linker script, but we
254 only want to define it if we are, in fact, creating a .dynamic
255 section. We don't want to define it if there is no .dynamic
256 section, since on some ELF platforms the start up code examines it
257 to decide how to initialize the process. */
258 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_DYNAMIC");
259 elf_hash_table (info
)->hdynamic
= h
;
265 s
= bfd_make_section_anyway_with_flags (abfd
, ".hash",
266 flags
| SEC_READONLY
);
268 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
270 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
273 if (info
->emit_gnu_hash
)
275 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.hash",
276 flags
| SEC_READONLY
);
278 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
280 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
281 4 32-bit words followed by variable count of 64-bit words, then
282 variable count of 32-bit words. */
283 if (bed
->s
->arch_size
== 64)
284 elf_section_data (s
)->this_hdr
.sh_entsize
= 0;
286 elf_section_data (s
)->this_hdr
.sh_entsize
= 4;
289 /* Let the backend create the rest of the sections. This lets the
290 backend set the right flags. The backend will normally create
291 the .got and .plt sections. */
292 if (bed
->elf_backend_create_dynamic_sections
== NULL
293 || ! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
296 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
301 /* Create dynamic sections when linking against a dynamic object. */
304 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
306 flagword flags
, pltflags
;
307 struct elf_link_hash_entry
*h
;
309 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
310 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
312 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
313 .rel[a].bss sections. */
314 flags
= bed
->dynamic_sec_flags
;
317 if (bed
->plt_not_loaded
)
318 /* We do not clear SEC_ALLOC here because we still want the OS to
319 allocate space for the section; it's just that there's nothing
320 to read in from the object file. */
321 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
323 pltflags
|= SEC_ALLOC
| SEC_CODE
| SEC_LOAD
;
324 if (bed
->plt_readonly
)
325 pltflags
|= SEC_READONLY
;
327 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
329 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
333 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
335 if (bed
->want_plt_sym
)
337 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
338 "_PROCEDURE_LINKAGE_TABLE_");
339 elf_hash_table (info
)->hplt
= h
;
344 s
= bfd_make_section_anyway_with_flags (abfd
,
345 (bed
->rela_plts_and_copies_p
346 ? ".rela.plt" : ".rel.plt"),
347 flags
| SEC_READONLY
);
349 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
353 if (! _bfd_elf_create_got_section (abfd
, info
))
356 if (bed
->want_dynbss
)
358 /* The .dynbss section is a place to put symbols which are defined
359 by dynamic objects, are referenced by regular objects, and are
360 not functions. We must allocate space for them in the process
361 image and use a R_*_COPY reloc to tell the dynamic linker to
362 initialize them at run time. The linker script puts the .dynbss
363 section into the .bss section of the final image. */
364 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
365 (SEC_ALLOC
| SEC_LINKER_CREATED
));
369 /* The .rel[a].bss section holds copy relocs. This section is not
370 normally needed. We need to create it here, though, so that the
371 linker will map it to an output section. We can't just create it
372 only if we need it, because we will not know whether we need it
373 until we have seen all the input files, and the first time the
374 main linker code calls BFD after examining all the input files
375 (size_dynamic_sections) the input sections have already been
376 mapped to the output sections. If the section turns out not to
377 be needed, we can discard it later. We will never need this
378 section when generating a shared object, since they do not use
382 s
= bfd_make_section_anyway_with_flags (abfd
,
383 (bed
->rela_plts_and_copies_p
384 ? ".rela.bss" : ".rel.bss"),
385 flags
| SEC_READONLY
);
387 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
395 /* Record a new dynamic symbol. We record the dynamic symbols as we
396 read the input files, since we need to have a list of all of them
397 before we can determine the final sizes of the output sections.
398 Note that we may actually call this function even though we are not
399 going to output any dynamic symbols; in some cases we know that a
400 symbol should be in the dynamic symbol table, but only if there is
404 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
405 struct elf_link_hash_entry
*h
)
407 if (h
->dynindx
== -1)
409 struct elf_strtab_hash
*dynstr
;
414 /* XXX: The ABI draft says the linker must turn hidden and
415 internal symbols into STB_LOCAL symbols when producing the
416 DSO. However, if ld.so honors st_other in the dynamic table,
417 this would not be necessary. */
418 switch (ELF_ST_VISIBILITY (h
->other
))
422 if (h
->root
.type
!= bfd_link_hash_undefined
423 && h
->root
.type
!= bfd_link_hash_undefweak
)
426 if (!elf_hash_table (info
)->is_relocatable_executable
)
434 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
435 ++elf_hash_table (info
)->dynsymcount
;
437 dynstr
= elf_hash_table (info
)->dynstr
;
440 /* Create a strtab to hold the dynamic symbol names. */
441 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
446 /* We don't put any version information in the dynamic string
448 name
= h
->root
.root
.string
;
449 p
= strchr (name
, ELF_VER_CHR
);
451 /* We know that the p points into writable memory. In fact,
452 there are only a few symbols that have read-only names, being
453 those like _GLOBAL_OFFSET_TABLE_ that are created specially
454 by the backends. Most symbols will have names pointing into
455 an ELF string table read from a file, or to objalloc memory. */
458 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
463 if (indx
== (bfd_size_type
) -1)
465 h
->dynstr_index
= indx
;
471 /* Mark a symbol dynamic. */
474 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info
*info
,
475 struct elf_link_hash_entry
*h
,
476 Elf_Internal_Sym
*sym
)
478 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
480 /* It may be called more than once on the same H. */
481 if(h
->dynamic
|| info
->relocatable
)
484 if ((info
->dynamic_data
485 && (h
->type
== STT_OBJECT
487 && ELF_ST_TYPE (sym
->st_info
) == STT_OBJECT
)))
489 && h
->root
.type
== bfd_link_hash_new
490 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
494 /* Record an assignment to a symbol made by a linker script. We need
495 this in case some dynamic object refers to this symbol. */
498 bfd_elf_record_link_assignment (bfd
*output_bfd
,
499 struct bfd_link_info
*info
,
504 struct elf_link_hash_entry
*h
, *hv
;
505 struct elf_link_hash_table
*htab
;
506 const struct elf_backend_data
*bed
;
508 if (!is_elf_hash_table (info
->hash
))
511 htab
= elf_hash_table (info
);
512 h
= elf_link_hash_lookup (htab
, name
, !provide
, TRUE
, FALSE
);
516 switch (h
->root
.type
)
518 case bfd_link_hash_defined
:
519 case bfd_link_hash_defweak
:
520 case bfd_link_hash_common
:
522 case bfd_link_hash_undefweak
:
523 case bfd_link_hash_undefined
:
524 /* Since we're defining the symbol, don't let it seem to have not
525 been defined. record_dynamic_symbol and size_dynamic_sections
526 may depend on this. */
527 h
->root
.type
= bfd_link_hash_new
;
528 if (h
->root
.u
.undef
.next
!= NULL
|| htab
->root
.undefs_tail
== &h
->root
)
529 bfd_link_repair_undef_list (&htab
->root
);
531 case bfd_link_hash_new
:
532 bfd_elf_link_mark_dynamic_symbol (info
, h
, NULL
);
535 case bfd_link_hash_indirect
:
536 /* We had a versioned symbol in a dynamic library. We make the
537 the versioned symbol point to this one. */
538 bed
= get_elf_backend_data (output_bfd
);
540 while (hv
->root
.type
== bfd_link_hash_indirect
541 || hv
->root
.type
== bfd_link_hash_warning
)
542 hv
= (struct elf_link_hash_entry
*) hv
->root
.u
.i
.link
;
543 /* We don't need to update h->root.u since linker will set them
545 h
->root
.type
= bfd_link_hash_undefined
;
546 hv
->root
.type
= bfd_link_hash_indirect
;
547 hv
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
548 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hv
);
550 case bfd_link_hash_warning
:
555 /* If this symbol is being provided by the linker script, and it is
556 currently defined by a dynamic object, but not by a regular
557 object, then mark it as undefined so that the generic linker will
558 force the correct value. */
562 h
->root
.type
= bfd_link_hash_undefined
;
564 /* If this symbol is not being provided by the linker script, and it is
565 currently defined by a dynamic object, but not by a regular object,
566 then clear out any version information because the symbol will not be
567 associated with the dynamic object any more. */
571 h
->verinfo
.verdef
= NULL
;
577 bed
= get_elf_backend_data (output_bfd
);
578 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
579 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
582 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
584 if (!info
->relocatable
586 && (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
587 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
))
593 || (info
->executable
&& elf_hash_table (info
)->is_relocatable_executable
))
596 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
599 /* If this is a weak defined symbol, and we know a corresponding
600 real symbol from the same dynamic object, make sure the real
601 symbol is also made into a dynamic symbol. */
602 if (h
->u
.weakdef
!= NULL
603 && h
->u
.weakdef
->dynindx
== -1)
605 if (! bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
613 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
614 success, and 2 on a failure caused by attempting to record a symbol
615 in a discarded section, eg. a discarded link-once section symbol. */
618 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
623 struct elf_link_local_dynamic_entry
*entry
;
624 struct elf_link_hash_table
*eht
;
625 struct elf_strtab_hash
*dynstr
;
626 unsigned long dynstr_index
;
628 Elf_External_Sym_Shndx eshndx
;
629 char esym
[sizeof (Elf64_External_Sym
)];
631 if (! is_elf_hash_table (info
->hash
))
634 /* See if the entry exists already. */
635 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
636 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
639 amt
= sizeof (*entry
);
640 entry
= (struct elf_link_local_dynamic_entry
*) bfd_alloc (input_bfd
, amt
);
644 /* Go find the symbol, so that we can find it's name. */
645 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
646 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
648 bfd_release (input_bfd
, entry
);
652 if (entry
->isym
.st_shndx
!= SHN_UNDEF
653 && entry
->isym
.st_shndx
< SHN_LORESERVE
)
657 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
658 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
660 /* We can still bfd_release here as nothing has done another
661 bfd_alloc. We can't do this later in this function. */
662 bfd_release (input_bfd
, entry
);
667 name
= (bfd_elf_string_from_elf_section
668 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
669 entry
->isym
.st_name
));
671 dynstr
= elf_hash_table (info
)->dynstr
;
674 /* Create a strtab to hold the dynamic symbol names. */
675 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
680 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, FALSE
);
681 if (dynstr_index
== (unsigned long) -1)
683 entry
->isym
.st_name
= dynstr_index
;
685 eht
= elf_hash_table (info
);
687 entry
->next
= eht
->dynlocal
;
688 eht
->dynlocal
= entry
;
689 entry
->input_bfd
= input_bfd
;
690 entry
->input_indx
= input_indx
;
693 /* Whatever binding the symbol had before, it's now local. */
695 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
697 /* The dynindx will be set at the end of size_dynamic_sections. */
702 /* Return the dynindex of a local dynamic symbol. */
705 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
709 struct elf_link_local_dynamic_entry
*e
;
711 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
712 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
717 /* This function is used to renumber the dynamic symbols, if some of
718 them are removed because they are marked as local. This is called
719 via elf_link_hash_traverse. */
722 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
725 size_t *count
= (size_t *) data
;
730 if (h
->dynindx
!= -1)
731 h
->dynindx
= ++(*count
);
737 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
738 STB_LOCAL binding. */
741 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
744 size_t *count
= (size_t *) data
;
746 if (!h
->forced_local
)
749 if (h
->dynindx
!= -1)
750 h
->dynindx
= ++(*count
);
755 /* Return true if the dynamic symbol for a given section should be
756 omitted when creating a shared library. */
758 _bfd_elf_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
759 struct bfd_link_info
*info
,
762 struct elf_link_hash_table
*htab
;
764 switch (elf_section_data (p
)->this_hdr
.sh_type
)
768 /* If sh_type is yet undecided, assume it could be
769 SHT_PROGBITS/SHT_NOBITS. */
771 htab
= elf_hash_table (info
);
772 if (p
== htab
->tls_sec
)
775 if (htab
->text_index_section
!= NULL
)
776 return p
!= htab
->text_index_section
&& p
!= htab
->data_index_section
;
778 if (strcmp (p
->name
, ".got") == 0
779 || strcmp (p
->name
, ".got.plt") == 0
780 || strcmp (p
->name
, ".plt") == 0)
784 if (htab
->dynobj
!= NULL
785 && (ip
= bfd_get_linker_section (htab
->dynobj
, p
->name
)) != NULL
786 && ip
->output_section
== p
)
791 /* There shouldn't be section relative relocations
792 against any other section. */
798 /* Assign dynsym indices. In a shared library we generate a section
799 symbol for each output section, which come first. Next come symbols
800 which have been forced to local binding. Then all of the back-end
801 allocated local dynamic syms, followed by the rest of the global
805 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
,
806 struct bfd_link_info
*info
,
807 unsigned long *section_sym_count
)
809 unsigned long dynsymcount
= 0;
811 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
813 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
815 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
816 if ((p
->flags
& SEC_EXCLUDE
) == 0
817 && (p
->flags
& SEC_ALLOC
) != 0
818 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
819 elf_section_data (p
)->dynindx
= ++dynsymcount
;
821 elf_section_data (p
)->dynindx
= 0;
823 *section_sym_count
= dynsymcount
;
825 elf_link_hash_traverse (elf_hash_table (info
),
826 elf_link_renumber_local_hash_table_dynsyms
,
829 if (elf_hash_table (info
)->dynlocal
)
831 struct elf_link_local_dynamic_entry
*p
;
832 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
833 p
->dynindx
= ++dynsymcount
;
836 elf_link_hash_traverse (elf_hash_table (info
),
837 elf_link_renumber_hash_table_dynsyms
,
840 /* There is an unused NULL entry at the head of the table which
841 we must account for in our count. Unless there weren't any
842 symbols, which means we'll have no table at all. */
843 if (dynsymcount
!= 0)
846 elf_hash_table (info
)->dynsymcount
= dynsymcount
;
850 /* Merge st_other field. */
853 elf_merge_st_other (bfd
*abfd
, struct elf_link_hash_entry
*h
,
854 Elf_Internal_Sym
*isym
, bfd_boolean definition
,
857 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
859 /* If st_other has a processor-specific meaning, specific
860 code might be needed here. We never merge the visibility
861 attribute with the one from a dynamic object. */
862 if (bed
->elf_backend_merge_symbol_attribute
)
863 (*bed
->elf_backend_merge_symbol_attribute
) (h
, isym
, definition
,
866 /* If this symbol has default visibility and the user has requested
867 we not re-export it, then mark it as hidden. */
871 || (abfd
->my_archive
&& abfd
->my_archive
->no_export
))
872 && ELF_ST_VISIBILITY (isym
->st_other
) != STV_INTERNAL
)
873 isym
->st_other
= (STV_HIDDEN
874 | (isym
->st_other
& ~ELF_ST_VISIBILITY (-1)));
876 if (!dynamic
&& ELF_ST_VISIBILITY (isym
->st_other
) != 0)
878 unsigned char hvis
, symvis
, other
, nvis
;
880 /* Only merge the visibility. Leave the remainder of the
881 st_other field to elf_backend_merge_symbol_attribute. */
882 other
= h
->other
& ~ELF_ST_VISIBILITY (-1);
884 /* Combine visibilities, using the most constraining one. */
885 hvis
= ELF_ST_VISIBILITY (h
->other
);
886 symvis
= ELF_ST_VISIBILITY (isym
->st_other
);
892 nvis
= hvis
< symvis
? hvis
: symvis
;
894 h
->other
= other
| nvis
;
898 /* Mark if a symbol has a definition in a dynamic object or is
899 weak in all dynamic objects. */
902 _bfd_elf_mark_dynamic_def_weak (struct elf_link_hash_entry
*h
,
903 asection
*sec
, int bind
)
907 if (!bfd_is_und_section (sec
))
911 /* Check if this symbol is weak in all dynamic objects. If it
912 is the first time we see it in a dynamic object, we mark
913 if it is weak. Otherwise, we clear it. */
916 if (bind
== STB_WEAK
)
919 else if (bind
!= STB_WEAK
)
925 /* This function is called when we want to define a new symbol. It
926 handles the various cases which arise when we find a definition in
927 a dynamic object, or when there is already a definition in a
928 dynamic object. The new symbol is described by NAME, SYM, PSEC,
929 and PVALUE. We set SYM_HASH to the hash table entry. We set
930 OVERRIDE if the old symbol is overriding a new definition. We set
931 TYPE_CHANGE_OK if it is OK for the type to change. We set
932 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
933 change, we mean that we shouldn't warn if the type or size does
934 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic
935 object is overridden by a regular object. */
938 _bfd_elf_merge_symbol (bfd
*abfd
,
939 struct bfd_link_info
*info
,
941 Elf_Internal_Sym
*sym
,
944 bfd_boolean
*pold_weak
,
945 unsigned int *pold_alignment
,
946 struct elf_link_hash_entry
**sym_hash
,
948 bfd_boolean
*override
,
949 bfd_boolean
*type_change_ok
,
950 bfd_boolean
*size_change_ok
)
952 asection
*sec
, *oldsec
;
953 struct elf_link_hash_entry
*h
;
954 struct elf_link_hash_entry
*hi
;
955 struct elf_link_hash_entry
*flip
;
958 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
959 bfd_boolean newweak
, oldweak
, newfunc
, oldfunc
;
960 const struct elf_backend_data
*bed
;
966 bind
= ELF_ST_BIND (sym
->st_info
);
968 /* Silently discard TLS symbols from --just-syms. There's no way to
969 combine a static TLS block with a new TLS block for this executable. */
970 if (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
971 && sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
977 if (! bfd_is_und_section (sec
))
978 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
980 h
= ((struct elf_link_hash_entry
*)
981 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
986 bed
= get_elf_backend_data (abfd
);
988 /* This code is for coping with dynamic objects, and is only useful
989 if we are doing an ELF link. */
990 if (!(*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
993 /* For merging, we only care about real symbols. But we need to make
994 sure that indirect symbol dynamic flags are updated. */
996 while (h
->root
.type
== bfd_link_hash_indirect
997 || h
->root
.type
== bfd_link_hash_warning
)
998 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1000 /* We have to check it for every instance since the first few may be
1001 refereences and not all compilers emit symbol type for undefined
1003 bfd_elf_link_mark_dynamic_symbol (info
, h
, sym
);
1005 /* If we just created the symbol, mark it as being an ELF symbol.
1006 Other than that, there is nothing to do--there is no merge issue
1007 with a newly defined symbol--so we just return. */
1009 if (h
->root
.type
== bfd_link_hash_new
)
1015 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
1018 switch (h
->root
.type
)
1025 case bfd_link_hash_undefined
:
1026 case bfd_link_hash_undefweak
:
1027 oldbfd
= h
->root
.u
.undef
.abfd
;
1031 case bfd_link_hash_defined
:
1032 case bfd_link_hash_defweak
:
1033 oldbfd
= h
->root
.u
.def
.section
->owner
;
1034 oldsec
= h
->root
.u
.def
.section
;
1037 case bfd_link_hash_common
:
1038 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
1039 oldsec
= h
->root
.u
.c
.p
->section
;
1043 /* Differentiate strong and weak symbols. */
1044 newweak
= bind
== STB_WEAK
;
1045 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
1046 || h
->root
.type
== bfd_link_hash_undefweak
);
1048 *pold_weak
= oldweak
;
1050 /* In cases involving weak versioned symbols, we may wind up trying
1051 to merge a symbol with itself. Catch that here, to avoid the
1052 confusion that results if we try to override a symbol with
1053 itself. The additional tests catch cases like
1054 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1055 dynamic object, which we do want to handle here. */
1057 && (newweak
|| oldweak
)
1058 && ((abfd
->flags
& DYNAMIC
) == 0
1059 || !h
->def_regular
))
1062 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1063 respectively, is from a dynamic object. */
1065 newdyn
= (abfd
->flags
& DYNAMIC
) != 0;
1069 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
1070 else if (oldsec
!= NULL
)
1072 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1073 indices used by MIPS ELF. */
1074 olddyn
= (oldsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
1077 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1078 respectively, appear to be a definition rather than reference. */
1080 newdef
= !bfd_is_und_section (sec
) && !bfd_is_com_section (sec
);
1082 olddef
= (h
->root
.type
!= bfd_link_hash_undefined
1083 && h
->root
.type
!= bfd_link_hash_undefweak
1084 && h
->root
.type
!= bfd_link_hash_common
);
1086 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1087 respectively, appear to be a function. */
1089 newfunc
= (ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1090 && bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)));
1092 oldfunc
= (h
->type
!= STT_NOTYPE
1093 && bed
->is_function_type (h
->type
));
1095 /* When we try to create a default indirect symbol from the dynamic
1096 definition with the default version, we skip it if its type and
1097 the type of existing regular definition mismatch. We only do it
1098 if the existing regular definition won't be dynamic. */
1099 if (pold_alignment
== NULL
1101 && !info
->export_dynamic
1106 && (olddef
|| h
->root
.type
== bfd_link_hash_common
)
1107 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1108 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1109 && h
->type
!= STT_NOTYPE
1110 && !(newfunc
&& oldfunc
))
1116 /* Plugin symbol type isn't currently set. Stop bogus errors. */
1117 if (oldbfd
!= NULL
&& (oldbfd
->flags
& BFD_PLUGIN
) != 0)
1118 *type_change_ok
= TRUE
;
1120 /* Check TLS symbol. We don't check undefined symbol introduced by
1122 else if (oldbfd
!= NULL
1123 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1124 && (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
|| h
->type
== STT_TLS
))
1127 bfd_boolean ntdef
, tdef
;
1128 asection
*ntsec
, *tsec
;
1130 if (h
->type
== STT_TLS
)
1150 (*_bfd_error_handler
)
1151 (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1152 tbfd
, tsec
, ntbfd
, ntsec
, h
->root
.root
.string
);
1153 else if (!tdef
&& !ntdef
)
1154 (*_bfd_error_handler
)
1155 (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1156 tbfd
, ntbfd
, h
->root
.root
.string
);
1158 (*_bfd_error_handler
)
1159 (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1160 tbfd
, tsec
, ntbfd
, h
->root
.root
.string
);
1162 (*_bfd_error_handler
)
1163 (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1164 tbfd
, ntbfd
, ntsec
, h
->root
.root
.string
);
1166 bfd_set_error (bfd_error_bad_value
);
1170 /* We need to remember if a symbol has a definition in a dynamic
1171 object or is weak in all dynamic objects. Internal and hidden
1172 visibility will make it unavailable to dynamic objects. */
1175 _bfd_elf_mark_dynamic_def_weak (h
, sec
, bind
);
1177 _bfd_elf_mark_dynamic_def_weak (hi
, sec
, bind
);
1180 /* If the old symbol has non-default visibility, we ignore the new
1181 definition from a dynamic object. */
1183 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1184 && !bfd_is_und_section (sec
))
1187 /* Make sure this symbol is dynamic. */
1189 hi
->ref_dynamic
= 1;
1190 /* A protected symbol has external availability. Make sure it is
1191 recorded as dynamic.
1193 FIXME: Should we check type and size for protected symbol? */
1194 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1195 return bfd_elf_link_record_dynamic_symbol (info
, h
);
1200 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
1203 /* If the new symbol with non-default visibility comes from a
1204 relocatable file and the old definition comes from a dynamic
1205 object, we remove the old definition. */
1206 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1208 /* Handle the case where the old dynamic definition is
1209 default versioned. We need to copy the symbol info from
1210 the symbol with default version to the normal one if it
1211 was referenced before. */
1214 struct elf_link_hash_entry
*vh
= *sym_hash
;
1216 vh
->root
.type
= h
->root
.type
;
1217 h
->root
.type
= bfd_link_hash_indirect
;
1218 (*bed
->elf_backend_copy_indirect_symbol
) (info
, vh
, h
);
1220 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) vh
;
1221 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1223 /* If the new symbol is hidden or internal, completely undo
1224 any dynamic link state. */
1225 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1226 h
->forced_local
= 0;
1234 /* FIXME: Should we check type and size for protected symbol? */
1244 /* If the old symbol was undefined before, then it will still be
1245 on the undefs list. If the new symbol is undefined or
1246 common, we can't make it bfd_link_hash_new here, because new
1247 undefined or common symbols will be added to the undefs list
1248 by _bfd_generic_link_add_one_symbol. Symbols may not be
1249 added twice to the undefs list. Also, if the new symbol is
1250 undefweak then we don't want to lose the strong undef. */
1251 if (h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1253 h
->root
.type
= bfd_link_hash_undefined
;
1254 h
->root
.u
.undef
.abfd
= abfd
;
1258 h
->root
.type
= bfd_link_hash_new
;
1259 h
->root
.u
.undef
.abfd
= NULL
;
1262 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1264 /* If the new symbol is hidden or internal, completely undo
1265 any dynamic link state. */
1266 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1267 h
->forced_local
= 0;
1274 /* FIXME: Should we check type and size for protected symbol? */
1280 if (bind
== STB_GNU_UNIQUE
)
1281 h
->unique_global
= 1;
1283 /* If a new weak symbol definition comes from a regular file and the
1284 old symbol comes from a dynamic library, we treat the new one as
1285 strong. Similarly, an old weak symbol definition from a regular
1286 file is treated as strong when the new symbol comes from a dynamic
1287 library. Further, an old weak symbol from a dynamic library is
1288 treated as strong if the new symbol is from a dynamic library.
1289 This reflects the way glibc's ld.so works.
1291 Do this before setting *type_change_ok or *size_change_ok so that
1292 we warn properly when dynamic library symbols are overridden. */
1294 if (newdef
&& !newdyn
&& olddyn
)
1296 if (olddef
&& newdyn
)
1299 /* Allow changes between different types of function symbol. */
1300 if (newfunc
&& oldfunc
)
1301 *type_change_ok
= TRUE
;
1303 /* It's OK to change the type if either the existing symbol or the
1304 new symbol is weak. A type change is also OK if the old symbol
1305 is undefined and the new symbol is defined. */
1310 && h
->root
.type
== bfd_link_hash_undefined
))
1311 *type_change_ok
= TRUE
;
1313 /* It's OK to change the size if either the existing symbol or the
1314 new symbol is weak, or if the old symbol is undefined. */
1317 || h
->root
.type
== bfd_link_hash_undefined
)
1318 *size_change_ok
= TRUE
;
1320 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1321 symbol, respectively, appears to be a common symbol in a dynamic
1322 object. If a symbol appears in an uninitialized section, and is
1323 not weak, and is not a function, then it may be a common symbol
1324 which was resolved when the dynamic object was created. We want
1325 to treat such symbols specially, because they raise special
1326 considerations when setting the symbol size: if the symbol
1327 appears as a common symbol in a regular object, and the size in
1328 the regular object is larger, we must make sure that we use the
1329 larger size. This problematic case can always be avoided in C,
1330 but it must be handled correctly when using Fortran shared
1333 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1334 likewise for OLDDYNCOMMON and OLDDEF.
1336 Note that this test is just a heuristic, and that it is quite
1337 possible to have an uninitialized symbol in a shared object which
1338 is really a definition, rather than a common symbol. This could
1339 lead to some minor confusion when the symbol really is a common
1340 symbol in some regular object. However, I think it will be
1346 && (sec
->flags
& SEC_ALLOC
) != 0
1347 && (sec
->flags
& SEC_LOAD
) == 0
1350 newdyncommon
= TRUE
;
1352 newdyncommon
= FALSE
;
1356 && h
->root
.type
== bfd_link_hash_defined
1358 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1359 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
1362 olddyncommon
= TRUE
;
1364 olddyncommon
= FALSE
;
1366 /* We now know everything about the old and new symbols. We ask the
1367 backend to check if we can merge them. */
1368 if (bed
->merge_symbol
1369 && !bed
->merge_symbol (info
, sym_hash
, h
, sym
, psec
, pvalue
,
1370 pold_alignment
, skip
, override
,
1371 type_change_ok
, size_change_ok
,
1372 &newdyn
, &newdef
, &newdyncommon
, &newweak
,
1374 &olddyn
, &olddef
, &olddyncommon
, &oldweak
,
1378 /* If both the old and the new symbols look like common symbols in a
1379 dynamic object, set the size of the symbol to the larger of the
1384 && sym
->st_size
!= h
->size
)
1386 /* Since we think we have two common symbols, issue a multiple
1387 common warning if desired. Note that we only warn if the
1388 size is different. If the size is the same, we simply let
1389 the old symbol override the new one as normally happens with
1390 symbols defined in dynamic objects. */
1392 if (! ((*info
->callbacks
->multiple_common
)
1393 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1396 if (sym
->st_size
> h
->size
)
1397 h
->size
= sym
->st_size
;
1399 *size_change_ok
= TRUE
;
1402 /* If we are looking at a dynamic object, and we have found a
1403 definition, we need to see if the symbol was already defined by
1404 some other object. If so, we want to use the existing
1405 definition, and we do not want to report a multiple symbol
1406 definition error; we do this by clobbering *PSEC to be
1407 bfd_und_section_ptr.
1409 We treat a common symbol as a definition if the symbol in the
1410 shared library is a function, since common symbols always
1411 represent variables; this can cause confusion in principle, but
1412 any such confusion would seem to indicate an erroneous program or
1413 shared library. We also permit a common symbol in a regular
1414 object to override a weak symbol in a shared object. */
1419 || (h
->root
.type
== bfd_link_hash_common
1420 && (newweak
|| newfunc
))))
1424 newdyncommon
= FALSE
;
1426 *psec
= sec
= bfd_und_section_ptr
;
1427 *size_change_ok
= TRUE
;
1429 /* If we get here when the old symbol is a common symbol, then
1430 we are explicitly letting it override a weak symbol or
1431 function in a dynamic object, and we don't want to warn about
1432 a type change. If the old symbol is a defined symbol, a type
1433 change warning may still be appropriate. */
1435 if (h
->root
.type
== bfd_link_hash_common
)
1436 *type_change_ok
= TRUE
;
1439 /* Handle the special case of an old common symbol merging with a
1440 new symbol which looks like a common symbol in a shared object.
1441 We change *PSEC and *PVALUE to make the new symbol look like a
1442 common symbol, and let _bfd_generic_link_add_one_symbol do the
1446 && h
->root
.type
== bfd_link_hash_common
)
1450 newdyncommon
= FALSE
;
1451 *pvalue
= sym
->st_size
;
1452 *psec
= sec
= bed
->common_section (oldsec
);
1453 *size_change_ok
= TRUE
;
1456 /* Skip weak definitions of symbols that are already defined. */
1457 if (newdef
&& olddef
&& newweak
)
1459 /* Don't skip new non-IR weak syms. */
1460 if (!(oldbfd
!= NULL
1461 && (oldbfd
->flags
& BFD_PLUGIN
) != 0
1462 && (abfd
->flags
& BFD_PLUGIN
) == 0))
1465 /* Merge st_other. If the symbol already has a dynamic index,
1466 but visibility says it should not be visible, turn it into a
1468 elf_merge_st_other (abfd
, h
, sym
, newdef
, newdyn
);
1469 if (h
->dynindx
!= -1)
1470 switch (ELF_ST_VISIBILITY (h
->other
))
1474 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1479 /* If the old symbol is from a dynamic object, and the new symbol is
1480 a definition which is not from a dynamic object, then the new
1481 symbol overrides the old symbol. Symbols from regular files
1482 always take precedence over symbols from dynamic objects, even if
1483 they are defined after the dynamic object in the link.
1485 As above, we again permit a common symbol in a regular object to
1486 override a definition in a shared object if the shared object
1487 symbol is a function or is weak. */
1492 || (bfd_is_com_section (sec
)
1493 && (oldweak
|| oldfunc
)))
1498 /* Change the hash table entry to undefined, and let
1499 _bfd_generic_link_add_one_symbol do the right thing with the
1502 h
->root
.type
= bfd_link_hash_undefined
;
1503 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1504 *size_change_ok
= TRUE
;
1507 olddyncommon
= FALSE
;
1509 /* We again permit a type change when a common symbol may be
1510 overriding a function. */
1512 if (bfd_is_com_section (sec
))
1516 /* If a common symbol overrides a function, make sure
1517 that it isn't defined dynamically nor has type
1520 h
->type
= STT_NOTYPE
;
1522 *type_change_ok
= TRUE
;
1525 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1528 /* This union may have been set to be non-NULL when this symbol
1529 was seen in a dynamic object. We must force the union to be
1530 NULL, so that it is correct for a regular symbol. */
1531 h
->verinfo
.vertree
= NULL
;
1534 /* Handle the special case of a new common symbol merging with an
1535 old symbol that looks like it might be a common symbol defined in
1536 a shared object. Note that we have already handled the case in
1537 which a new common symbol should simply override the definition
1538 in the shared library. */
1541 && bfd_is_com_section (sec
)
1544 /* It would be best if we could set the hash table entry to a
1545 common symbol, but we don't know what to use for the section
1546 or the alignment. */
1547 if (! ((*info
->callbacks
->multiple_common
)
1548 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1551 /* If the presumed common symbol in the dynamic object is
1552 larger, pretend that the new symbol has its size. */
1554 if (h
->size
> *pvalue
)
1557 /* We need to remember the alignment required by the symbol
1558 in the dynamic object. */
1559 BFD_ASSERT (pold_alignment
);
1560 *pold_alignment
= h
->root
.u
.def
.section
->alignment_power
;
1563 olddyncommon
= FALSE
;
1565 h
->root
.type
= bfd_link_hash_undefined
;
1566 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1568 *size_change_ok
= TRUE
;
1569 *type_change_ok
= TRUE
;
1571 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1574 h
->verinfo
.vertree
= NULL
;
1579 /* Handle the case where we had a versioned symbol in a dynamic
1580 library and now find a definition in a normal object. In this
1581 case, we make the versioned symbol point to the normal one. */
1582 flip
->root
.type
= h
->root
.type
;
1583 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1584 h
->root
.type
= bfd_link_hash_indirect
;
1585 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1586 (*bed
->elf_backend_copy_indirect_symbol
) (info
, flip
, h
);
1590 flip
->ref_dynamic
= 1;
1597 /* This function is called to create an indirect symbol from the
1598 default for the symbol with the default version if needed. The
1599 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
1600 set DYNSYM if the new indirect symbol is dynamic. */
1603 _bfd_elf_add_default_symbol (bfd
*abfd
,
1604 struct bfd_link_info
*info
,
1605 struct elf_link_hash_entry
*h
,
1607 Elf_Internal_Sym
*sym
,
1610 bfd_boolean
*dynsym
,
1611 bfd_boolean override
)
1613 bfd_boolean type_change_ok
;
1614 bfd_boolean size_change_ok
;
1617 struct elf_link_hash_entry
*hi
;
1618 struct bfd_link_hash_entry
*bh
;
1619 const struct elf_backend_data
*bed
;
1620 bfd_boolean collect
;
1621 bfd_boolean dynamic
;
1623 size_t len
, shortlen
;
1626 /* If this symbol has a version, and it is the default version, we
1627 create an indirect symbol from the default name to the fully
1628 decorated name. This will cause external references which do not
1629 specify a version to be bound to this version of the symbol. */
1630 p
= strchr (name
, ELF_VER_CHR
);
1631 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
1636 /* We are overridden by an old definition. We need to check if we
1637 need to create the indirect symbol from the default name. */
1638 hi
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
,
1640 BFD_ASSERT (hi
!= NULL
);
1643 while (hi
->root
.type
== bfd_link_hash_indirect
1644 || hi
->root
.type
== bfd_link_hash_warning
)
1646 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1652 bed
= get_elf_backend_data (abfd
);
1653 collect
= bed
->collect
;
1654 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1656 shortlen
= p
- name
;
1657 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1658 if (shortname
== NULL
)
1660 memcpy (shortname
, name
, shortlen
);
1661 shortname
[shortlen
] = '\0';
1663 /* We are going to create a new symbol. Merge it with any existing
1664 symbol with this name. For the purposes of the merge, act as
1665 though we were defining the symbol we just defined, although we
1666 actually going to define an indirect symbol. */
1667 type_change_ok
= FALSE
;
1668 size_change_ok
= FALSE
;
1670 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1671 NULL
, NULL
, &hi
, &skip
, &override
,
1672 &type_change_ok
, &size_change_ok
))
1681 if (! (_bfd_generic_link_add_one_symbol
1682 (info
, abfd
, shortname
, BSF_INDIRECT
, bfd_ind_section_ptr
,
1683 0, name
, FALSE
, collect
, &bh
)))
1685 hi
= (struct elf_link_hash_entry
*) bh
;
1689 /* In this case the symbol named SHORTNAME is overriding the
1690 indirect symbol we want to add. We were planning on making
1691 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1692 is the name without a version. NAME is the fully versioned
1693 name, and it is the default version.
1695 Overriding means that we already saw a definition for the
1696 symbol SHORTNAME in a regular object, and it is overriding
1697 the symbol defined in the dynamic object.
1699 When this happens, we actually want to change NAME, the
1700 symbol we just added, to refer to SHORTNAME. This will cause
1701 references to NAME in the shared object to become references
1702 to SHORTNAME in the regular object. This is what we expect
1703 when we override a function in a shared object: that the
1704 references in the shared object will be mapped to the
1705 definition in the regular object. */
1707 while (hi
->root
.type
== bfd_link_hash_indirect
1708 || hi
->root
.type
== bfd_link_hash_warning
)
1709 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1711 h
->root
.type
= bfd_link_hash_indirect
;
1712 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1716 hi
->ref_dynamic
= 1;
1720 if (! bfd_elf_link_record_dynamic_symbol (info
, hi
))
1725 /* Now set HI to H, so that the following code will set the
1726 other fields correctly. */
1730 /* Check if HI is a warning symbol. */
1731 if (hi
->root
.type
== bfd_link_hash_warning
)
1732 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1734 /* If there is a duplicate definition somewhere, then HI may not
1735 point to an indirect symbol. We will have reported an error to
1736 the user in that case. */
1738 if (hi
->root
.type
== bfd_link_hash_indirect
)
1740 struct elf_link_hash_entry
*ht
;
1742 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1743 (*bed
->elf_backend_copy_indirect_symbol
) (info
, ht
, hi
);
1745 /* See if the new flags lead us to realize that the symbol must
1751 if (! info
->executable
1758 if (hi
->ref_regular
)
1764 /* We also need to define an indirection from the nondefault version
1768 len
= strlen (name
);
1769 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, len
);
1770 if (shortname
== NULL
)
1772 memcpy (shortname
, name
, shortlen
);
1773 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1775 /* Once again, merge with any existing symbol. */
1776 type_change_ok
= FALSE
;
1777 size_change_ok
= FALSE
;
1779 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1780 NULL
, NULL
, &hi
, &skip
, &override
,
1781 &type_change_ok
, &size_change_ok
))
1789 /* Here SHORTNAME is a versioned name, so we don't expect to see
1790 the type of override we do in the case above unless it is
1791 overridden by a versioned definition. */
1792 if (hi
->root
.type
!= bfd_link_hash_defined
1793 && hi
->root
.type
!= bfd_link_hash_defweak
)
1794 (*_bfd_error_handler
)
1795 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1801 if (! (_bfd_generic_link_add_one_symbol
1802 (info
, abfd
, shortname
, BSF_INDIRECT
,
1803 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
1805 hi
= (struct elf_link_hash_entry
*) bh
;
1807 /* If there is a duplicate definition somewhere, then HI may not
1808 point to an indirect symbol. We will have reported an error
1809 to the user in that case. */
1811 if (hi
->root
.type
== bfd_link_hash_indirect
)
1813 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
1815 /* See if the new flags lead us to realize that the symbol
1821 if (! info
->executable
1827 if (hi
->ref_regular
)
1837 /* This routine is used to export all defined symbols into the dynamic
1838 symbol table. It is called via elf_link_hash_traverse. */
1841 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
1843 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1845 /* Ignore indirect symbols. These are added by the versioning code. */
1846 if (h
->root
.type
== bfd_link_hash_indirect
)
1849 /* Ignore this if we won't export it. */
1850 if (!eif
->info
->export_dynamic
&& !h
->dynamic
)
1853 if (h
->dynindx
== -1
1854 && (h
->def_regular
|| h
->ref_regular
)
1855 && ! bfd_hide_sym_by_version (eif
->info
->version_info
,
1856 h
->root
.root
.string
))
1858 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1868 /* Look through the symbols which are defined in other shared
1869 libraries and referenced here. Update the list of version
1870 dependencies. This will be put into the .gnu.version_r section.
1871 This function is called via elf_link_hash_traverse. */
1874 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1877 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
1878 Elf_Internal_Verneed
*t
;
1879 Elf_Internal_Vernaux
*a
;
1882 /* We only care about symbols defined in shared objects with version
1887 || h
->verinfo
.verdef
== NULL
)
1890 /* See if we already know about this version. */
1891 for (t
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1895 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1898 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1899 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1905 /* This is a new version. Add it to tree we are building. */
1910 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1913 rinfo
->failed
= TRUE
;
1917 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1918 t
->vn_nextref
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1919 elf_tdata (rinfo
->info
->output_bfd
)->verref
= t
;
1923 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1926 rinfo
->failed
= TRUE
;
1930 /* Note that we are copying a string pointer here, and testing it
1931 above. If bfd_elf_string_from_elf_section is ever changed to
1932 discard the string data when low in memory, this will have to be
1934 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1936 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1937 a
->vna_nextptr
= t
->vn_auxptr
;
1939 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1942 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1949 /* Figure out appropriate versions for all the symbols. We may not
1950 have the version number script until we have read all of the input
1951 files, so until that point we don't know which symbols should be
1952 local. This function is called via elf_link_hash_traverse. */
1955 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1957 struct elf_info_failed
*sinfo
;
1958 struct bfd_link_info
*info
;
1959 const struct elf_backend_data
*bed
;
1960 struct elf_info_failed eif
;
1964 sinfo
= (struct elf_info_failed
*) data
;
1967 /* Fix the symbol flags. */
1970 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1973 sinfo
->failed
= TRUE
;
1977 /* We only need version numbers for symbols defined in regular
1979 if (!h
->def_regular
)
1982 bed
= get_elf_backend_data (info
->output_bfd
);
1983 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1984 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1986 struct bfd_elf_version_tree
*t
;
1991 /* There are two consecutive ELF_VER_CHR characters if this is
1992 not a hidden symbol. */
1994 if (*p
== ELF_VER_CHR
)
2000 /* If there is no version string, we can just return out. */
2008 /* Look for the version. If we find it, it is no longer weak. */
2009 for (t
= sinfo
->info
->version_info
; t
!= NULL
; t
= t
->next
)
2011 if (strcmp (t
->name
, p
) == 0)
2015 struct bfd_elf_version_expr
*d
;
2017 len
= p
- h
->root
.root
.string
;
2018 alc
= (char *) bfd_malloc (len
);
2021 sinfo
->failed
= TRUE
;
2024 memcpy (alc
, h
->root
.root
.string
, len
- 1);
2025 alc
[len
- 1] = '\0';
2026 if (alc
[len
- 2] == ELF_VER_CHR
)
2027 alc
[len
- 2] = '\0';
2029 h
->verinfo
.vertree
= t
;
2033 if (t
->globals
.list
!= NULL
)
2034 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
2036 /* See if there is anything to force this symbol to
2038 if (d
== NULL
&& t
->locals
.list
!= NULL
)
2040 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
2043 && ! info
->export_dynamic
)
2044 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2052 /* If we are building an application, we need to create a
2053 version node for this version. */
2054 if (t
== NULL
&& info
->executable
)
2056 struct bfd_elf_version_tree
**pp
;
2059 /* If we aren't going to export this symbol, we don't need
2060 to worry about it. */
2061 if (h
->dynindx
== -1)
2065 t
= (struct bfd_elf_version_tree
*) bfd_zalloc (info
->output_bfd
, amt
);
2068 sinfo
->failed
= TRUE
;
2073 t
->name_indx
= (unsigned int) -1;
2077 /* Don't count anonymous version tag. */
2078 if (sinfo
->info
->version_info
!= NULL
2079 && sinfo
->info
->version_info
->vernum
== 0)
2081 for (pp
= &sinfo
->info
->version_info
;
2085 t
->vernum
= version_index
;
2089 h
->verinfo
.vertree
= t
;
2093 /* We could not find the version for a symbol when
2094 generating a shared archive. Return an error. */
2095 (*_bfd_error_handler
)
2096 (_("%B: version node not found for symbol %s"),
2097 info
->output_bfd
, h
->root
.root
.string
);
2098 bfd_set_error (bfd_error_bad_value
);
2099 sinfo
->failed
= TRUE
;
2107 /* If we don't have a version for this symbol, see if we can find
2109 if (h
->verinfo
.vertree
== NULL
&& sinfo
->info
->version_info
!= NULL
)
2114 = bfd_find_version_for_sym (sinfo
->info
->version_info
,
2115 h
->root
.root
.string
, &hide
);
2116 if (h
->verinfo
.vertree
!= NULL
&& hide
)
2117 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2123 /* Read and swap the relocs from the section indicated by SHDR. This
2124 may be either a REL or a RELA section. The relocations are
2125 translated into RELA relocations and stored in INTERNAL_RELOCS,
2126 which should have already been allocated to contain enough space.
2127 The EXTERNAL_RELOCS are a buffer where the external form of the
2128 relocations should be stored.
2130 Returns FALSE if something goes wrong. */
2133 elf_link_read_relocs_from_section (bfd
*abfd
,
2135 Elf_Internal_Shdr
*shdr
,
2136 void *external_relocs
,
2137 Elf_Internal_Rela
*internal_relocs
)
2139 const struct elf_backend_data
*bed
;
2140 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2141 const bfd_byte
*erela
;
2142 const bfd_byte
*erelaend
;
2143 Elf_Internal_Rela
*irela
;
2144 Elf_Internal_Shdr
*symtab_hdr
;
2147 /* Position ourselves at the start of the section. */
2148 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2151 /* Read the relocations. */
2152 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
2155 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2156 nsyms
= NUM_SHDR_ENTRIES (symtab_hdr
);
2158 bed
= get_elf_backend_data (abfd
);
2160 /* Convert the external relocations to the internal format. */
2161 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2162 swap_in
= bed
->s
->swap_reloc_in
;
2163 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2164 swap_in
= bed
->s
->swap_reloca_in
;
2167 bfd_set_error (bfd_error_wrong_format
);
2171 erela
= (const bfd_byte
*) external_relocs
;
2172 erelaend
= erela
+ shdr
->sh_size
;
2173 irela
= internal_relocs
;
2174 while (erela
< erelaend
)
2178 (*swap_in
) (abfd
, erela
, irela
);
2179 r_symndx
= ELF32_R_SYM (irela
->r_info
);
2180 if (bed
->s
->arch_size
== 64)
2184 if ((size_t) r_symndx
>= nsyms
)
2186 (*_bfd_error_handler
)
2187 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2188 " for offset 0x%lx in section `%A'"),
2190 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2191 bfd_set_error (bfd_error_bad_value
);
2195 else if (r_symndx
!= STN_UNDEF
)
2197 (*_bfd_error_handler
)
2198 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2199 " when the object file has no symbol table"),
2201 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2202 bfd_set_error (bfd_error_bad_value
);
2205 irela
+= bed
->s
->int_rels_per_ext_rel
;
2206 erela
+= shdr
->sh_entsize
;
2212 /* Read and swap the relocs for a section O. They may have been
2213 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2214 not NULL, they are used as buffers to read into. They are known to
2215 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2216 the return value is allocated using either malloc or bfd_alloc,
2217 according to the KEEP_MEMORY argument. If O has two relocation
2218 sections (both REL and RELA relocations), then the REL_HDR
2219 relocations will appear first in INTERNAL_RELOCS, followed by the
2220 RELA_HDR relocations. */
2223 _bfd_elf_link_read_relocs (bfd
*abfd
,
2225 void *external_relocs
,
2226 Elf_Internal_Rela
*internal_relocs
,
2227 bfd_boolean keep_memory
)
2229 void *alloc1
= NULL
;
2230 Elf_Internal_Rela
*alloc2
= NULL
;
2231 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2232 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
2233 Elf_Internal_Rela
*internal_rela_relocs
;
2235 if (esdo
->relocs
!= NULL
)
2236 return esdo
->relocs
;
2238 if (o
->reloc_count
== 0)
2241 if (internal_relocs
== NULL
)
2245 size
= o
->reloc_count
;
2246 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
2248 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2250 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2251 if (internal_relocs
== NULL
)
2255 if (external_relocs
== NULL
)
2257 bfd_size_type size
= 0;
2260 size
+= esdo
->rel
.hdr
->sh_size
;
2262 size
+= esdo
->rela
.hdr
->sh_size
;
2264 alloc1
= bfd_malloc (size
);
2267 external_relocs
= alloc1
;
2270 internal_rela_relocs
= internal_relocs
;
2273 if (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rel
.hdr
,
2277 external_relocs
= (((bfd_byte
*) external_relocs
)
2278 + esdo
->rel
.hdr
->sh_size
);
2279 internal_rela_relocs
+= (NUM_SHDR_ENTRIES (esdo
->rel
.hdr
)
2280 * bed
->s
->int_rels_per_ext_rel
);
2284 && (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rela
.hdr
,
2286 internal_rela_relocs
)))
2289 /* Cache the results for next time, if we can. */
2291 esdo
->relocs
= internal_relocs
;
2296 /* Don't free alloc2, since if it was allocated we are passing it
2297 back (under the name of internal_relocs). */
2299 return internal_relocs
;
2307 bfd_release (abfd
, alloc2
);
2314 /* Compute the size of, and allocate space for, REL_HDR which is the
2315 section header for a section containing relocations for O. */
2318 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2319 struct bfd_elf_section_reloc_data
*reldata
)
2321 Elf_Internal_Shdr
*rel_hdr
= reldata
->hdr
;
2323 /* That allows us to calculate the size of the section. */
2324 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reldata
->count
;
2326 /* The contents field must last into write_object_contents, so we
2327 allocate it with bfd_alloc rather than malloc. Also since we
2328 cannot be sure that the contents will actually be filled in,
2329 we zero the allocated space. */
2330 rel_hdr
->contents
= (unsigned char *) bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2331 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2334 if (reldata
->hashes
== NULL
&& reldata
->count
)
2336 struct elf_link_hash_entry
**p
;
2338 p
= (struct elf_link_hash_entry
**)
2339 bfd_zmalloc (reldata
->count
* sizeof (struct elf_link_hash_entry
*));
2343 reldata
->hashes
= p
;
2349 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2350 originated from the section given by INPUT_REL_HDR) to the
2354 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2355 asection
*input_section
,
2356 Elf_Internal_Shdr
*input_rel_hdr
,
2357 Elf_Internal_Rela
*internal_relocs
,
2358 struct elf_link_hash_entry
**rel_hash
2361 Elf_Internal_Rela
*irela
;
2362 Elf_Internal_Rela
*irelaend
;
2364 struct bfd_elf_section_reloc_data
*output_reldata
;
2365 asection
*output_section
;
2366 const struct elf_backend_data
*bed
;
2367 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2368 struct bfd_elf_section_data
*esdo
;
2370 output_section
= input_section
->output_section
;
2372 bed
= get_elf_backend_data (output_bfd
);
2373 esdo
= elf_section_data (output_section
);
2374 if (esdo
->rel
.hdr
&& esdo
->rel
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2376 output_reldata
= &esdo
->rel
;
2377 swap_out
= bed
->s
->swap_reloc_out
;
2379 else if (esdo
->rela
.hdr
2380 && esdo
->rela
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2382 output_reldata
= &esdo
->rela
;
2383 swap_out
= bed
->s
->swap_reloca_out
;
2387 (*_bfd_error_handler
)
2388 (_("%B: relocation size mismatch in %B section %A"),
2389 output_bfd
, input_section
->owner
, input_section
);
2390 bfd_set_error (bfd_error_wrong_format
);
2394 erel
= output_reldata
->hdr
->contents
;
2395 erel
+= output_reldata
->count
* input_rel_hdr
->sh_entsize
;
2396 irela
= internal_relocs
;
2397 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2398 * bed
->s
->int_rels_per_ext_rel
);
2399 while (irela
< irelaend
)
2401 (*swap_out
) (output_bfd
, irela
, erel
);
2402 irela
+= bed
->s
->int_rels_per_ext_rel
;
2403 erel
+= input_rel_hdr
->sh_entsize
;
2406 /* Bump the counter, so that we know where to add the next set of
2408 output_reldata
->count
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2413 /* Make weak undefined symbols in PIE dynamic. */
2416 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info
*info
,
2417 struct elf_link_hash_entry
*h
)
2421 && h
->root
.type
== bfd_link_hash_undefweak
)
2422 return bfd_elf_link_record_dynamic_symbol (info
, h
);
2427 /* Fix up the flags for a symbol. This handles various cases which
2428 can only be fixed after all the input files are seen. This is
2429 currently called by both adjust_dynamic_symbol and
2430 assign_sym_version, which is unnecessary but perhaps more robust in
2431 the face of future changes. */
2434 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2435 struct elf_info_failed
*eif
)
2437 const struct elf_backend_data
*bed
;
2439 /* If this symbol was mentioned in a non-ELF file, try to set
2440 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2441 permit a non-ELF file to correctly refer to a symbol defined in
2442 an ELF dynamic object. */
2445 while (h
->root
.type
== bfd_link_hash_indirect
)
2446 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2448 if (h
->root
.type
!= bfd_link_hash_defined
2449 && h
->root
.type
!= bfd_link_hash_defweak
)
2452 h
->ref_regular_nonweak
= 1;
2456 if (h
->root
.u
.def
.section
->owner
!= NULL
2457 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2458 == bfd_target_elf_flavour
))
2461 h
->ref_regular_nonweak
= 1;
2467 if (h
->dynindx
== -1
2471 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2480 /* Unfortunately, NON_ELF is only correct if the symbol
2481 was first seen in a non-ELF file. Fortunately, if the symbol
2482 was first seen in an ELF file, we're probably OK unless the
2483 symbol was defined in a non-ELF file. Catch that case here.
2484 FIXME: We're still in trouble if the symbol was first seen in
2485 a dynamic object, and then later in a non-ELF regular object. */
2486 if ((h
->root
.type
== bfd_link_hash_defined
2487 || h
->root
.type
== bfd_link_hash_defweak
)
2489 && (h
->root
.u
.def
.section
->owner
!= NULL
2490 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2491 != bfd_target_elf_flavour
)
2492 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2493 && !h
->def_dynamic
)))
2497 /* Backend specific symbol fixup. */
2498 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2499 if (bed
->elf_backend_fixup_symbol
2500 && !(*bed
->elf_backend_fixup_symbol
) (eif
->info
, h
))
2503 /* If this is a final link, and the symbol was defined as a common
2504 symbol in a regular object file, and there was no definition in
2505 any dynamic object, then the linker will have allocated space for
2506 the symbol in a common section but the DEF_REGULAR
2507 flag will not have been set. */
2508 if (h
->root
.type
== bfd_link_hash_defined
2512 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2515 /* If -Bsymbolic was used (which means to bind references to global
2516 symbols to the definition within the shared object), and this
2517 symbol was defined in a regular object, then it actually doesn't
2518 need a PLT entry. Likewise, if the symbol has non-default
2519 visibility. If the symbol has hidden or internal visibility, we
2520 will force it local. */
2522 && eif
->info
->shared
2523 && is_elf_hash_table (eif
->info
->hash
)
2524 && (SYMBOLIC_BIND (eif
->info
, h
)
2525 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2528 bfd_boolean force_local
;
2530 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2531 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2532 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2535 /* If a weak undefined symbol has non-default visibility, we also
2536 hide it from the dynamic linker. */
2537 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2538 && h
->root
.type
== bfd_link_hash_undefweak
)
2539 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2541 /* If this is a weak defined symbol in a dynamic object, and we know
2542 the real definition in the dynamic object, copy interesting flags
2543 over to the real definition. */
2544 if (h
->u
.weakdef
!= NULL
)
2546 /* If the real definition is defined by a regular object file,
2547 don't do anything special. See the longer description in
2548 _bfd_elf_adjust_dynamic_symbol, below. */
2549 if (h
->u
.weakdef
->def_regular
)
2550 h
->u
.weakdef
= NULL
;
2553 struct elf_link_hash_entry
*weakdef
= h
->u
.weakdef
;
2555 while (h
->root
.type
== bfd_link_hash_indirect
)
2556 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2558 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2559 || h
->root
.type
== bfd_link_hash_defweak
);
2560 BFD_ASSERT (weakdef
->def_dynamic
);
2561 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2562 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2563 (*bed
->elf_backend_copy_indirect_symbol
) (eif
->info
, weakdef
, h
);
2570 /* Make the backend pick a good value for a dynamic symbol. This is
2571 called via elf_link_hash_traverse, and also calls itself
2575 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2577 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2579 const struct elf_backend_data
*bed
;
2581 if (! is_elf_hash_table (eif
->info
->hash
))
2584 /* Ignore indirect symbols. These are added by the versioning code. */
2585 if (h
->root
.type
== bfd_link_hash_indirect
)
2588 /* Fix the symbol flags. */
2589 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2592 /* If this symbol does not require a PLT entry, and it is not
2593 defined by a dynamic object, or is not referenced by a regular
2594 object, ignore it. We do have to handle a weak defined symbol,
2595 even if no regular object refers to it, if we decided to add it
2596 to the dynamic symbol table. FIXME: Do we normally need to worry
2597 about symbols which are defined by one dynamic object and
2598 referenced by another one? */
2600 && h
->type
!= STT_GNU_IFUNC
2604 && (h
->u
.weakdef
== NULL
|| h
->u
.weakdef
->dynindx
== -1))))
2606 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
2610 /* If we've already adjusted this symbol, don't do it again. This
2611 can happen via a recursive call. */
2612 if (h
->dynamic_adjusted
)
2615 /* Don't look at this symbol again. Note that we must set this
2616 after checking the above conditions, because we may look at a
2617 symbol once, decide not to do anything, and then get called
2618 recursively later after REF_REGULAR is set below. */
2619 h
->dynamic_adjusted
= 1;
2621 /* If this is a weak definition, and we know a real definition, and
2622 the real symbol is not itself defined by a regular object file,
2623 then get a good value for the real definition. We handle the
2624 real symbol first, for the convenience of the backend routine.
2626 Note that there is a confusing case here. If the real definition
2627 is defined by a regular object file, we don't get the real symbol
2628 from the dynamic object, but we do get the weak symbol. If the
2629 processor backend uses a COPY reloc, then if some routine in the
2630 dynamic object changes the real symbol, we will not see that
2631 change in the corresponding weak symbol. This is the way other
2632 ELF linkers work as well, and seems to be a result of the shared
2635 I will clarify this issue. Most SVR4 shared libraries define the
2636 variable _timezone and define timezone as a weak synonym. The
2637 tzset call changes _timezone. If you write
2638 extern int timezone;
2640 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2641 you might expect that, since timezone is a synonym for _timezone,
2642 the same number will print both times. However, if the processor
2643 backend uses a COPY reloc, then actually timezone will be copied
2644 into your process image, and, since you define _timezone
2645 yourself, _timezone will not. Thus timezone and _timezone will
2646 wind up at different memory locations. The tzset call will set
2647 _timezone, leaving timezone unchanged. */
2649 if (h
->u
.weakdef
!= NULL
)
2651 /* If we get to this point, there is an implicit reference to
2652 H->U.WEAKDEF by a regular object file via the weak symbol H. */
2653 h
->u
.weakdef
->ref_regular
= 1;
2655 /* Ensure that the backend adjust_dynamic_symbol function sees
2656 H->U.WEAKDEF before H by recursively calling ourselves. */
2657 if (! _bfd_elf_adjust_dynamic_symbol (h
->u
.weakdef
, eif
))
2661 /* If a symbol has no type and no size and does not require a PLT
2662 entry, then we are probably about to do the wrong thing here: we
2663 are probably going to create a COPY reloc for an empty object.
2664 This case can arise when a shared object is built with assembly
2665 code, and the assembly code fails to set the symbol type. */
2667 && h
->type
== STT_NOTYPE
2669 (*_bfd_error_handler
)
2670 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2671 h
->root
.root
.string
);
2673 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2674 bed
= get_elf_backend_data (dynobj
);
2676 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2685 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2689 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry
*h
,
2692 unsigned int power_of_two
;
2694 asection
*sec
= h
->root
.u
.def
.section
;
2696 /* The section aligment of definition is the maximum alignment
2697 requirement of symbols defined in the section. Since we don't
2698 know the symbol alignment requirement, we start with the
2699 maximum alignment and check low bits of the symbol address
2700 for the minimum alignment. */
2701 power_of_two
= bfd_get_section_alignment (sec
->owner
, sec
);
2702 mask
= ((bfd_vma
) 1 << power_of_two
) - 1;
2703 while ((h
->root
.u
.def
.value
& mask
) != 0)
2709 if (power_of_two
> bfd_get_section_alignment (dynbss
->owner
,
2712 /* Adjust the section alignment if needed. */
2713 if (! bfd_set_section_alignment (dynbss
->owner
, dynbss
,
2718 /* We make sure that the symbol will be aligned properly. */
2719 dynbss
->size
= BFD_ALIGN (dynbss
->size
, mask
+ 1);
2721 /* Define the symbol as being at this point in DYNBSS. */
2722 h
->root
.u
.def
.section
= dynbss
;
2723 h
->root
.u
.def
.value
= dynbss
->size
;
2725 /* Increment the size of DYNBSS to make room for the symbol. */
2726 dynbss
->size
+= h
->size
;
2731 /* Adjust all external symbols pointing into SEC_MERGE sections
2732 to reflect the object merging within the sections. */
2735 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2739 if ((h
->root
.type
== bfd_link_hash_defined
2740 || h
->root
.type
== bfd_link_hash_defweak
)
2741 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2742 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
2744 bfd
*output_bfd
= (bfd
*) data
;
2746 h
->root
.u
.def
.value
=
2747 _bfd_merged_section_offset (output_bfd
,
2748 &h
->root
.u
.def
.section
,
2749 elf_section_data (sec
)->sec_info
,
2750 h
->root
.u
.def
.value
);
2756 /* Returns false if the symbol referred to by H should be considered
2757 to resolve local to the current module, and true if it should be
2758 considered to bind dynamically. */
2761 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2762 struct bfd_link_info
*info
,
2763 bfd_boolean not_local_protected
)
2765 bfd_boolean binding_stays_local_p
;
2766 const struct elf_backend_data
*bed
;
2767 struct elf_link_hash_table
*hash_table
;
2772 while (h
->root
.type
== bfd_link_hash_indirect
2773 || h
->root
.type
== bfd_link_hash_warning
)
2774 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2776 /* If it was forced local, then clearly it's not dynamic. */
2777 if (h
->dynindx
== -1)
2779 if (h
->forced_local
)
2782 /* Identify the cases where name binding rules say that a
2783 visible symbol resolves locally. */
2784 binding_stays_local_p
= info
->executable
|| SYMBOLIC_BIND (info
, h
);
2786 switch (ELF_ST_VISIBILITY (h
->other
))
2793 hash_table
= elf_hash_table (info
);
2794 if (!is_elf_hash_table (hash_table
))
2797 bed
= get_elf_backend_data (hash_table
->dynobj
);
2799 /* Proper resolution for function pointer equality may require
2800 that these symbols perhaps be resolved dynamically, even though
2801 we should be resolving them to the current module. */
2802 if (!not_local_protected
|| !bed
->is_function_type (h
->type
))
2803 binding_stays_local_p
= TRUE
;
2810 /* If it isn't defined locally, then clearly it's dynamic. */
2811 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
2814 /* Otherwise, the symbol is dynamic if binding rules don't tell
2815 us that it remains local. */
2816 return !binding_stays_local_p
;
2819 /* Return true if the symbol referred to by H should be considered
2820 to resolve local to the current module, and false otherwise. Differs
2821 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2822 undefined symbols. The two functions are virtually identical except
2823 for the place where forced_local and dynindx == -1 are tested. If
2824 either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2825 the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2826 the symbol is local only for defined symbols.
2827 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2828 !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2829 treatment of undefined weak symbols. For those that do not make
2830 undefined weak symbols dynamic, both functions may return false. */
2833 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2834 struct bfd_link_info
*info
,
2835 bfd_boolean local_protected
)
2837 const struct elf_backend_data
*bed
;
2838 struct elf_link_hash_table
*hash_table
;
2840 /* If it's a local sym, of course we resolve locally. */
2844 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
2845 if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
2846 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
2849 /* Common symbols that become definitions don't get the DEF_REGULAR
2850 flag set, so test it first, and don't bail out. */
2851 if (ELF_COMMON_DEF_P (h
))
2853 /* If we don't have a definition in a regular file, then we can't
2854 resolve locally. The sym is either undefined or dynamic. */
2855 else if (!h
->def_regular
)
2858 /* Forced local symbols resolve locally. */
2859 if (h
->forced_local
)
2862 /* As do non-dynamic symbols. */
2863 if (h
->dynindx
== -1)
2866 /* At this point, we know the symbol is defined and dynamic. In an
2867 executable it must resolve locally, likewise when building symbolic
2868 shared libraries. */
2869 if (info
->executable
|| SYMBOLIC_BIND (info
, h
))
2872 /* Now deal with defined dynamic symbols in shared libraries. Ones
2873 with default visibility might not resolve locally. */
2874 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2877 hash_table
= elf_hash_table (info
);
2878 if (!is_elf_hash_table (hash_table
))
2881 bed
= get_elf_backend_data (hash_table
->dynobj
);
2883 /* STV_PROTECTED non-function symbols are local. */
2884 if (!bed
->is_function_type (h
->type
))
2887 /* Function pointer equality tests may require that STV_PROTECTED
2888 symbols be treated as dynamic symbols. If the address of a
2889 function not defined in an executable is set to that function's
2890 plt entry in the executable, then the address of the function in
2891 a shared library must also be the plt entry in the executable. */
2892 return local_protected
;
2895 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2896 aligned. Returns the first TLS output section. */
2898 struct bfd_section
*
2899 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
2901 struct bfd_section
*sec
, *tls
;
2902 unsigned int align
= 0;
2904 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2905 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
2909 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
2910 if (sec
->alignment_power
> align
)
2911 align
= sec
->alignment_power
;
2913 elf_hash_table (info
)->tls_sec
= tls
;
2915 /* Ensure the alignment of the first section is the largest alignment,
2916 so that the tls segment starts aligned. */
2918 tls
->alignment_power
= align
;
2923 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2925 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
2926 Elf_Internal_Sym
*sym
)
2928 const struct elf_backend_data
*bed
;
2930 /* Local symbols do not count, but target specific ones might. */
2931 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
2932 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
2935 bed
= get_elf_backend_data (abfd
);
2936 /* Function symbols do not count. */
2937 if (bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)))
2940 /* If the section is undefined, then so is the symbol. */
2941 if (sym
->st_shndx
== SHN_UNDEF
)
2944 /* If the symbol is defined in the common section, then
2945 it is a common definition and so does not count. */
2946 if (bed
->common_definition (sym
))
2949 /* If the symbol is in a target specific section then we
2950 must rely upon the backend to tell us what it is. */
2951 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
2952 /* FIXME - this function is not coded yet:
2954 return _bfd_is_global_symbol_definition (abfd, sym);
2956 Instead for now assume that the definition is not global,
2957 Even if this is wrong, at least the linker will behave
2958 in the same way that it used to do. */
2964 /* Search the symbol table of the archive element of the archive ABFD
2965 whose archive map contains a mention of SYMDEF, and determine if
2966 the symbol is defined in this element. */
2968 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
2970 Elf_Internal_Shdr
* hdr
;
2971 bfd_size_type symcount
;
2972 bfd_size_type extsymcount
;
2973 bfd_size_type extsymoff
;
2974 Elf_Internal_Sym
*isymbuf
;
2975 Elf_Internal_Sym
*isym
;
2976 Elf_Internal_Sym
*isymend
;
2979 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
2983 if (! bfd_check_format (abfd
, bfd_object
))
2986 /* If we have already included the element containing this symbol in the
2987 link then we do not need to include it again. Just claim that any symbol
2988 it contains is not a definition, so that our caller will not decide to
2989 (re)include this element. */
2990 if (abfd
->archive_pass
)
2993 /* Select the appropriate symbol table. */
2994 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
2995 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2997 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2999 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3001 /* The sh_info field of the symtab header tells us where the
3002 external symbols start. We don't care about the local symbols. */
3003 if (elf_bad_symtab (abfd
))
3005 extsymcount
= symcount
;
3010 extsymcount
= symcount
- hdr
->sh_info
;
3011 extsymoff
= hdr
->sh_info
;
3014 if (extsymcount
== 0)
3017 /* Read in the symbol table. */
3018 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3020 if (isymbuf
== NULL
)
3023 /* Scan the symbol table looking for SYMDEF. */
3025 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
3029 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3034 if (strcmp (name
, symdef
->name
) == 0)
3036 result
= is_global_data_symbol_definition (abfd
, isym
);
3046 /* Add an entry to the .dynamic table. */
3049 _bfd_elf_add_dynamic_entry (struct bfd_link_info
*info
,
3053 struct elf_link_hash_table
*hash_table
;
3054 const struct elf_backend_data
*bed
;
3056 bfd_size_type newsize
;
3057 bfd_byte
*newcontents
;
3058 Elf_Internal_Dyn dyn
;
3060 hash_table
= elf_hash_table (info
);
3061 if (! is_elf_hash_table (hash_table
))
3064 bed
= get_elf_backend_data (hash_table
->dynobj
);
3065 s
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3066 BFD_ASSERT (s
!= NULL
);
3068 newsize
= s
->size
+ bed
->s
->sizeof_dyn
;
3069 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
3070 if (newcontents
== NULL
)
3074 dyn
.d_un
.d_val
= val
;
3075 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
, newcontents
+ s
->size
);
3078 s
->contents
= newcontents
;
3083 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3084 otherwise just check whether one already exists. Returns -1 on error,
3085 1 if a DT_NEEDED tag already exists, and 0 on success. */
3088 elf_add_dt_needed_tag (bfd
*abfd
,
3089 struct bfd_link_info
*info
,
3093 struct elf_link_hash_table
*hash_table
;
3094 bfd_size_type strindex
;
3096 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
3099 hash_table
= elf_hash_table (info
);
3100 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, soname
, FALSE
);
3101 if (strindex
== (bfd_size_type
) -1)
3104 if (_bfd_elf_strtab_refcount (hash_table
->dynstr
, strindex
) != 1)
3107 const struct elf_backend_data
*bed
;
3110 bed
= get_elf_backend_data (hash_table
->dynobj
);
3111 sdyn
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3113 for (extdyn
= sdyn
->contents
;
3114 extdyn
< sdyn
->contents
+ sdyn
->size
;
3115 extdyn
+= bed
->s
->sizeof_dyn
)
3117 Elf_Internal_Dyn dyn
;
3119 bed
->s
->swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
3120 if (dyn
.d_tag
== DT_NEEDED
3121 && dyn
.d_un
.d_val
== strindex
)
3123 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3131 if (!_bfd_elf_link_create_dynamic_sections (hash_table
->dynobj
, info
))
3134 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
3138 /* We were just checking for existence of the tag. */
3139 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3145 on_needed_list (const char *soname
, struct bfd_link_needed_list
*needed
)
3147 for (; needed
!= NULL
; needed
= needed
->next
)
3148 if (strcmp (soname
, needed
->name
) == 0)
3154 /* Sort symbol by value, section, and size. */
3156 elf_sort_symbol (const void *arg1
, const void *arg2
)
3158 const struct elf_link_hash_entry
*h1
;
3159 const struct elf_link_hash_entry
*h2
;
3160 bfd_signed_vma vdiff
;
3162 h1
= *(const struct elf_link_hash_entry
**) arg1
;
3163 h2
= *(const struct elf_link_hash_entry
**) arg2
;
3164 vdiff
= h1
->root
.u
.def
.value
- h2
->root
.u
.def
.value
;
3166 return vdiff
> 0 ? 1 : -1;
3169 long sdiff
= h1
->root
.u
.def
.section
->id
- h2
->root
.u
.def
.section
->id
;
3171 return sdiff
> 0 ? 1 : -1;
3173 vdiff
= h1
->size
- h2
->size
;
3174 return vdiff
== 0 ? 0 : vdiff
> 0 ? 1 : -1;
3177 /* This function is used to adjust offsets into .dynstr for
3178 dynamic symbols. This is called via elf_link_hash_traverse. */
3181 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
3183 struct elf_strtab_hash
*dynstr
= (struct elf_strtab_hash
*) data
;
3185 if (h
->dynindx
!= -1)
3186 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
3190 /* Assign string offsets in .dynstr, update all structures referencing
3194 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
3196 struct elf_link_hash_table
*hash_table
= elf_hash_table (info
);
3197 struct elf_link_local_dynamic_entry
*entry
;
3198 struct elf_strtab_hash
*dynstr
= hash_table
->dynstr
;
3199 bfd
*dynobj
= hash_table
->dynobj
;
3202 const struct elf_backend_data
*bed
;
3205 _bfd_elf_strtab_finalize (dynstr
);
3206 size
= _bfd_elf_strtab_size (dynstr
);
3208 bed
= get_elf_backend_data (dynobj
);
3209 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3210 BFD_ASSERT (sdyn
!= NULL
);
3212 /* Update all .dynamic entries referencing .dynstr strings. */
3213 for (extdyn
= sdyn
->contents
;
3214 extdyn
< sdyn
->contents
+ sdyn
->size
;
3215 extdyn
+= bed
->s
->sizeof_dyn
)
3217 Elf_Internal_Dyn dyn
;
3219 bed
->s
->swap_dyn_in (dynobj
, extdyn
, &dyn
);
3223 dyn
.d_un
.d_val
= size
;
3233 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
3238 bed
->s
->swap_dyn_out (dynobj
, &dyn
, extdyn
);
3241 /* Now update local dynamic symbols. */
3242 for (entry
= hash_table
->dynlocal
; entry
; entry
= entry
->next
)
3243 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
3244 entry
->isym
.st_name
);
3246 /* And the rest of dynamic symbols. */
3247 elf_link_hash_traverse (hash_table
, elf_adjust_dynstr_offsets
, dynstr
);
3249 /* Adjust version definitions. */
3250 if (elf_tdata (output_bfd
)->cverdefs
)
3255 Elf_Internal_Verdef def
;
3256 Elf_Internal_Verdaux defaux
;
3258 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
3262 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
3264 p
+= sizeof (Elf_External_Verdef
);
3265 if (def
.vd_aux
!= sizeof (Elf_External_Verdef
))
3267 for (i
= 0; i
< def
.vd_cnt
; ++i
)
3269 _bfd_elf_swap_verdaux_in (output_bfd
,
3270 (Elf_External_Verdaux
*) p
, &defaux
);
3271 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
3273 _bfd_elf_swap_verdaux_out (output_bfd
,
3274 &defaux
, (Elf_External_Verdaux
*) p
);
3275 p
+= sizeof (Elf_External_Verdaux
);
3278 while (def
.vd_next
);
3281 /* Adjust version references. */
3282 if (elf_tdata (output_bfd
)->verref
)
3287 Elf_Internal_Verneed need
;
3288 Elf_Internal_Vernaux needaux
;
3290 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
3294 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
3296 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
3297 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
3298 (Elf_External_Verneed
*) p
);
3299 p
+= sizeof (Elf_External_Verneed
);
3300 for (i
= 0; i
< need
.vn_cnt
; ++i
)
3302 _bfd_elf_swap_vernaux_in (output_bfd
,
3303 (Elf_External_Vernaux
*) p
, &needaux
);
3304 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
3306 _bfd_elf_swap_vernaux_out (output_bfd
,
3308 (Elf_External_Vernaux
*) p
);
3309 p
+= sizeof (Elf_External_Vernaux
);
3312 while (need
.vn_next
);
3318 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3319 The default is to only match when the INPUT and OUTPUT are exactly
3323 _bfd_elf_default_relocs_compatible (const bfd_target
*input
,
3324 const bfd_target
*output
)
3326 return input
== output
;
3329 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3330 This version is used when different targets for the same architecture
3331 are virtually identical. */
3334 _bfd_elf_relocs_compatible (const bfd_target
*input
,
3335 const bfd_target
*output
)
3337 const struct elf_backend_data
*obed
, *ibed
;
3339 if (input
== output
)
3342 ibed
= xvec_get_elf_backend_data (input
);
3343 obed
= xvec_get_elf_backend_data (output
);
3345 if (ibed
->arch
!= obed
->arch
)
3348 /* If both backends are using this function, deem them compatible. */
3349 return ibed
->relocs_compatible
== obed
->relocs_compatible
;
3352 /* Add symbols from an ELF object file to the linker hash table. */
3355 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3357 Elf_Internal_Ehdr
*ehdr
;
3358 Elf_Internal_Shdr
*hdr
;
3359 bfd_size_type symcount
;
3360 bfd_size_type extsymcount
;
3361 bfd_size_type extsymoff
;
3362 struct elf_link_hash_entry
**sym_hash
;
3363 bfd_boolean dynamic
;
3364 Elf_External_Versym
*extversym
= NULL
;
3365 Elf_External_Versym
*ever
;
3366 struct elf_link_hash_entry
*weaks
;
3367 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
3368 bfd_size_type nondeflt_vers_cnt
= 0;
3369 Elf_Internal_Sym
*isymbuf
= NULL
;
3370 Elf_Internal_Sym
*isym
;
3371 Elf_Internal_Sym
*isymend
;
3372 const struct elf_backend_data
*bed
;
3373 bfd_boolean add_needed
;
3374 struct elf_link_hash_table
*htab
;
3376 void *alloc_mark
= NULL
;
3377 struct bfd_hash_entry
**old_table
= NULL
;
3378 unsigned int old_size
= 0;
3379 unsigned int old_count
= 0;
3380 void *old_tab
= NULL
;
3383 struct bfd_link_hash_entry
*old_undefs
= NULL
;
3384 struct bfd_link_hash_entry
*old_undefs_tail
= NULL
;
3385 long old_dynsymcount
= 0;
3386 bfd_size_type old_dynstr_size
= 0;
3388 size_t hashsize
= 0;
3390 htab
= elf_hash_table (info
);
3391 bed
= get_elf_backend_data (abfd
);
3393 if ((abfd
->flags
& DYNAMIC
) == 0)
3399 /* You can't use -r against a dynamic object. Also, there's no
3400 hope of using a dynamic object which does not exactly match
3401 the format of the output file. */
3402 if (info
->relocatable
3403 || !is_elf_hash_table (htab
)
3404 || info
->output_bfd
->xvec
!= abfd
->xvec
)
3406 if (info
->relocatable
)
3407 bfd_set_error (bfd_error_invalid_operation
);
3409 bfd_set_error (bfd_error_wrong_format
);
3414 ehdr
= elf_elfheader (abfd
);
3415 if (info
->warn_alternate_em
3416 && bed
->elf_machine_code
!= ehdr
->e_machine
3417 && ((bed
->elf_machine_alt1
!= 0
3418 && ehdr
->e_machine
== bed
->elf_machine_alt1
)
3419 || (bed
->elf_machine_alt2
!= 0
3420 && ehdr
->e_machine
== bed
->elf_machine_alt2
)))
3421 info
->callbacks
->einfo
3422 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3423 ehdr
->e_machine
, abfd
, bed
->elf_machine_code
);
3425 /* As a GNU extension, any input sections which are named
3426 .gnu.warning.SYMBOL are treated as warning symbols for the given
3427 symbol. This differs from .gnu.warning sections, which generate
3428 warnings when they are included in an output file. */
3429 /* PR 12761: Also generate this warning when building shared libraries. */
3430 if (info
->executable
|| info
->shared
)
3434 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3438 name
= bfd_get_section_name (abfd
, s
);
3439 if (CONST_STRNEQ (name
, ".gnu.warning."))
3444 name
+= sizeof ".gnu.warning." - 1;
3446 /* If this is a shared object, then look up the symbol
3447 in the hash table. If it is there, and it is already
3448 been defined, then we will not be using the entry
3449 from this shared object, so we don't need to warn.
3450 FIXME: If we see the definition in a regular object
3451 later on, we will warn, but we shouldn't. The only
3452 fix is to keep track of what warnings we are supposed
3453 to emit, and then handle them all at the end of the
3457 struct elf_link_hash_entry
*h
;
3459 h
= elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
3461 /* FIXME: What about bfd_link_hash_common? */
3463 && (h
->root
.type
== bfd_link_hash_defined
3464 || h
->root
.type
== bfd_link_hash_defweak
))
3466 /* We don't want to issue this warning. Clobber
3467 the section size so that the warning does not
3468 get copied into the output file. */
3475 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
3479 if (! bfd_get_section_contents (abfd
, s
, msg
, 0, sz
))
3484 if (! (_bfd_generic_link_add_one_symbol
3485 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
3486 FALSE
, bed
->collect
, NULL
)))
3489 if (! info
->relocatable
)
3491 /* Clobber the section size so that the warning does
3492 not get copied into the output file. */
3495 /* Also set SEC_EXCLUDE, so that symbols defined in
3496 the warning section don't get copied to the output. */
3497 s
->flags
|= SEC_EXCLUDE
;
3506 /* If we are creating a shared library, create all the dynamic
3507 sections immediately. We need to attach them to something,
3508 so we attach them to this BFD, provided it is the right
3509 format. FIXME: If there are no input BFD's of the same
3510 format as the output, we can't make a shared library. */
3512 && is_elf_hash_table (htab
)
3513 && info
->output_bfd
->xvec
== abfd
->xvec
3514 && !htab
->dynamic_sections_created
)
3516 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
3520 else if (!is_elf_hash_table (htab
))
3525 const char *soname
= NULL
;
3527 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
3530 /* ld --just-symbols and dynamic objects don't mix very well.
3531 ld shouldn't allow it. */
3532 if ((s
= abfd
->sections
) != NULL
3533 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
3536 /* If this dynamic lib was specified on the command line with
3537 --as-needed in effect, then we don't want to add a DT_NEEDED
3538 tag unless the lib is actually used. Similary for libs brought
3539 in by another lib's DT_NEEDED. When --no-add-needed is used
3540 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3541 any dynamic library in DT_NEEDED tags in the dynamic lib at
3543 add_needed
= (elf_dyn_lib_class (abfd
)
3544 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
3545 | DYN_NO_NEEDED
)) == 0;
3547 s
= bfd_get_section_by_name (abfd
, ".dynamic");
3552 unsigned int elfsec
;
3553 unsigned long shlink
;
3555 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
3562 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
3563 if (elfsec
== SHN_BAD
)
3564 goto error_free_dyn
;
3565 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
3567 for (extdyn
= dynbuf
;
3568 extdyn
< dynbuf
+ s
->size
;
3569 extdyn
+= bed
->s
->sizeof_dyn
)
3571 Elf_Internal_Dyn dyn
;
3573 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
3574 if (dyn
.d_tag
== DT_SONAME
)
3576 unsigned int tagv
= dyn
.d_un
.d_val
;
3577 soname
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3579 goto error_free_dyn
;
3581 if (dyn
.d_tag
== DT_NEEDED
)
3583 struct bfd_link_needed_list
*n
, **pn
;
3585 unsigned int tagv
= dyn
.d_un
.d_val
;
3587 amt
= sizeof (struct bfd_link_needed_list
);
3588 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3589 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3590 if (n
== NULL
|| fnm
== NULL
)
3591 goto error_free_dyn
;
3592 amt
= strlen (fnm
) + 1;
3593 anm
= (char *) bfd_alloc (abfd
, amt
);
3595 goto error_free_dyn
;
3596 memcpy (anm
, fnm
, amt
);
3600 for (pn
= &htab
->needed
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3604 if (dyn
.d_tag
== DT_RUNPATH
)
3606 struct bfd_link_needed_list
*n
, **pn
;
3608 unsigned int tagv
= dyn
.d_un
.d_val
;
3610 amt
= sizeof (struct bfd_link_needed_list
);
3611 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3612 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3613 if (n
== NULL
|| fnm
== NULL
)
3614 goto error_free_dyn
;
3615 amt
= strlen (fnm
) + 1;
3616 anm
= (char *) bfd_alloc (abfd
, amt
);
3618 goto error_free_dyn
;
3619 memcpy (anm
, fnm
, amt
);
3623 for (pn
= & runpath
;
3629 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3630 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
3632 struct bfd_link_needed_list
*n
, **pn
;
3634 unsigned int tagv
= dyn
.d_un
.d_val
;
3636 amt
= sizeof (struct bfd_link_needed_list
);
3637 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3638 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3639 if (n
== NULL
|| fnm
== NULL
)
3640 goto error_free_dyn
;
3641 amt
= strlen (fnm
) + 1;
3642 anm
= (char *) bfd_alloc (abfd
, amt
);
3644 goto error_free_dyn
;
3645 memcpy (anm
, fnm
, amt
);
3655 if (dyn
.d_tag
== DT_AUDIT
)
3657 unsigned int tagv
= dyn
.d_un
.d_val
;
3658 audit
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3665 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3666 frees all more recently bfd_alloc'd blocks as well. */
3672 struct bfd_link_needed_list
**pn
;
3673 for (pn
= &htab
->runpath
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3678 /* We do not want to include any of the sections in a dynamic
3679 object in the output file. We hack by simply clobbering the
3680 list of sections in the BFD. This could be handled more
3681 cleanly by, say, a new section flag; the existing
3682 SEC_NEVER_LOAD flag is not the one we want, because that one
3683 still implies that the section takes up space in the output
3685 bfd_section_list_clear (abfd
);
3687 /* Find the name to use in a DT_NEEDED entry that refers to this
3688 object. If the object has a DT_SONAME entry, we use it.
3689 Otherwise, if the generic linker stuck something in
3690 elf_dt_name, we use that. Otherwise, we just use the file
3692 if (soname
== NULL
|| *soname
== '\0')
3694 soname
= elf_dt_name (abfd
);
3695 if (soname
== NULL
|| *soname
== '\0')
3696 soname
= bfd_get_filename (abfd
);
3699 /* Save the SONAME because sometimes the linker emulation code
3700 will need to know it. */
3701 elf_dt_name (abfd
) = soname
;
3703 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
3707 /* If we have already included this dynamic object in the
3708 link, just ignore it. There is no reason to include a
3709 particular dynamic object more than once. */
3713 /* Save the DT_AUDIT entry for the linker emulation code. */
3714 elf_dt_audit (abfd
) = audit
;
3717 /* If this is a dynamic object, we always link against the .dynsym
3718 symbol table, not the .symtab symbol table. The dynamic linker
3719 will only see the .dynsym symbol table, so there is no reason to
3720 look at .symtab for a dynamic object. */
3722 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
3723 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3725 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3727 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
3729 /* The sh_info field of the symtab header tells us where the
3730 external symbols start. We don't care about the local symbols at
3732 if (elf_bad_symtab (abfd
))
3734 extsymcount
= symcount
;
3739 extsymcount
= symcount
- hdr
->sh_info
;
3740 extsymoff
= hdr
->sh_info
;
3744 if (extsymcount
!= 0)
3746 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3748 if (isymbuf
== NULL
)
3751 /* We store a pointer to the hash table entry for each external
3753 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3754 sym_hash
= (struct elf_link_hash_entry
**) bfd_alloc (abfd
, amt
);
3755 if (sym_hash
== NULL
)
3756 goto error_free_sym
;
3757 elf_sym_hashes (abfd
) = sym_hash
;
3762 /* Read in any version definitions. */
3763 if (!_bfd_elf_slurp_version_tables (abfd
,
3764 info
->default_imported_symver
))
3765 goto error_free_sym
;
3767 /* Read in the symbol versions, but don't bother to convert them
3768 to internal format. */
3769 if (elf_dynversym (abfd
) != 0)
3771 Elf_Internal_Shdr
*versymhdr
;
3773 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
3774 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
3775 if (extversym
== NULL
)
3776 goto error_free_sym
;
3777 amt
= versymhdr
->sh_size
;
3778 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
3779 || bfd_bread (extversym
, amt
, abfd
) != amt
)
3780 goto error_free_vers
;
3784 /* If we are loading an as-needed shared lib, save the symbol table
3785 state before we start adding symbols. If the lib turns out
3786 to be unneeded, restore the state. */
3787 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
3792 for (entsize
= 0, i
= 0; i
< htab
->root
.table
.size
; i
++)
3794 struct bfd_hash_entry
*p
;
3795 struct elf_link_hash_entry
*h
;
3797 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3799 h
= (struct elf_link_hash_entry
*) p
;
3800 entsize
+= htab
->root
.table
.entsize
;
3801 if (h
->root
.type
== bfd_link_hash_warning
)
3802 entsize
+= htab
->root
.table
.entsize
;
3806 tabsize
= htab
->root
.table
.size
* sizeof (struct bfd_hash_entry
*);
3807 hashsize
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3808 old_tab
= bfd_malloc (tabsize
+ entsize
+ hashsize
);
3809 if (old_tab
== NULL
)
3810 goto error_free_vers
;
3812 /* Remember the current objalloc pointer, so that all mem for
3813 symbols added can later be reclaimed. */
3814 alloc_mark
= bfd_hash_allocate (&htab
->root
.table
, 1);
3815 if (alloc_mark
== NULL
)
3816 goto error_free_vers
;
3818 /* Make a special call to the linker "notice" function to
3819 tell it that we are about to handle an as-needed lib. */
3820 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
3821 notice_as_needed
, 0, NULL
))
3822 goto error_free_vers
;
3824 /* Clone the symbol table and sym hashes. Remember some
3825 pointers into the symbol table, and dynamic symbol count. */
3826 old_hash
= (char *) old_tab
+ tabsize
;
3827 old_ent
= (char *) old_hash
+ hashsize
;
3828 memcpy (old_tab
, htab
->root
.table
.table
, tabsize
);
3829 memcpy (old_hash
, sym_hash
, hashsize
);
3830 old_undefs
= htab
->root
.undefs
;
3831 old_undefs_tail
= htab
->root
.undefs_tail
;
3832 old_table
= htab
->root
.table
.table
;
3833 old_size
= htab
->root
.table
.size
;
3834 old_count
= htab
->root
.table
.count
;
3835 old_dynsymcount
= htab
->dynsymcount
;
3836 old_dynstr_size
= _bfd_elf_strtab_size (htab
->dynstr
);
3838 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
3840 struct bfd_hash_entry
*p
;
3841 struct elf_link_hash_entry
*h
;
3843 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3845 memcpy (old_ent
, p
, htab
->root
.table
.entsize
);
3846 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3847 h
= (struct elf_link_hash_entry
*) p
;
3848 if (h
->root
.type
== bfd_link_hash_warning
)
3850 memcpy (old_ent
, h
->root
.u
.i
.link
, htab
->root
.table
.entsize
);
3851 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3858 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
3859 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
3861 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
3865 asection
*sec
, *new_sec
;
3868 struct elf_link_hash_entry
*h
;
3869 struct elf_link_hash_entry
*hi
;
3870 bfd_boolean definition
;
3871 bfd_boolean size_change_ok
;
3872 bfd_boolean type_change_ok
;
3873 bfd_boolean new_weakdef
;
3874 bfd_boolean new_weak
;
3875 bfd_boolean old_weak
;
3876 bfd_boolean override
;
3878 unsigned int old_alignment
;
3880 bfd
* undef_bfd
= NULL
;
3884 flags
= BSF_NO_FLAGS
;
3886 value
= isym
->st_value
;
3888 common
= bed
->common_definition (isym
);
3890 bind
= ELF_ST_BIND (isym
->st_info
);
3894 /* This should be impossible, since ELF requires that all
3895 global symbols follow all local symbols, and that sh_info
3896 point to the first global symbol. Unfortunately, Irix 5
3901 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
3909 case STB_GNU_UNIQUE
:
3910 flags
= BSF_GNU_UNIQUE
;
3914 /* Leave it up to the processor backend. */
3918 if (isym
->st_shndx
== SHN_UNDEF
)
3919 sec
= bfd_und_section_ptr
;
3920 else if (isym
->st_shndx
== SHN_ABS
)
3921 sec
= bfd_abs_section_ptr
;
3922 else if (isym
->st_shndx
== SHN_COMMON
)
3924 sec
= bfd_com_section_ptr
;
3925 /* What ELF calls the size we call the value. What ELF
3926 calls the value we call the alignment. */
3927 value
= isym
->st_size
;
3931 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3933 sec
= bfd_abs_section_ptr
;
3934 else if (discarded_section (sec
))
3936 /* Symbols from discarded section are undefined. We keep
3938 sec
= bfd_und_section_ptr
;
3939 isym
->st_shndx
= SHN_UNDEF
;
3941 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
3945 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3948 goto error_free_vers
;
3950 if (isym
->st_shndx
== SHN_COMMON
3951 && (abfd
->flags
& BFD_PLUGIN
) != 0)
3953 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
3957 flagword sflags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
3959 xc
= bfd_make_section_with_flags (abfd
, "COMMON", sflags
);
3961 goto error_free_vers
;
3965 else if (isym
->st_shndx
== SHN_COMMON
3966 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
3967 && !info
->relocatable
)
3969 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
3973 flagword sflags
= (SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_IS_COMMON
3974 | SEC_LINKER_CREATED
);
3975 tcomm
= bfd_make_section_with_flags (abfd
, ".tcommon", sflags
);
3977 goto error_free_vers
;
3981 else if (bed
->elf_add_symbol_hook
)
3983 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
3985 goto error_free_vers
;
3987 /* The hook function sets the name to NULL if this symbol
3988 should be skipped for some reason. */
3993 /* Sanity check that all possibilities were handled. */
3996 bfd_set_error (bfd_error_bad_value
);
3997 goto error_free_vers
;
4000 if (bfd_is_und_section (sec
)
4001 || bfd_is_com_section (sec
))
4006 size_change_ok
= FALSE
;
4007 type_change_ok
= bed
->type_change_ok
;
4013 if (is_elf_hash_table (htab
))
4015 Elf_Internal_Versym iver
;
4016 unsigned int vernum
= 0;
4019 /* If this is a definition of a symbol which was previously
4020 referenced in a non-weak manner then make a note of the bfd
4021 that contained the reference. This is used if we need to
4022 refer to the source of the reference later on. */
4023 if (! bfd_is_und_section (sec
))
4025 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
4028 && h
->root
.type
== bfd_link_hash_undefined
4029 && h
->root
.u
.undef
.abfd
)
4030 undef_bfd
= h
->root
.u
.undef
.abfd
;
4035 if (info
->default_imported_symver
)
4036 /* Use the default symbol version created earlier. */
4037 iver
.vs_vers
= elf_tdata (abfd
)->cverdefs
;
4042 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
4044 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
4046 /* If this is a hidden symbol, or if it is not version
4047 1, we append the version name to the symbol name.
4048 However, we do not modify a non-hidden absolute symbol
4049 if it is not a function, because it might be the version
4050 symbol itself. FIXME: What if it isn't? */
4051 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
4053 && (!bfd_is_abs_section (sec
)
4054 || bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
)))))
4057 size_t namelen
, verlen
, newlen
;
4060 if (isym
->st_shndx
!= SHN_UNDEF
)
4062 if (vernum
> elf_tdata (abfd
)->cverdefs
)
4064 else if (vernum
> 1)
4066 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
4072 (*_bfd_error_handler
)
4073 (_("%B: %s: invalid version %u (max %d)"),
4075 elf_tdata (abfd
)->cverdefs
);
4076 bfd_set_error (bfd_error_bad_value
);
4077 goto error_free_vers
;
4082 /* We cannot simply test for the number of
4083 entries in the VERNEED section since the
4084 numbers for the needed versions do not start
4086 Elf_Internal_Verneed
*t
;
4089 for (t
= elf_tdata (abfd
)->verref
;
4093 Elf_Internal_Vernaux
*a
;
4095 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
4097 if (a
->vna_other
== vernum
)
4099 verstr
= a
->vna_nodename
;
4108 (*_bfd_error_handler
)
4109 (_("%B: %s: invalid needed version %d"),
4110 abfd
, name
, vernum
);
4111 bfd_set_error (bfd_error_bad_value
);
4112 goto error_free_vers
;
4116 namelen
= strlen (name
);
4117 verlen
= strlen (verstr
);
4118 newlen
= namelen
+ verlen
+ 2;
4119 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4120 && isym
->st_shndx
!= SHN_UNDEF
)
4123 newname
= (char *) bfd_hash_allocate (&htab
->root
.table
, newlen
);
4124 if (newname
== NULL
)
4125 goto error_free_vers
;
4126 memcpy (newname
, name
, namelen
);
4127 p
= newname
+ namelen
;
4129 /* If this is a defined non-hidden version symbol,
4130 we add another @ to the name. This indicates the
4131 default version of the symbol. */
4132 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4133 && isym
->st_shndx
!= SHN_UNDEF
)
4135 memcpy (p
, verstr
, verlen
+ 1);
4140 /* If necessary, make a second attempt to locate the bfd
4141 containing an unresolved, non-weak reference to the
4143 if (! bfd_is_und_section (sec
) && undef_bfd
== NULL
)
4145 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
4148 && h
->root
.type
== bfd_link_hash_undefined
4149 && h
->root
.u
.undef
.abfd
)
4150 undef_bfd
= h
->root
.u
.undef
.abfd
;
4153 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
,
4154 &value
, &old_weak
, &old_alignment
,
4155 sym_hash
, &skip
, &override
,
4156 &type_change_ok
, &size_change_ok
))
4157 goto error_free_vers
;
4166 while (h
->root
.type
== bfd_link_hash_indirect
4167 || h
->root
.type
== bfd_link_hash_warning
)
4168 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4170 /* Remember the old alignment if this is a common symbol, so
4171 that we don't reduce the alignment later on. We can't
4172 check later, because _bfd_generic_link_add_one_symbol
4173 will set a default for the alignment which we want to
4174 override. We also remember the old bfd where the existing
4175 definition comes from. */
4176 switch (h
->root
.type
)
4181 case bfd_link_hash_defined
:
4182 case bfd_link_hash_defweak
:
4183 old_bfd
= h
->root
.u
.def
.section
->owner
;
4186 case bfd_link_hash_common
:
4187 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
4188 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
4192 if (elf_tdata (abfd
)->verdef
!= NULL
4196 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
4199 if (! (_bfd_generic_link_add_one_symbol
4200 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
4201 (struct bfd_link_hash_entry
**) sym_hash
)))
4202 goto error_free_vers
;
4205 /* We need to make sure that indirect symbol dynamic flags are
4208 while (h
->root
.type
== bfd_link_hash_indirect
4209 || h
->root
.type
== bfd_link_hash_warning
)
4210 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4213 if (is_elf_hash_table (htab
))
4214 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
4216 new_weak
= (flags
& BSF_WEAK
) != 0;
4217 new_weakdef
= FALSE
;
4221 && !bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
))
4222 && is_elf_hash_table (htab
)
4223 && h
->u
.weakdef
== NULL
)
4225 /* Keep a list of all weak defined non function symbols from
4226 a dynamic object, using the weakdef field. Later in this
4227 function we will set the weakdef field to the correct
4228 value. We only put non-function symbols from dynamic
4229 objects on this list, because that happens to be the only
4230 time we need to know the normal symbol corresponding to a
4231 weak symbol, and the information is time consuming to
4232 figure out. If the weakdef field is not already NULL,
4233 then this symbol was already defined by some previous
4234 dynamic object, and we will be using that previous
4235 definition anyhow. */
4237 h
->u
.weakdef
= weaks
;
4242 /* Set the alignment of a common symbol. */
4243 if ((common
|| bfd_is_com_section (sec
))
4244 && h
->root
.type
== bfd_link_hash_common
)
4249 align
= bfd_log2 (isym
->st_value
);
4252 /* The new symbol is a common symbol in a shared object.
4253 We need to get the alignment from the section. */
4254 align
= new_sec
->alignment_power
;
4256 if (align
> old_alignment
)
4257 h
->root
.u
.c
.p
->alignment_power
= align
;
4259 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
4262 if (is_elf_hash_table (htab
))
4266 /* Check the alignment when a common symbol is involved. This
4267 can change when a common symbol is overridden by a normal
4268 definition or a common symbol is ignored due to the old
4269 normal definition. We need to make sure the maximum
4270 alignment is maintained. */
4271 if ((old_alignment
|| common
)
4272 && h
->root
.type
!= bfd_link_hash_common
)
4274 unsigned int common_align
;
4275 unsigned int normal_align
;
4276 unsigned int symbol_align
;
4280 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
4281 if (h
->root
.u
.def
.section
->owner
!= NULL
4282 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
4284 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
4285 if (normal_align
> symbol_align
)
4286 normal_align
= symbol_align
;
4289 normal_align
= symbol_align
;
4293 common_align
= old_alignment
;
4294 common_bfd
= old_bfd
;
4299 common_align
= bfd_log2 (isym
->st_value
);
4301 normal_bfd
= old_bfd
;
4304 if (normal_align
< common_align
)
4306 /* PR binutils/2735 */
4307 if (normal_bfd
== NULL
)
4308 (*_bfd_error_handler
)
4309 (_("Warning: alignment %u of common symbol `%s' in %B"
4310 " is greater than the alignment (%u) of its section %A"),
4311 common_bfd
, h
->root
.u
.def
.section
,
4312 1 << common_align
, name
, 1 << normal_align
);
4314 (*_bfd_error_handler
)
4315 (_("Warning: alignment %u of symbol `%s' in %B"
4316 " is smaller than %u in %B"),
4317 normal_bfd
, common_bfd
,
4318 1 << normal_align
, name
, 1 << common_align
);
4322 /* Remember the symbol size if it isn't undefined. */
4323 if ((isym
->st_size
!= 0 && isym
->st_shndx
!= SHN_UNDEF
)
4324 && (definition
|| h
->size
== 0))
4327 && h
->size
!= isym
->st_size
4328 && ! size_change_ok
)
4329 (*_bfd_error_handler
)
4330 (_("Warning: size of symbol `%s' changed"
4331 " from %lu in %B to %lu in %B"),
4333 name
, (unsigned long) h
->size
,
4334 (unsigned long) isym
->st_size
);
4336 h
->size
= isym
->st_size
;
4339 /* If this is a common symbol, then we always want H->SIZE
4340 to be the size of the common symbol. The code just above
4341 won't fix the size if a common symbol becomes larger. We
4342 don't warn about a size change here, because that is
4343 covered by --warn-common. Allow changed between different
4345 if (h
->root
.type
== bfd_link_hash_common
)
4346 h
->size
= h
->root
.u
.c
.size
;
4348 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
4349 && ((definition
&& !new_weak
)
4350 || (old_weak
&& h
->root
.type
== bfd_link_hash_common
)
4351 || h
->type
== STT_NOTYPE
))
4353 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
4355 /* Turn an IFUNC symbol from a DSO into a normal FUNC
4357 if (type
== STT_GNU_IFUNC
4358 && (abfd
->flags
& DYNAMIC
) != 0)
4361 if (h
->type
!= type
)
4363 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
4364 (*_bfd_error_handler
)
4365 (_("Warning: type of symbol `%s' changed"
4366 " from %d to %d in %B"),
4367 abfd
, name
, h
->type
, type
);
4373 /* Merge st_other field. */
4374 elf_merge_st_other (abfd
, h
, isym
, definition
, dynamic
);
4376 /* Set a flag in the hash table entry indicating the type of
4377 reference or definition we just found. Keep a count of
4378 the number of dynamic symbols we find. A dynamic symbol
4379 is one which is referenced or defined by both a regular
4380 object and a shared object. */
4387 if (bind
!= STB_WEAK
)
4388 h
->ref_regular_nonweak
= 1;
4400 /* If the indirect symbol has been forced local, don't
4401 make the real symbol dynamic. */
4402 if ((h
== hi
|| !hi
->forced_local
)
4403 && (! info
->executable
4413 hi
->ref_dynamic
= 1;
4419 hi
->def_dynamic
= 1;
4420 hi
->dynamic_def
= 1;
4423 /* If the indirect symbol has been forced local, don't
4424 make the real symbol dynamic. */
4425 if ((h
== hi
|| !hi
->forced_local
)
4428 || (h
->u
.weakdef
!= NULL
4430 && h
->u
.weakdef
->dynindx
!= -1)))
4434 /* We don't want to make debug symbol dynamic. */
4435 if (definition
&& (sec
->flags
& SEC_DEBUGGING
) && !info
->relocatable
)
4438 /* Nor should we make plugin symbols dynamic. */
4439 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
4443 h
->target_internal
= isym
->st_target_internal
;
4445 /* Check to see if we need to add an indirect symbol for
4446 the default name. */
4447 if (definition
|| h
->root
.type
== bfd_link_hash_common
)
4448 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
4449 &sec
, &value
, &dynsym
,
4451 goto error_free_vers
;
4453 if (definition
&& !dynamic
)
4455 char *p
= strchr (name
, ELF_VER_CHR
);
4456 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
4458 /* Queue non-default versions so that .symver x, x@FOO
4459 aliases can be checked. */
4462 amt
= ((isymend
- isym
+ 1)
4463 * sizeof (struct elf_link_hash_entry
*));
4465 (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4467 goto error_free_vers
;
4469 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
4473 if (dynsym
&& h
->dynindx
== -1)
4475 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4476 goto error_free_vers
;
4477 if (h
->u
.weakdef
!= NULL
4479 && h
->u
.weakdef
->dynindx
== -1)
4481 if (!bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
4482 goto error_free_vers
;
4485 else if (dynsym
&& h
->dynindx
!= -1)
4486 /* If the symbol already has a dynamic index, but
4487 visibility says it should not be visible, turn it into
4489 switch (ELF_ST_VISIBILITY (h
->other
))
4493 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
4503 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0
4504 && !on_needed_list (elf_dt_name (abfd
), htab
->needed
))))
4507 const char *soname
= elf_dt_name (abfd
);
4509 /* A symbol from a library loaded via DT_NEEDED of some
4510 other library is referenced by a regular object.
4511 Add a DT_NEEDED entry for it. Issue an error if
4512 --no-add-needed is used and the reference was not
4514 if (undef_bfd
!= NULL
4515 && (elf_dyn_lib_class (abfd
) & DYN_NO_NEEDED
) != 0)
4517 (*_bfd_error_handler
)
4518 (_("%B: undefined reference to symbol '%s'"),
4520 (*_bfd_error_handler
)
4521 (_("note: '%s' is defined in DSO %B so try adding it to the linker command line"),
4523 bfd_set_error (bfd_error_invalid_operation
);
4524 goto error_free_vers
;
4527 elf_dyn_lib_class (abfd
) = (enum dynamic_lib_link_class
)
4528 (elf_dyn_lib_class (abfd
) & ~DYN_AS_NEEDED
);
4531 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
4533 goto error_free_vers
;
4535 BFD_ASSERT (ret
== 0);
4540 if (extversym
!= NULL
)
4546 if (isymbuf
!= NULL
)
4552 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4556 /* Restore the symbol table. */
4557 if (bed
->as_needed_cleanup
)
4558 (*bed
->as_needed_cleanup
) (abfd
, info
);
4559 old_hash
= (char *) old_tab
+ tabsize
;
4560 old_ent
= (char *) old_hash
+ hashsize
;
4561 sym_hash
= elf_sym_hashes (abfd
);
4562 htab
->root
.table
.table
= old_table
;
4563 htab
->root
.table
.size
= old_size
;
4564 htab
->root
.table
.count
= old_count
;
4565 memcpy (htab
->root
.table
.table
, old_tab
, tabsize
);
4566 memcpy (sym_hash
, old_hash
, hashsize
);
4567 htab
->root
.undefs
= old_undefs
;
4568 htab
->root
.undefs_tail
= old_undefs_tail
;
4569 _bfd_elf_strtab_clear_refs (htab
->dynstr
, old_dynstr_size
);
4570 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4572 struct bfd_hash_entry
*p
;
4573 struct elf_link_hash_entry
*h
;
4575 unsigned int alignment_power
;
4577 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4579 h
= (struct elf_link_hash_entry
*) p
;
4580 if (h
->root
.type
== bfd_link_hash_warning
)
4581 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4582 if (h
->dynindx
>= old_dynsymcount
4583 && h
->dynstr_index
< old_dynstr_size
)
4584 _bfd_elf_strtab_delref (htab
->dynstr
, h
->dynstr_index
);
4586 /* Preserve the maximum alignment and size for common
4587 symbols even if this dynamic lib isn't on DT_NEEDED
4588 since it can still be loaded at run time by another
4590 if (h
->root
.type
== bfd_link_hash_common
)
4592 size
= h
->root
.u
.c
.size
;
4593 alignment_power
= h
->root
.u
.c
.p
->alignment_power
;
4598 alignment_power
= 0;
4600 memcpy (p
, old_ent
, htab
->root
.table
.entsize
);
4601 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4602 h
= (struct elf_link_hash_entry
*) p
;
4603 if (h
->root
.type
== bfd_link_hash_warning
)
4605 memcpy (h
->root
.u
.i
.link
, old_ent
, htab
->root
.table
.entsize
);
4606 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4607 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4609 if (h
->root
.type
== bfd_link_hash_common
)
4611 if (size
> h
->root
.u
.c
.size
)
4612 h
->root
.u
.c
.size
= size
;
4613 if (alignment_power
> h
->root
.u
.c
.p
->alignment_power
)
4614 h
->root
.u
.c
.p
->alignment_power
= alignment_power
;
4619 /* Make a special call to the linker "notice" function to
4620 tell it that symbols added for crefs may need to be removed. */
4621 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4622 notice_not_needed
, 0, NULL
))
4623 goto error_free_vers
;
4626 objalloc_free_block ((struct objalloc
*) htab
->root
.table
.memory
,
4628 if (nondeflt_vers
!= NULL
)
4629 free (nondeflt_vers
);
4633 if (old_tab
!= NULL
)
4635 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4636 notice_needed
, 0, NULL
))
4637 goto error_free_vers
;
4642 /* Now that all the symbols from this input file are created, handle
4643 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4644 if (nondeflt_vers
!= NULL
)
4646 bfd_size_type cnt
, symidx
;
4648 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
4650 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
4651 char *shortname
, *p
;
4653 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
4655 || (h
->root
.type
!= bfd_link_hash_defined
4656 && h
->root
.type
!= bfd_link_hash_defweak
))
4659 amt
= p
- h
->root
.root
.string
;
4660 shortname
= (char *) bfd_malloc (amt
+ 1);
4662 goto error_free_vers
;
4663 memcpy (shortname
, h
->root
.root
.string
, amt
);
4664 shortname
[amt
] = '\0';
4666 hi
= (struct elf_link_hash_entry
*)
4667 bfd_link_hash_lookup (&htab
->root
, shortname
,
4668 FALSE
, FALSE
, FALSE
);
4670 && hi
->root
.type
== h
->root
.type
4671 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
4672 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
4674 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
4675 hi
->root
.type
= bfd_link_hash_indirect
;
4676 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
4677 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
4678 sym_hash
= elf_sym_hashes (abfd
);
4680 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
4681 if (sym_hash
[symidx
] == hi
)
4683 sym_hash
[symidx
] = h
;
4689 free (nondeflt_vers
);
4690 nondeflt_vers
= NULL
;
4693 /* Now set the weakdefs field correctly for all the weak defined
4694 symbols we found. The only way to do this is to search all the
4695 symbols. Since we only need the information for non functions in
4696 dynamic objects, that's the only time we actually put anything on
4697 the list WEAKS. We need this information so that if a regular
4698 object refers to a symbol defined weakly in a dynamic object, the
4699 real symbol in the dynamic object is also put in the dynamic
4700 symbols; we also must arrange for both symbols to point to the
4701 same memory location. We could handle the general case of symbol
4702 aliasing, but a general symbol alias can only be generated in
4703 assembler code, handling it correctly would be very time
4704 consuming, and other ELF linkers don't handle general aliasing
4708 struct elf_link_hash_entry
**hpp
;
4709 struct elf_link_hash_entry
**hppend
;
4710 struct elf_link_hash_entry
**sorted_sym_hash
;
4711 struct elf_link_hash_entry
*h
;
4714 /* Since we have to search the whole symbol list for each weak
4715 defined symbol, search time for N weak defined symbols will be
4716 O(N^2). Binary search will cut it down to O(NlogN). */
4717 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4718 sorted_sym_hash
= (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4719 if (sorted_sym_hash
== NULL
)
4721 sym_hash
= sorted_sym_hash
;
4722 hpp
= elf_sym_hashes (abfd
);
4723 hppend
= hpp
+ extsymcount
;
4725 for (; hpp
< hppend
; hpp
++)
4729 && h
->root
.type
== bfd_link_hash_defined
4730 && !bed
->is_function_type (h
->type
))
4738 qsort (sorted_sym_hash
, sym_count
,
4739 sizeof (struct elf_link_hash_entry
*),
4742 while (weaks
!= NULL
)
4744 struct elf_link_hash_entry
*hlook
;
4750 weaks
= hlook
->u
.weakdef
;
4751 hlook
->u
.weakdef
= NULL
;
4753 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4754 || hlook
->root
.type
== bfd_link_hash_defweak
4755 || hlook
->root
.type
== bfd_link_hash_common
4756 || hlook
->root
.type
== bfd_link_hash_indirect
);
4757 slook
= hlook
->root
.u
.def
.section
;
4758 vlook
= hlook
->root
.u
.def
.value
;
4764 bfd_signed_vma vdiff
;
4766 h
= sorted_sym_hash
[idx
];
4767 vdiff
= vlook
- h
->root
.u
.def
.value
;
4774 long sdiff
= slook
->id
- h
->root
.u
.def
.section
->id
;
4784 /* We didn't find a value/section match. */
4788 /* With multiple aliases, or when the weak symbol is already
4789 strongly defined, we have multiple matching symbols and
4790 the binary search above may land on any of them. Step
4791 one past the matching symbol(s). */
4794 h
= sorted_sym_hash
[idx
];
4795 if (h
->root
.u
.def
.section
!= slook
4796 || h
->root
.u
.def
.value
!= vlook
)
4800 /* Now look back over the aliases. Since we sorted by size
4801 as well as value and section, we'll choose the one with
4802 the largest size. */
4805 h
= sorted_sym_hash
[idx
];
4807 /* Stop if value or section doesn't match. */
4808 if (h
->root
.u
.def
.section
!= slook
4809 || h
->root
.u
.def
.value
!= vlook
)
4811 else if (h
!= hlook
)
4813 hlook
->u
.weakdef
= h
;
4815 /* If the weak definition is in the list of dynamic
4816 symbols, make sure the real definition is put
4818 if (hlook
->dynindx
!= -1 && h
->dynindx
== -1)
4820 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4823 free (sorted_sym_hash
);
4828 /* If the real definition is in the list of dynamic
4829 symbols, make sure the weak definition is put
4830 there as well. If we don't do this, then the
4831 dynamic loader might not merge the entries for the
4832 real definition and the weak definition. */
4833 if (h
->dynindx
!= -1 && hlook
->dynindx
== -1)
4835 if (! bfd_elf_link_record_dynamic_symbol (info
, hlook
))
4836 goto err_free_sym_hash
;
4843 free (sorted_sym_hash
);
4846 if (bed
->check_directives
4847 && !(*bed
->check_directives
) (abfd
, info
))
4850 /* If this object is the same format as the output object, and it is
4851 not a shared library, then let the backend look through the
4854 This is required to build global offset table entries and to
4855 arrange for dynamic relocs. It is not required for the
4856 particular common case of linking non PIC code, even when linking
4857 against shared libraries, but unfortunately there is no way of
4858 knowing whether an object file has been compiled PIC or not.
4859 Looking through the relocs is not particularly time consuming.
4860 The problem is that we must either (1) keep the relocs in memory,
4861 which causes the linker to require additional runtime memory or
4862 (2) read the relocs twice from the input file, which wastes time.
4863 This would be a good case for using mmap.
4865 I have no idea how to handle linking PIC code into a file of a
4866 different format. It probably can't be done. */
4868 && is_elf_hash_table (htab
)
4869 && bed
->check_relocs
!= NULL
4870 && elf_object_id (abfd
) == elf_hash_table_id (htab
)
4871 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
4875 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4877 Elf_Internal_Rela
*internal_relocs
;
4880 if ((o
->flags
& SEC_RELOC
) == 0
4881 || o
->reloc_count
== 0
4882 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
4883 && (o
->flags
& SEC_DEBUGGING
) != 0)
4884 || bfd_is_abs_section (o
->output_section
))
4887 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
4889 if (internal_relocs
== NULL
)
4892 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
4894 if (elf_section_data (o
)->relocs
!= internal_relocs
)
4895 free (internal_relocs
);
4902 /* If this is a non-traditional link, try to optimize the handling
4903 of the .stab/.stabstr sections. */
4905 && ! info
->traditional_format
4906 && is_elf_hash_table (htab
)
4907 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
4911 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
4912 if (stabstr
!= NULL
)
4914 bfd_size_type string_offset
= 0;
4917 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
4918 if (CONST_STRNEQ (stab
->name
, ".stab")
4919 && (!stab
->name
[5] ||
4920 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
4921 && (stab
->flags
& SEC_MERGE
) == 0
4922 && !bfd_is_abs_section (stab
->output_section
))
4924 struct bfd_elf_section_data
*secdata
;
4926 secdata
= elf_section_data (stab
);
4927 if (! _bfd_link_section_stabs (abfd
, &htab
->stab_info
, stab
,
4928 stabstr
, &secdata
->sec_info
,
4931 if (secdata
->sec_info
)
4932 stab
->sec_info_type
= SEC_INFO_TYPE_STABS
;
4937 if (is_elf_hash_table (htab
) && add_needed
)
4939 /* Add this bfd to the loaded list. */
4940 struct elf_link_loaded_list
*n
;
4942 n
= (struct elf_link_loaded_list
*)
4943 bfd_alloc (abfd
, sizeof (struct elf_link_loaded_list
));
4947 n
->next
= htab
->loaded
;
4954 if (old_tab
!= NULL
)
4956 if (nondeflt_vers
!= NULL
)
4957 free (nondeflt_vers
);
4958 if (extversym
!= NULL
)
4961 if (isymbuf
!= NULL
)
4967 /* Return the linker hash table entry of a symbol that might be
4968 satisfied by an archive symbol. Return -1 on error. */
4970 struct elf_link_hash_entry
*
4971 _bfd_elf_archive_symbol_lookup (bfd
*abfd
,
4972 struct bfd_link_info
*info
,
4975 struct elf_link_hash_entry
*h
;
4979 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, TRUE
);
4983 /* If this is a default version (the name contains @@), look up the
4984 symbol again with only one `@' as well as without the version.
4985 The effect is that references to the symbol with and without the
4986 version will be matched by the default symbol in the archive. */
4988 p
= strchr (name
, ELF_VER_CHR
);
4989 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
4992 /* First check with only one `@'. */
4993 len
= strlen (name
);
4994 copy
= (char *) bfd_alloc (abfd
, len
);
4996 return (struct elf_link_hash_entry
*) 0 - 1;
4998 first
= p
- name
+ 1;
4999 memcpy (copy
, name
, first
);
5000 memcpy (copy
+ first
, name
+ first
+ 1, len
- first
);
5002 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
, FALSE
, FALSE
, TRUE
);
5005 /* We also need to check references to the symbol without the
5007 copy
[first
- 1] = '\0';
5008 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
5009 FALSE
, FALSE
, TRUE
);
5012 bfd_release (abfd
, copy
);
5016 /* Add symbols from an ELF archive file to the linker hash table. We
5017 don't use _bfd_generic_link_add_archive_symbols because of a
5018 problem which arises on UnixWare. The UnixWare libc.so is an
5019 archive which includes an entry libc.so.1 which defines a bunch of
5020 symbols. The libc.so archive also includes a number of other
5021 object files, which also define symbols, some of which are the same
5022 as those defined in libc.so.1. Correct linking requires that we
5023 consider each object file in turn, and include it if it defines any
5024 symbols we need. _bfd_generic_link_add_archive_symbols does not do
5025 this; it looks through the list of undefined symbols, and includes
5026 any object file which defines them. When this algorithm is used on
5027 UnixWare, it winds up pulling in libc.so.1 early and defining a
5028 bunch of symbols. This means that some of the other objects in the
5029 archive are not included in the link, which is incorrect since they
5030 precede libc.so.1 in the archive.
5032 Fortunately, ELF archive handling is simpler than that done by
5033 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
5034 oddities. In ELF, if we find a symbol in the archive map, and the
5035 symbol is currently undefined, we know that we must pull in that
5038 Unfortunately, we do have to make multiple passes over the symbol
5039 table until nothing further is resolved. */
5042 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5045 bfd_boolean
*defined
= NULL
;
5046 bfd_boolean
*included
= NULL
;
5050 const struct elf_backend_data
*bed
;
5051 struct elf_link_hash_entry
* (*archive_symbol_lookup
)
5052 (bfd
*, struct bfd_link_info
*, const char *);
5054 if (! bfd_has_map (abfd
))
5056 /* An empty archive is a special case. */
5057 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
5059 bfd_set_error (bfd_error_no_armap
);
5063 /* Keep track of all symbols we know to be already defined, and all
5064 files we know to be already included. This is to speed up the
5065 second and subsequent passes. */
5066 c
= bfd_ardata (abfd
)->symdef_count
;
5070 amt
*= sizeof (bfd_boolean
);
5071 defined
= (bfd_boolean
*) bfd_zmalloc (amt
);
5072 included
= (bfd_boolean
*) bfd_zmalloc (amt
);
5073 if (defined
== NULL
|| included
== NULL
)
5076 symdefs
= bfd_ardata (abfd
)->symdefs
;
5077 bed
= get_elf_backend_data (abfd
);
5078 archive_symbol_lookup
= bed
->elf_backend_archive_symbol_lookup
;
5091 symdefend
= symdef
+ c
;
5092 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
5094 struct elf_link_hash_entry
*h
;
5096 struct bfd_link_hash_entry
*undefs_tail
;
5099 if (defined
[i
] || included
[i
])
5101 if (symdef
->file_offset
== last
)
5107 h
= archive_symbol_lookup (abfd
, info
, symdef
->name
);
5108 if (h
== (struct elf_link_hash_entry
*) 0 - 1)
5114 if (h
->root
.type
== bfd_link_hash_common
)
5116 /* We currently have a common symbol. The archive map contains
5117 a reference to this symbol, so we may want to include it. We
5118 only want to include it however, if this archive element
5119 contains a definition of the symbol, not just another common
5122 Unfortunately some archivers (including GNU ar) will put
5123 declarations of common symbols into their archive maps, as
5124 well as real definitions, so we cannot just go by the archive
5125 map alone. Instead we must read in the element's symbol
5126 table and check that to see what kind of symbol definition
5128 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
5131 else if (h
->root
.type
!= bfd_link_hash_undefined
)
5133 if (h
->root
.type
!= bfd_link_hash_undefweak
)
5138 /* We need to include this archive member. */
5139 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
5140 if (element
== NULL
)
5143 if (! bfd_check_format (element
, bfd_object
))
5146 /* Doublecheck that we have not included this object
5147 already--it should be impossible, but there may be
5148 something wrong with the archive. */
5149 if (element
->archive_pass
!= 0)
5151 bfd_set_error (bfd_error_bad_value
);
5154 element
->archive_pass
= 1;
5156 undefs_tail
= info
->hash
->undefs_tail
;
5158 if (!(*info
->callbacks
5159 ->add_archive_element
) (info
, element
, symdef
->name
, &element
))
5161 if (!bfd_link_add_symbols (element
, info
))
5164 /* If there are any new undefined symbols, we need to make
5165 another pass through the archive in order to see whether
5166 they can be defined. FIXME: This isn't perfect, because
5167 common symbols wind up on undefs_tail and because an
5168 undefined symbol which is defined later on in this pass
5169 does not require another pass. This isn't a bug, but it
5170 does make the code less efficient than it could be. */
5171 if (undefs_tail
!= info
->hash
->undefs_tail
)
5174 /* Look backward to mark all symbols from this object file
5175 which we have already seen in this pass. */
5179 included
[mark
] = TRUE
;
5184 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
5186 /* We mark subsequent symbols from this object file as we go
5187 on through the loop. */
5188 last
= symdef
->file_offset
;
5199 if (defined
!= NULL
)
5201 if (included
!= NULL
)
5206 /* Given an ELF BFD, add symbols to the global hash table as
5210 bfd_elf_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5212 switch (bfd_get_format (abfd
))
5215 return elf_link_add_object_symbols (abfd
, info
);
5217 return elf_link_add_archive_symbols (abfd
, info
);
5219 bfd_set_error (bfd_error_wrong_format
);
5224 struct hash_codes_info
5226 unsigned long *hashcodes
;
5230 /* This function will be called though elf_link_hash_traverse to store
5231 all hash value of the exported symbols in an array. */
5234 elf_collect_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5236 struct hash_codes_info
*inf
= (struct hash_codes_info
*) data
;
5242 /* Ignore indirect symbols. These are added by the versioning code. */
5243 if (h
->dynindx
== -1)
5246 name
= h
->root
.root
.string
;
5247 p
= strchr (name
, ELF_VER_CHR
);
5250 alc
= (char *) bfd_malloc (p
- name
+ 1);
5256 memcpy (alc
, name
, p
- name
);
5257 alc
[p
- name
] = '\0';
5261 /* Compute the hash value. */
5262 ha
= bfd_elf_hash (name
);
5264 /* Store the found hash value in the array given as the argument. */
5265 *(inf
->hashcodes
)++ = ha
;
5267 /* And store it in the struct so that we can put it in the hash table
5269 h
->u
.elf_hash_value
= ha
;
5277 struct collect_gnu_hash_codes
5280 const struct elf_backend_data
*bed
;
5281 unsigned long int nsyms
;
5282 unsigned long int maskbits
;
5283 unsigned long int *hashcodes
;
5284 unsigned long int *hashval
;
5285 unsigned long int *indx
;
5286 unsigned long int *counts
;
5289 long int min_dynindx
;
5290 unsigned long int bucketcount
;
5291 unsigned long int symindx
;
5292 long int local_indx
;
5293 long int shift1
, shift2
;
5294 unsigned long int mask
;
5298 /* This function will be called though elf_link_hash_traverse to store
5299 all hash value of the exported symbols in an array. */
5302 elf_collect_gnu_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5304 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5310 /* Ignore indirect symbols. These are added by the versioning code. */
5311 if (h
->dynindx
== -1)
5314 /* Ignore also local symbols and undefined symbols. */
5315 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5318 name
= h
->root
.root
.string
;
5319 p
= strchr (name
, ELF_VER_CHR
);
5322 alc
= (char *) bfd_malloc (p
- name
+ 1);
5328 memcpy (alc
, name
, p
- name
);
5329 alc
[p
- name
] = '\0';
5333 /* Compute the hash value. */
5334 ha
= bfd_elf_gnu_hash (name
);
5336 /* Store the found hash value in the array for compute_bucket_count,
5337 and also for .dynsym reordering purposes. */
5338 s
->hashcodes
[s
->nsyms
] = ha
;
5339 s
->hashval
[h
->dynindx
] = ha
;
5341 if (s
->min_dynindx
< 0 || s
->min_dynindx
> h
->dynindx
)
5342 s
->min_dynindx
= h
->dynindx
;
5350 /* This function will be called though elf_link_hash_traverse to do
5351 final dynaminc symbol renumbering. */
5354 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry
*h
, void *data
)
5356 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5357 unsigned long int bucket
;
5358 unsigned long int val
;
5360 /* Ignore indirect symbols. */
5361 if (h
->dynindx
== -1)
5364 /* Ignore also local symbols and undefined symbols. */
5365 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5367 if (h
->dynindx
>= s
->min_dynindx
)
5368 h
->dynindx
= s
->local_indx
++;
5372 bucket
= s
->hashval
[h
->dynindx
] % s
->bucketcount
;
5373 val
= (s
->hashval
[h
->dynindx
] >> s
->shift1
)
5374 & ((s
->maskbits
>> s
->shift1
) - 1);
5375 s
->bitmask
[val
] |= ((bfd_vma
) 1) << (s
->hashval
[h
->dynindx
] & s
->mask
);
5377 |= ((bfd_vma
) 1) << ((s
->hashval
[h
->dynindx
] >> s
->shift2
) & s
->mask
);
5378 val
= s
->hashval
[h
->dynindx
] & ~(unsigned long int) 1;
5379 if (s
->counts
[bucket
] == 1)
5380 /* Last element terminates the chain. */
5382 bfd_put_32 (s
->output_bfd
, val
,
5383 s
->contents
+ (s
->indx
[bucket
] - s
->symindx
) * 4);
5384 --s
->counts
[bucket
];
5385 h
->dynindx
= s
->indx
[bucket
]++;
5389 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5392 _bfd_elf_hash_symbol (struct elf_link_hash_entry
*h
)
5394 return !(h
->forced_local
5395 || h
->root
.type
== bfd_link_hash_undefined
5396 || h
->root
.type
== bfd_link_hash_undefweak
5397 || ((h
->root
.type
== bfd_link_hash_defined
5398 || h
->root
.type
== bfd_link_hash_defweak
)
5399 && h
->root
.u
.def
.section
->output_section
== NULL
));
5402 /* Array used to determine the number of hash table buckets to use
5403 based on the number of symbols there are. If there are fewer than
5404 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5405 fewer than 37 we use 17 buckets, and so forth. We never use more
5406 than 32771 buckets. */
5408 static const size_t elf_buckets
[] =
5410 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5414 /* Compute bucket count for hashing table. We do not use a static set
5415 of possible tables sizes anymore. Instead we determine for all
5416 possible reasonable sizes of the table the outcome (i.e., the
5417 number of collisions etc) and choose the best solution. The
5418 weighting functions are not too simple to allow the table to grow
5419 without bounds. Instead one of the weighting factors is the size.
5420 Therefore the result is always a good payoff between few collisions
5421 (= short chain lengths) and table size. */
5423 compute_bucket_count (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5424 unsigned long int *hashcodes ATTRIBUTE_UNUSED
,
5425 unsigned long int nsyms
,
5428 size_t best_size
= 0;
5429 unsigned long int i
;
5431 /* We have a problem here. The following code to optimize the table
5432 size requires an integer type with more the 32 bits. If
5433 BFD_HOST_U_64_BIT is set we know about such a type. */
5434 #ifdef BFD_HOST_U_64_BIT
5439 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
5440 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
5441 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5442 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
5443 unsigned long int *counts
;
5445 unsigned int no_improvement_count
= 0;
5447 /* Possible optimization parameters: if we have NSYMS symbols we say
5448 that the hashing table must at least have NSYMS/4 and at most
5450 minsize
= nsyms
/ 4;
5453 best_size
= maxsize
= nsyms
* 2;
5458 if ((best_size
& 31) == 0)
5462 /* Create array where we count the collisions in. We must use bfd_malloc
5463 since the size could be large. */
5465 amt
*= sizeof (unsigned long int);
5466 counts
= (unsigned long int *) bfd_malloc (amt
);
5470 /* Compute the "optimal" size for the hash table. The criteria is a
5471 minimal chain length. The minor criteria is (of course) the size
5473 for (i
= minsize
; i
< maxsize
; ++i
)
5475 /* Walk through the array of hashcodes and count the collisions. */
5476 BFD_HOST_U_64_BIT max
;
5477 unsigned long int j
;
5478 unsigned long int fact
;
5480 if (gnu_hash
&& (i
& 31) == 0)
5483 memset (counts
, '\0', i
* sizeof (unsigned long int));
5485 /* Determine how often each hash bucket is used. */
5486 for (j
= 0; j
< nsyms
; ++j
)
5487 ++counts
[hashcodes
[j
] % i
];
5489 /* For the weight function we need some information about the
5490 pagesize on the target. This is information need not be 100%
5491 accurate. Since this information is not available (so far) we
5492 define it here to a reasonable default value. If it is crucial
5493 to have a better value some day simply define this value. */
5494 # ifndef BFD_TARGET_PAGESIZE
5495 # define BFD_TARGET_PAGESIZE (4096)
5498 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5500 max
= (2 + dynsymcount
) * bed
->s
->sizeof_hash_entry
;
5503 /* Variant 1: optimize for short chains. We add the squares
5504 of all the chain lengths (which favors many small chain
5505 over a few long chains). */
5506 for (j
= 0; j
< i
; ++j
)
5507 max
+= counts
[j
] * counts
[j
];
5509 /* This adds penalties for the overall size of the table. */
5510 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5513 /* Variant 2: Optimize a lot more for small table. Here we
5514 also add squares of the size but we also add penalties for
5515 empty slots (the +1 term). */
5516 for (j
= 0; j
< i
; ++j
)
5517 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
5519 /* The overall size of the table is considered, but not as
5520 strong as in variant 1, where it is squared. */
5521 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5525 /* Compare with current best results. */
5526 if (max
< best_chlen
)
5530 no_improvement_count
= 0;
5532 /* PR 11843: Avoid futile long searches for the best bucket size
5533 when there are a large number of symbols. */
5534 else if (++no_improvement_count
== 100)
5541 #endif /* defined (BFD_HOST_U_64_BIT) */
5543 /* This is the fallback solution if no 64bit type is available or if we
5544 are not supposed to spend much time on optimizations. We select the
5545 bucket count using a fixed set of numbers. */
5546 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5548 best_size
= elf_buckets
[i
];
5549 if (nsyms
< elf_buckets
[i
+ 1])
5552 if (gnu_hash
&& best_size
< 2)
5559 /* Size any SHT_GROUP section for ld -r. */
5562 _bfd_elf_size_group_sections (struct bfd_link_info
*info
)
5566 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
5567 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
5568 && !_bfd_elf_fixup_group_sections (ibfd
, bfd_abs_section_ptr
))
5573 /* Set a default stack segment size. The value in INFO wins. If it
5574 is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5575 undefined it is initialized. */
5578 bfd_elf_stack_segment_size (bfd
*output_bfd
,
5579 struct bfd_link_info
*info
,
5580 const char *legacy_symbol
,
5581 bfd_vma default_size
)
5583 struct elf_link_hash_entry
*h
= NULL
;
5585 /* Look for legacy symbol. */
5587 h
= elf_link_hash_lookup (elf_hash_table (info
), legacy_symbol
,
5588 FALSE
, FALSE
, FALSE
);
5589 if (h
&& (h
->root
.type
== bfd_link_hash_defined
5590 || h
->root
.type
== bfd_link_hash_defweak
)
5592 && (h
->type
== STT_NOTYPE
|| h
->type
== STT_OBJECT
))
5594 /* The symbol has no type if specified on the command line. */
5595 h
->type
= STT_OBJECT
;
5596 if (info
->stacksize
)
5597 (*_bfd_error_handler
) (_("%B: stack size specified and %s set"),
5598 output_bfd
, legacy_symbol
);
5599 else if (h
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
5600 (*_bfd_error_handler
) (_("%B: %s not absolute"),
5601 output_bfd
, legacy_symbol
);
5603 info
->stacksize
= h
->root
.u
.def
.value
;
5606 if (!info
->stacksize
)
5607 /* If the user didn't set a size, or explicitly inhibit the
5608 size, set it now. */
5609 info
->stacksize
= default_size
;
5611 /* Provide the legacy symbol, if it is referenced. */
5612 if (h
&& (h
->root
.type
== bfd_link_hash_undefined
5613 || h
->root
.type
== bfd_link_hash_undefweak
))
5615 struct bfd_link_hash_entry
*bh
= NULL
;
5617 if (!(_bfd_generic_link_add_one_symbol
5618 (info
, output_bfd
, legacy_symbol
,
5619 BSF_GLOBAL
, bfd_abs_section_ptr
,
5620 info
->stacksize
>= 0 ? info
->stacksize
: 0,
5621 NULL
, FALSE
, get_elf_backend_data (output_bfd
)->collect
, &bh
)))
5624 h
= (struct elf_link_hash_entry
*) bh
;
5626 h
->type
= STT_OBJECT
;
5632 /* Set up the sizes and contents of the ELF dynamic sections. This is
5633 called by the ELF linker emulation before_allocation routine. We
5634 must set the sizes of the sections before the linker sets the
5635 addresses of the various sections. */
5638 bfd_elf_size_dynamic_sections (bfd
*output_bfd
,
5641 const char *filter_shlib
,
5643 const char *depaudit
,
5644 const char * const *auxiliary_filters
,
5645 struct bfd_link_info
*info
,
5646 asection
**sinterpptr
)
5648 bfd_size_type soname_indx
;
5650 const struct elf_backend_data
*bed
;
5651 struct elf_info_failed asvinfo
;
5655 soname_indx
= (bfd_size_type
) -1;
5657 if (!is_elf_hash_table (info
->hash
))
5660 bed
= get_elf_backend_data (output_bfd
);
5662 /* Any syms created from now on start with -1 in
5663 got.refcount/offset and plt.refcount/offset. */
5664 elf_hash_table (info
)->init_got_refcount
5665 = elf_hash_table (info
)->init_got_offset
;
5666 elf_hash_table (info
)->init_plt_refcount
5667 = elf_hash_table (info
)->init_plt_offset
;
5669 if (info
->relocatable
5670 && !_bfd_elf_size_group_sections (info
))
5673 /* The backend may have to create some sections regardless of whether
5674 we're dynamic or not. */
5675 if (bed
->elf_backend_always_size_sections
5676 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
5679 /* Determine any GNU_STACK segment requirements, after the backend
5680 has had a chance to set a default segment size. */
5681 if (info
->execstack
)
5682 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
5683 else if (info
->noexecstack
)
5684 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
;
5688 asection
*notesec
= NULL
;
5691 for (inputobj
= info
->input_bfds
;
5693 inputobj
= inputobj
->link_next
)
5698 & (DYNAMIC
| EXEC_P
| BFD_PLUGIN
| BFD_LINKER_CREATED
))
5700 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
5703 if (s
->flags
& SEC_CODE
)
5707 else if (bed
->default_execstack
)
5710 if (notesec
|| info
->stacksize
> 0)
5711 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| exec
;
5712 if (notesec
&& exec
&& info
->relocatable
5713 && notesec
->output_section
!= bfd_abs_section_ptr
)
5714 notesec
->output_section
->flags
|= SEC_CODE
;
5717 dynobj
= elf_hash_table (info
)->dynobj
;
5719 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
5721 struct elf_info_failed eif
;
5722 struct elf_link_hash_entry
*h
;
5724 struct bfd_elf_version_tree
*t
;
5725 struct bfd_elf_version_expr
*d
;
5727 bfd_boolean all_defined
;
5729 *sinterpptr
= bfd_get_linker_section (dynobj
, ".interp");
5730 BFD_ASSERT (*sinterpptr
!= NULL
|| !info
->executable
);
5734 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5736 if (soname_indx
== (bfd_size_type
) -1
5737 || !_bfd_elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
5743 if (!_bfd_elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
5745 info
->flags
|= DF_SYMBOLIC
;
5752 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5754 if (indx
== (bfd_size_type
) -1
5755 || !_bfd_elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5758 if (info
->new_dtags
)
5760 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
, indx
);
5761 if (!_bfd_elf_add_dynamic_entry (info
, DT_RUNPATH
, indx
))
5766 if (filter_shlib
!= NULL
)
5770 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5771 filter_shlib
, TRUE
);
5772 if (indx
== (bfd_size_type
) -1
5773 || !_bfd_elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
5777 if (auxiliary_filters
!= NULL
)
5779 const char * const *p
;
5781 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
5785 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5787 if (indx
== (bfd_size_type
) -1
5788 || !_bfd_elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
5797 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, audit
,
5799 if (indx
== (bfd_size_type
) -1
5800 || !_bfd_elf_add_dynamic_entry (info
, DT_AUDIT
, indx
))
5804 if (depaudit
!= NULL
)
5808 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, depaudit
,
5810 if (indx
== (bfd_size_type
) -1
5811 || !_bfd_elf_add_dynamic_entry (info
, DT_DEPAUDIT
, indx
))
5818 /* If we are supposed to export all symbols into the dynamic symbol
5819 table (this is not the normal case), then do so. */
5820 if (info
->export_dynamic
5821 || (info
->executable
&& info
->dynamic
))
5823 elf_link_hash_traverse (elf_hash_table (info
),
5824 _bfd_elf_export_symbol
,
5830 /* Make all global versions with definition. */
5831 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
5832 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5833 if (!d
->symver
&& d
->literal
)
5835 const char *verstr
, *name
;
5836 size_t namelen
, verlen
, newlen
;
5837 char *newname
, *p
, leading_char
;
5838 struct elf_link_hash_entry
*newh
;
5840 leading_char
= bfd_get_symbol_leading_char (output_bfd
);
5842 namelen
= strlen (name
) + (leading_char
!= '\0');
5844 verlen
= strlen (verstr
);
5845 newlen
= namelen
+ verlen
+ 3;
5847 newname
= (char *) bfd_malloc (newlen
);
5848 if (newname
== NULL
)
5850 newname
[0] = leading_char
;
5851 memcpy (newname
+ (leading_char
!= '\0'), name
, namelen
);
5853 /* Check the hidden versioned definition. */
5854 p
= newname
+ namelen
;
5856 memcpy (p
, verstr
, verlen
+ 1);
5857 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5858 newname
, FALSE
, FALSE
,
5861 || (newh
->root
.type
!= bfd_link_hash_defined
5862 && newh
->root
.type
!= bfd_link_hash_defweak
))
5864 /* Check the default versioned definition. */
5866 memcpy (p
, verstr
, verlen
+ 1);
5867 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5868 newname
, FALSE
, FALSE
,
5873 /* Mark this version if there is a definition and it is
5874 not defined in a shared object. */
5876 && !newh
->def_dynamic
5877 && (newh
->root
.type
== bfd_link_hash_defined
5878 || newh
->root
.type
== bfd_link_hash_defweak
))
5882 /* Attach all the symbols to their version information. */
5883 asvinfo
.info
= info
;
5884 asvinfo
.failed
= FALSE
;
5886 elf_link_hash_traverse (elf_hash_table (info
),
5887 _bfd_elf_link_assign_sym_version
,
5892 if (!info
->allow_undefined_version
)
5894 /* Check if all global versions have a definition. */
5896 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
5897 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5898 if (d
->literal
&& !d
->symver
&& !d
->script
)
5900 (*_bfd_error_handler
)
5901 (_("%s: undefined version: %s"),
5902 d
->pattern
, t
->name
);
5903 all_defined
= FALSE
;
5908 bfd_set_error (bfd_error_bad_value
);
5913 /* Find all symbols which were defined in a dynamic object and make
5914 the backend pick a reasonable value for them. */
5915 elf_link_hash_traverse (elf_hash_table (info
),
5916 _bfd_elf_adjust_dynamic_symbol
,
5921 /* Add some entries to the .dynamic section. We fill in some of the
5922 values later, in bfd_elf_final_link, but we must add the entries
5923 now so that we know the final size of the .dynamic section. */
5925 /* If there are initialization and/or finalization functions to
5926 call then add the corresponding DT_INIT/DT_FINI entries. */
5927 h
= (info
->init_function
5928 ? elf_link_hash_lookup (elf_hash_table (info
),
5929 info
->init_function
, FALSE
,
5936 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT
, 0))
5939 h
= (info
->fini_function
5940 ? elf_link_hash_lookup (elf_hash_table (info
),
5941 info
->fini_function
, FALSE
,
5948 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI
, 0))
5952 s
= bfd_get_section_by_name (output_bfd
, ".preinit_array");
5953 if (s
!= NULL
&& s
->linker_has_input
)
5955 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5956 if (! info
->executable
)
5961 for (sub
= info
->input_bfds
; sub
!= NULL
;
5962 sub
= sub
->link_next
)
5963 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
)
5964 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5965 if (elf_section_data (o
)->this_hdr
.sh_type
5966 == SHT_PREINIT_ARRAY
)
5968 (*_bfd_error_handler
)
5969 (_("%B: .preinit_array section is not allowed in DSO"),
5974 bfd_set_error (bfd_error_nonrepresentable_section
);
5978 if (!_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
5979 || !_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
5982 s
= bfd_get_section_by_name (output_bfd
, ".init_array");
5983 if (s
!= NULL
&& s
->linker_has_input
)
5985 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
5986 || !_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
5989 s
= bfd_get_section_by_name (output_bfd
, ".fini_array");
5990 if (s
!= NULL
&& s
->linker_has_input
)
5992 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
5993 || !_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
5997 dynstr
= bfd_get_linker_section (dynobj
, ".dynstr");
5998 /* If .dynstr is excluded from the link, we don't want any of
5999 these tags. Strictly, we should be checking each section
6000 individually; This quick check covers for the case where
6001 someone does a /DISCARD/ : { *(*) }. */
6002 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
6004 bfd_size_type strsize
;
6006 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6007 if ((info
->emit_hash
6008 && !_bfd_elf_add_dynamic_entry (info
, DT_HASH
, 0))
6009 || (info
->emit_gnu_hash
6010 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_HASH
, 0))
6011 || !_bfd_elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
6012 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
6013 || !_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
6014 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMENT
,
6015 bed
->s
->sizeof_sym
))
6020 /* The backend must work out the sizes of all the other dynamic
6023 && bed
->elf_backend_size_dynamic_sections
!= NULL
6024 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
6027 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
6030 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
6032 unsigned long section_sym_count
;
6033 struct bfd_elf_version_tree
*verdefs
;
6036 /* Set up the version definition section. */
6037 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
6038 BFD_ASSERT (s
!= NULL
);
6040 /* We may have created additional version definitions if we are
6041 just linking a regular application. */
6042 verdefs
= info
->version_info
;
6044 /* Skip anonymous version tag. */
6045 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
6046 verdefs
= verdefs
->next
;
6048 if (verdefs
== NULL
&& !info
->create_default_symver
)
6049 s
->flags
|= SEC_EXCLUDE
;
6054 struct bfd_elf_version_tree
*t
;
6056 Elf_Internal_Verdef def
;
6057 Elf_Internal_Verdaux defaux
;
6058 struct bfd_link_hash_entry
*bh
;
6059 struct elf_link_hash_entry
*h
;
6065 /* Make space for the base version. */
6066 size
+= sizeof (Elf_External_Verdef
);
6067 size
+= sizeof (Elf_External_Verdaux
);
6070 /* Make space for the default version. */
6071 if (info
->create_default_symver
)
6073 size
+= sizeof (Elf_External_Verdef
);
6077 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6079 struct bfd_elf_version_deps
*n
;
6081 /* Don't emit base version twice. */
6085 size
+= sizeof (Elf_External_Verdef
);
6086 size
+= sizeof (Elf_External_Verdaux
);
6089 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6090 size
+= sizeof (Elf_External_Verdaux
);
6094 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6095 if (s
->contents
== NULL
&& s
->size
!= 0)
6098 /* Fill in the version definition section. */
6102 def
.vd_version
= VER_DEF_CURRENT
;
6103 def
.vd_flags
= VER_FLG_BASE
;
6106 if (info
->create_default_symver
)
6108 def
.vd_aux
= 2 * sizeof (Elf_External_Verdef
);
6109 def
.vd_next
= sizeof (Elf_External_Verdef
);
6113 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6114 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6115 + sizeof (Elf_External_Verdaux
));
6118 if (soname_indx
!= (bfd_size_type
) -1)
6120 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6122 def
.vd_hash
= bfd_elf_hash (soname
);
6123 defaux
.vda_name
= soname_indx
;
6130 name
= lbasename (output_bfd
->filename
);
6131 def
.vd_hash
= bfd_elf_hash (name
);
6132 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6134 if (indx
== (bfd_size_type
) -1)
6136 defaux
.vda_name
= indx
;
6138 defaux
.vda_next
= 0;
6140 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6141 (Elf_External_Verdef
*) p
);
6142 p
+= sizeof (Elf_External_Verdef
);
6143 if (info
->create_default_symver
)
6145 /* Add a symbol representing this version. */
6147 if (! (_bfd_generic_link_add_one_symbol
6148 (info
, dynobj
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6150 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6152 h
= (struct elf_link_hash_entry
*) bh
;
6155 h
->type
= STT_OBJECT
;
6156 h
->verinfo
.vertree
= NULL
;
6158 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6161 /* Create a duplicate of the base version with the same
6162 aux block, but different flags. */
6165 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6167 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6168 + sizeof (Elf_External_Verdaux
));
6171 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6172 (Elf_External_Verdef
*) p
);
6173 p
+= sizeof (Elf_External_Verdef
);
6175 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6176 (Elf_External_Verdaux
*) p
);
6177 p
+= sizeof (Elf_External_Verdaux
);
6179 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6182 struct bfd_elf_version_deps
*n
;
6184 /* Don't emit the base version twice. */
6189 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6192 /* Add a symbol representing this version. */
6194 if (! (_bfd_generic_link_add_one_symbol
6195 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6197 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6199 h
= (struct elf_link_hash_entry
*) bh
;
6202 h
->type
= STT_OBJECT
;
6203 h
->verinfo
.vertree
= t
;
6205 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6208 def
.vd_version
= VER_DEF_CURRENT
;
6210 if (t
->globals
.list
== NULL
6211 && t
->locals
.list
== NULL
6213 def
.vd_flags
|= VER_FLG_WEAK
;
6214 def
.vd_ndx
= t
->vernum
+ (info
->create_default_symver
? 2 : 1);
6215 def
.vd_cnt
= cdeps
+ 1;
6216 def
.vd_hash
= bfd_elf_hash (t
->name
);
6217 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6220 /* If a basever node is next, it *must* be the last node in
6221 the chain, otherwise Verdef construction breaks. */
6222 if (t
->next
!= NULL
&& t
->next
->vernum
== 0)
6223 BFD_ASSERT (t
->next
->next
== NULL
);
6225 if (t
->next
!= NULL
&& t
->next
->vernum
!= 0)
6226 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6227 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
6229 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6230 (Elf_External_Verdef
*) p
);
6231 p
+= sizeof (Elf_External_Verdef
);
6233 defaux
.vda_name
= h
->dynstr_index
;
6234 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6236 defaux
.vda_next
= 0;
6237 if (t
->deps
!= NULL
)
6238 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6239 t
->name_indx
= defaux
.vda_name
;
6241 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6242 (Elf_External_Verdaux
*) p
);
6243 p
+= sizeof (Elf_External_Verdaux
);
6245 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6247 if (n
->version_needed
== NULL
)
6249 /* This can happen if there was an error in the
6251 defaux
.vda_name
= 0;
6255 defaux
.vda_name
= n
->version_needed
->name_indx
;
6256 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6259 if (n
->next
== NULL
)
6260 defaux
.vda_next
= 0;
6262 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6264 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6265 (Elf_External_Verdaux
*) p
);
6266 p
+= sizeof (Elf_External_Verdaux
);
6270 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
6271 || !_bfd_elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
6274 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
6277 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
6279 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
6282 else if (info
->flags
& DF_BIND_NOW
)
6284 if (!_bfd_elf_add_dynamic_entry (info
, DT_BIND_NOW
, 0))
6290 if (info
->executable
)
6291 info
->flags_1
&= ~ (DF_1_INITFIRST
6294 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
6298 /* Work out the size of the version reference section. */
6300 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
6301 BFD_ASSERT (s
!= NULL
);
6303 struct elf_find_verdep_info sinfo
;
6306 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
6307 if (sinfo
.vers
== 0)
6309 sinfo
.failed
= FALSE
;
6311 elf_link_hash_traverse (elf_hash_table (info
),
6312 _bfd_elf_link_find_version_dependencies
,
6317 if (elf_tdata (output_bfd
)->verref
== NULL
)
6318 s
->flags
|= SEC_EXCLUDE
;
6321 Elf_Internal_Verneed
*t
;
6326 /* Build the version dependency section. */
6329 for (t
= elf_tdata (output_bfd
)->verref
;
6333 Elf_Internal_Vernaux
*a
;
6335 size
+= sizeof (Elf_External_Verneed
);
6337 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6338 size
+= sizeof (Elf_External_Vernaux
);
6342 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6343 if (s
->contents
== NULL
)
6347 for (t
= elf_tdata (output_bfd
)->verref
;
6352 Elf_Internal_Vernaux
*a
;
6356 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6359 t
->vn_version
= VER_NEED_CURRENT
;
6361 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6362 elf_dt_name (t
->vn_bfd
) != NULL
6363 ? elf_dt_name (t
->vn_bfd
)
6364 : lbasename (t
->vn_bfd
->filename
),
6366 if (indx
== (bfd_size_type
) -1)
6369 t
->vn_aux
= sizeof (Elf_External_Verneed
);
6370 if (t
->vn_nextref
== NULL
)
6373 t
->vn_next
= (sizeof (Elf_External_Verneed
)
6374 + caux
* sizeof (Elf_External_Vernaux
));
6376 _bfd_elf_swap_verneed_out (output_bfd
, t
,
6377 (Elf_External_Verneed
*) p
);
6378 p
+= sizeof (Elf_External_Verneed
);
6380 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6382 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
6383 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6384 a
->vna_nodename
, FALSE
);
6385 if (indx
== (bfd_size_type
) -1)
6388 if (a
->vna_nextptr
== NULL
)
6391 a
->vna_next
= sizeof (Elf_External_Vernaux
);
6393 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
6394 (Elf_External_Vernaux
*) p
);
6395 p
+= sizeof (Elf_External_Vernaux
);
6399 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
6400 || !_bfd_elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
6403 elf_tdata (output_bfd
)->cverrefs
= crefs
;
6407 if ((elf_tdata (output_bfd
)->cverrefs
== 0
6408 && elf_tdata (output_bfd
)->cverdefs
== 0)
6409 || _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6410 §ion_sym_count
) == 0)
6412 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6413 s
->flags
|= SEC_EXCLUDE
;
6419 /* Find the first non-excluded output section. We'll use its
6420 section symbol for some emitted relocs. */
6422 _bfd_elf_init_1_index_section (bfd
*output_bfd
, struct bfd_link_info
*info
)
6426 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6427 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
6428 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6430 elf_hash_table (info
)->text_index_section
= s
;
6435 /* Find two non-excluded output sections, one for code, one for data.
6436 We'll use their section symbols for some emitted relocs. */
6438 _bfd_elf_init_2_index_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6442 /* Data first, since setting text_index_section changes
6443 _bfd_elf_link_omit_section_dynsym. */
6444 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6445 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
)) == SEC_ALLOC
)
6446 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6448 elf_hash_table (info
)->data_index_section
= s
;
6452 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6453 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
))
6454 == (SEC_ALLOC
| SEC_READONLY
))
6455 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6457 elf_hash_table (info
)->text_index_section
= s
;
6461 if (elf_hash_table (info
)->text_index_section
== NULL
)
6462 elf_hash_table (info
)->text_index_section
6463 = elf_hash_table (info
)->data_index_section
;
6467 bfd_elf_size_dynsym_hash_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
6469 const struct elf_backend_data
*bed
;
6471 if (!is_elf_hash_table (info
->hash
))
6474 bed
= get_elf_backend_data (output_bfd
);
6475 (*bed
->elf_backend_init_index_section
) (output_bfd
, info
);
6477 if (elf_hash_table (info
)->dynamic_sections_created
)
6481 bfd_size_type dynsymcount
;
6482 unsigned long section_sym_count
;
6483 unsigned int dtagcount
;
6485 dynobj
= elf_hash_table (info
)->dynobj
;
6487 /* Assign dynsym indicies. In a shared library we generate a
6488 section symbol for each output section, which come first.
6489 Next come all of the back-end allocated local dynamic syms,
6490 followed by the rest of the global symbols. */
6492 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6493 §ion_sym_count
);
6495 /* Work out the size of the symbol version section. */
6496 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6497 BFD_ASSERT (s
!= NULL
);
6498 if (dynsymcount
!= 0
6499 && (s
->flags
& SEC_EXCLUDE
) == 0)
6501 s
->size
= dynsymcount
* sizeof (Elf_External_Versym
);
6502 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6503 if (s
->contents
== NULL
)
6506 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
6510 /* Set the size of the .dynsym and .hash sections. We counted
6511 the number of dynamic symbols in elf_link_add_object_symbols.
6512 We will build the contents of .dynsym and .hash when we build
6513 the final symbol table, because until then we do not know the
6514 correct value to give the symbols. We built the .dynstr
6515 section as we went along in elf_link_add_object_symbols. */
6516 s
= bfd_get_linker_section (dynobj
, ".dynsym");
6517 BFD_ASSERT (s
!= NULL
);
6518 s
->size
= dynsymcount
* bed
->s
->sizeof_sym
;
6520 if (dynsymcount
!= 0)
6522 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6523 if (s
->contents
== NULL
)
6526 /* The first entry in .dynsym is a dummy symbol.
6527 Clear all the section syms, in case we don't output them all. */
6528 ++section_sym_count
;
6529 memset (s
->contents
, 0, section_sym_count
* bed
->s
->sizeof_sym
);
6532 elf_hash_table (info
)->bucketcount
= 0;
6534 /* Compute the size of the hashing table. As a side effect this
6535 computes the hash values for all the names we export. */
6536 if (info
->emit_hash
)
6538 unsigned long int *hashcodes
;
6539 struct hash_codes_info hashinf
;
6541 unsigned long int nsyms
;
6543 size_t hash_entry_size
;
6545 /* Compute the hash values for all exported symbols. At the same
6546 time store the values in an array so that we could use them for
6548 amt
= dynsymcount
* sizeof (unsigned long int);
6549 hashcodes
= (unsigned long int *) bfd_malloc (amt
);
6550 if (hashcodes
== NULL
)
6552 hashinf
.hashcodes
= hashcodes
;
6553 hashinf
.error
= FALSE
;
6555 /* Put all hash values in HASHCODES. */
6556 elf_link_hash_traverse (elf_hash_table (info
),
6557 elf_collect_hash_codes
, &hashinf
);
6564 nsyms
= hashinf
.hashcodes
- hashcodes
;
6566 = compute_bucket_count (info
, hashcodes
, nsyms
, 0);
6569 if (bucketcount
== 0)
6572 elf_hash_table (info
)->bucketcount
= bucketcount
;
6574 s
= bfd_get_linker_section (dynobj
, ".hash");
6575 BFD_ASSERT (s
!= NULL
);
6576 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
6577 s
->size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
6578 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6579 if (s
->contents
== NULL
)
6582 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
6583 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
6584 s
->contents
+ hash_entry_size
);
6587 if (info
->emit_gnu_hash
)
6590 unsigned char *contents
;
6591 struct collect_gnu_hash_codes cinfo
;
6595 memset (&cinfo
, 0, sizeof (cinfo
));
6597 /* Compute the hash values for all exported symbols. At the same
6598 time store the values in an array so that we could use them for
6600 amt
= dynsymcount
* 2 * sizeof (unsigned long int);
6601 cinfo
.hashcodes
= (long unsigned int *) bfd_malloc (amt
);
6602 if (cinfo
.hashcodes
== NULL
)
6605 cinfo
.hashval
= cinfo
.hashcodes
+ dynsymcount
;
6606 cinfo
.min_dynindx
= -1;
6607 cinfo
.output_bfd
= output_bfd
;
6610 /* Put all hash values in HASHCODES. */
6611 elf_link_hash_traverse (elf_hash_table (info
),
6612 elf_collect_gnu_hash_codes
, &cinfo
);
6615 free (cinfo
.hashcodes
);
6620 = compute_bucket_count (info
, cinfo
.hashcodes
, cinfo
.nsyms
, 1);
6622 if (bucketcount
== 0)
6624 free (cinfo
.hashcodes
);
6628 s
= bfd_get_linker_section (dynobj
, ".gnu.hash");
6629 BFD_ASSERT (s
!= NULL
);
6631 if (cinfo
.nsyms
== 0)
6633 /* Empty .gnu.hash section is special. */
6634 BFD_ASSERT (cinfo
.min_dynindx
== -1);
6635 free (cinfo
.hashcodes
);
6636 s
->size
= 5 * 4 + bed
->s
->arch_size
/ 8;
6637 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6638 if (contents
== NULL
)
6640 s
->contents
= contents
;
6641 /* 1 empty bucket. */
6642 bfd_put_32 (output_bfd
, 1, contents
);
6643 /* SYMIDX above the special symbol 0. */
6644 bfd_put_32 (output_bfd
, 1, contents
+ 4);
6645 /* Just one word for bitmask. */
6646 bfd_put_32 (output_bfd
, 1, contents
+ 8);
6647 /* Only hash fn bloom filter. */
6648 bfd_put_32 (output_bfd
, 0, contents
+ 12);
6649 /* No hashes are valid - empty bitmask. */
6650 bfd_put (bed
->s
->arch_size
, output_bfd
, 0, contents
+ 16);
6651 /* No hashes in the only bucket. */
6652 bfd_put_32 (output_bfd
, 0,
6653 contents
+ 16 + bed
->s
->arch_size
/ 8);
6657 unsigned long int maskwords
, maskbitslog2
, x
;
6658 BFD_ASSERT (cinfo
.min_dynindx
!= -1);
6662 while ((x
>>= 1) != 0)
6664 if (maskbitslog2
< 3)
6666 else if ((1 << (maskbitslog2
- 2)) & cinfo
.nsyms
)
6667 maskbitslog2
= maskbitslog2
+ 3;
6669 maskbitslog2
= maskbitslog2
+ 2;
6670 if (bed
->s
->arch_size
== 64)
6672 if (maskbitslog2
== 5)
6678 cinfo
.mask
= (1 << cinfo
.shift1
) - 1;
6679 cinfo
.shift2
= maskbitslog2
;
6680 cinfo
.maskbits
= 1 << maskbitslog2
;
6681 maskwords
= 1 << (maskbitslog2
- cinfo
.shift1
);
6682 amt
= bucketcount
* sizeof (unsigned long int) * 2;
6683 amt
+= maskwords
* sizeof (bfd_vma
);
6684 cinfo
.bitmask
= (bfd_vma
*) bfd_malloc (amt
);
6685 if (cinfo
.bitmask
== NULL
)
6687 free (cinfo
.hashcodes
);
6691 cinfo
.counts
= (long unsigned int *) (cinfo
.bitmask
+ maskwords
);
6692 cinfo
.indx
= cinfo
.counts
+ bucketcount
;
6693 cinfo
.symindx
= dynsymcount
- cinfo
.nsyms
;
6694 memset (cinfo
.bitmask
, 0, maskwords
* sizeof (bfd_vma
));
6696 /* Determine how often each hash bucket is used. */
6697 memset (cinfo
.counts
, 0, bucketcount
* sizeof (cinfo
.counts
[0]));
6698 for (i
= 0; i
< cinfo
.nsyms
; ++i
)
6699 ++cinfo
.counts
[cinfo
.hashcodes
[i
] % bucketcount
];
6701 for (i
= 0, cnt
= cinfo
.symindx
; i
< bucketcount
; ++i
)
6702 if (cinfo
.counts
[i
] != 0)
6704 cinfo
.indx
[i
] = cnt
;
6705 cnt
+= cinfo
.counts
[i
];
6707 BFD_ASSERT (cnt
== dynsymcount
);
6708 cinfo
.bucketcount
= bucketcount
;
6709 cinfo
.local_indx
= cinfo
.min_dynindx
;
6711 s
->size
= (4 + bucketcount
+ cinfo
.nsyms
) * 4;
6712 s
->size
+= cinfo
.maskbits
/ 8;
6713 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6714 if (contents
== NULL
)
6716 free (cinfo
.bitmask
);
6717 free (cinfo
.hashcodes
);
6721 s
->contents
= contents
;
6722 bfd_put_32 (output_bfd
, bucketcount
, contents
);
6723 bfd_put_32 (output_bfd
, cinfo
.symindx
, contents
+ 4);
6724 bfd_put_32 (output_bfd
, maskwords
, contents
+ 8);
6725 bfd_put_32 (output_bfd
, cinfo
.shift2
, contents
+ 12);
6726 contents
+= 16 + cinfo
.maskbits
/ 8;
6728 for (i
= 0; i
< bucketcount
; ++i
)
6730 if (cinfo
.counts
[i
] == 0)
6731 bfd_put_32 (output_bfd
, 0, contents
);
6733 bfd_put_32 (output_bfd
, cinfo
.indx
[i
], contents
);
6737 cinfo
.contents
= contents
;
6739 /* Renumber dynamic symbols, populate .gnu.hash section. */
6740 elf_link_hash_traverse (elf_hash_table (info
),
6741 elf_renumber_gnu_hash_syms
, &cinfo
);
6743 contents
= s
->contents
+ 16;
6744 for (i
= 0; i
< maskwords
; ++i
)
6746 bfd_put (bed
->s
->arch_size
, output_bfd
, cinfo
.bitmask
[i
],
6748 contents
+= bed
->s
->arch_size
/ 8;
6751 free (cinfo
.bitmask
);
6752 free (cinfo
.hashcodes
);
6756 s
= bfd_get_linker_section (dynobj
, ".dynstr");
6757 BFD_ASSERT (s
!= NULL
);
6759 elf_finalize_dynstr (output_bfd
, info
);
6761 s
->size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6763 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
6764 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0))
6771 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
6774 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
6777 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
);
6778 sec
->sec_info_type
= SEC_INFO_TYPE_NONE
;
6781 /* Finish SHF_MERGE section merging. */
6784 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6789 if (!is_elf_hash_table (info
->hash
))
6792 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
6793 if ((ibfd
->flags
& DYNAMIC
) == 0)
6794 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6795 if ((sec
->flags
& SEC_MERGE
) != 0
6796 && !bfd_is_abs_section (sec
->output_section
))
6798 struct bfd_elf_section_data
*secdata
;
6800 secdata
= elf_section_data (sec
);
6801 if (! _bfd_add_merge_section (abfd
,
6802 &elf_hash_table (info
)->merge_info
,
6803 sec
, &secdata
->sec_info
))
6805 else if (secdata
->sec_info
)
6806 sec
->sec_info_type
= SEC_INFO_TYPE_MERGE
;
6809 if (elf_hash_table (info
)->merge_info
!= NULL
)
6810 _bfd_merge_sections (abfd
, info
, elf_hash_table (info
)->merge_info
,
6811 merge_sections_remove_hook
);
6815 /* Create an entry in an ELF linker hash table. */
6817 struct bfd_hash_entry
*
6818 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
6819 struct bfd_hash_table
*table
,
6822 /* Allocate the structure if it has not already been allocated by a
6826 entry
= (struct bfd_hash_entry
*)
6827 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
6832 /* Call the allocation method of the superclass. */
6833 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
6836 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
6837 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
6839 /* Set local fields. */
6842 ret
->got
= htab
->init_got_refcount
;
6843 ret
->plt
= htab
->init_plt_refcount
;
6844 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
6845 - offsetof (struct elf_link_hash_entry
, size
)));
6846 /* Assume that we have been called by a non-ELF symbol reader.
6847 This flag is then reset by the code which reads an ELF input
6848 file. This ensures that a symbol created by a non-ELF symbol
6849 reader will have the flag set correctly. */
6856 /* Copy data from an indirect symbol to its direct symbol, hiding the
6857 old indirect symbol. Also used for copying flags to a weakdef. */
6860 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info
*info
,
6861 struct elf_link_hash_entry
*dir
,
6862 struct elf_link_hash_entry
*ind
)
6864 struct elf_link_hash_table
*htab
;
6866 /* Copy down any references that we may have already seen to the
6867 symbol which just became indirect. */
6869 dir
->ref_dynamic
|= ind
->ref_dynamic
;
6870 dir
->ref_regular
|= ind
->ref_regular
;
6871 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
6872 dir
->non_got_ref
|= ind
->non_got_ref
;
6873 dir
->needs_plt
|= ind
->needs_plt
;
6874 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
6876 if (ind
->root
.type
!= bfd_link_hash_indirect
)
6879 /* Copy over the global and procedure linkage table refcount entries.
6880 These may have been already set up by a check_relocs routine. */
6881 htab
= elf_hash_table (info
);
6882 if (ind
->got
.refcount
> htab
->init_got_refcount
.refcount
)
6884 if (dir
->got
.refcount
< 0)
6885 dir
->got
.refcount
= 0;
6886 dir
->got
.refcount
+= ind
->got
.refcount
;
6887 ind
->got
.refcount
= htab
->init_got_refcount
.refcount
;
6890 if (ind
->plt
.refcount
> htab
->init_plt_refcount
.refcount
)
6892 if (dir
->plt
.refcount
< 0)
6893 dir
->plt
.refcount
= 0;
6894 dir
->plt
.refcount
+= ind
->plt
.refcount
;
6895 ind
->plt
.refcount
= htab
->init_plt_refcount
.refcount
;
6898 if (ind
->dynindx
!= -1)
6900 if (dir
->dynindx
!= -1)
6901 _bfd_elf_strtab_delref (htab
->dynstr
, dir
->dynstr_index
);
6902 dir
->dynindx
= ind
->dynindx
;
6903 dir
->dynstr_index
= ind
->dynstr_index
;
6905 ind
->dynstr_index
= 0;
6910 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
6911 struct elf_link_hash_entry
*h
,
6912 bfd_boolean force_local
)
6914 /* STT_GNU_IFUNC symbol must go through PLT. */
6915 if (h
->type
!= STT_GNU_IFUNC
)
6917 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
6922 h
->forced_local
= 1;
6923 if (h
->dynindx
!= -1)
6926 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
6932 /* Initialize an ELF linker hash table. */
6935 _bfd_elf_link_hash_table_init
6936 (struct elf_link_hash_table
*table
,
6938 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
6939 struct bfd_hash_table
*,
6941 unsigned int entsize
,
6942 enum elf_target_id target_id
)
6945 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
6947 memset (table
, 0, sizeof * table
);
6948 table
->init_got_refcount
.refcount
= can_refcount
- 1;
6949 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
6950 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
6951 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
6952 /* The first dynamic symbol is a dummy. */
6953 table
->dynsymcount
= 1;
6955 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
6957 table
->root
.type
= bfd_link_elf_hash_table
;
6958 table
->hash_table_id
= target_id
;
6963 /* Create an ELF linker hash table. */
6965 struct bfd_link_hash_table
*
6966 _bfd_elf_link_hash_table_create (bfd
*abfd
)
6968 struct elf_link_hash_table
*ret
;
6969 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
6971 ret
= (struct elf_link_hash_table
*) bfd_malloc (amt
);
6975 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
,
6976 sizeof (struct elf_link_hash_entry
),
6986 /* This is a hook for the ELF emulation code in the generic linker to
6987 tell the backend linker what file name to use for the DT_NEEDED
6988 entry for a dynamic object. */
6991 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
6993 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6994 && bfd_get_format (abfd
) == bfd_object
)
6995 elf_dt_name (abfd
) = name
;
6999 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
7002 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7003 && bfd_get_format (abfd
) == bfd_object
)
7004 lib_class
= elf_dyn_lib_class (abfd
);
7011 bfd_elf_set_dyn_lib_class (bfd
*abfd
, enum dynamic_lib_link_class lib_class
)
7013 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7014 && bfd_get_format (abfd
) == bfd_object
)
7015 elf_dyn_lib_class (abfd
) = lib_class
;
7018 /* Get the list of DT_NEEDED entries for a link. This is a hook for
7019 the linker ELF emulation code. */
7021 struct bfd_link_needed_list
*
7022 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
7023 struct bfd_link_info
*info
)
7025 if (! is_elf_hash_table (info
->hash
))
7027 return elf_hash_table (info
)->needed
;
7030 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
7031 hook for the linker ELF emulation code. */
7033 struct bfd_link_needed_list
*
7034 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
7035 struct bfd_link_info
*info
)
7037 if (! is_elf_hash_table (info
->hash
))
7039 return elf_hash_table (info
)->runpath
;
7042 /* Get the name actually used for a dynamic object for a link. This
7043 is the SONAME entry if there is one. Otherwise, it is the string
7044 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
7047 bfd_elf_get_dt_soname (bfd
*abfd
)
7049 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7050 && bfd_get_format (abfd
) == bfd_object
)
7051 return elf_dt_name (abfd
);
7055 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
7056 the ELF linker emulation code. */
7059 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
7060 struct bfd_link_needed_list
**pneeded
)
7063 bfd_byte
*dynbuf
= NULL
;
7064 unsigned int elfsec
;
7065 unsigned long shlink
;
7066 bfd_byte
*extdyn
, *extdynend
;
7068 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
7072 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
7073 || bfd_get_format (abfd
) != bfd_object
)
7076 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7077 if (s
== NULL
|| s
->size
== 0)
7080 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
7083 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
7084 if (elfsec
== SHN_BAD
)
7087 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
7089 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
7090 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
7093 extdynend
= extdyn
+ s
->size
;
7094 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
7096 Elf_Internal_Dyn dyn
;
7098 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
7100 if (dyn
.d_tag
== DT_NULL
)
7103 if (dyn
.d_tag
== DT_NEEDED
)
7106 struct bfd_link_needed_list
*l
;
7107 unsigned int tagv
= dyn
.d_un
.d_val
;
7110 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
7115 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
7136 struct elf_symbuf_symbol
7138 unsigned long st_name
; /* Symbol name, index in string tbl */
7139 unsigned char st_info
; /* Type and binding attributes */
7140 unsigned char st_other
; /* Visibilty, and target specific */
7143 struct elf_symbuf_head
7145 struct elf_symbuf_symbol
*ssym
;
7146 bfd_size_type count
;
7147 unsigned int st_shndx
;
7154 Elf_Internal_Sym
*isym
;
7155 struct elf_symbuf_symbol
*ssym
;
7160 /* Sort references to symbols by ascending section number. */
7163 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
7165 const Elf_Internal_Sym
*s1
= *(const Elf_Internal_Sym
**) arg1
;
7166 const Elf_Internal_Sym
*s2
= *(const Elf_Internal_Sym
**) arg2
;
7168 return s1
->st_shndx
- s2
->st_shndx
;
7172 elf_sym_name_compare (const void *arg1
, const void *arg2
)
7174 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
7175 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
7176 return strcmp (s1
->name
, s2
->name
);
7179 static struct elf_symbuf_head
*
7180 elf_create_symbuf (bfd_size_type symcount
, Elf_Internal_Sym
*isymbuf
)
7182 Elf_Internal_Sym
**ind
, **indbufend
, **indbuf
;
7183 struct elf_symbuf_symbol
*ssym
;
7184 struct elf_symbuf_head
*ssymbuf
, *ssymhead
;
7185 bfd_size_type i
, shndx_count
, total_size
;
7187 indbuf
= (Elf_Internal_Sym
**) bfd_malloc2 (symcount
, sizeof (*indbuf
));
7191 for (ind
= indbuf
, i
= 0; i
< symcount
; i
++)
7192 if (isymbuf
[i
].st_shndx
!= SHN_UNDEF
)
7193 *ind
++ = &isymbuf
[i
];
7196 qsort (indbuf
, indbufend
- indbuf
, sizeof (Elf_Internal_Sym
*),
7197 elf_sort_elf_symbol
);
7200 if (indbufend
> indbuf
)
7201 for (ind
= indbuf
, shndx_count
++; ind
< indbufend
- 1; ind
++)
7202 if (ind
[0]->st_shndx
!= ind
[1]->st_shndx
)
7205 total_size
= ((shndx_count
+ 1) * sizeof (*ssymbuf
)
7206 + (indbufend
- indbuf
) * sizeof (*ssym
));
7207 ssymbuf
= (struct elf_symbuf_head
*) bfd_malloc (total_size
);
7208 if (ssymbuf
== NULL
)
7214 ssym
= (struct elf_symbuf_symbol
*) (ssymbuf
+ shndx_count
+ 1);
7215 ssymbuf
->ssym
= NULL
;
7216 ssymbuf
->count
= shndx_count
;
7217 ssymbuf
->st_shndx
= 0;
7218 for (ssymhead
= ssymbuf
, ind
= indbuf
; ind
< indbufend
; ssym
++, ind
++)
7220 if (ind
== indbuf
|| ssymhead
->st_shndx
!= (*ind
)->st_shndx
)
7223 ssymhead
->ssym
= ssym
;
7224 ssymhead
->count
= 0;
7225 ssymhead
->st_shndx
= (*ind
)->st_shndx
;
7227 ssym
->st_name
= (*ind
)->st_name
;
7228 ssym
->st_info
= (*ind
)->st_info
;
7229 ssym
->st_other
= (*ind
)->st_other
;
7232 BFD_ASSERT ((bfd_size_type
) (ssymhead
- ssymbuf
) == shndx_count
7233 && (((bfd_hostptr_t
) ssym
- (bfd_hostptr_t
) ssymbuf
)
7240 /* Check if 2 sections define the same set of local and global
7244 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
,
7245 struct bfd_link_info
*info
)
7248 const struct elf_backend_data
*bed1
, *bed2
;
7249 Elf_Internal_Shdr
*hdr1
, *hdr2
;
7250 bfd_size_type symcount1
, symcount2
;
7251 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
7252 struct elf_symbuf_head
*ssymbuf1
, *ssymbuf2
;
7253 Elf_Internal_Sym
*isym
, *isymend
;
7254 struct elf_symbol
*symtable1
= NULL
, *symtable2
= NULL
;
7255 bfd_size_type count1
, count2
, i
;
7256 unsigned int shndx1
, shndx2
;
7262 /* Both sections have to be in ELF. */
7263 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
7264 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
7267 if (elf_section_type (sec1
) != elf_section_type (sec2
))
7270 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
7271 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
7272 if (shndx1
== SHN_BAD
|| shndx2
== SHN_BAD
)
7275 bed1
= get_elf_backend_data (bfd1
);
7276 bed2
= get_elf_backend_data (bfd2
);
7277 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
7278 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
7279 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
7280 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
7282 if (symcount1
== 0 || symcount2
== 0)
7288 ssymbuf1
= (struct elf_symbuf_head
*) elf_tdata (bfd1
)->symbuf
;
7289 ssymbuf2
= (struct elf_symbuf_head
*) elf_tdata (bfd2
)->symbuf
;
7291 if (ssymbuf1
== NULL
)
7293 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
7295 if (isymbuf1
== NULL
)
7298 if (!info
->reduce_memory_overheads
)
7299 elf_tdata (bfd1
)->symbuf
= ssymbuf1
7300 = elf_create_symbuf (symcount1
, isymbuf1
);
7303 if (ssymbuf1
== NULL
|| ssymbuf2
== NULL
)
7305 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
7307 if (isymbuf2
== NULL
)
7310 if (ssymbuf1
!= NULL
&& !info
->reduce_memory_overheads
)
7311 elf_tdata (bfd2
)->symbuf
= ssymbuf2
7312 = elf_create_symbuf (symcount2
, isymbuf2
);
7315 if (ssymbuf1
!= NULL
&& ssymbuf2
!= NULL
)
7317 /* Optimized faster version. */
7318 bfd_size_type lo
, hi
, mid
;
7319 struct elf_symbol
*symp
;
7320 struct elf_symbuf_symbol
*ssym
, *ssymend
;
7323 hi
= ssymbuf1
->count
;
7328 mid
= (lo
+ hi
) / 2;
7329 if (shndx1
< ssymbuf1
[mid
].st_shndx
)
7331 else if (shndx1
> ssymbuf1
[mid
].st_shndx
)
7335 count1
= ssymbuf1
[mid
].count
;
7342 hi
= ssymbuf2
->count
;
7347 mid
= (lo
+ hi
) / 2;
7348 if (shndx2
< ssymbuf2
[mid
].st_shndx
)
7350 else if (shndx2
> ssymbuf2
[mid
].st_shndx
)
7354 count2
= ssymbuf2
[mid
].count
;
7360 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7363 symtable1
= (struct elf_symbol
*)
7364 bfd_malloc (count1
* sizeof (struct elf_symbol
));
7365 symtable2
= (struct elf_symbol
*)
7366 bfd_malloc (count2
* sizeof (struct elf_symbol
));
7367 if (symtable1
== NULL
|| symtable2
== NULL
)
7371 for (ssym
= ssymbuf1
->ssym
, ssymend
= ssym
+ count1
;
7372 ssym
< ssymend
; ssym
++, symp
++)
7374 symp
->u
.ssym
= ssym
;
7375 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
7381 for (ssym
= ssymbuf2
->ssym
, ssymend
= ssym
+ count2
;
7382 ssym
< ssymend
; ssym
++, symp
++)
7384 symp
->u
.ssym
= ssym
;
7385 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
7390 /* Sort symbol by name. */
7391 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7392 elf_sym_name_compare
);
7393 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7394 elf_sym_name_compare
);
7396 for (i
= 0; i
< count1
; i
++)
7397 /* Two symbols must have the same binding, type and name. */
7398 if (symtable1
[i
].u
.ssym
->st_info
!= symtable2
[i
].u
.ssym
->st_info
7399 || symtable1
[i
].u
.ssym
->st_other
!= symtable2
[i
].u
.ssym
->st_other
7400 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7407 symtable1
= (struct elf_symbol
*)
7408 bfd_malloc (symcount1
* sizeof (struct elf_symbol
));
7409 symtable2
= (struct elf_symbol
*)
7410 bfd_malloc (symcount2
* sizeof (struct elf_symbol
));
7411 if (symtable1
== NULL
|| symtable2
== NULL
)
7414 /* Count definitions in the section. */
7416 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
; isym
< isymend
; isym
++)
7417 if (isym
->st_shndx
== shndx1
)
7418 symtable1
[count1
++].u
.isym
= isym
;
7421 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
; isym
< isymend
; isym
++)
7422 if (isym
->st_shndx
== shndx2
)
7423 symtable2
[count2
++].u
.isym
= isym
;
7425 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7428 for (i
= 0; i
< count1
; i
++)
7430 = bfd_elf_string_from_elf_section (bfd1
, hdr1
->sh_link
,
7431 symtable1
[i
].u
.isym
->st_name
);
7433 for (i
= 0; i
< count2
; i
++)
7435 = bfd_elf_string_from_elf_section (bfd2
, hdr2
->sh_link
,
7436 symtable2
[i
].u
.isym
->st_name
);
7438 /* Sort symbol by name. */
7439 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7440 elf_sym_name_compare
);
7441 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7442 elf_sym_name_compare
);
7444 for (i
= 0; i
< count1
; i
++)
7445 /* Two symbols must have the same binding, type and name. */
7446 if (symtable1
[i
].u
.isym
->st_info
!= symtable2
[i
].u
.isym
->st_info
7447 || symtable1
[i
].u
.isym
->st_other
!= symtable2
[i
].u
.isym
->st_other
7448 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7466 /* Return TRUE if 2 section types are compatible. */
7469 _bfd_elf_match_sections_by_type (bfd
*abfd
, const asection
*asec
,
7470 bfd
*bbfd
, const asection
*bsec
)
7474 || abfd
->xvec
->flavour
!= bfd_target_elf_flavour
7475 || bbfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7478 return elf_section_type (asec
) == elf_section_type (bsec
);
7481 /* Final phase of ELF linker. */
7483 /* A structure we use to avoid passing large numbers of arguments. */
7485 struct elf_final_link_info
7487 /* General link information. */
7488 struct bfd_link_info
*info
;
7491 /* Symbol string table. */
7492 struct bfd_strtab_hash
*symstrtab
;
7493 /* .dynsym section. */
7494 asection
*dynsym_sec
;
7495 /* .hash section. */
7497 /* symbol version section (.gnu.version). */
7498 asection
*symver_sec
;
7499 /* Buffer large enough to hold contents of any section. */
7501 /* Buffer large enough to hold external relocs of any section. */
7502 void *external_relocs
;
7503 /* Buffer large enough to hold internal relocs of any section. */
7504 Elf_Internal_Rela
*internal_relocs
;
7505 /* Buffer large enough to hold external local symbols of any input
7507 bfd_byte
*external_syms
;
7508 /* And a buffer for symbol section indices. */
7509 Elf_External_Sym_Shndx
*locsym_shndx
;
7510 /* Buffer large enough to hold internal local symbols of any input
7512 Elf_Internal_Sym
*internal_syms
;
7513 /* Array large enough to hold a symbol index for each local symbol
7514 of any input BFD. */
7516 /* Array large enough to hold a section pointer for each local
7517 symbol of any input BFD. */
7518 asection
**sections
;
7519 /* Buffer to hold swapped out symbols. */
7521 /* And one for symbol section indices. */
7522 Elf_External_Sym_Shndx
*symshndxbuf
;
7523 /* Number of swapped out symbols in buffer. */
7524 size_t symbuf_count
;
7525 /* Number of symbols which fit in symbuf. */
7527 /* And same for symshndxbuf. */
7528 size_t shndxbuf_size
;
7529 /* Number of STT_FILE syms seen. */
7530 size_t filesym_count
;
7533 /* This struct is used to pass information to elf_link_output_extsym. */
7535 struct elf_outext_info
7538 bfd_boolean localsyms
;
7539 bfd_boolean need_second_pass
;
7540 bfd_boolean second_pass
;
7541 struct elf_final_link_info
*flinfo
;
7545 /* Support for evaluating a complex relocation.
7547 Complex relocations are generalized, self-describing relocations. The
7548 implementation of them consists of two parts: complex symbols, and the
7549 relocations themselves.
7551 The relocations are use a reserved elf-wide relocation type code (R_RELC
7552 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7553 information (start bit, end bit, word width, etc) into the addend. This
7554 information is extracted from CGEN-generated operand tables within gas.
7556 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7557 internal) representing prefix-notation expressions, including but not
7558 limited to those sorts of expressions normally encoded as addends in the
7559 addend field. The symbol mangling format is:
7562 | <unary-operator> ':' <node>
7563 | <binary-operator> ':' <node> ':' <node>
7566 <literal> := 's' <digits=N> ':' <N character symbol name>
7567 | 'S' <digits=N> ':' <N character section name>
7571 <binary-operator> := as in C
7572 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7575 set_symbol_value (bfd
*bfd_with_globals
,
7576 Elf_Internal_Sym
*isymbuf
,
7581 struct elf_link_hash_entry
**sym_hashes
;
7582 struct elf_link_hash_entry
*h
;
7583 size_t extsymoff
= locsymcount
;
7585 if (symidx
< locsymcount
)
7587 Elf_Internal_Sym
*sym
;
7589 sym
= isymbuf
+ symidx
;
7590 if (ELF_ST_BIND (sym
->st_info
) == STB_LOCAL
)
7592 /* It is a local symbol: move it to the
7593 "absolute" section and give it a value. */
7594 sym
->st_shndx
= SHN_ABS
;
7595 sym
->st_value
= val
;
7598 BFD_ASSERT (elf_bad_symtab (bfd_with_globals
));
7602 /* It is a global symbol: set its link type
7603 to "defined" and give it a value. */
7605 sym_hashes
= elf_sym_hashes (bfd_with_globals
);
7606 h
= sym_hashes
[symidx
- extsymoff
];
7607 while (h
->root
.type
== bfd_link_hash_indirect
7608 || h
->root
.type
== bfd_link_hash_warning
)
7609 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7610 h
->root
.type
= bfd_link_hash_defined
;
7611 h
->root
.u
.def
.value
= val
;
7612 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
7616 resolve_symbol (const char *name
,
7618 struct elf_final_link_info
*flinfo
,
7620 Elf_Internal_Sym
*isymbuf
,
7623 Elf_Internal_Sym
*sym
;
7624 struct bfd_link_hash_entry
*global_entry
;
7625 const char *candidate
= NULL
;
7626 Elf_Internal_Shdr
*symtab_hdr
;
7629 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
7631 for (i
= 0; i
< locsymcount
; ++ i
)
7635 if (ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7638 candidate
= bfd_elf_string_from_elf_section (input_bfd
,
7639 symtab_hdr
->sh_link
,
7642 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7643 name
, candidate
, (unsigned long) sym
->st_value
);
7645 if (candidate
&& strcmp (candidate
, name
) == 0)
7647 asection
*sec
= flinfo
->sections
[i
];
7649 *result
= _bfd_elf_rel_local_sym (input_bfd
, sym
, &sec
, 0);
7650 *result
+= sec
->output_offset
+ sec
->output_section
->vma
;
7652 printf ("Found symbol with value %8.8lx\n",
7653 (unsigned long) *result
);
7659 /* Hmm, haven't found it yet. perhaps it is a global. */
7660 global_entry
= bfd_link_hash_lookup (flinfo
->info
->hash
, name
,
7661 FALSE
, FALSE
, TRUE
);
7665 if (global_entry
->type
== bfd_link_hash_defined
7666 || global_entry
->type
== bfd_link_hash_defweak
)
7668 *result
= (global_entry
->u
.def
.value
7669 + global_entry
->u
.def
.section
->output_section
->vma
7670 + global_entry
->u
.def
.section
->output_offset
);
7672 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7673 global_entry
->root
.string
, (unsigned long) *result
);
7682 resolve_section (const char *name
,
7689 for (curr
= sections
; curr
; curr
= curr
->next
)
7690 if (strcmp (curr
->name
, name
) == 0)
7692 *result
= curr
->vma
;
7696 /* Hmm. still haven't found it. try pseudo-section names. */
7697 for (curr
= sections
; curr
; curr
= curr
->next
)
7699 len
= strlen (curr
->name
);
7700 if (len
> strlen (name
))
7703 if (strncmp (curr
->name
, name
, len
) == 0)
7705 if (strncmp (".end", name
+ len
, 4) == 0)
7707 *result
= curr
->vma
+ curr
->size
;
7711 /* Insert more pseudo-section names here, if you like. */
7719 undefined_reference (const char *reftype
, const char *name
)
7721 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7726 eval_symbol (bfd_vma
*result
,
7729 struct elf_final_link_info
*flinfo
,
7731 Elf_Internal_Sym
*isymbuf
,
7740 const char *sym
= *symp
;
7742 bfd_boolean symbol_is_section
= FALSE
;
7747 if (len
< 1 || len
> sizeof (symbuf
))
7749 bfd_set_error (bfd_error_invalid_operation
);
7762 *result
= strtoul (sym
, (char **) symp
, 16);
7766 symbol_is_section
= TRUE
;
7769 symlen
= strtol (sym
, (char **) symp
, 10);
7770 sym
= *symp
+ 1; /* Skip the trailing ':'. */
7772 if (symend
< sym
|| symlen
+ 1 > sizeof (symbuf
))
7774 bfd_set_error (bfd_error_invalid_operation
);
7778 memcpy (symbuf
, sym
, symlen
);
7779 symbuf
[symlen
] = '\0';
7780 *symp
= sym
+ symlen
;
7782 /* Is it always possible, with complex symbols, that gas "mis-guessed"
7783 the symbol as a section, or vice-versa. so we're pretty liberal in our
7784 interpretation here; section means "try section first", not "must be a
7785 section", and likewise with symbol. */
7787 if (symbol_is_section
)
7789 if (!resolve_section (symbuf
, flinfo
->output_bfd
->sections
, result
)
7790 && !resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
7791 isymbuf
, locsymcount
))
7793 undefined_reference ("section", symbuf
);
7799 if (!resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
7800 isymbuf
, locsymcount
)
7801 && !resolve_section (symbuf
, flinfo
->output_bfd
->sections
,
7804 undefined_reference ("symbol", symbuf
);
7811 /* All that remains are operators. */
7813 #define UNARY_OP(op) \
7814 if (strncmp (sym, #op, strlen (#op)) == 0) \
7816 sym += strlen (#op); \
7820 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7821 isymbuf, locsymcount, signed_p)) \
7824 *result = op ((bfd_signed_vma) a); \
7830 #define BINARY_OP(op) \
7831 if (strncmp (sym, #op, strlen (#op)) == 0) \
7833 sym += strlen (#op); \
7837 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7838 isymbuf, locsymcount, signed_p)) \
7841 if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
7842 isymbuf, locsymcount, signed_p)) \
7845 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7875 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym
);
7876 bfd_set_error (bfd_error_invalid_operation
);
7882 put_value (bfd_vma size
,
7883 unsigned long chunksz
,
7888 location
+= (size
- chunksz
);
7890 for (; size
; size
-= chunksz
, location
-= chunksz
, x
>>= (chunksz
* 8))
7898 bfd_put_8 (input_bfd
, x
, location
);
7901 bfd_put_16 (input_bfd
, x
, location
);
7904 bfd_put_32 (input_bfd
, x
, location
);
7908 bfd_put_64 (input_bfd
, x
, location
);
7918 get_value (bfd_vma size
,
7919 unsigned long chunksz
,
7926 /* Sanity checks. */
7927 BFD_ASSERT (chunksz
<= sizeof (x
)
7930 && (size
% chunksz
) == 0
7931 && input_bfd
!= NULL
7932 && location
!= NULL
);
7934 if (chunksz
== sizeof (x
))
7936 BFD_ASSERT (size
== chunksz
);
7938 /* Make sure that we do not perform an undefined shift operation.
7939 We know that size == chunksz so there will only be one iteration
7940 of the loop below. */
7944 shift
= 8 * chunksz
;
7946 for (; size
; size
-= chunksz
, location
+= chunksz
)
7951 x
= (x
<< shift
) | bfd_get_8 (input_bfd
, location
);
7954 x
= (x
<< shift
) | bfd_get_16 (input_bfd
, location
);
7957 x
= (x
<< shift
) | bfd_get_32 (input_bfd
, location
);
7961 x
= (x
<< shift
) | bfd_get_64 (input_bfd
, location
);
7972 decode_complex_addend (unsigned long *start
, /* in bits */
7973 unsigned long *oplen
, /* in bits */
7974 unsigned long *len
, /* in bits */
7975 unsigned long *wordsz
, /* in bytes */
7976 unsigned long *chunksz
, /* in bytes */
7977 unsigned long *lsb0_p
,
7978 unsigned long *signed_p
,
7979 unsigned long *trunc_p
,
7980 unsigned long encoded
)
7982 * start
= encoded
& 0x3F;
7983 * len
= (encoded
>> 6) & 0x3F;
7984 * oplen
= (encoded
>> 12) & 0x3F;
7985 * wordsz
= (encoded
>> 18) & 0xF;
7986 * chunksz
= (encoded
>> 22) & 0xF;
7987 * lsb0_p
= (encoded
>> 27) & 1;
7988 * signed_p
= (encoded
>> 28) & 1;
7989 * trunc_p
= (encoded
>> 29) & 1;
7992 bfd_reloc_status_type
7993 bfd_elf_perform_complex_relocation (bfd
*input_bfd
,
7994 asection
*input_section ATTRIBUTE_UNUSED
,
7996 Elf_Internal_Rela
*rel
,
7999 bfd_vma shift
, x
, mask
;
8000 unsigned long start
, oplen
, len
, wordsz
, chunksz
, lsb0_p
, signed_p
, trunc_p
;
8001 bfd_reloc_status_type r
;
8003 /* Perform this reloc, since it is complex.
8004 (this is not to say that it necessarily refers to a complex
8005 symbol; merely that it is a self-describing CGEN based reloc.
8006 i.e. the addend has the complete reloc information (bit start, end,
8007 word size, etc) encoded within it.). */
8009 decode_complex_addend (&start
, &oplen
, &len
, &wordsz
,
8010 &chunksz
, &lsb0_p
, &signed_p
,
8011 &trunc_p
, rel
->r_addend
);
8013 mask
= (((1L << (len
- 1)) - 1) << 1) | 1;
8016 shift
= (start
+ 1) - len
;
8018 shift
= (8 * wordsz
) - (start
+ len
);
8020 /* FIXME: octets_per_byte. */
8021 x
= get_value (wordsz
, chunksz
, input_bfd
, contents
+ rel
->r_offset
);
8024 printf ("Doing complex reloc: "
8025 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
8026 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
8027 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
8028 lsb0_p
, signed_p
, trunc_p
, wordsz
, chunksz
, start
, len
,
8029 oplen
, (unsigned long) x
, (unsigned long) mask
,
8030 (unsigned long) relocation
);
8035 /* Now do an overflow check. */
8036 r
= bfd_check_overflow ((signed_p
8037 ? complain_overflow_signed
8038 : complain_overflow_unsigned
),
8039 len
, 0, (8 * wordsz
),
8043 x
= (x
& ~(mask
<< shift
)) | ((relocation
& mask
) << shift
);
8046 printf (" relocation: %8.8lx\n"
8047 " shifted mask: %8.8lx\n"
8048 " shifted/masked reloc: %8.8lx\n"
8049 " result: %8.8lx\n",
8050 (unsigned long) relocation
, (unsigned long) (mask
<< shift
),
8051 (unsigned long) ((relocation
& mask
) << shift
), (unsigned long) x
);
8053 /* FIXME: octets_per_byte. */
8054 put_value (wordsz
, chunksz
, input_bfd
, x
, contents
+ rel
->r_offset
);
8058 /* When performing a relocatable link, the input relocations are
8059 preserved. But, if they reference global symbols, the indices
8060 referenced must be updated. Update all the relocations found in
8064 elf_link_adjust_relocs (bfd
*abfd
,
8065 struct bfd_elf_section_reloc_data
*reldata
)
8068 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8070 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8071 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8072 bfd_vma r_type_mask
;
8074 unsigned int count
= reldata
->count
;
8075 struct elf_link_hash_entry
**rel_hash
= reldata
->hashes
;
8077 if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
8079 swap_in
= bed
->s
->swap_reloc_in
;
8080 swap_out
= bed
->s
->swap_reloc_out
;
8082 else if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
8084 swap_in
= bed
->s
->swap_reloca_in
;
8085 swap_out
= bed
->s
->swap_reloca_out
;
8090 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
8093 if (bed
->s
->arch_size
== 32)
8100 r_type_mask
= 0xffffffff;
8104 erela
= reldata
->hdr
->contents
;
8105 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= reldata
->hdr
->sh_entsize
)
8107 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
8110 if (*rel_hash
== NULL
)
8113 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
8115 (*swap_in
) (abfd
, erela
, irela
);
8116 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
8117 irela
[j
].r_info
= ((bfd_vma
) (*rel_hash
)->indx
<< r_sym_shift
8118 | (irela
[j
].r_info
& r_type_mask
));
8119 (*swap_out
) (abfd
, irela
, erela
);
8123 struct elf_link_sort_rela
8129 enum elf_reloc_type_class type
;
8130 /* We use this as an array of size int_rels_per_ext_rel. */
8131 Elf_Internal_Rela rela
[1];
8135 elf_link_sort_cmp1 (const void *A
, const void *B
)
8137 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8138 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8139 int relativea
, relativeb
;
8141 relativea
= a
->type
== reloc_class_relative
;
8142 relativeb
= b
->type
== reloc_class_relative
;
8144 if (relativea
< relativeb
)
8146 if (relativea
> relativeb
)
8148 if ((a
->rela
->r_info
& a
->u
.sym_mask
) < (b
->rela
->r_info
& b
->u
.sym_mask
))
8150 if ((a
->rela
->r_info
& a
->u
.sym_mask
) > (b
->rela
->r_info
& b
->u
.sym_mask
))
8152 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8154 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8160 elf_link_sort_cmp2 (const void *A
, const void *B
)
8162 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8163 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8166 if (a
->u
.offset
< b
->u
.offset
)
8168 if (a
->u
.offset
> b
->u
.offset
)
8170 copya
= (a
->type
== reloc_class_copy
) * 2 + (a
->type
== reloc_class_plt
);
8171 copyb
= (b
->type
== reloc_class_copy
) * 2 + (b
->type
== reloc_class_plt
);
8176 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8178 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8184 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
8186 asection
*dynamic_relocs
;
8189 bfd_size_type count
, size
;
8190 size_t i
, ret
, sort_elt
, ext_size
;
8191 bfd_byte
*sort
, *s_non_relative
, *p
;
8192 struct elf_link_sort_rela
*sq
;
8193 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8194 int i2e
= bed
->s
->int_rels_per_ext_rel
;
8195 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8196 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8197 struct bfd_link_order
*lo
;
8199 bfd_boolean use_rela
;
8201 /* Find a dynamic reloc section. */
8202 rela_dyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
8203 rel_dyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
8204 if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0
8205 && rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8207 bfd_boolean use_rela_initialised
= FALSE
;
8209 /* This is just here to stop gcc from complaining.
8210 It's initialization checking code is not perfect. */
8213 /* Both sections are present. Examine the sizes
8214 of the indirect sections to help us choose. */
8215 for (lo
= rela_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8216 if (lo
->type
== bfd_indirect_link_order
)
8218 asection
*o
= lo
->u
.indirect
.section
;
8220 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8222 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8223 /* Section size is divisible by both rel and rela sizes.
8224 It is of no help to us. */
8228 /* Section size is only divisible by rela. */
8229 if (use_rela_initialised
&& (use_rela
== FALSE
))
8232 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8233 bfd_set_error (bfd_error_invalid_operation
);
8239 use_rela_initialised
= TRUE
;
8243 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8245 /* Section size is only divisible by rel. */
8246 if (use_rela_initialised
&& (use_rela
== TRUE
))
8249 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8250 bfd_set_error (bfd_error_invalid_operation
);
8256 use_rela_initialised
= TRUE
;
8261 /* The section size is not divisible by either - something is wrong. */
8263 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8264 bfd_set_error (bfd_error_invalid_operation
);
8269 for (lo
= rel_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8270 if (lo
->type
== bfd_indirect_link_order
)
8272 asection
*o
= lo
->u
.indirect
.section
;
8274 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8276 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8277 /* Section size is divisible by both rel and rela sizes.
8278 It is of no help to us. */
8282 /* Section size is only divisible by rela. */
8283 if (use_rela_initialised
&& (use_rela
== FALSE
))
8286 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8287 bfd_set_error (bfd_error_invalid_operation
);
8293 use_rela_initialised
= TRUE
;
8297 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8299 /* Section size is only divisible by rel. */
8300 if (use_rela_initialised
&& (use_rela
== TRUE
))
8303 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8304 bfd_set_error (bfd_error_invalid_operation
);
8310 use_rela_initialised
= TRUE
;
8315 /* The section size is not divisible by either - something is wrong. */
8317 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8318 bfd_set_error (bfd_error_invalid_operation
);
8323 if (! use_rela_initialised
)
8327 else if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0)
8329 else if (rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8336 dynamic_relocs
= rela_dyn
;
8337 ext_size
= bed
->s
->sizeof_rela
;
8338 swap_in
= bed
->s
->swap_reloca_in
;
8339 swap_out
= bed
->s
->swap_reloca_out
;
8343 dynamic_relocs
= rel_dyn
;
8344 ext_size
= bed
->s
->sizeof_rel
;
8345 swap_in
= bed
->s
->swap_reloc_in
;
8346 swap_out
= bed
->s
->swap_reloc_out
;
8350 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8351 if (lo
->type
== bfd_indirect_link_order
)
8352 size
+= lo
->u
.indirect
.section
->size
;
8354 if (size
!= dynamic_relocs
->size
)
8357 sort_elt
= (sizeof (struct elf_link_sort_rela
)
8358 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
8360 count
= dynamic_relocs
->size
/ ext_size
;
8363 sort
= (bfd_byte
*) bfd_zmalloc (sort_elt
* count
);
8367 (*info
->callbacks
->warning
)
8368 (info
, _("Not enough memory to sort relocations"), 0, abfd
, 0, 0);
8372 if (bed
->s
->arch_size
== 32)
8373 r_sym_mask
= ~(bfd_vma
) 0xff;
8375 r_sym_mask
= ~(bfd_vma
) 0xffffffff;
8377 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8378 if (lo
->type
== bfd_indirect_link_order
)
8380 bfd_byte
*erel
, *erelend
;
8381 asection
*o
= lo
->u
.indirect
.section
;
8383 if (o
->contents
== NULL
&& o
->size
!= 0)
8385 /* This is a reloc section that is being handled as a normal
8386 section. See bfd_section_from_shdr. We can't combine
8387 relocs in this case. */
8392 erelend
= o
->contents
+ o
->size
;
8393 /* FIXME: octets_per_byte. */
8394 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8396 while (erel
< erelend
)
8398 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8400 (*swap_in
) (abfd
, erel
, s
->rela
);
8401 s
->type
= (*bed
->elf_backend_reloc_type_class
) (s
->rela
);
8402 s
->u
.sym_mask
= r_sym_mask
;
8408 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
8410 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
8412 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8413 if (s
->type
!= reloc_class_relative
)
8419 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
8420 for (; i
< count
; i
++, p
+= sort_elt
)
8422 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
8423 if (((sp
->rela
->r_info
^ sq
->rela
->r_info
) & r_sym_mask
) != 0)
8425 sp
->u
.offset
= sq
->rela
->r_offset
;
8428 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
8430 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8431 if (lo
->type
== bfd_indirect_link_order
)
8433 bfd_byte
*erel
, *erelend
;
8434 asection
*o
= lo
->u
.indirect
.section
;
8437 erelend
= o
->contents
+ o
->size
;
8438 /* FIXME: octets_per_byte. */
8439 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8440 while (erel
< erelend
)
8442 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8443 (*swap_out
) (abfd
, s
->rela
, erel
);
8450 *psec
= dynamic_relocs
;
8454 /* Flush the output symbols to the file. */
8457 elf_link_flush_output_syms (struct elf_final_link_info
*flinfo
,
8458 const struct elf_backend_data
*bed
)
8460 if (flinfo
->symbuf_count
> 0)
8462 Elf_Internal_Shdr
*hdr
;
8466 hdr
= &elf_tdata (flinfo
->output_bfd
)->symtab_hdr
;
8467 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
8468 amt
= flinfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8469 if (bfd_seek (flinfo
->output_bfd
, pos
, SEEK_SET
) != 0
8470 || bfd_bwrite (flinfo
->symbuf
, amt
, flinfo
->output_bfd
) != amt
)
8473 hdr
->sh_size
+= amt
;
8474 flinfo
->symbuf_count
= 0;
8480 /* Add a symbol to the output symbol table. */
8483 elf_link_output_sym (struct elf_final_link_info
*flinfo
,
8485 Elf_Internal_Sym
*elfsym
,
8486 asection
*input_sec
,
8487 struct elf_link_hash_entry
*h
)
8490 Elf_External_Sym_Shndx
*destshndx
;
8491 int (*output_symbol_hook
)
8492 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*, asection
*,
8493 struct elf_link_hash_entry
*);
8494 const struct elf_backend_data
*bed
;
8496 bed
= get_elf_backend_data (flinfo
->output_bfd
);
8497 output_symbol_hook
= bed
->elf_backend_link_output_symbol_hook
;
8498 if (output_symbol_hook
!= NULL
)
8500 int ret
= (*output_symbol_hook
) (flinfo
->info
, name
, elfsym
, input_sec
, h
);
8505 if (name
== NULL
|| *name
== '\0')
8506 elfsym
->st_name
= 0;
8507 else if (input_sec
->flags
& SEC_EXCLUDE
)
8508 elfsym
->st_name
= 0;
8511 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (flinfo
->symstrtab
,
8513 if (elfsym
->st_name
== (unsigned long) -1)
8517 if (flinfo
->symbuf_count
>= flinfo
->symbuf_size
)
8519 if (! elf_link_flush_output_syms (flinfo
, bed
))
8523 dest
= flinfo
->symbuf
+ flinfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8524 destshndx
= flinfo
->symshndxbuf
;
8525 if (destshndx
!= NULL
)
8527 if (bfd_get_symcount (flinfo
->output_bfd
) >= flinfo
->shndxbuf_size
)
8531 amt
= flinfo
->shndxbuf_size
* sizeof (Elf_External_Sym_Shndx
);
8532 destshndx
= (Elf_External_Sym_Shndx
*) bfd_realloc (destshndx
,
8534 if (destshndx
== NULL
)
8536 flinfo
->symshndxbuf
= destshndx
;
8537 memset ((char *) destshndx
+ amt
, 0, amt
);
8538 flinfo
->shndxbuf_size
*= 2;
8540 destshndx
+= bfd_get_symcount (flinfo
->output_bfd
);
8543 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, elfsym
, dest
, destshndx
);
8544 flinfo
->symbuf_count
+= 1;
8545 bfd_get_symcount (flinfo
->output_bfd
) += 1;
8550 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8553 check_dynsym (bfd
*abfd
, Elf_Internal_Sym
*sym
)
8555 if (sym
->st_shndx
>= (SHN_LORESERVE
& 0xffff)
8556 && sym
->st_shndx
< SHN_LORESERVE
)
8558 /* The gABI doesn't support dynamic symbols in output sections
8560 (*_bfd_error_handler
)
8561 (_("%B: Too many sections: %d (>= %d)"),
8562 abfd
, bfd_count_sections (abfd
), SHN_LORESERVE
& 0xffff);
8563 bfd_set_error (bfd_error_nonrepresentable_section
);
8569 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8570 allowing an unsatisfied unversioned symbol in the DSO to match a
8571 versioned symbol that would normally require an explicit version.
8572 We also handle the case that a DSO references a hidden symbol
8573 which may be satisfied by a versioned symbol in another DSO. */
8576 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
8577 const struct elf_backend_data
*bed
,
8578 struct elf_link_hash_entry
*h
)
8581 struct elf_link_loaded_list
*loaded
;
8583 if (!is_elf_hash_table (info
->hash
))
8586 /* Check indirect symbol. */
8587 while (h
->root
.type
== bfd_link_hash_indirect
)
8588 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8590 switch (h
->root
.type
)
8596 case bfd_link_hash_undefined
:
8597 case bfd_link_hash_undefweak
:
8598 abfd
= h
->root
.u
.undef
.abfd
;
8599 if ((abfd
->flags
& DYNAMIC
) == 0
8600 || (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) == 0)
8604 case bfd_link_hash_defined
:
8605 case bfd_link_hash_defweak
:
8606 abfd
= h
->root
.u
.def
.section
->owner
;
8609 case bfd_link_hash_common
:
8610 abfd
= h
->root
.u
.c
.p
->section
->owner
;
8613 BFD_ASSERT (abfd
!= NULL
);
8615 for (loaded
= elf_hash_table (info
)->loaded
;
8617 loaded
= loaded
->next
)
8620 Elf_Internal_Shdr
*hdr
;
8621 bfd_size_type symcount
;
8622 bfd_size_type extsymcount
;
8623 bfd_size_type extsymoff
;
8624 Elf_Internal_Shdr
*versymhdr
;
8625 Elf_Internal_Sym
*isym
;
8626 Elf_Internal_Sym
*isymend
;
8627 Elf_Internal_Sym
*isymbuf
;
8628 Elf_External_Versym
*ever
;
8629 Elf_External_Versym
*extversym
;
8631 input
= loaded
->abfd
;
8633 /* We check each DSO for a possible hidden versioned definition. */
8635 || (input
->flags
& DYNAMIC
) == 0
8636 || elf_dynversym (input
) == 0)
8639 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
8641 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
8642 if (elf_bad_symtab (input
))
8644 extsymcount
= symcount
;
8649 extsymcount
= symcount
- hdr
->sh_info
;
8650 extsymoff
= hdr
->sh_info
;
8653 if (extsymcount
== 0)
8656 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
8658 if (isymbuf
== NULL
)
8661 /* Read in any version definitions. */
8662 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
8663 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
8664 if (extversym
== NULL
)
8667 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
8668 || (bfd_bread (extversym
, versymhdr
->sh_size
, input
)
8669 != versymhdr
->sh_size
))
8677 ever
= extversym
+ extsymoff
;
8678 isymend
= isymbuf
+ extsymcount
;
8679 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
8682 Elf_Internal_Versym iver
;
8683 unsigned short version_index
;
8685 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
8686 || isym
->st_shndx
== SHN_UNDEF
)
8689 name
= bfd_elf_string_from_elf_section (input
,
8692 if (strcmp (name
, h
->root
.root
.string
) != 0)
8695 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
8697 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
8699 && h
->forced_local
))
8701 /* If we have a non-hidden versioned sym, then it should
8702 have provided a definition for the undefined sym unless
8703 it is defined in a non-shared object and forced local.
8708 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
8709 if (version_index
== 1 || version_index
== 2)
8711 /* This is the base or first version. We can use it. */
8725 /* Add an external symbol to the symbol table. This is called from
8726 the hash table traversal routine. When generating a shared object,
8727 we go through the symbol table twice. The first time we output
8728 anything that might have been forced to local scope in a version
8729 script. The second time we output the symbols that are still
8733 elf_link_output_extsym (struct bfd_hash_entry
*bh
, void *data
)
8735 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
8736 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
8737 struct elf_final_link_info
*flinfo
= eoinfo
->flinfo
;
8739 Elf_Internal_Sym sym
;
8740 asection
*input_sec
;
8741 const struct elf_backend_data
*bed
;
8745 if (h
->root
.type
== bfd_link_hash_warning
)
8747 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8748 if (h
->root
.type
== bfd_link_hash_new
)
8752 /* Decide whether to output this symbol in this pass. */
8753 if (eoinfo
->localsyms
)
8755 if (!h
->forced_local
)
8757 if (eoinfo
->second_pass
8758 && !((h
->root
.type
== bfd_link_hash_defined
8759 || h
->root
.type
== bfd_link_hash_defweak
)
8760 && h
->root
.u
.def
.section
->output_section
!= NULL
))
8765 if (h
->forced_local
)
8769 bed
= get_elf_backend_data (flinfo
->output_bfd
);
8771 if (h
->root
.type
== bfd_link_hash_undefined
)
8773 /* If we have an undefined symbol reference here then it must have
8774 come from a shared library that is being linked in. (Undefined
8775 references in regular files have already been handled unless
8776 they are in unreferenced sections which are removed by garbage
8778 bfd_boolean ignore_undef
= FALSE
;
8780 /* Some symbols may be special in that the fact that they're
8781 undefined can be safely ignored - let backend determine that. */
8782 if (bed
->elf_backend_ignore_undef_symbol
)
8783 ignore_undef
= bed
->elf_backend_ignore_undef_symbol (h
);
8785 /* If we are reporting errors for this situation then do so now. */
8788 && (!h
->ref_regular
|| flinfo
->info
->gc_sections
)
8789 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
)
8790 && flinfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
8792 if (!(flinfo
->info
->callbacks
->undefined_symbol
8793 (flinfo
->info
, h
->root
.root
.string
,
8794 h
->ref_regular
? NULL
: h
->root
.u
.undef
.abfd
,
8796 (flinfo
->info
->unresolved_syms_in_shared_libs
8797 == RM_GENERATE_ERROR
))))
8799 bfd_set_error (bfd_error_bad_value
);
8800 eoinfo
->failed
= TRUE
;
8806 /* We should also warn if a forced local symbol is referenced from
8807 shared libraries. */
8808 if (!flinfo
->info
->relocatable
8809 && flinfo
->info
->executable
8815 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
))
8819 struct elf_link_hash_entry
*hi
= h
;
8821 /* Check indirect symbol. */
8822 while (hi
->root
.type
== bfd_link_hash_indirect
)
8823 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
8825 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
8826 msg
= _("%B: internal symbol `%s' in %B is referenced by DSO");
8827 else if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
8828 msg
= _("%B: hidden symbol `%s' in %B is referenced by DSO");
8830 msg
= _("%B: local symbol `%s' in %B is referenced by DSO");
8831 def_bfd
= flinfo
->output_bfd
;
8832 if (hi
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
8833 def_bfd
= hi
->root
.u
.def
.section
->owner
;
8834 (*_bfd_error_handler
) (msg
, flinfo
->output_bfd
, def_bfd
,
8835 h
->root
.root
.string
);
8836 bfd_set_error (bfd_error_bad_value
);
8837 eoinfo
->failed
= TRUE
;
8841 /* We don't want to output symbols that have never been mentioned by
8842 a regular file, or that we have been told to strip. However, if
8843 h->indx is set to -2, the symbol is used by a reloc and we must
8847 else if ((h
->def_dynamic
8849 || h
->root
.type
== bfd_link_hash_new
)
8853 else if (flinfo
->info
->strip
== strip_all
)
8855 else if (flinfo
->info
->strip
== strip_some
8856 && bfd_hash_lookup (flinfo
->info
->keep_hash
,
8857 h
->root
.root
.string
, FALSE
, FALSE
) == NULL
)
8859 else if ((h
->root
.type
== bfd_link_hash_defined
8860 || h
->root
.type
== bfd_link_hash_defweak
)
8861 && ((flinfo
->info
->strip_discarded
8862 && discarded_section (h
->root
.u
.def
.section
))
8863 || (h
->root
.u
.def
.section
->owner
!= NULL
8864 && (h
->root
.u
.def
.section
->owner
->flags
& BFD_PLUGIN
) != 0)))
8866 else if ((h
->root
.type
== bfd_link_hash_undefined
8867 || h
->root
.type
== bfd_link_hash_undefweak
)
8868 && h
->root
.u
.undef
.abfd
!= NULL
8869 && (h
->root
.u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0)
8874 /* If we're stripping it, and it's not a dynamic symbol, there's
8875 nothing else to do unless it is a forced local symbol or a
8876 STT_GNU_IFUNC symbol. */
8879 && h
->type
!= STT_GNU_IFUNC
8880 && !h
->forced_local
)
8884 sym
.st_size
= h
->size
;
8885 sym
.st_other
= h
->other
;
8886 if (h
->forced_local
)
8888 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
8889 /* Turn off visibility on local symbol. */
8890 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
8892 else if (h
->unique_global
)
8893 sym
.st_info
= ELF_ST_INFO (STB_GNU_UNIQUE
, h
->type
);
8894 else if (h
->root
.type
== bfd_link_hash_undefweak
8895 || h
->root
.type
== bfd_link_hash_defweak
)
8896 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
8898 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
8899 sym
.st_target_internal
= h
->target_internal
;
8901 switch (h
->root
.type
)
8904 case bfd_link_hash_new
:
8905 case bfd_link_hash_warning
:
8909 case bfd_link_hash_undefined
:
8910 case bfd_link_hash_undefweak
:
8911 input_sec
= bfd_und_section_ptr
;
8912 sym
.st_shndx
= SHN_UNDEF
;
8915 case bfd_link_hash_defined
:
8916 case bfd_link_hash_defweak
:
8918 input_sec
= h
->root
.u
.def
.section
;
8919 if (input_sec
->output_section
!= NULL
)
8921 if (eoinfo
->localsyms
&& flinfo
->filesym_count
== 1)
8923 bfd_boolean second_pass_sym
8924 = (input_sec
->owner
== flinfo
->output_bfd
8925 || input_sec
->owner
== NULL
8926 || (input_sec
->flags
& SEC_LINKER_CREATED
) != 0
8927 || (input_sec
->owner
->flags
& BFD_LINKER_CREATED
) != 0);
8929 eoinfo
->need_second_pass
|= second_pass_sym
;
8930 if (eoinfo
->second_pass
!= second_pass_sym
)
8935 _bfd_elf_section_from_bfd_section (flinfo
->output_bfd
,
8936 input_sec
->output_section
);
8937 if (sym
.st_shndx
== SHN_BAD
)
8939 (*_bfd_error_handler
)
8940 (_("%B: could not find output section %A for input section %A"),
8941 flinfo
->output_bfd
, input_sec
->output_section
, input_sec
);
8942 bfd_set_error (bfd_error_nonrepresentable_section
);
8943 eoinfo
->failed
= TRUE
;
8947 /* ELF symbols in relocatable files are section relative,
8948 but in nonrelocatable files they are virtual
8950 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
8951 if (!flinfo
->info
->relocatable
)
8953 sym
.st_value
+= input_sec
->output_section
->vma
;
8954 if (h
->type
== STT_TLS
)
8956 asection
*tls_sec
= elf_hash_table (flinfo
->info
)->tls_sec
;
8957 if (tls_sec
!= NULL
)
8958 sym
.st_value
-= tls_sec
->vma
;
8961 /* The TLS section may have been garbage collected. */
8962 BFD_ASSERT (flinfo
->info
->gc_sections
8963 && !input_sec
->gc_mark
);
8970 BFD_ASSERT (input_sec
->owner
== NULL
8971 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
8972 sym
.st_shndx
= SHN_UNDEF
;
8973 input_sec
= bfd_und_section_ptr
;
8978 case bfd_link_hash_common
:
8979 input_sec
= h
->root
.u
.c
.p
->section
;
8980 sym
.st_shndx
= bed
->common_section_index (input_sec
);
8981 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
8984 case bfd_link_hash_indirect
:
8985 /* These symbols are created by symbol versioning. They point
8986 to the decorated version of the name. For example, if the
8987 symbol foo@@GNU_1.2 is the default, which should be used when
8988 foo is used with no version, then we add an indirect symbol
8989 foo which points to foo@@GNU_1.2. We ignore these symbols,
8990 since the indirected symbol is already in the hash table. */
8994 /* Give the processor backend a chance to tweak the symbol value,
8995 and also to finish up anything that needs to be done for this
8996 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
8997 forced local syms when non-shared is due to a historical quirk.
8998 STT_GNU_IFUNC symbol must go through PLT. */
8999 if ((h
->type
== STT_GNU_IFUNC
9001 && !flinfo
->info
->relocatable
)
9002 || ((h
->dynindx
!= -1
9004 && ((flinfo
->info
->shared
9005 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
9006 || h
->root
.type
!= bfd_link_hash_undefweak
))
9007 || !h
->forced_local
)
9008 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
))
9010 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
9011 (flinfo
->output_bfd
, flinfo
->info
, h
, &sym
)))
9013 eoinfo
->failed
= TRUE
;
9018 /* If we are marking the symbol as undefined, and there are no
9019 non-weak references to this symbol from a regular object, then
9020 mark the symbol as weak undefined; if there are non-weak
9021 references, mark the symbol as strong. We can't do this earlier,
9022 because it might not be marked as undefined until the
9023 finish_dynamic_symbol routine gets through with it. */
9024 if (sym
.st_shndx
== SHN_UNDEF
9026 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
9027 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
9030 unsigned int type
= ELF_ST_TYPE (sym
.st_info
);
9032 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
9033 if (type
== STT_GNU_IFUNC
)
9036 if (h
->ref_regular_nonweak
)
9037 bindtype
= STB_GLOBAL
;
9039 bindtype
= STB_WEAK
;
9040 sym
.st_info
= ELF_ST_INFO (bindtype
, type
);
9043 /* If this is a symbol defined in a dynamic library, don't use the
9044 symbol size from the dynamic library. Relinking an executable
9045 against a new library may introduce gratuitous changes in the
9046 executable's symbols if we keep the size. */
9047 if (sym
.st_shndx
== SHN_UNDEF
9052 /* If a non-weak symbol with non-default visibility is not defined
9053 locally, it is a fatal error. */
9054 if (!flinfo
->info
->relocatable
9055 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
9056 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
9057 && h
->root
.type
== bfd_link_hash_undefined
9062 if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
)
9063 msg
= _("%B: protected symbol `%s' isn't defined");
9064 else if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
)
9065 msg
= _("%B: internal symbol `%s' isn't defined");
9067 msg
= _("%B: hidden symbol `%s' isn't defined");
9068 (*_bfd_error_handler
) (msg
, flinfo
->output_bfd
, h
->root
.root
.string
);
9069 bfd_set_error (bfd_error_bad_value
);
9070 eoinfo
->failed
= TRUE
;
9074 /* If this symbol should be put in the .dynsym section, then put it
9075 there now. We already know the symbol index. We also fill in
9076 the entry in the .hash section. */
9077 if (flinfo
->dynsym_sec
!= NULL
9079 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
)
9083 /* Since there is no version information in the dynamic string,
9084 if there is no version info in symbol version section, we will
9085 have a run-time problem. */
9086 if (h
->verinfo
.verdef
== NULL
)
9088 char *p
= strrchr (h
->root
.root
.string
, ELF_VER_CHR
);
9090 if (p
&& p
[1] != '\0')
9092 (*_bfd_error_handler
)
9093 (_("%B: No symbol version section for versioned symbol `%s'"),
9094 flinfo
->output_bfd
, h
->root
.root
.string
);
9095 eoinfo
->failed
= TRUE
;
9100 sym
.st_name
= h
->dynstr_index
;
9101 esym
= flinfo
->dynsym_sec
->contents
+ h
->dynindx
* bed
->s
->sizeof_sym
;
9102 if (!check_dynsym (flinfo
->output_bfd
, &sym
))
9104 eoinfo
->failed
= TRUE
;
9107 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, &sym
, esym
, 0);
9109 if (flinfo
->hash_sec
!= NULL
)
9111 size_t hash_entry_size
;
9112 bfd_byte
*bucketpos
;
9117 bucketcount
= elf_hash_table (flinfo
->info
)->bucketcount
;
9118 bucket
= h
->u
.elf_hash_value
% bucketcount
;
9121 = elf_section_data (flinfo
->hash_sec
)->this_hdr
.sh_entsize
;
9122 bucketpos
= ((bfd_byte
*) flinfo
->hash_sec
->contents
9123 + (bucket
+ 2) * hash_entry_size
);
9124 chain
= bfd_get (8 * hash_entry_size
, flinfo
->output_bfd
, bucketpos
);
9125 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, h
->dynindx
,
9127 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, chain
,
9128 ((bfd_byte
*) flinfo
->hash_sec
->contents
9129 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
9132 if (flinfo
->symver_sec
!= NULL
&& flinfo
->symver_sec
->contents
!= NULL
)
9134 Elf_Internal_Versym iversym
;
9135 Elf_External_Versym
*eversym
;
9137 if (!h
->def_regular
)
9139 if (h
->verinfo
.verdef
== NULL
)
9140 iversym
.vs_vers
= 0;
9142 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
9146 if (h
->verinfo
.vertree
== NULL
)
9147 iversym
.vs_vers
= 1;
9149 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
9150 if (flinfo
->info
->create_default_symver
)
9155 iversym
.vs_vers
|= VERSYM_HIDDEN
;
9157 eversym
= (Elf_External_Versym
*) flinfo
->symver_sec
->contents
;
9158 eversym
+= h
->dynindx
;
9159 _bfd_elf_swap_versym_out (flinfo
->output_bfd
, &iversym
, eversym
);
9163 /* If we're stripping it, then it was just a dynamic symbol, and
9164 there's nothing else to do. */
9165 if (strip
|| (input_sec
->flags
& SEC_EXCLUDE
) != 0)
9168 indx
= bfd_get_symcount (flinfo
->output_bfd
);
9169 ret
= elf_link_output_sym (flinfo
, h
->root
.root
.string
, &sym
, input_sec
, h
);
9172 eoinfo
->failed
= TRUE
;
9177 else if (h
->indx
== -2)
9183 /* Return TRUE if special handling is done for relocs in SEC against
9184 symbols defined in discarded sections. */
9187 elf_section_ignore_discarded_relocs (asection
*sec
)
9189 const struct elf_backend_data
*bed
;
9191 switch (sec
->sec_info_type
)
9193 case SEC_INFO_TYPE_STABS
:
9194 case SEC_INFO_TYPE_EH_FRAME
:
9200 bed
= get_elf_backend_data (sec
->owner
);
9201 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
9202 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))
9208 /* Return a mask saying how ld should treat relocations in SEC against
9209 symbols defined in discarded sections. If this function returns
9210 COMPLAIN set, ld will issue a warning message. If this function
9211 returns PRETEND set, and the discarded section was link-once and the
9212 same size as the kept link-once section, ld will pretend that the
9213 symbol was actually defined in the kept section. Otherwise ld will
9214 zero the reloc (at least that is the intent, but some cooperation by
9215 the target dependent code is needed, particularly for REL targets). */
9218 _bfd_elf_default_action_discarded (asection
*sec
)
9220 if (sec
->flags
& SEC_DEBUGGING
)
9223 if (strcmp (".eh_frame", sec
->name
) == 0)
9226 if (strcmp (".gcc_except_table", sec
->name
) == 0)
9229 return COMPLAIN
| PRETEND
;
9232 /* Find a match between a section and a member of a section group. */
9235 match_group_member (asection
*sec
, asection
*group
,
9236 struct bfd_link_info
*info
)
9238 asection
*first
= elf_next_in_group (group
);
9239 asection
*s
= first
;
9243 if (bfd_elf_match_symbols_in_sections (s
, sec
, info
))
9246 s
= elf_next_in_group (s
);
9254 /* Check if the kept section of a discarded section SEC can be used
9255 to replace it. Return the replacement if it is OK. Otherwise return
9259 _bfd_elf_check_kept_section (asection
*sec
, struct bfd_link_info
*info
)
9263 kept
= sec
->kept_section
;
9266 if ((kept
->flags
& SEC_GROUP
) != 0)
9267 kept
= match_group_member (sec
, kept
, info
);
9269 && ((sec
->rawsize
!= 0 ? sec
->rawsize
: sec
->size
)
9270 != (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9272 sec
->kept_section
= kept
;
9277 /* Link an input file into the linker output file. This function
9278 handles all the sections and relocations of the input file at once.
9279 This is so that we only have to read the local symbols once, and
9280 don't have to keep them in memory. */
9283 elf_link_input_bfd (struct elf_final_link_info
*flinfo
, bfd
*input_bfd
)
9285 int (*relocate_section
)
9286 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
9287 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
9289 Elf_Internal_Shdr
*symtab_hdr
;
9292 Elf_Internal_Sym
*isymbuf
;
9293 Elf_Internal_Sym
*isym
;
9294 Elf_Internal_Sym
*isymend
;
9296 asection
**ppsection
;
9298 const struct elf_backend_data
*bed
;
9299 struct elf_link_hash_entry
**sym_hashes
;
9300 bfd_size_type address_size
;
9301 bfd_vma r_type_mask
;
9303 bfd_boolean have_file_sym
= FALSE
;
9305 output_bfd
= flinfo
->output_bfd
;
9306 bed
= get_elf_backend_data (output_bfd
);
9307 relocate_section
= bed
->elf_backend_relocate_section
;
9309 /* If this is a dynamic object, we don't want to do anything here:
9310 we don't want the local symbols, and we don't want the section
9312 if ((input_bfd
->flags
& DYNAMIC
) != 0)
9315 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
9316 if (elf_bad_symtab (input_bfd
))
9318 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
9323 locsymcount
= symtab_hdr
->sh_info
;
9324 extsymoff
= symtab_hdr
->sh_info
;
9327 /* Read the local symbols. */
9328 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
9329 if (isymbuf
== NULL
&& locsymcount
!= 0)
9331 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
9332 flinfo
->internal_syms
,
9333 flinfo
->external_syms
,
9334 flinfo
->locsym_shndx
);
9335 if (isymbuf
== NULL
)
9339 /* Find local symbol sections and adjust values of symbols in
9340 SEC_MERGE sections. Write out those local symbols we know are
9341 going into the output file. */
9342 isymend
= isymbuf
+ locsymcount
;
9343 for (isym
= isymbuf
, pindex
= flinfo
->indices
, ppsection
= flinfo
->sections
;
9345 isym
++, pindex
++, ppsection
++)
9349 Elf_Internal_Sym osym
;
9355 if (elf_bad_symtab (input_bfd
))
9357 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
9364 if (isym
->st_shndx
== SHN_UNDEF
)
9365 isec
= bfd_und_section_ptr
;
9366 else if (isym
->st_shndx
== SHN_ABS
)
9367 isec
= bfd_abs_section_ptr
;
9368 else if (isym
->st_shndx
== SHN_COMMON
)
9369 isec
= bfd_com_section_ptr
;
9372 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
9375 /* Don't attempt to output symbols with st_shnx in the
9376 reserved range other than SHN_ABS and SHN_COMMON. */
9380 else if (isec
->sec_info_type
== SEC_INFO_TYPE_MERGE
9381 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
9383 _bfd_merged_section_offset (output_bfd
, &isec
,
9384 elf_section_data (isec
)->sec_info
,
9390 /* Don't output the first, undefined, symbol. */
9391 if (ppsection
== flinfo
->sections
)
9394 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
9396 /* We never output section symbols. Instead, we use the
9397 section symbol of the corresponding section in the output
9402 /* If we are stripping all symbols, we don't want to output this
9404 if (flinfo
->info
->strip
== strip_all
)
9407 /* If we are discarding all local symbols, we don't want to
9408 output this one. If we are generating a relocatable output
9409 file, then some of the local symbols may be required by
9410 relocs; we output them below as we discover that they are
9412 if (flinfo
->info
->discard
== discard_all
)
9415 /* If this symbol is defined in a section which we are
9416 discarding, we don't need to keep it. */
9417 if (isym
->st_shndx
!= SHN_UNDEF
9418 && isym
->st_shndx
< SHN_LORESERVE
9419 && bfd_section_removed_from_list (output_bfd
,
9420 isec
->output_section
))
9423 /* Get the name of the symbol. */
9424 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
9429 /* See if we are discarding symbols with this name. */
9430 if ((flinfo
->info
->strip
== strip_some
9431 && (bfd_hash_lookup (flinfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
9433 || (((flinfo
->info
->discard
== discard_sec_merge
9434 && (isec
->flags
& SEC_MERGE
) && !flinfo
->info
->relocatable
)
9435 || flinfo
->info
->discard
== discard_l
)
9436 && bfd_is_local_label_name (input_bfd
, name
)))
9439 if (ELF_ST_TYPE (isym
->st_info
) == STT_FILE
)
9441 have_file_sym
= TRUE
;
9442 flinfo
->filesym_count
+= 1;
9446 /* In the absence of debug info, bfd_find_nearest_line uses
9447 FILE symbols to determine the source file for local
9448 function symbols. Provide a FILE symbol here if input
9449 files lack such, so that their symbols won't be
9450 associated with a previous input file. It's not the
9451 source file, but the best we can do. */
9452 have_file_sym
= TRUE
;
9453 flinfo
->filesym_count
+= 1;
9454 memset (&osym
, 0, sizeof (osym
));
9455 osym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
9456 osym
.st_shndx
= SHN_ABS
;
9457 if (!elf_link_output_sym (flinfo
, input_bfd
->filename
, &osym
,
9458 bfd_abs_section_ptr
, NULL
))
9464 /* Adjust the section index for the output file. */
9465 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9466 isec
->output_section
);
9467 if (osym
.st_shndx
== SHN_BAD
)
9470 /* ELF symbols in relocatable files are section relative, but
9471 in executable files they are virtual addresses. Note that
9472 this code assumes that all ELF sections have an associated
9473 BFD section with a reasonable value for output_offset; below
9474 we assume that they also have a reasonable value for
9475 output_section. Any special sections must be set up to meet
9476 these requirements. */
9477 osym
.st_value
+= isec
->output_offset
;
9478 if (!flinfo
->info
->relocatable
)
9480 osym
.st_value
+= isec
->output_section
->vma
;
9481 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
9483 /* STT_TLS symbols are relative to PT_TLS segment base. */
9484 BFD_ASSERT (elf_hash_table (flinfo
->info
)->tls_sec
!= NULL
);
9485 osym
.st_value
-= elf_hash_table (flinfo
->info
)->tls_sec
->vma
;
9489 indx
= bfd_get_symcount (output_bfd
);
9490 ret
= elf_link_output_sym (flinfo
, name
, &osym
, isec
, NULL
);
9497 if (bed
->s
->arch_size
== 32)
9505 r_type_mask
= 0xffffffff;
9510 /* Relocate the contents of each section. */
9511 sym_hashes
= elf_sym_hashes (input_bfd
);
9512 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
9516 if (! o
->linker_mark
)
9518 /* This section was omitted from the link. */
9522 if (flinfo
->info
->relocatable
9523 && (o
->flags
& (SEC_LINKER_CREATED
| SEC_GROUP
)) == SEC_GROUP
)
9525 /* Deal with the group signature symbol. */
9526 struct bfd_elf_section_data
*sec_data
= elf_section_data (o
);
9527 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
9528 asection
*osec
= o
->output_section
;
9530 if (symndx
>= locsymcount
9531 || (elf_bad_symtab (input_bfd
)
9532 && flinfo
->sections
[symndx
] == NULL
))
9534 struct elf_link_hash_entry
*h
= sym_hashes
[symndx
- extsymoff
];
9535 while (h
->root
.type
== bfd_link_hash_indirect
9536 || h
->root
.type
== bfd_link_hash_warning
)
9537 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9538 /* Arrange for symbol to be output. */
9540 elf_section_data (osec
)->this_hdr
.sh_info
= -2;
9542 else if (ELF_ST_TYPE (isymbuf
[symndx
].st_info
) == STT_SECTION
)
9544 /* We'll use the output section target_index. */
9545 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
9546 elf_section_data (osec
)->this_hdr
.sh_info
= sec
->target_index
;
9550 if (flinfo
->indices
[symndx
] == -1)
9552 /* Otherwise output the local symbol now. */
9553 Elf_Internal_Sym sym
= isymbuf
[symndx
];
9554 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
9559 name
= bfd_elf_string_from_elf_section (input_bfd
,
9560 symtab_hdr
->sh_link
,
9565 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9567 if (sym
.st_shndx
== SHN_BAD
)
9570 sym
.st_value
+= o
->output_offset
;
9572 indx
= bfd_get_symcount (output_bfd
);
9573 ret
= elf_link_output_sym (flinfo
, name
, &sym
, o
, NULL
);
9577 flinfo
->indices
[symndx
] = indx
;
9581 elf_section_data (osec
)->this_hdr
.sh_info
9582 = flinfo
->indices
[symndx
];
9586 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
9587 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
9590 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
9592 /* Section was created by _bfd_elf_link_create_dynamic_sections
9597 /* Get the contents of the section. They have been cached by a
9598 relaxation routine. Note that o is a section in an input
9599 file, so the contents field will not have been set by any of
9600 the routines which work on output files. */
9601 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
9602 contents
= elf_section_data (o
)->this_hdr
.contents
;
9605 contents
= flinfo
->contents
;
9606 if (! bfd_get_full_section_contents (input_bfd
, o
, &contents
))
9610 if ((o
->flags
& SEC_RELOC
) != 0)
9612 Elf_Internal_Rela
*internal_relocs
;
9613 Elf_Internal_Rela
*rel
, *relend
;
9614 int action_discarded
;
9617 /* Get the swapped relocs. */
9619 = _bfd_elf_link_read_relocs (input_bfd
, o
, flinfo
->external_relocs
,
9620 flinfo
->internal_relocs
, FALSE
);
9621 if (internal_relocs
== NULL
9622 && o
->reloc_count
> 0)
9625 /* We need to reverse-copy input .ctors/.dtors sections if
9626 they are placed in .init_array/.finit_array for output. */
9627 if (o
->size
> address_size
9628 && ((strncmp (o
->name
, ".ctors", 6) == 0
9629 && strcmp (o
->output_section
->name
,
9630 ".init_array") == 0)
9631 || (strncmp (o
->name
, ".dtors", 6) == 0
9632 && strcmp (o
->output_section
->name
,
9633 ".fini_array") == 0))
9634 && (o
->name
[6] == 0 || o
->name
[6] == '.'))
9636 if (o
->size
!= o
->reloc_count
* address_size
)
9638 (*_bfd_error_handler
)
9639 (_("error: %B: size of section %A is not "
9640 "multiple of address size"),
9642 bfd_set_error (bfd_error_on_input
);
9645 o
->flags
|= SEC_ELF_REVERSE_COPY
;
9648 action_discarded
= -1;
9649 if (!elf_section_ignore_discarded_relocs (o
))
9650 action_discarded
= (*bed
->action_discarded
) (o
);
9652 /* Run through the relocs evaluating complex reloc symbols and
9653 looking for relocs against symbols from discarded sections
9654 or section symbols from removed link-once sections.
9655 Complain about relocs against discarded sections. Zero
9656 relocs against removed link-once sections. */
9658 rel
= internal_relocs
;
9659 relend
= rel
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9660 for ( ; rel
< relend
; rel
++)
9662 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
9663 unsigned int s_type
;
9664 asection
**ps
, *sec
;
9665 struct elf_link_hash_entry
*h
= NULL
;
9666 const char *sym_name
;
9668 if (r_symndx
== STN_UNDEF
)
9671 if (r_symndx
>= locsymcount
9672 || (elf_bad_symtab (input_bfd
)
9673 && flinfo
->sections
[r_symndx
] == NULL
))
9675 h
= sym_hashes
[r_symndx
- extsymoff
];
9677 /* Badly formatted input files can contain relocs that
9678 reference non-existant symbols. Check here so that
9679 we do not seg fault. */
9684 sprintf_vma (buffer
, rel
->r_info
);
9685 (*_bfd_error_handler
)
9686 (_("error: %B contains a reloc (0x%s) for section %A "
9687 "that references a non-existent global symbol"),
9688 input_bfd
, o
, buffer
);
9689 bfd_set_error (bfd_error_bad_value
);
9693 while (h
->root
.type
== bfd_link_hash_indirect
9694 || h
->root
.type
== bfd_link_hash_warning
)
9695 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9700 if (h
->root
.type
== bfd_link_hash_defined
9701 || h
->root
.type
== bfd_link_hash_defweak
)
9702 ps
= &h
->root
.u
.def
.section
;
9704 sym_name
= h
->root
.root
.string
;
9708 Elf_Internal_Sym
*sym
= isymbuf
+ r_symndx
;
9710 s_type
= ELF_ST_TYPE (sym
->st_info
);
9711 ps
= &flinfo
->sections
[r_symndx
];
9712 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
9716 if ((s_type
== STT_RELC
|| s_type
== STT_SRELC
)
9717 && !flinfo
->info
->relocatable
)
9720 bfd_vma dot
= (rel
->r_offset
9721 + o
->output_offset
+ o
->output_section
->vma
);
9723 printf ("Encountered a complex symbol!");
9724 printf (" (input_bfd %s, section %s, reloc %ld\n",
9725 input_bfd
->filename
, o
->name
,
9726 (long) (rel
- internal_relocs
));
9727 printf (" symbol: idx %8.8lx, name %s\n",
9728 r_symndx
, sym_name
);
9729 printf (" reloc : info %8.8lx, addr %8.8lx\n",
9730 (unsigned long) rel
->r_info
,
9731 (unsigned long) rel
->r_offset
);
9733 if (!eval_symbol (&val
, &sym_name
, input_bfd
, flinfo
, dot
,
9734 isymbuf
, locsymcount
, s_type
== STT_SRELC
))
9737 /* Symbol evaluated OK. Update to absolute value. */
9738 set_symbol_value (input_bfd
, isymbuf
, locsymcount
,
9743 if (action_discarded
!= -1 && ps
!= NULL
)
9745 /* Complain if the definition comes from a
9746 discarded section. */
9747 if ((sec
= *ps
) != NULL
&& discarded_section (sec
))
9749 BFD_ASSERT (r_symndx
!= STN_UNDEF
);
9750 if (action_discarded
& COMPLAIN
)
9751 (*flinfo
->info
->callbacks
->einfo
)
9752 (_("%X`%s' referenced in section `%A' of %B: "
9753 "defined in discarded section `%A' of %B\n"),
9754 sym_name
, o
, input_bfd
, sec
, sec
->owner
);
9756 /* Try to do the best we can to support buggy old
9757 versions of gcc. Pretend that the symbol is
9758 really defined in the kept linkonce section.
9759 FIXME: This is quite broken. Modifying the
9760 symbol here means we will be changing all later
9761 uses of the symbol, not just in this section. */
9762 if (action_discarded
& PRETEND
)
9766 kept
= _bfd_elf_check_kept_section (sec
,
9778 /* Relocate the section by invoking a back end routine.
9780 The back end routine is responsible for adjusting the
9781 section contents as necessary, and (if using Rela relocs
9782 and generating a relocatable output file) adjusting the
9783 reloc addend as necessary.
9785 The back end routine does not have to worry about setting
9786 the reloc address or the reloc symbol index.
9788 The back end routine is given a pointer to the swapped in
9789 internal symbols, and can access the hash table entries
9790 for the external symbols via elf_sym_hashes (input_bfd).
9792 When generating relocatable output, the back end routine
9793 must handle STB_LOCAL/STT_SECTION symbols specially. The
9794 output symbol is going to be a section symbol
9795 corresponding to the output section, which will require
9796 the addend to be adjusted. */
9798 ret
= (*relocate_section
) (output_bfd
, flinfo
->info
,
9799 input_bfd
, o
, contents
,
9807 || flinfo
->info
->relocatable
9808 || flinfo
->info
->emitrelocations
)
9810 Elf_Internal_Rela
*irela
;
9811 Elf_Internal_Rela
*irelaend
, *irelamid
;
9812 bfd_vma last_offset
;
9813 struct elf_link_hash_entry
**rel_hash
;
9814 struct elf_link_hash_entry
**rel_hash_list
, **rela_hash_list
;
9815 Elf_Internal_Shdr
*input_rel_hdr
, *input_rela_hdr
;
9816 unsigned int next_erel
;
9817 bfd_boolean rela_normal
;
9818 struct bfd_elf_section_data
*esdi
, *esdo
;
9820 esdi
= elf_section_data (o
);
9821 esdo
= elf_section_data (o
->output_section
);
9822 rela_normal
= FALSE
;
9824 /* Adjust the reloc addresses and symbol indices. */
9826 irela
= internal_relocs
;
9827 irelaend
= irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9828 rel_hash
= esdo
->rel
.hashes
+ esdo
->rel
.count
;
9829 /* We start processing the REL relocs, if any. When we reach
9830 IRELAMID in the loop, we switch to the RELA relocs. */
9832 if (esdi
->rel
.hdr
!= NULL
)
9833 irelamid
+= (NUM_SHDR_ENTRIES (esdi
->rel
.hdr
)
9834 * bed
->s
->int_rels_per_ext_rel
);
9835 rel_hash_list
= rel_hash
;
9836 rela_hash_list
= NULL
;
9837 last_offset
= o
->output_offset
;
9838 if (!flinfo
->info
->relocatable
)
9839 last_offset
+= o
->output_section
->vma
;
9840 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
9842 unsigned long r_symndx
;
9844 Elf_Internal_Sym sym
;
9846 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
9852 if (irela
== irelamid
)
9854 rel_hash
= esdo
->rela
.hashes
+ esdo
->rela
.count
;
9855 rela_hash_list
= rel_hash
;
9856 rela_normal
= bed
->rela_normal
;
9859 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
9862 if (irela
->r_offset
>= (bfd_vma
) -2)
9864 /* This is a reloc for a deleted entry or somesuch.
9865 Turn it into an R_*_NONE reloc, at the same
9866 offset as the last reloc. elf_eh_frame.c and
9867 bfd_elf_discard_info rely on reloc offsets
9869 irela
->r_offset
= last_offset
;
9871 irela
->r_addend
= 0;
9875 irela
->r_offset
+= o
->output_offset
;
9877 /* Relocs in an executable have to be virtual addresses. */
9878 if (!flinfo
->info
->relocatable
)
9879 irela
->r_offset
+= o
->output_section
->vma
;
9881 last_offset
= irela
->r_offset
;
9883 r_symndx
= irela
->r_info
>> r_sym_shift
;
9884 if (r_symndx
== STN_UNDEF
)
9887 if (r_symndx
>= locsymcount
9888 || (elf_bad_symtab (input_bfd
)
9889 && flinfo
->sections
[r_symndx
] == NULL
))
9891 struct elf_link_hash_entry
*rh
;
9894 /* This is a reloc against a global symbol. We
9895 have not yet output all the local symbols, so
9896 we do not know the symbol index of any global
9897 symbol. We set the rel_hash entry for this
9898 reloc to point to the global hash table entry
9899 for this symbol. The symbol index is then
9900 set at the end of bfd_elf_final_link. */
9901 indx
= r_symndx
- extsymoff
;
9902 rh
= elf_sym_hashes (input_bfd
)[indx
];
9903 while (rh
->root
.type
== bfd_link_hash_indirect
9904 || rh
->root
.type
== bfd_link_hash_warning
)
9905 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
9907 /* Setting the index to -2 tells
9908 elf_link_output_extsym that this symbol is
9910 BFD_ASSERT (rh
->indx
< 0);
9918 /* This is a reloc against a local symbol. */
9921 sym
= isymbuf
[r_symndx
];
9922 sec
= flinfo
->sections
[r_symndx
];
9923 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
9925 /* I suppose the backend ought to fill in the
9926 section of any STT_SECTION symbol against a
9927 processor specific section. */
9928 r_symndx
= STN_UNDEF
;
9929 if (bfd_is_abs_section (sec
))
9931 else if (sec
== NULL
|| sec
->owner
== NULL
)
9933 bfd_set_error (bfd_error_bad_value
);
9938 asection
*osec
= sec
->output_section
;
9940 /* If we have discarded a section, the output
9941 section will be the absolute section. In
9942 case of discarded SEC_MERGE sections, use
9943 the kept section. relocate_section should
9944 have already handled discarded linkonce
9946 if (bfd_is_abs_section (osec
)
9947 && sec
->kept_section
!= NULL
9948 && sec
->kept_section
->output_section
!= NULL
)
9950 osec
= sec
->kept_section
->output_section
;
9951 irela
->r_addend
-= osec
->vma
;
9954 if (!bfd_is_abs_section (osec
))
9956 r_symndx
= osec
->target_index
;
9957 if (r_symndx
== STN_UNDEF
)
9959 irela
->r_addend
+= osec
->vma
;
9960 osec
= _bfd_nearby_section (output_bfd
, osec
,
9962 irela
->r_addend
-= osec
->vma
;
9963 r_symndx
= osec
->target_index
;
9968 /* Adjust the addend according to where the
9969 section winds up in the output section. */
9971 irela
->r_addend
+= sec
->output_offset
;
9975 if (flinfo
->indices
[r_symndx
] == -1)
9977 unsigned long shlink
;
9982 if (flinfo
->info
->strip
== strip_all
)
9984 /* You can't do ld -r -s. */
9985 bfd_set_error (bfd_error_invalid_operation
);
9989 /* This symbol was skipped earlier, but
9990 since it is needed by a reloc, we
9991 must output it now. */
9992 shlink
= symtab_hdr
->sh_link
;
9993 name
= (bfd_elf_string_from_elf_section
9994 (input_bfd
, shlink
, sym
.st_name
));
9998 osec
= sec
->output_section
;
10000 _bfd_elf_section_from_bfd_section (output_bfd
,
10002 if (sym
.st_shndx
== SHN_BAD
)
10005 sym
.st_value
+= sec
->output_offset
;
10006 if (!flinfo
->info
->relocatable
)
10008 sym
.st_value
+= osec
->vma
;
10009 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
10011 /* STT_TLS symbols are relative to PT_TLS
10013 BFD_ASSERT (elf_hash_table (flinfo
->info
)
10014 ->tls_sec
!= NULL
);
10015 sym
.st_value
-= (elf_hash_table (flinfo
->info
)
10020 indx
= bfd_get_symcount (output_bfd
);
10021 ret
= elf_link_output_sym (flinfo
, name
, &sym
, sec
,
10026 flinfo
->indices
[r_symndx
] = indx
;
10031 r_symndx
= flinfo
->indices
[r_symndx
];
10034 irela
->r_info
= ((bfd_vma
) r_symndx
<< r_sym_shift
10035 | (irela
->r_info
& r_type_mask
));
10038 /* Swap out the relocs. */
10039 input_rel_hdr
= esdi
->rel
.hdr
;
10040 if (input_rel_hdr
&& input_rel_hdr
->sh_size
!= 0)
10042 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
10047 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
10048 * bed
->s
->int_rels_per_ext_rel
);
10049 rel_hash_list
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
10052 input_rela_hdr
= esdi
->rela
.hdr
;
10053 if (input_rela_hdr
&& input_rela_hdr
->sh_size
!= 0)
10055 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
10064 /* Write out the modified section contents. */
10065 if (bed
->elf_backend_write_section
10066 && (*bed
->elf_backend_write_section
) (output_bfd
, flinfo
->info
, o
,
10069 /* Section written out. */
10071 else switch (o
->sec_info_type
)
10073 case SEC_INFO_TYPE_STABS
:
10074 if (! (_bfd_write_section_stabs
10076 &elf_hash_table (flinfo
->info
)->stab_info
,
10077 o
, &elf_section_data (o
)->sec_info
, contents
)))
10080 case SEC_INFO_TYPE_MERGE
:
10081 if (! _bfd_write_merged_section (output_bfd
, o
,
10082 elf_section_data (o
)->sec_info
))
10085 case SEC_INFO_TYPE_EH_FRAME
:
10087 if (! _bfd_elf_write_section_eh_frame (output_bfd
, flinfo
->info
,
10094 /* FIXME: octets_per_byte. */
10095 if (! (o
->flags
& SEC_EXCLUDE
))
10097 file_ptr offset
= (file_ptr
) o
->output_offset
;
10098 bfd_size_type todo
= o
->size
;
10099 if ((o
->flags
& SEC_ELF_REVERSE_COPY
))
10101 /* Reverse-copy input section to output. */
10104 todo
-= address_size
;
10105 if (! bfd_set_section_contents (output_bfd
,
10113 offset
+= address_size
;
10117 else if (! bfd_set_section_contents (output_bfd
,
10131 /* Generate a reloc when linking an ELF file. This is a reloc
10132 requested by the linker, and does not come from any input file. This
10133 is used to build constructor and destructor tables when linking
10137 elf_reloc_link_order (bfd
*output_bfd
,
10138 struct bfd_link_info
*info
,
10139 asection
*output_section
,
10140 struct bfd_link_order
*link_order
)
10142 reloc_howto_type
*howto
;
10146 struct bfd_elf_section_reloc_data
*reldata
;
10147 struct elf_link_hash_entry
**rel_hash_ptr
;
10148 Elf_Internal_Shdr
*rel_hdr
;
10149 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
10150 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
10153 struct bfd_elf_section_data
*esdo
= elf_section_data (output_section
);
10155 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
10158 bfd_set_error (bfd_error_bad_value
);
10162 addend
= link_order
->u
.reloc
.p
->addend
;
10165 reldata
= &esdo
->rel
;
10166 else if (esdo
->rela
.hdr
)
10167 reldata
= &esdo
->rela
;
10174 /* Figure out the symbol index. */
10175 rel_hash_ptr
= reldata
->hashes
+ reldata
->count
;
10176 if (link_order
->type
== bfd_section_reloc_link_order
)
10178 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
10179 BFD_ASSERT (indx
!= 0);
10180 *rel_hash_ptr
= NULL
;
10184 struct elf_link_hash_entry
*h
;
10186 /* Treat a reloc against a defined symbol as though it were
10187 actually against the section. */
10188 h
= ((struct elf_link_hash_entry
*)
10189 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
10190 link_order
->u
.reloc
.p
->u
.name
,
10191 FALSE
, FALSE
, TRUE
));
10193 && (h
->root
.type
== bfd_link_hash_defined
10194 || h
->root
.type
== bfd_link_hash_defweak
))
10198 section
= h
->root
.u
.def
.section
;
10199 indx
= section
->output_section
->target_index
;
10200 *rel_hash_ptr
= NULL
;
10201 /* It seems that we ought to add the symbol value to the
10202 addend here, but in practice it has already been added
10203 because it was passed to constructor_callback. */
10204 addend
+= section
->output_section
->vma
+ section
->output_offset
;
10206 else if (h
!= NULL
)
10208 /* Setting the index to -2 tells elf_link_output_extsym that
10209 this symbol is used by a reloc. */
10216 if (! ((*info
->callbacks
->unattached_reloc
)
10217 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0)))
10223 /* If this is an inplace reloc, we must write the addend into the
10225 if (howto
->partial_inplace
&& addend
!= 0)
10227 bfd_size_type size
;
10228 bfd_reloc_status_type rstat
;
10231 const char *sym_name
;
10233 size
= (bfd_size_type
) bfd_get_reloc_size (howto
);
10234 buf
= (bfd_byte
*) bfd_zmalloc (size
);
10237 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
10244 case bfd_reloc_outofrange
:
10247 case bfd_reloc_overflow
:
10248 if (link_order
->type
== bfd_section_reloc_link_order
)
10249 sym_name
= bfd_section_name (output_bfd
,
10250 link_order
->u
.reloc
.p
->u
.section
);
10252 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
10253 if (! ((*info
->callbacks
->reloc_overflow
)
10254 (info
, NULL
, sym_name
, howto
->name
, addend
, NULL
,
10255 NULL
, (bfd_vma
) 0)))
10262 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
10263 link_order
->offset
, size
);
10269 /* The address of a reloc is relative to the section in a
10270 relocatable file, and is a virtual address in an executable
10272 offset
= link_order
->offset
;
10273 if (! info
->relocatable
)
10274 offset
+= output_section
->vma
;
10276 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
10278 irel
[i
].r_offset
= offset
;
10279 irel
[i
].r_info
= 0;
10280 irel
[i
].r_addend
= 0;
10282 if (bed
->s
->arch_size
== 32)
10283 irel
[0].r_info
= ELF32_R_INFO (indx
, howto
->type
);
10285 irel
[0].r_info
= ELF64_R_INFO (indx
, howto
->type
);
10287 rel_hdr
= reldata
->hdr
;
10288 erel
= rel_hdr
->contents
;
10289 if (rel_hdr
->sh_type
== SHT_REL
)
10291 erel
+= reldata
->count
* bed
->s
->sizeof_rel
;
10292 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
10296 irel
[0].r_addend
= addend
;
10297 erel
+= reldata
->count
* bed
->s
->sizeof_rela
;
10298 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
10307 /* Get the output vma of the section pointed to by the sh_link field. */
10310 elf_get_linked_section_vma (struct bfd_link_order
*p
)
10312 Elf_Internal_Shdr
**elf_shdrp
;
10316 s
= p
->u
.indirect
.section
;
10317 elf_shdrp
= elf_elfsections (s
->owner
);
10318 elfsec
= _bfd_elf_section_from_bfd_section (s
->owner
, s
);
10319 elfsec
= elf_shdrp
[elfsec
]->sh_link
;
10321 The Intel C compiler generates SHT_IA_64_UNWIND with
10322 SHF_LINK_ORDER. But it doesn't set the sh_link or
10323 sh_info fields. Hence we could get the situation
10324 where elfsec is 0. */
10327 const struct elf_backend_data
*bed
10328 = get_elf_backend_data (s
->owner
);
10329 if (bed
->link_order_error_handler
)
10330 bed
->link_order_error_handler
10331 (_("%B: warning: sh_link not set for section `%A'"), s
->owner
, s
);
10336 s
= elf_shdrp
[elfsec
]->bfd_section
;
10337 return s
->output_section
->vma
+ s
->output_offset
;
10342 /* Compare two sections based on the locations of the sections they are
10343 linked to. Used by elf_fixup_link_order. */
10346 compare_link_order (const void * a
, const void * b
)
10351 apos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)a
);
10352 bpos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)b
);
10355 return apos
> bpos
;
10359 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
10360 order as their linked sections. Returns false if this could not be done
10361 because an output section includes both ordered and unordered
10362 sections. Ideally we'd do this in the linker proper. */
10365 elf_fixup_link_order (bfd
*abfd
, asection
*o
)
10367 int seen_linkorder
;
10370 struct bfd_link_order
*p
;
10372 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10374 struct bfd_link_order
**sections
;
10375 asection
*s
, *other_sec
, *linkorder_sec
;
10379 linkorder_sec
= NULL
;
10381 seen_linkorder
= 0;
10382 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10384 if (p
->type
== bfd_indirect_link_order
)
10386 s
= p
->u
.indirect
.section
;
10388 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
10389 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
10390 && (elfsec
= _bfd_elf_section_from_bfd_section (sub
, s
))
10391 && elfsec
< elf_numsections (sub
)
10392 && elf_elfsections (sub
)[elfsec
]->sh_flags
& SHF_LINK_ORDER
10393 && elf_elfsections (sub
)[elfsec
]->sh_link
< elf_numsections (sub
))
10407 if (seen_other
&& seen_linkorder
)
10409 if (other_sec
&& linkorder_sec
)
10410 (*_bfd_error_handler
) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10412 linkorder_sec
->owner
, other_sec
,
10415 (*_bfd_error_handler
) (_("%A has both ordered and unordered sections"),
10417 bfd_set_error (bfd_error_bad_value
);
10422 if (!seen_linkorder
)
10425 sections
= (struct bfd_link_order
**)
10426 bfd_malloc (seen_linkorder
* sizeof (struct bfd_link_order
*));
10427 if (sections
== NULL
)
10429 seen_linkorder
= 0;
10431 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10433 sections
[seen_linkorder
++] = p
;
10435 /* Sort the input sections in the order of their linked section. */
10436 qsort (sections
, seen_linkorder
, sizeof (struct bfd_link_order
*),
10437 compare_link_order
);
10439 /* Change the offsets of the sections. */
10441 for (n
= 0; n
< seen_linkorder
; n
++)
10443 s
= sections
[n
]->u
.indirect
.section
;
10444 offset
&= ~(bfd_vma
) 0 << s
->alignment_power
;
10445 s
->output_offset
= offset
;
10446 sections
[n
]->offset
= offset
;
10447 /* FIXME: octets_per_byte. */
10448 offset
+= sections
[n
]->size
;
10456 /* Do the final step of an ELF link. */
10459 bfd_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10461 bfd_boolean dynamic
;
10462 bfd_boolean emit_relocs
;
10464 struct elf_final_link_info flinfo
;
10466 struct bfd_link_order
*p
;
10468 bfd_size_type max_contents_size
;
10469 bfd_size_type max_external_reloc_size
;
10470 bfd_size_type max_internal_reloc_count
;
10471 bfd_size_type max_sym_count
;
10472 bfd_size_type max_sym_shndx_count
;
10474 Elf_Internal_Sym elfsym
;
10476 Elf_Internal_Shdr
*symtab_hdr
;
10477 Elf_Internal_Shdr
*symtab_shndx_hdr
;
10478 Elf_Internal_Shdr
*symstrtab_hdr
;
10479 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10480 struct elf_outext_info eoinfo
;
10481 bfd_boolean merged
;
10482 size_t relativecount
= 0;
10483 asection
*reldyn
= 0;
10485 asection
*attr_section
= NULL
;
10486 bfd_vma attr_size
= 0;
10487 const char *std_attrs_section
;
10489 if (! is_elf_hash_table (info
->hash
))
10493 abfd
->flags
|= DYNAMIC
;
10495 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
10496 dynobj
= elf_hash_table (info
)->dynobj
;
10498 emit_relocs
= (info
->relocatable
10499 || info
->emitrelocations
);
10501 flinfo
.info
= info
;
10502 flinfo
.output_bfd
= abfd
;
10503 flinfo
.symstrtab
= _bfd_elf_stringtab_init ();
10504 if (flinfo
.symstrtab
== NULL
)
10509 flinfo
.dynsym_sec
= NULL
;
10510 flinfo
.hash_sec
= NULL
;
10511 flinfo
.symver_sec
= NULL
;
10515 flinfo
.dynsym_sec
= bfd_get_linker_section (dynobj
, ".dynsym");
10516 flinfo
.hash_sec
= bfd_get_linker_section (dynobj
, ".hash");
10517 /* Note that dynsym_sec can be NULL (on VMS). */
10518 flinfo
.symver_sec
= bfd_get_linker_section (dynobj
, ".gnu.version");
10519 /* Note that it is OK if symver_sec is NULL. */
10522 flinfo
.contents
= NULL
;
10523 flinfo
.external_relocs
= NULL
;
10524 flinfo
.internal_relocs
= NULL
;
10525 flinfo
.external_syms
= NULL
;
10526 flinfo
.locsym_shndx
= NULL
;
10527 flinfo
.internal_syms
= NULL
;
10528 flinfo
.indices
= NULL
;
10529 flinfo
.sections
= NULL
;
10530 flinfo
.symbuf
= NULL
;
10531 flinfo
.symshndxbuf
= NULL
;
10532 flinfo
.symbuf_count
= 0;
10533 flinfo
.shndxbuf_size
= 0;
10534 flinfo
.filesym_count
= 0;
10536 /* The object attributes have been merged. Remove the input
10537 sections from the link, and set the contents of the output
10539 std_attrs_section
= get_elf_backend_data (abfd
)->obj_attrs_section
;
10540 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10542 if ((std_attrs_section
&& strcmp (o
->name
, std_attrs_section
) == 0)
10543 || strcmp (o
->name
, ".gnu.attributes") == 0)
10545 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10547 asection
*input_section
;
10549 if (p
->type
!= bfd_indirect_link_order
)
10551 input_section
= p
->u
.indirect
.section
;
10552 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10553 elf_link_input_bfd ignores this section. */
10554 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10557 attr_size
= bfd_elf_obj_attr_size (abfd
);
10560 bfd_set_section_size (abfd
, o
, attr_size
);
10562 /* Skip this section later on. */
10563 o
->map_head
.link_order
= NULL
;
10566 o
->flags
|= SEC_EXCLUDE
;
10570 /* Count up the number of relocations we will output for each output
10571 section, so that we know the sizes of the reloc sections. We
10572 also figure out some maximum sizes. */
10573 max_contents_size
= 0;
10574 max_external_reloc_size
= 0;
10575 max_internal_reloc_count
= 0;
10577 max_sym_shndx_count
= 0;
10579 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10581 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10582 o
->reloc_count
= 0;
10584 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10586 unsigned int reloc_count
= 0;
10587 struct bfd_elf_section_data
*esdi
= NULL
;
10589 if (p
->type
== bfd_section_reloc_link_order
10590 || p
->type
== bfd_symbol_reloc_link_order
)
10592 else if (p
->type
== bfd_indirect_link_order
)
10596 sec
= p
->u
.indirect
.section
;
10597 esdi
= elf_section_data (sec
);
10599 /* Mark all sections which are to be included in the
10600 link. This will normally be every section. We need
10601 to do this so that we can identify any sections which
10602 the linker has decided to not include. */
10603 sec
->linker_mark
= TRUE
;
10605 if (sec
->flags
& SEC_MERGE
)
10608 if (esdo
->this_hdr
.sh_type
== SHT_REL
10609 || esdo
->this_hdr
.sh_type
== SHT_RELA
)
10610 /* Some backends use reloc_count in relocation sections
10611 to count particular types of relocs. Of course,
10612 reloc sections themselves can't have relocations. */
10614 else if (info
->relocatable
|| info
->emitrelocations
)
10615 reloc_count
= sec
->reloc_count
;
10616 else if (bed
->elf_backend_count_relocs
)
10617 reloc_count
= (*bed
->elf_backend_count_relocs
) (info
, sec
);
10619 if (sec
->rawsize
> max_contents_size
)
10620 max_contents_size
= sec
->rawsize
;
10621 if (sec
->size
> max_contents_size
)
10622 max_contents_size
= sec
->size
;
10624 /* We are interested in just local symbols, not all
10626 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
10627 && (sec
->owner
->flags
& DYNAMIC
) == 0)
10631 if (elf_bad_symtab (sec
->owner
))
10632 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
10633 / bed
->s
->sizeof_sym
);
10635 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
10637 if (sym_count
> max_sym_count
)
10638 max_sym_count
= sym_count
;
10640 if (sym_count
> max_sym_shndx_count
10641 && elf_symtab_shndx (sec
->owner
) != 0)
10642 max_sym_shndx_count
= sym_count
;
10644 if ((sec
->flags
& SEC_RELOC
) != 0)
10646 size_t ext_size
= 0;
10648 if (esdi
->rel
.hdr
!= NULL
)
10649 ext_size
= esdi
->rel
.hdr
->sh_size
;
10650 if (esdi
->rela
.hdr
!= NULL
)
10651 ext_size
+= esdi
->rela
.hdr
->sh_size
;
10653 if (ext_size
> max_external_reloc_size
)
10654 max_external_reloc_size
= ext_size
;
10655 if (sec
->reloc_count
> max_internal_reloc_count
)
10656 max_internal_reloc_count
= sec
->reloc_count
;
10661 if (reloc_count
== 0)
10664 o
->reloc_count
+= reloc_count
;
10666 if (p
->type
== bfd_indirect_link_order
10667 && (info
->relocatable
|| info
->emitrelocations
))
10670 esdo
->rel
.count
+= NUM_SHDR_ENTRIES (esdi
->rel
.hdr
);
10671 if (esdi
->rela
.hdr
)
10672 esdo
->rela
.count
+= NUM_SHDR_ENTRIES (esdi
->rela
.hdr
);
10677 esdo
->rela
.count
+= reloc_count
;
10679 esdo
->rel
.count
+= reloc_count
;
10683 if (o
->reloc_count
> 0)
10684 o
->flags
|= SEC_RELOC
;
10687 /* Explicitly clear the SEC_RELOC flag. The linker tends to
10688 set it (this is probably a bug) and if it is set
10689 assign_section_numbers will create a reloc section. */
10690 o
->flags
&=~ SEC_RELOC
;
10693 /* If the SEC_ALLOC flag is not set, force the section VMA to
10694 zero. This is done in elf_fake_sections as well, but forcing
10695 the VMA to 0 here will ensure that relocs against these
10696 sections are handled correctly. */
10697 if ((o
->flags
& SEC_ALLOC
) == 0
10698 && ! o
->user_set_vma
)
10702 if (! info
->relocatable
&& merged
)
10703 elf_link_hash_traverse (elf_hash_table (info
),
10704 _bfd_elf_link_sec_merge_syms
, abfd
);
10706 /* Figure out the file positions for everything but the symbol table
10707 and the relocs. We set symcount to force assign_section_numbers
10708 to create a symbol table. */
10709 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
10710 BFD_ASSERT (! abfd
->output_has_begun
);
10711 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
10714 /* Set sizes, and assign file positions for reloc sections. */
10715 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10717 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10718 if ((o
->flags
& SEC_RELOC
) != 0)
10721 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rel
)))
10725 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rela
)))
10729 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10730 to count upwards while actually outputting the relocations. */
10731 esdo
->rel
.count
= 0;
10732 esdo
->rela
.count
= 0;
10735 _bfd_elf_assign_file_positions_for_relocs (abfd
);
10737 /* We have now assigned file positions for all the sections except
10738 .symtab and .strtab. We start the .symtab section at the current
10739 file position, and write directly to it. We build the .strtab
10740 section in memory. */
10741 bfd_get_symcount (abfd
) = 0;
10742 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10743 /* sh_name is set in prep_headers. */
10744 symtab_hdr
->sh_type
= SHT_SYMTAB
;
10745 /* sh_flags, sh_addr and sh_size all start off zero. */
10746 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
10747 /* sh_link is set in assign_section_numbers. */
10748 /* sh_info is set below. */
10749 /* sh_offset is set just below. */
10750 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
10752 off
= elf_tdata (abfd
)->next_file_pos
;
10753 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, TRUE
);
10755 /* Note that at this point elf_tdata (abfd)->next_file_pos is
10756 incorrect. We do not yet know the size of the .symtab section.
10757 We correct next_file_pos below, after we do know the size. */
10759 /* Allocate a buffer to hold swapped out symbols. This is to avoid
10760 continuously seeking to the right position in the file. */
10761 if (! info
->keep_memory
|| max_sym_count
< 20)
10762 flinfo
.symbuf_size
= 20;
10764 flinfo
.symbuf_size
= max_sym_count
;
10765 amt
= flinfo
.symbuf_size
;
10766 amt
*= bed
->s
->sizeof_sym
;
10767 flinfo
.symbuf
= (bfd_byte
*) bfd_malloc (amt
);
10768 if (flinfo
.symbuf
== NULL
)
10770 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
10772 /* Wild guess at number of output symbols. realloc'd as needed. */
10773 amt
= 2 * max_sym_count
+ elf_numsections (abfd
) + 1000;
10774 flinfo
.shndxbuf_size
= amt
;
10775 amt
*= sizeof (Elf_External_Sym_Shndx
);
10776 flinfo
.symshndxbuf
= (Elf_External_Sym_Shndx
*) bfd_zmalloc (amt
);
10777 if (flinfo
.symshndxbuf
== NULL
)
10781 /* Start writing out the symbol table. The first symbol is always a
10783 if (info
->strip
!= strip_all
10786 elfsym
.st_value
= 0;
10787 elfsym
.st_size
= 0;
10788 elfsym
.st_info
= 0;
10789 elfsym
.st_other
= 0;
10790 elfsym
.st_shndx
= SHN_UNDEF
;
10791 elfsym
.st_target_internal
= 0;
10792 if (elf_link_output_sym (&flinfo
, NULL
, &elfsym
, bfd_und_section_ptr
,
10797 /* Output a symbol for each section. We output these even if we are
10798 discarding local symbols, since they are used for relocs. These
10799 symbols have no names. We store the index of each one in the
10800 index field of the section, so that we can find it again when
10801 outputting relocs. */
10802 if (info
->strip
!= strip_all
10805 elfsym
.st_size
= 0;
10806 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
10807 elfsym
.st_other
= 0;
10808 elfsym
.st_value
= 0;
10809 elfsym
.st_target_internal
= 0;
10810 for (i
= 1; i
< elf_numsections (abfd
); i
++)
10812 o
= bfd_section_from_elf_index (abfd
, i
);
10815 o
->target_index
= bfd_get_symcount (abfd
);
10816 elfsym
.st_shndx
= i
;
10817 if (!info
->relocatable
)
10818 elfsym
.st_value
= o
->vma
;
10819 if (elf_link_output_sym (&flinfo
, NULL
, &elfsym
, o
, NULL
) != 1)
10825 /* Allocate some memory to hold information read in from the input
10827 if (max_contents_size
!= 0)
10829 flinfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
10830 if (flinfo
.contents
== NULL
)
10834 if (max_external_reloc_size
!= 0)
10836 flinfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
10837 if (flinfo
.external_relocs
== NULL
)
10841 if (max_internal_reloc_count
!= 0)
10843 amt
= max_internal_reloc_count
* bed
->s
->int_rels_per_ext_rel
;
10844 amt
*= sizeof (Elf_Internal_Rela
);
10845 flinfo
.internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
10846 if (flinfo
.internal_relocs
== NULL
)
10850 if (max_sym_count
!= 0)
10852 amt
= max_sym_count
* bed
->s
->sizeof_sym
;
10853 flinfo
.external_syms
= (bfd_byte
*) bfd_malloc (amt
);
10854 if (flinfo
.external_syms
== NULL
)
10857 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
10858 flinfo
.internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
10859 if (flinfo
.internal_syms
== NULL
)
10862 amt
= max_sym_count
* sizeof (long);
10863 flinfo
.indices
= (long int *) bfd_malloc (amt
);
10864 if (flinfo
.indices
== NULL
)
10867 amt
= max_sym_count
* sizeof (asection
*);
10868 flinfo
.sections
= (asection
**) bfd_malloc (amt
);
10869 if (flinfo
.sections
== NULL
)
10873 if (max_sym_shndx_count
!= 0)
10875 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
10876 flinfo
.locsym_shndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
10877 if (flinfo
.locsym_shndx
== NULL
)
10881 if (elf_hash_table (info
)->tls_sec
)
10883 bfd_vma base
, end
= 0;
10886 for (sec
= elf_hash_table (info
)->tls_sec
;
10887 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
10890 bfd_size_type size
= sec
->size
;
10893 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
10895 struct bfd_link_order
*ord
= sec
->map_tail
.link_order
;
10898 size
= ord
->offset
+ ord
->size
;
10900 end
= sec
->vma
+ size
;
10902 base
= elf_hash_table (info
)->tls_sec
->vma
;
10903 /* Only align end of TLS section if static TLS doesn't have special
10904 alignment requirements. */
10905 if (bed
->static_tls_alignment
== 1)
10906 end
= align_power (end
,
10907 elf_hash_table (info
)->tls_sec
->alignment_power
);
10908 elf_hash_table (info
)->tls_size
= end
- base
;
10911 /* Reorder SHF_LINK_ORDER sections. */
10912 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10914 if (!elf_fixup_link_order (abfd
, o
))
10918 /* Since ELF permits relocations to be against local symbols, we
10919 must have the local symbols available when we do the relocations.
10920 Since we would rather only read the local symbols once, and we
10921 would rather not keep them in memory, we handle all the
10922 relocations for a single input file at the same time.
10924 Unfortunately, there is no way to know the total number of local
10925 symbols until we have seen all of them, and the local symbol
10926 indices precede the global symbol indices. This means that when
10927 we are generating relocatable output, and we see a reloc against
10928 a global symbol, we can not know the symbol index until we have
10929 finished examining all the local symbols to see which ones we are
10930 going to output. To deal with this, we keep the relocations in
10931 memory, and don't output them until the end of the link. This is
10932 an unfortunate waste of memory, but I don't see a good way around
10933 it. Fortunately, it only happens when performing a relocatable
10934 link, which is not the common case. FIXME: If keep_memory is set
10935 we could write the relocs out and then read them again; I don't
10936 know how bad the memory loss will be. */
10938 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
10939 sub
->output_has_begun
= FALSE
;
10940 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10942 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10944 if (p
->type
== bfd_indirect_link_order
10945 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
10946 == bfd_target_elf_flavour
)
10947 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
10949 if (! sub
->output_has_begun
)
10951 if (! elf_link_input_bfd (&flinfo
, sub
))
10953 sub
->output_has_begun
= TRUE
;
10956 else if (p
->type
== bfd_section_reloc_link_order
10957 || p
->type
== bfd_symbol_reloc_link_order
)
10959 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
10964 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
10966 if (p
->type
== bfd_indirect_link_order
10967 && (bfd_get_flavour (sub
)
10968 == bfd_target_elf_flavour
)
10969 && (elf_elfheader (sub
)->e_ident
[EI_CLASS
]
10970 != bed
->s
->elfclass
))
10972 const char *iclass
, *oclass
;
10974 if (bed
->s
->elfclass
== ELFCLASS64
)
10976 iclass
= "ELFCLASS32";
10977 oclass
= "ELFCLASS64";
10981 iclass
= "ELFCLASS64";
10982 oclass
= "ELFCLASS32";
10985 bfd_set_error (bfd_error_wrong_format
);
10986 (*_bfd_error_handler
)
10987 (_("%B: file class %s incompatible with %s"),
10988 sub
, iclass
, oclass
);
10997 /* Free symbol buffer if needed. */
10998 if (!info
->reduce_memory_overheads
)
11000 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
11001 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
11002 && elf_tdata (sub
)->symbuf
)
11004 free (elf_tdata (sub
)->symbuf
);
11005 elf_tdata (sub
)->symbuf
= NULL
;
11009 /* Output a FILE symbol so that following locals are not associated
11010 with the wrong input file. */
11011 memset (&elfsym
, 0, sizeof (elfsym
));
11012 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
11013 elfsym
.st_shndx
= SHN_ABS
;
11015 if (flinfo
.filesym_count
> 1
11016 && !elf_link_output_sym (&flinfo
, NULL
, &elfsym
,
11017 bfd_und_section_ptr
, NULL
))
11020 /* Output any global symbols that got converted to local in a
11021 version script or due to symbol visibility. We do this in a
11022 separate step since ELF requires all local symbols to appear
11023 prior to any global symbols. FIXME: We should only do this if
11024 some global symbols were, in fact, converted to become local.
11025 FIXME: Will this work correctly with the Irix 5 linker? */
11026 eoinfo
.failed
= FALSE
;
11027 eoinfo
.flinfo
= &flinfo
;
11028 eoinfo
.localsyms
= TRUE
;
11029 eoinfo
.need_second_pass
= FALSE
;
11030 eoinfo
.second_pass
= FALSE
;
11031 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11035 if (flinfo
.filesym_count
== 1
11036 && !elf_link_output_sym (&flinfo
, NULL
, &elfsym
,
11037 bfd_und_section_ptr
, NULL
))
11040 if (eoinfo
.need_second_pass
)
11042 eoinfo
.second_pass
= TRUE
;
11043 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11048 /* If backend needs to output some local symbols not present in the hash
11049 table, do it now. */
11050 if (bed
->elf_backend_output_arch_local_syms
)
11052 typedef int (*out_sym_func
)
11053 (void *, const char *, Elf_Internal_Sym
*, asection
*,
11054 struct elf_link_hash_entry
*);
11056 if (! ((*bed
->elf_backend_output_arch_local_syms
)
11057 (abfd
, info
, &flinfo
, (out_sym_func
) elf_link_output_sym
)))
11061 /* That wrote out all the local symbols. Finish up the symbol table
11062 with the global symbols. Even if we want to strip everything we
11063 can, we still need to deal with those global symbols that got
11064 converted to local in a version script. */
11066 /* The sh_info field records the index of the first non local symbol. */
11067 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
11070 && flinfo
.dynsym_sec
!= NULL
11071 && flinfo
.dynsym_sec
->output_section
!= bfd_abs_section_ptr
)
11073 Elf_Internal_Sym sym
;
11074 bfd_byte
*dynsym
= flinfo
.dynsym_sec
->contents
;
11075 long last_local
= 0;
11077 /* Write out the section symbols for the output sections. */
11078 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
11084 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
11086 sym
.st_target_internal
= 0;
11088 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
11094 dynindx
= elf_section_data (s
)->dynindx
;
11097 indx
= elf_section_data (s
)->this_idx
;
11098 BFD_ASSERT (indx
> 0);
11099 sym
.st_shndx
= indx
;
11100 if (! check_dynsym (abfd
, &sym
))
11102 sym
.st_value
= s
->vma
;
11103 dest
= dynsym
+ dynindx
* bed
->s
->sizeof_sym
;
11104 if (last_local
< dynindx
)
11105 last_local
= dynindx
;
11106 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
11110 /* Write out the local dynsyms. */
11111 if (elf_hash_table (info
)->dynlocal
)
11113 struct elf_link_local_dynamic_entry
*e
;
11114 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
11119 /* Copy the internal symbol and turn off visibility.
11120 Note that we saved a word of storage and overwrote
11121 the original st_name with the dynstr_index. */
11123 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
11125 s
= bfd_section_from_elf_index (e
->input_bfd
,
11130 elf_section_data (s
->output_section
)->this_idx
;
11131 if (! check_dynsym (abfd
, &sym
))
11133 sym
.st_value
= (s
->output_section
->vma
11135 + e
->isym
.st_value
);
11138 if (last_local
< e
->dynindx
)
11139 last_local
= e
->dynindx
;
11141 dest
= dynsym
+ e
->dynindx
* bed
->s
->sizeof_sym
;
11142 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
11146 elf_section_data (flinfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
=
11150 /* We get the global symbols from the hash table. */
11151 eoinfo
.failed
= FALSE
;
11152 eoinfo
.localsyms
= FALSE
;
11153 eoinfo
.flinfo
= &flinfo
;
11154 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11158 /* If backend needs to output some symbols not present in the hash
11159 table, do it now. */
11160 if (bed
->elf_backend_output_arch_syms
)
11162 typedef int (*out_sym_func
)
11163 (void *, const char *, Elf_Internal_Sym
*, asection
*,
11164 struct elf_link_hash_entry
*);
11166 if (! ((*bed
->elf_backend_output_arch_syms
)
11167 (abfd
, info
, &flinfo
, (out_sym_func
) elf_link_output_sym
)))
11171 /* Flush all symbols to the file. */
11172 if (! elf_link_flush_output_syms (&flinfo
, bed
))
11175 /* Now we know the size of the symtab section. */
11176 off
+= symtab_hdr
->sh_size
;
11178 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
11179 if (symtab_shndx_hdr
->sh_name
!= 0)
11181 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
11182 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
11183 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
11184 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
11185 symtab_shndx_hdr
->sh_size
= amt
;
11187 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
11190 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
11191 || (bfd_bwrite (flinfo
.symshndxbuf
, amt
, abfd
) != amt
))
11196 /* Finish up and write out the symbol string table (.strtab)
11198 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
11199 /* sh_name was set in prep_headers. */
11200 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
11201 symstrtab_hdr
->sh_flags
= 0;
11202 symstrtab_hdr
->sh_addr
= 0;
11203 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (flinfo
.symstrtab
);
11204 symstrtab_hdr
->sh_entsize
= 0;
11205 symstrtab_hdr
->sh_link
= 0;
11206 symstrtab_hdr
->sh_info
= 0;
11207 /* sh_offset is set just below. */
11208 symstrtab_hdr
->sh_addralign
= 1;
11210 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, TRUE
);
11211 elf_tdata (abfd
)->next_file_pos
= off
;
11213 if (bfd_get_symcount (abfd
) > 0)
11215 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
11216 || ! _bfd_stringtab_emit (abfd
, flinfo
.symstrtab
))
11220 /* Adjust the relocs to have the correct symbol indices. */
11221 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11223 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11224 if ((o
->flags
& SEC_RELOC
) == 0)
11227 if (esdo
->rel
.hdr
!= NULL
)
11228 elf_link_adjust_relocs (abfd
, &esdo
->rel
);
11229 if (esdo
->rela
.hdr
!= NULL
)
11230 elf_link_adjust_relocs (abfd
, &esdo
->rela
);
11232 /* Set the reloc_count field to 0 to prevent write_relocs from
11233 trying to swap the relocs out itself. */
11234 o
->reloc_count
= 0;
11237 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
11238 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
11240 /* If we are linking against a dynamic object, or generating a
11241 shared library, finish up the dynamic linking information. */
11244 bfd_byte
*dyncon
, *dynconend
;
11246 /* Fix up .dynamic entries. */
11247 o
= bfd_get_linker_section (dynobj
, ".dynamic");
11248 BFD_ASSERT (o
!= NULL
);
11250 dyncon
= o
->contents
;
11251 dynconend
= o
->contents
+ o
->size
;
11252 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
11254 Elf_Internal_Dyn dyn
;
11258 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11265 if (relativecount
> 0 && dyncon
+ bed
->s
->sizeof_dyn
< dynconend
)
11267 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
11269 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
11270 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
11273 dyn
.d_un
.d_val
= relativecount
;
11280 name
= info
->init_function
;
11283 name
= info
->fini_function
;
11286 struct elf_link_hash_entry
*h
;
11288 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
11289 FALSE
, FALSE
, TRUE
);
11291 && (h
->root
.type
== bfd_link_hash_defined
11292 || h
->root
.type
== bfd_link_hash_defweak
))
11294 dyn
.d_un
.d_ptr
= h
->root
.u
.def
.value
;
11295 o
= h
->root
.u
.def
.section
;
11296 if (o
->output_section
!= NULL
)
11297 dyn
.d_un
.d_ptr
+= (o
->output_section
->vma
11298 + o
->output_offset
);
11301 /* The symbol is imported from another shared
11302 library and does not apply to this one. */
11303 dyn
.d_un
.d_ptr
= 0;
11310 case DT_PREINIT_ARRAYSZ
:
11311 name
= ".preinit_array";
11313 case DT_INIT_ARRAYSZ
:
11314 name
= ".init_array";
11316 case DT_FINI_ARRAYSZ
:
11317 name
= ".fini_array";
11319 o
= bfd_get_section_by_name (abfd
, name
);
11322 (*_bfd_error_handler
)
11323 (_("%B: could not find output section %s"), abfd
, name
);
11327 (*_bfd_error_handler
)
11328 (_("warning: %s section has zero size"), name
);
11329 dyn
.d_un
.d_val
= o
->size
;
11332 case DT_PREINIT_ARRAY
:
11333 name
= ".preinit_array";
11335 case DT_INIT_ARRAY
:
11336 name
= ".init_array";
11338 case DT_FINI_ARRAY
:
11339 name
= ".fini_array";
11346 name
= ".gnu.hash";
11355 name
= ".gnu.version_d";
11358 name
= ".gnu.version_r";
11361 name
= ".gnu.version";
11363 o
= bfd_get_section_by_name (abfd
, name
);
11366 (*_bfd_error_handler
)
11367 (_("%B: could not find output section %s"), abfd
, name
);
11370 if (elf_section_data (o
->output_section
)->this_hdr
.sh_type
== SHT_NOTE
)
11372 (*_bfd_error_handler
)
11373 (_("warning: section '%s' is being made into a note"), name
);
11374 bfd_set_error (bfd_error_nonrepresentable_section
);
11377 dyn
.d_un
.d_ptr
= o
->vma
;
11384 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
11388 dyn
.d_un
.d_val
= 0;
11389 dyn
.d_un
.d_ptr
= 0;
11390 for (i
= 1; i
< elf_numsections (abfd
); i
++)
11392 Elf_Internal_Shdr
*hdr
;
11394 hdr
= elf_elfsections (abfd
)[i
];
11395 if (hdr
->sh_type
== type
11396 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
11398 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
11399 dyn
.d_un
.d_val
+= hdr
->sh_size
;
11402 if (dyn
.d_un
.d_ptr
== 0
11403 || hdr
->sh_addr
< dyn
.d_un
.d_ptr
)
11404 dyn
.d_un
.d_ptr
= hdr
->sh_addr
;
11410 bed
->s
->swap_dyn_out (dynobj
, &dyn
, dyncon
);
11414 /* If we have created any dynamic sections, then output them. */
11415 if (dynobj
!= NULL
)
11417 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
11420 /* Check for DT_TEXTREL (late, in case the backend removes it). */
11421 if (((info
->warn_shared_textrel
&& info
->shared
)
11422 || info
->error_textrel
)
11423 && (o
= bfd_get_linker_section (dynobj
, ".dynamic")) != NULL
)
11425 bfd_byte
*dyncon
, *dynconend
;
11427 dyncon
= o
->contents
;
11428 dynconend
= o
->contents
+ o
->size
;
11429 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
11431 Elf_Internal_Dyn dyn
;
11433 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11435 if (dyn
.d_tag
== DT_TEXTREL
)
11437 if (info
->error_textrel
)
11438 info
->callbacks
->einfo
11439 (_("%P%X: read-only segment has dynamic relocations.\n"));
11441 info
->callbacks
->einfo
11442 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11448 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
11450 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
11452 || o
->output_section
== bfd_abs_section_ptr
)
11454 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
11456 /* At this point, we are only interested in sections
11457 created by _bfd_elf_link_create_dynamic_sections. */
11460 if (elf_hash_table (info
)->stab_info
.stabstr
== o
)
11462 if (elf_hash_table (info
)->eh_info
.hdr_sec
== o
)
11464 if (strcmp (o
->name
, ".dynstr") != 0)
11466 /* FIXME: octets_per_byte. */
11467 if (! bfd_set_section_contents (abfd
, o
->output_section
,
11469 (file_ptr
) o
->output_offset
,
11475 /* The contents of the .dynstr section are actually in a
11477 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
11478 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
11479 || ! _bfd_elf_strtab_emit (abfd
,
11480 elf_hash_table (info
)->dynstr
))
11486 if (info
->relocatable
)
11488 bfd_boolean failed
= FALSE
;
11490 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
11495 /* If we have optimized stabs strings, output them. */
11496 if (elf_hash_table (info
)->stab_info
.stabstr
!= NULL
)
11498 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
11502 if (info
->eh_frame_hdr
)
11504 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
11508 if (flinfo
.symstrtab
!= NULL
)
11509 _bfd_stringtab_free (flinfo
.symstrtab
);
11510 if (flinfo
.contents
!= NULL
)
11511 free (flinfo
.contents
);
11512 if (flinfo
.external_relocs
!= NULL
)
11513 free (flinfo
.external_relocs
);
11514 if (flinfo
.internal_relocs
!= NULL
)
11515 free (flinfo
.internal_relocs
);
11516 if (flinfo
.external_syms
!= NULL
)
11517 free (flinfo
.external_syms
);
11518 if (flinfo
.locsym_shndx
!= NULL
)
11519 free (flinfo
.locsym_shndx
);
11520 if (flinfo
.internal_syms
!= NULL
)
11521 free (flinfo
.internal_syms
);
11522 if (flinfo
.indices
!= NULL
)
11523 free (flinfo
.indices
);
11524 if (flinfo
.sections
!= NULL
)
11525 free (flinfo
.sections
);
11526 if (flinfo
.symbuf
!= NULL
)
11527 free (flinfo
.symbuf
);
11528 if (flinfo
.symshndxbuf
!= NULL
)
11529 free (flinfo
.symshndxbuf
);
11530 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11532 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11533 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
11534 free (esdo
->rel
.hashes
);
11535 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
11536 free (esdo
->rela
.hashes
);
11539 elf_tdata (abfd
)->linker
= TRUE
;
11543 bfd_byte
*contents
= (bfd_byte
*) bfd_malloc (attr_size
);
11544 if (contents
== NULL
)
11545 return FALSE
; /* Bail out and fail. */
11546 bfd_elf_set_obj_attr_contents (abfd
, contents
, attr_size
);
11547 bfd_set_section_contents (abfd
, attr_section
, contents
, 0, attr_size
);
11554 if (flinfo
.symstrtab
!= NULL
)
11555 _bfd_stringtab_free (flinfo
.symstrtab
);
11556 if (flinfo
.contents
!= NULL
)
11557 free (flinfo
.contents
);
11558 if (flinfo
.external_relocs
!= NULL
)
11559 free (flinfo
.external_relocs
);
11560 if (flinfo
.internal_relocs
!= NULL
)
11561 free (flinfo
.internal_relocs
);
11562 if (flinfo
.external_syms
!= NULL
)
11563 free (flinfo
.external_syms
);
11564 if (flinfo
.locsym_shndx
!= NULL
)
11565 free (flinfo
.locsym_shndx
);
11566 if (flinfo
.internal_syms
!= NULL
)
11567 free (flinfo
.internal_syms
);
11568 if (flinfo
.indices
!= NULL
)
11569 free (flinfo
.indices
);
11570 if (flinfo
.sections
!= NULL
)
11571 free (flinfo
.sections
);
11572 if (flinfo
.symbuf
!= NULL
)
11573 free (flinfo
.symbuf
);
11574 if (flinfo
.symshndxbuf
!= NULL
)
11575 free (flinfo
.symshndxbuf
);
11576 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11578 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11579 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
11580 free (esdo
->rel
.hashes
);
11581 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
11582 free (esdo
->rela
.hashes
);
11588 /* Initialize COOKIE for input bfd ABFD. */
11591 init_reloc_cookie (struct elf_reloc_cookie
*cookie
,
11592 struct bfd_link_info
*info
, bfd
*abfd
)
11594 Elf_Internal_Shdr
*symtab_hdr
;
11595 const struct elf_backend_data
*bed
;
11597 bed
= get_elf_backend_data (abfd
);
11598 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11600 cookie
->abfd
= abfd
;
11601 cookie
->sym_hashes
= elf_sym_hashes (abfd
);
11602 cookie
->bad_symtab
= elf_bad_symtab (abfd
);
11603 if (cookie
->bad_symtab
)
11605 cookie
->locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
11606 cookie
->extsymoff
= 0;
11610 cookie
->locsymcount
= symtab_hdr
->sh_info
;
11611 cookie
->extsymoff
= symtab_hdr
->sh_info
;
11614 if (bed
->s
->arch_size
== 32)
11615 cookie
->r_sym_shift
= 8;
11617 cookie
->r_sym_shift
= 32;
11619 cookie
->locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
11620 if (cookie
->locsyms
== NULL
&& cookie
->locsymcount
!= 0)
11622 cookie
->locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
11623 cookie
->locsymcount
, 0,
11625 if (cookie
->locsyms
== NULL
)
11627 info
->callbacks
->einfo (_("%P%X: can not read symbols: %E\n"));
11630 if (info
->keep_memory
)
11631 symtab_hdr
->contents
= (bfd_byte
*) cookie
->locsyms
;
11636 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
11639 fini_reloc_cookie (struct elf_reloc_cookie
*cookie
, bfd
*abfd
)
11641 Elf_Internal_Shdr
*symtab_hdr
;
11643 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11644 if (cookie
->locsyms
!= NULL
11645 && symtab_hdr
->contents
!= (unsigned char *) cookie
->locsyms
)
11646 free (cookie
->locsyms
);
11649 /* Initialize the relocation information in COOKIE for input section SEC
11650 of input bfd ABFD. */
11653 init_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11654 struct bfd_link_info
*info
, bfd
*abfd
,
11657 const struct elf_backend_data
*bed
;
11659 if (sec
->reloc_count
== 0)
11661 cookie
->rels
= NULL
;
11662 cookie
->relend
= NULL
;
11666 bed
= get_elf_backend_data (abfd
);
11668 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
11669 info
->keep_memory
);
11670 if (cookie
->rels
== NULL
)
11672 cookie
->rel
= cookie
->rels
;
11673 cookie
->relend
= (cookie
->rels
11674 + sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
);
11676 cookie
->rel
= cookie
->rels
;
11680 /* Free the memory allocated by init_reloc_cookie_rels,
11684 fini_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11687 if (cookie
->rels
&& elf_section_data (sec
)->relocs
!= cookie
->rels
)
11688 free (cookie
->rels
);
11691 /* Initialize the whole of COOKIE for input section SEC. */
11694 init_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11695 struct bfd_link_info
*info
,
11698 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
11700 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
11705 fini_reloc_cookie (cookie
, sec
->owner
);
11710 /* Free the memory allocated by init_reloc_cookie_for_section,
11714 fini_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11717 fini_reloc_cookie_rels (cookie
, sec
);
11718 fini_reloc_cookie (cookie
, sec
->owner
);
11721 /* Garbage collect unused sections. */
11723 /* Default gc_mark_hook. */
11726 _bfd_elf_gc_mark_hook (asection
*sec
,
11727 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11728 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
11729 struct elf_link_hash_entry
*h
,
11730 Elf_Internal_Sym
*sym
)
11732 const char *sec_name
;
11736 switch (h
->root
.type
)
11738 case bfd_link_hash_defined
:
11739 case bfd_link_hash_defweak
:
11740 return h
->root
.u
.def
.section
;
11742 case bfd_link_hash_common
:
11743 return h
->root
.u
.c
.p
->section
;
11745 case bfd_link_hash_undefined
:
11746 case bfd_link_hash_undefweak
:
11747 /* To work around a glibc bug, keep all XXX input sections
11748 when there is an as yet undefined reference to __start_XXX
11749 or __stop_XXX symbols. The linker will later define such
11750 symbols for orphan input sections that have a name
11751 representable as a C identifier. */
11752 if (strncmp (h
->root
.root
.string
, "__start_", 8) == 0)
11753 sec_name
= h
->root
.root
.string
+ 8;
11754 else if (strncmp (h
->root
.root
.string
, "__stop_", 7) == 0)
11755 sec_name
= h
->root
.root
.string
+ 7;
11759 if (sec_name
&& *sec_name
!= '\0')
11763 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
11765 sec
= bfd_get_section_by_name (i
, sec_name
);
11767 sec
->flags
|= SEC_KEEP
;
11777 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
11782 /* COOKIE->rel describes a relocation against section SEC, which is
11783 a section we've decided to keep. Return the section that contains
11784 the relocation symbol, or NULL if no section contains it. */
11787 _bfd_elf_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
11788 elf_gc_mark_hook_fn gc_mark_hook
,
11789 struct elf_reloc_cookie
*cookie
)
11791 unsigned long r_symndx
;
11792 struct elf_link_hash_entry
*h
;
11794 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
11795 if (r_symndx
== STN_UNDEF
)
11798 if (r_symndx
>= cookie
->locsymcount
11799 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
11801 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
11802 while (h
->root
.type
== bfd_link_hash_indirect
11803 || h
->root
.type
== bfd_link_hash_warning
)
11804 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11806 /* If this symbol is weak and there is a non-weak definition, we
11807 keep the non-weak definition because many backends put
11808 dynamic reloc info on the non-weak definition for code
11809 handling copy relocs. */
11810 if (h
->u
.weakdef
!= NULL
)
11811 h
->u
.weakdef
->mark
= 1;
11812 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
11815 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
11816 &cookie
->locsyms
[r_symndx
]);
11819 /* COOKIE->rel describes a relocation against section SEC, which is
11820 a section we've decided to keep. Mark the section that contains
11821 the relocation symbol. */
11824 _bfd_elf_gc_mark_reloc (struct bfd_link_info
*info
,
11826 elf_gc_mark_hook_fn gc_mark_hook
,
11827 struct elf_reloc_cookie
*cookie
)
11831 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
11832 if (rsec
&& !rsec
->gc_mark
)
11834 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
11835 || (rsec
->owner
->flags
& DYNAMIC
) != 0)
11837 else if (!_bfd_elf_gc_mark (info
, rsec
, gc_mark_hook
))
11843 /* The mark phase of garbage collection. For a given section, mark
11844 it and any sections in this section's group, and all the sections
11845 which define symbols to which it refers. */
11848 _bfd_elf_gc_mark (struct bfd_link_info
*info
,
11850 elf_gc_mark_hook_fn gc_mark_hook
)
11853 asection
*group_sec
, *eh_frame
;
11857 /* Mark all the sections in the group. */
11858 group_sec
= elf_section_data (sec
)->next_in_group
;
11859 if (group_sec
&& !group_sec
->gc_mark
)
11860 if (!_bfd_elf_gc_mark (info
, group_sec
, gc_mark_hook
))
11863 /* Look through the section relocs. */
11865 eh_frame
= elf_eh_frame_section (sec
->owner
);
11866 if ((sec
->flags
& SEC_RELOC
) != 0
11867 && sec
->reloc_count
> 0
11868 && sec
!= eh_frame
)
11870 struct elf_reloc_cookie cookie
;
11872 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
11876 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
11877 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
11882 fini_reloc_cookie_for_section (&cookie
, sec
);
11886 if (ret
&& eh_frame
&& elf_fde_list (sec
))
11888 struct elf_reloc_cookie cookie
;
11890 if (!init_reloc_cookie_for_section (&cookie
, info
, eh_frame
))
11894 if (!_bfd_elf_gc_mark_fdes (info
, sec
, eh_frame
,
11895 gc_mark_hook
, &cookie
))
11897 fini_reloc_cookie_for_section (&cookie
, eh_frame
);
11904 /* Keep debug and special sections. */
11907 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
11908 elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
11912 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
11915 bfd_boolean some_kept
;
11917 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
11920 /* Ensure all linker created sections are kept, and see whether
11921 any other section is already marked. */
11923 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
11925 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
11927 else if (isec
->gc_mark
)
11931 /* If no section in this file will be kept, then we can
11932 toss out debug sections. */
11936 /* Keep debug and special sections like .comment when they are
11937 not part of a group, or when we have single-member groups. */
11938 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
11939 if ((elf_next_in_group (isec
) == NULL
11940 || elf_next_in_group (isec
) == isec
)
11941 && ((isec
->flags
& SEC_DEBUGGING
) != 0
11942 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0))
11948 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
11950 struct elf_gc_sweep_symbol_info
11952 struct bfd_link_info
*info
;
11953 void (*hide_symbol
) (struct bfd_link_info
*, struct elf_link_hash_entry
*,
11958 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *data
)
11961 && (((h
->root
.type
== bfd_link_hash_defined
11962 || h
->root
.type
== bfd_link_hash_defweak
)
11963 && !(h
->def_regular
11964 && h
->root
.u
.def
.section
->gc_mark
))
11965 || h
->root
.type
== bfd_link_hash_undefined
11966 || h
->root
.type
== bfd_link_hash_undefweak
))
11968 struct elf_gc_sweep_symbol_info
*inf
;
11970 inf
= (struct elf_gc_sweep_symbol_info
*) data
;
11971 (*inf
->hide_symbol
) (inf
->info
, h
, TRUE
);
11972 h
->def_regular
= 0;
11973 h
->ref_regular
= 0;
11974 h
->ref_regular_nonweak
= 0;
11980 /* The sweep phase of garbage collection. Remove all garbage sections. */
11982 typedef bfd_boolean (*gc_sweep_hook_fn
)
11983 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
11986 elf_gc_sweep (bfd
*abfd
, struct bfd_link_info
*info
)
11989 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11990 gc_sweep_hook_fn gc_sweep_hook
= bed
->gc_sweep_hook
;
11991 unsigned long section_sym_count
;
11992 struct elf_gc_sweep_symbol_info sweep_info
;
11994 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
11998 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
12001 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
12003 /* When any section in a section group is kept, we keep all
12004 sections in the section group. If the first member of
12005 the section group is excluded, we will also exclude the
12007 if (o
->flags
& SEC_GROUP
)
12009 asection
*first
= elf_next_in_group (o
);
12010 o
->gc_mark
= first
->gc_mark
;
12016 /* Skip sweeping sections already excluded. */
12017 if (o
->flags
& SEC_EXCLUDE
)
12020 /* Since this is early in the link process, it is simple
12021 to remove a section from the output. */
12022 o
->flags
|= SEC_EXCLUDE
;
12024 if (info
->print_gc_sections
&& o
->size
!= 0)
12025 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub
, o
->name
);
12027 /* But we also have to update some of the relocation
12028 info we collected before. */
12030 && (o
->flags
& SEC_RELOC
) != 0
12031 && o
->reloc_count
> 0
12032 && !bfd_is_abs_section (o
->output_section
))
12034 Elf_Internal_Rela
*internal_relocs
;
12038 = _bfd_elf_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
12039 info
->keep_memory
);
12040 if (internal_relocs
== NULL
)
12043 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
12045 if (elf_section_data (o
)->relocs
!= internal_relocs
)
12046 free (internal_relocs
);
12054 /* Remove the symbols that were in the swept sections from the dynamic
12055 symbol table. GCFIXME: Anyone know how to get them out of the
12056 static symbol table as well? */
12057 sweep_info
.info
= info
;
12058 sweep_info
.hide_symbol
= bed
->elf_backend_hide_symbol
;
12059 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
,
12062 _bfd_elf_link_renumber_dynsyms (abfd
, info
, §ion_sym_count
);
12066 /* Propagate collected vtable information. This is called through
12067 elf_link_hash_traverse. */
12070 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
12072 /* Those that are not vtables. */
12073 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
12076 /* Those vtables that do not have parents, we cannot merge. */
12077 if (h
->vtable
->parent
== (struct elf_link_hash_entry
*) -1)
12080 /* If we've already been done, exit. */
12081 if (h
->vtable
->used
&& h
->vtable
->used
[-1])
12084 /* Make sure the parent's table is up to date. */
12085 elf_gc_propagate_vtable_entries_used (h
->vtable
->parent
, okp
);
12087 if (h
->vtable
->used
== NULL
)
12089 /* None of this table's entries were referenced. Re-use the
12091 h
->vtable
->used
= h
->vtable
->parent
->vtable
->used
;
12092 h
->vtable
->size
= h
->vtable
->parent
->vtable
->size
;
12097 bfd_boolean
*cu
, *pu
;
12099 /* Or the parent's entries into ours. */
12100 cu
= h
->vtable
->used
;
12102 pu
= h
->vtable
->parent
->vtable
->used
;
12105 const struct elf_backend_data
*bed
;
12106 unsigned int log_file_align
;
12108 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
12109 log_file_align
= bed
->s
->log_file_align
;
12110 n
= h
->vtable
->parent
->vtable
->size
>> log_file_align
;
12125 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
, void *okp
)
12128 bfd_vma hstart
, hend
;
12129 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
12130 const struct elf_backend_data
*bed
;
12131 unsigned int log_file_align
;
12133 /* Take care of both those symbols that do not describe vtables as
12134 well as those that are not loaded. */
12135 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
12138 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
12139 || h
->root
.type
== bfd_link_hash_defweak
);
12141 sec
= h
->root
.u
.def
.section
;
12142 hstart
= h
->root
.u
.def
.value
;
12143 hend
= hstart
+ h
->size
;
12145 relstart
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, TRUE
);
12147 return *(bfd_boolean
*) okp
= FALSE
;
12148 bed
= get_elf_backend_data (sec
->owner
);
12149 log_file_align
= bed
->s
->log_file_align
;
12151 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
12153 for (rel
= relstart
; rel
< relend
; ++rel
)
12154 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
12156 /* If the entry is in use, do nothing. */
12157 if (h
->vtable
->used
12158 && (rel
->r_offset
- hstart
) < h
->vtable
->size
)
12160 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
12161 if (h
->vtable
->used
[entry
])
12164 /* Otherwise, kill it. */
12165 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
12171 /* Mark sections containing dynamically referenced symbols. When
12172 building shared libraries, we must assume that any visible symbol is
12176 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry
*h
, void *inf
)
12178 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
12180 if ((h
->root
.type
== bfd_link_hash_defined
12181 || h
->root
.type
== bfd_link_hash_defweak
)
12183 || ((!info
->executable
|| info
->export_dynamic
)
12185 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
12186 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
12187 && (strchr (h
->root
.root
.string
, ELF_VER_CHR
) != NULL
12188 || !bfd_hide_sym_by_version (info
->version_info
,
12189 h
->root
.root
.string
)))))
12190 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
12195 /* Keep all sections containing symbols undefined on the command-line,
12196 and the section containing the entry symbol. */
12199 _bfd_elf_gc_keep (struct bfd_link_info
*info
)
12201 struct bfd_sym_chain
*sym
;
12203 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
12205 struct elf_link_hash_entry
*h
;
12207 h
= elf_link_hash_lookup (elf_hash_table (info
), sym
->name
,
12208 FALSE
, FALSE
, FALSE
);
12211 && (h
->root
.type
== bfd_link_hash_defined
12212 || h
->root
.type
== bfd_link_hash_defweak
)
12213 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
12214 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
12218 /* Do mark and sweep of unused sections. */
12221 bfd_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
12223 bfd_boolean ok
= TRUE
;
12225 elf_gc_mark_hook_fn gc_mark_hook
;
12226 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12228 if (!bed
->can_gc_sections
12229 || !is_elf_hash_table (info
->hash
))
12231 (*_bfd_error_handler
)(_("Warning: gc-sections option ignored"));
12235 bed
->gc_keep (info
);
12237 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
12238 at the .eh_frame section if we can mark the FDEs individually. */
12239 _bfd_elf_begin_eh_frame_parsing (info
);
12240 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
12243 struct elf_reloc_cookie cookie
;
12245 sec
= bfd_get_section_by_name (sub
, ".eh_frame");
12246 while (sec
&& init_reloc_cookie_for_section (&cookie
, info
, sec
))
12248 _bfd_elf_parse_eh_frame (sub
, info
, sec
, &cookie
);
12249 if (elf_section_data (sec
)->sec_info
12250 && (sec
->flags
& SEC_LINKER_CREATED
) == 0)
12251 elf_eh_frame_section (sub
) = sec
;
12252 fini_reloc_cookie_for_section (&cookie
, sec
);
12253 sec
= bfd_get_next_section_by_name (sec
);
12256 _bfd_elf_end_eh_frame_parsing (info
);
12258 /* Apply transitive closure to the vtable entry usage info. */
12259 elf_link_hash_traverse (elf_hash_table (info
),
12260 elf_gc_propagate_vtable_entries_used
,
12265 /* Kill the vtable relocations that were not used. */
12266 elf_link_hash_traverse (elf_hash_table (info
),
12267 elf_gc_smash_unused_vtentry_relocs
,
12272 /* Mark dynamically referenced symbols. */
12273 if (elf_hash_table (info
)->dynamic_sections_created
)
12274 elf_link_hash_traverse (elf_hash_table (info
),
12275 bed
->gc_mark_dynamic_ref
,
12278 /* Grovel through relocs to find out who stays ... */
12279 gc_mark_hook
= bed
->gc_mark_hook
;
12280 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
12284 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
12287 /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12288 Also treat note sections as a root, if the section is not part
12290 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
12292 && (o
->flags
& SEC_EXCLUDE
) == 0
12293 && ((o
->flags
& SEC_KEEP
) != 0
12294 || (elf_section_data (o
)->this_hdr
.sh_type
== SHT_NOTE
12295 && elf_next_in_group (o
) == NULL
)))
12297 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
12302 /* Allow the backend to mark additional target specific sections. */
12303 bed
->gc_mark_extra_sections (info
, gc_mark_hook
);
12305 /* ... and mark SEC_EXCLUDE for those that go. */
12306 return elf_gc_sweep (abfd
, info
);
12309 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
12312 bfd_elf_gc_record_vtinherit (bfd
*abfd
,
12314 struct elf_link_hash_entry
*h
,
12317 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
12318 struct elf_link_hash_entry
**search
, *child
;
12319 bfd_size_type extsymcount
;
12320 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12322 /* The sh_info field of the symtab header tells us where the
12323 external symbols start. We don't care about the local symbols at
12325 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/ bed
->s
->sizeof_sym
;
12326 if (!elf_bad_symtab (abfd
))
12327 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
12329 sym_hashes
= elf_sym_hashes (abfd
);
12330 sym_hashes_end
= sym_hashes
+ extsymcount
;
12332 /* Hunt down the child symbol, which is in this section at the same
12333 offset as the relocation. */
12334 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
12336 if ((child
= *search
) != NULL
12337 && (child
->root
.type
== bfd_link_hash_defined
12338 || child
->root
.type
== bfd_link_hash_defweak
)
12339 && child
->root
.u
.def
.section
== sec
12340 && child
->root
.u
.def
.value
== offset
)
12344 (*_bfd_error_handler
) ("%B: %A+%lu: No symbol found for INHERIT",
12345 abfd
, sec
, (unsigned long) offset
);
12346 bfd_set_error (bfd_error_invalid_operation
);
12350 if (!child
->vtable
)
12352 child
->vtable
= (struct elf_link_virtual_table_entry
*)
12353 bfd_zalloc (abfd
, sizeof (*child
->vtable
));
12354 if (!child
->vtable
)
12359 /* This *should* only be the absolute section. It could potentially
12360 be that someone has defined a non-global vtable though, which
12361 would be bad. It isn't worth paging in the local symbols to be
12362 sure though; that case should simply be handled by the assembler. */
12364 child
->vtable
->parent
= (struct elf_link_hash_entry
*) -1;
12367 child
->vtable
->parent
= h
;
12372 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
12375 bfd_elf_gc_record_vtentry (bfd
*abfd ATTRIBUTE_UNUSED
,
12376 asection
*sec ATTRIBUTE_UNUSED
,
12377 struct elf_link_hash_entry
*h
,
12380 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12381 unsigned int log_file_align
= bed
->s
->log_file_align
;
12385 h
->vtable
= (struct elf_link_virtual_table_entry
*)
12386 bfd_zalloc (abfd
, sizeof (*h
->vtable
));
12391 if (addend
>= h
->vtable
->size
)
12393 size_t size
, bytes
, file_align
;
12394 bfd_boolean
*ptr
= h
->vtable
->used
;
12396 /* While the symbol is undefined, we have to be prepared to handle
12398 file_align
= 1 << log_file_align
;
12399 if (h
->root
.type
== bfd_link_hash_undefined
)
12400 size
= addend
+ file_align
;
12404 if (addend
>= size
)
12406 /* Oops! We've got a reference past the defined end of
12407 the table. This is probably a bug -- shall we warn? */
12408 size
= addend
+ file_align
;
12411 size
= (size
+ file_align
- 1) & -file_align
;
12413 /* Allocate one extra entry for use as a "done" flag for the
12414 consolidation pass. */
12415 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bfd_boolean
);
12419 ptr
= (bfd_boolean
*) bfd_realloc (ptr
- 1, bytes
);
12425 oldbytes
= (((h
->vtable
->size
>> log_file_align
) + 1)
12426 * sizeof (bfd_boolean
));
12427 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
12431 ptr
= (bfd_boolean
*) bfd_zmalloc (bytes
);
12436 /* And arrange for that done flag to be at index -1. */
12437 h
->vtable
->used
= ptr
+ 1;
12438 h
->vtable
->size
= size
;
12441 h
->vtable
->used
[addend
>> log_file_align
] = TRUE
;
12446 /* Map an ELF section header flag to its corresponding string. */
12450 flagword flag_value
;
12451 } elf_flags_to_name_table
;
12453 static elf_flags_to_name_table elf_flags_to_names
[] =
12455 { "SHF_WRITE", SHF_WRITE
},
12456 { "SHF_ALLOC", SHF_ALLOC
},
12457 { "SHF_EXECINSTR", SHF_EXECINSTR
},
12458 { "SHF_MERGE", SHF_MERGE
},
12459 { "SHF_STRINGS", SHF_STRINGS
},
12460 { "SHF_INFO_LINK", SHF_INFO_LINK
},
12461 { "SHF_LINK_ORDER", SHF_LINK_ORDER
},
12462 { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING
},
12463 { "SHF_GROUP", SHF_GROUP
},
12464 { "SHF_TLS", SHF_TLS
},
12465 { "SHF_MASKOS", SHF_MASKOS
},
12466 { "SHF_EXCLUDE", SHF_EXCLUDE
},
12469 /* Returns TRUE if the section is to be included, otherwise FALSE. */
12471 bfd_elf_lookup_section_flags (struct bfd_link_info
*info
,
12472 struct flag_info
*flaginfo
,
12475 const bfd_vma sh_flags
= elf_section_flags (section
);
12477 if (!flaginfo
->flags_initialized
)
12479 bfd
*obfd
= info
->output_bfd
;
12480 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
12481 struct flag_info_list
*tf
= flaginfo
->flag_list
;
12483 int without_hex
= 0;
12485 for (tf
= flaginfo
->flag_list
; tf
!= NULL
; tf
= tf
->next
)
12488 flagword (*lookup
) (char *);
12490 lookup
= bed
->elf_backend_lookup_section_flags_hook
;
12491 if (lookup
!= NULL
)
12493 flagword hexval
= (*lookup
) ((char *) tf
->name
);
12497 if (tf
->with
== with_flags
)
12498 with_hex
|= hexval
;
12499 else if (tf
->with
== without_flags
)
12500 without_hex
|= hexval
;
12505 for (i
= 0; i
< ARRAY_SIZE (elf_flags_to_names
); ++i
)
12507 if (strcmp (tf
->name
, elf_flags_to_names
[i
].flag_name
) == 0)
12509 if (tf
->with
== with_flags
)
12510 with_hex
|= elf_flags_to_names
[i
].flag_value
;
12511 else if (tf
->with
== without_flags
)
12512 without_hex
|= elf_flags_to_names
[i
].flag_value
;
12519 info
->callbacks
->einfo
12520 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf
->name
);
12524 flaginfo
->flags_initialized
= TRUE
;
12525 flaginfo
->only_with_flags
|= with_hex
;
12526 flaginfo
->not_with_flags
|= without_hex
;
12529 if ((flaginfo
->only_with_flags
& sh_flags
) != flaginfo
->only_with_flags
)
12532 if ((flaginfo
->not_with_flags
& sh_flags
) != 0)
12538 struct alloc_got_off_arg
{
12540 struct bfd_link_info
*info
;
12543 /* We need a special top-level link routine to convert got reference counts
12544 to real got offsets. */
12547 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *arg
)
12549 struct alloc_got_off_arg
*gofarg
= (struct alloc_got_off_arg
*) arg
;
12550 bfd
*obfd
= gofarg
->info
->output_bfd
;
12551 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
12553 if (h
->got
.refcount
> 0)
12555 h
->got
.offset
= gofarg
->gotoff
;
12556 gofarg
->gotoff
+= bed
->got_elt_size (obfd
, gofarg
->info
, h
, NULL
, 0);
12559 h
->got
.offset
= (bfd_vma
) -1;
12564 /* And an accompanying bit to work out final got entry offsets once
12565 we're done. Should be called from final_link. */
12568 bfd_elf_gc_common_finalize_got_offsets (bfd
*abfd
,
12569 struct bfd_link_info
*info
)
12572 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12574 struct alloc_got_off_arg gofarg
;
12576 BFD_ASSERT (abfd
== info
->output_bfd
);
12578 if (! is_elf_hash_table (info
->hash
))
12581 /* The GOT offset is relative to the .got section, but the GOT header is
12582 put into the .got.plt section, if the backend uses it. */
12583 if (bed
->want_got_plt
)
12586 gotoff
= bed
->got_header_size
;
12588 /* Do the local .got entries first. */
12589 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
12591 bfd_signed_vma
*local_got
;
12592 bfd_size_type j
, locsymcount
;
12593 Elf_Internal_Shdr
*symtab_hdr
;
12595 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
12598 local_got
= elf_local_got_refcounts (i
);
12602 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
12603 if (elf_bad_symtab (i
))
12604 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
12606 locsymcount
= symtab_hdr
->sh_info
;
12608 for (j
= 0; j
< locsymcount
; ++j
)
12610 if (local_got
[j
] > 0)
12612 local_got
[j
] = gotoff
;
12613 gotoff
+= bed
->got_elt_size (abfd
, info
, NULL
, i
, j
);
12616 local_got
[j
] = (bfd_vma
) -1;
12620 /* Then the global .got entries. .plt refcounts are handled by
12621 adjust_dynamic_symbol */
12622 gofarg
.gotoff
= gotoff
;
12623 gofarg
.info
= info
;
12624 elf_link_hash_traverse (elf_hash_table (info
),
12625 elf_gc_allocate_got_offsets
,
12630 /* Many folk need no more in the way of final link than this, once
12631 got entry reference counting is enabled. */
12634 bfd_elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
12636 if (!bfd_elf_gc_common_finalize_got_offsets (abfd
, info
))
12639 /* Invoke the regular ELF backend linker to do all the work. */
12640 return bfd_elf_final_link (abfd
, info
);
12644 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
12646 struct elf_reloc_cookie
*rcookie
= (struct elf_reloc_cookie
*) cookie
;
12648 if (rcookie
->bad_symtab
)
12649 rcookie
->rel
= rcookie
->rels
;
12651 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
12653 unsigned long r_symndx
;
12655 if (! rcookie
->bad_symtab
)
12656 if (rcookie
->rel
->r_offset
> offset
)
12658 if (rcookie
->rel
->r_offset
!= offset
)
12661 r_symndx
= rcookie
->rel
->r_info
>> rcookie
->r_sym_shift
;
12662 if (r_symndx
== STN_UNDEF
)
12665 if (r_symndx
>= rcookie
->locsymcount
12666 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
12668 struct elf_link_hash_entry
*h
;
12670 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
12672 while (h
->root
.type
== bfd_link_hash_indirect
12673 || h
->root
.type
== bfd_link_hash_warning
)
12674 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
12676 if ((h
->root
.type
== bfd_link_hash_defined
12677 || h
->root
.type
== bfd_link_hash_defweak
)
12678 && discarded_section (h
->root
.u
.def
.section
))
12685 /* It's not a relocation against a global symbol,
12686 but it could be a relocation against a local
12687 symbol for a discarded section. */
12689 Elf_Internal_Sym
*isym
;
12691 /* Need to: get the symbol; get the section. */
12692 isym
= &rcookie
->locsyms
[r_symndx
];
12693 isec
= bfd_section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
12694 if (isec
!= NULL
&& discarded_section (isec
))
12702 /* Discard unneeded references to discarded sections.
12703 Returns TRUE if any section's size was changed. */
12704 /* This function assumes that the relocations are in sorted order,
12705 which is true for all known assemblers. */
12708 bfd_elf_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
12710 struct elf_reloc_cookie cookie
;
12711 asection
*stab
, *eh
;
12712 const struct elf_backend_data
*bed
;
12714 bfd_boolean ret
= FALSE
;
12716 if (info
->traditional_format
12717 || !is_elf_hash_table (info
->hash
))
12720 _bfd_elf_begin_eh_frame_parsing (info
);
12721 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
12723 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
12726 bed
= get_elf_backend_data (abfd
);
12729 if (!info
->relocatable
)
12731 eh
= bfd_get_section_by_name (abfd
, ".eh_frame");
12734 || bfd_is_abs_section (eh
->output_section
)))
12735 eh
= bfd_get_next_section_by_name (eh
);
12738 stab
= bfd_get_section_by_name (abfd
, ".stab");
12740 && (stab
->size
== 0
12741 || bfd_is_abs_section (stab
->output_section
)
12742 || stab
->sec_info_type
!= SEC_INFO_TYPE_STABS
))
12747 && bed
->elf_backend_discard_info
== NULL
)
12750 if (!init_reloc_cookie (&cookie
, info
, abfd
))
12754 && stab
->reloc_count
> 0
12755 && init_reloc_cookie_rels (&cookie
, info
, abfd
, stab
))
12757 if (_bfd_discard_section_stabs (abfd
, stab
,
12758 elf_section_data (stab
)->sec_info
,
12759 bfd_elf_reloc_symbol_deleted_p
,
12762 fini_reloc_cookie_rels (&cookie
, stab
);
12766 && init_reloc_cookie_rels (&cookie
, info
, abfd
, eh
))
12768 _bfd_elf_parse_eh_frame (abfd
, info
, eh
, &cookie
);
12769 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, eh
,
12770 bfd_elf_reloc_symbol_deleted_p
,
12773 fini_reloc_cookie_rels (&cookie
, eh
);
12774 eh
= bfd_get_next_section_by_name (eh
);
12777 if (bed
->elf_backend_discard_info
!= NULL
12778 && (*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
12781 fini_reloc_cookie (&cookie
, abfd
);
12783 _bfd_elf_end_eh_frame_parsing (info
);
12785 if (info
->eh_frame_hdr
12786 && !info
->relocatable
12787 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
12794 _bfd_elf_section_already_linked (bfd
*abfd
,
12796 struct bfd_link_info
*info
)
12799 const char *name
, *key
;
12800 struct bfd_section_already_linked
*l
;
12801 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
12803 if (sec
->output_section
== bfd_abs_section_ptr
)
12806 flags
= sec
->flags
;
12808 /* Return if it isn't a linkonce section. A comdat group section
12809 also has SEC_LINK_ONCE set. */
12810 if ((flags
& SEC_LINK_ONCE
) == 0)
12813 /* Don't put group member sections on our list of already linked
12814 sections. They are handled as a group via their group section. */
12815 if (elf_sec_group (sec
) != NULL
)
12818 /* For a SHT_GROUP section, use the group signature as the key. */
12820 if ((flags
& SEC_GROUP
) != 0
12821 && elf_next_in_group (sec
) != NULL
12822 && elf_group_name (elf_next_in_group (sec
)) != NULL
)
12823 key
= elf_group_name (elf_next_in_group (sec
));
12826 /* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */
12827 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
12828 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
12831 /* Must be a user linkonce section that doesn't follow gcc's
12832 naming convention. In this case we won't be matching
12833 single member groups. */
12837 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
12839 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12841 /* We may have 2 different types of sections on the list: group
12842 sections with a signature of <key> (<key> is some string),
12843 and linkonce sections named .gnu.linkonce.<type>.<key>.
12844 Match like sections. LTO plugin sections are an exception.
12845 They are always named .gnu.linkonce.t.<key> and match either
12846 type of section. */
12847 if (((flags
& SEC_GROUP
) == (l
->sec
->flags
& SEC_GROUP
)
12848 && ((flags
& SEC_GROUP
) != 0
12849 || strcmp (name
, l
->sec
->name
) == 0))
12850 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
12852 /* The section has already been linked. See if we should
12853 issue a warning. */
12854 if (!_bfd_handle_already_linked (sec
, l
, info
))
12857 if (flags
& SEC_GROUP
)
12859 asection
*first
= elf_next_in_group (sec
);
12860 asection
*s
= first
;
12864 s
->output_section
= bfd_abs_section_ptr
;
12865 /* Record which group discards it. */
12866 s
->kept_section
= l
->sec
;
12867 s
= elf_next_in_group (s
);
12868 /* These lists are circular. */
12878 /* A single member comdat group section may be discarded by a
12879 linkonce section and vice versa. */
12880 if ((flags
& SEC_GROUP
) != 0)
12882 asection
*first
= elf_next_in_group (sec
);
12884 if (first
!= NULL
&& elf_next_in_group (first
) == first
)
12885 /* Check this single member group against linkonce sections. */
12886 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12887 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12888 && bfd_elf_match_symbols_in_sections (l
->sec
, first
, info
))
12890 first
->output_section
= bfd_abs_section_ptr
;
12891 first
->kept_section
= l
->sec
;
12892 sec
->output_section
= bfd_abs_section_ptr
;
12897 /* Check this linkonce section against single member groups. */
12898 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12899 if (l
->sec
->flags
& SEC_GROUP
)
12901 asection
*first
= elf_next_in_group (l
->sec
);
12904 && elf_next_in_group (first
) == first
12905 && bfd_elf_match_symbols_in_sections (first
, sec
, info
))
12907 sec
->output_section
= bfd_abs_section_ptr
;
12908 sec
->kept_section
= first
;
12913 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12914 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12915 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12916 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
12917 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
12918 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12919 `.gnu.linkonce.t.F' section from a different bfd not requiring any
12920 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
12921 The reverse order cannot happen as there is never a bfd with only the
12922 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
12923 matter as here were are looking only for cross-bfd sections. */
12925 if ((flags
& SEC_GROUP
) == 0 && CONST_STRNEQ (name
, ".gnu.linkonce.r."))
12926 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12927 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12928 && CONST_STRNEQ (l
->sec
->name
, ".gnu.linkonce.t."))
12930 if (abfd
!= l
->sec
->owner
)
12931 sec
->output_section
= bfd_abs_section_ptr
;
12935 /* This is the first section with this name. Record it. */
12936 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
12937 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
12938 return sec
->output_section
== bfd_abs_section_ptr
;
12942 _bfd_elf_common_definition (Elf_Internal_Sym
*sym
)
12944 return sym
->st_shndx
== SHN_COMMON
;
12948 _bfd_elf_common_section_index (asection
*sec ATTRIBUTE_UNUSED
)
12954 _bfd_elf_common_section (asection
*sec ATTRIBUTE_UNUSED
)
12956 return bfd_com_section_ptr
;
12960 _bfd_elf_default_got_elt_size (bfd
*abfd
,
12961 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12962 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
12963 bfd
*ibfd ATTRIBUTE_UNUSED
,
12964 unsigned long symndx ATTRIBUTE_UNUSED
)
12966 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12967 return bed
->s
->arch_size
/ 8;
12970 /* Routines to support the creation of dynamic relocs. */
12972 /* Returns the name of the dynamic reloc section associated with SEC. */
12974 static const char *
12975 get_dynamic_reloc_section_name (bfd
* abfd
,
12977 bfd_boolean is_rela
)
12980 const char *old_name
= bfd_get_section_name (NULL
, sec
);
12981 const char *prefix
= is_rela
? ".rela" : ".rel";
12983 if (old_name
== NULL
)
12986 name
= bfd_alloc (abfd
, strlen (prefix
) + strlen (old_name
) + 1);
12987 sprintf (name
, "%s%s", prefix
, old_name
);
12992 /* Returns the dynamic reloc section associated with SEC.
12993 If necessary compute the name of the dynamic reloc section based
12994 on SEC's name (looked up in ABFD's string table) and the setting
12998 _bfd_elf_get_dynamic_reloc_section (bfd
* abfd
,
13000 bfd_boolean is_rela
)
13002 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
13004 if (reloc_sec
== NULL
)
13006 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
13010 reloc_sec
= bfd_get_linker_section (abfd
, name
);
13012 if (reloc_sec
!= NULL
)
13013 elf_section_data (sec
)->sreloc
= reloc_sec
;
13020 /* Returns the dynamic reloc section associated with SEC. If the
13021 section does not exist it is created and attached to the DYNOBJ
13022 bfd and stored in the SRELOC field of SEC's elf_section_data
13025 ALIGNMENT is the alignment for the newly created section and
13026 IS_RELA defines whether the name should be .rela.<SEC's name>
13027 or .rel.<SEC's name>. The section name is looked up in the
13028 string table associated with ABFD. */
13031 _bfd_elf_make_dynamic_reloc_section (asection
* sec
,
13033 unsigned int alignment
,
13035 bfd_boolean is_rela
)
13037 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
13039 if (reloc_sec
== NULL
)
13041 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
13046 reloc_sec
= bfd_get_linker_section (dynobj
, name
);
13048 if (reloc_sec
== NULL
)
13050 flagword flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
13051 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
13052 if ((sec
->flags
& SEC_ALLOC
) != 0)
13053 flags
|= SEC_ALLOC
| SEC_LOAD
;
13055 reloc_sec
= bfd_make_section_anyway_with_flags (dynobj
, name
, flags
);
13056 if (reloc_sec
!= NULL
)
13058 if (! bfd_set_section_alignment (dynobj
, reloc_sec
, alignment
))
13063 elf_section_data (sec
)->sreloc
= reloc_sec
;
13069 /* Copy the ELF symbol type associated with a linker hash entry. */
13071 _bfd_elf_copy_link_hash_symbol_type (bfd
*abfd ATTRIBUTE_UNUSED
,
13072 struct bfd_link_hash_entry
* hdest
,
13073 struct bfd_link_hash_entry
* hsrc
)
13075 struct elf_link_hash_entry
*ehdest
= (struct elf_link_hash_entry
*)hdest
;
13076 struct elf_link_hash_entry
*ehsrc
= (struct elf_link_hash_entry
*)hsrc
;
13078 ehdest
->type
= ehsrc
->type
;
13079 ehdest
->target_internal
= ehsrc
->target_internal
;
13082 /* Append a RELA relocation REL to section S in BFD. */
13085 elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
13087 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13088 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
13089 BFD_ASSERT (loc
+ bed
->s
->sizeof_rela
<= s
->contents
+ s
->size
);
13090 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
13093 /* Append a REL relocation REL to section S in BFD. */
13096 elf_append_rel (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
13098 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13099 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rel
);
13100 BFD_ASSERT (loc
+ bed
->s
->sizeof_rel
<= s
->contents
+ s
->size
);
13101 bed
->s
->swap_reloc_out (abfd
, rel
, loc
);