1 /* ELF linking support for BFD.
2 Copyright 1995-2013 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
27 #include "safe-ctype.h"
28 #include "libiberty.h"
31 /* This struct is used to pass information to routines called via
32 elf_link_hash_traverse which must return failure. */
34 struct elf_info_failed
36 struct bfd_link_info
*info
;
40 /* This structure is used to pass information to
41 _bfd_elf_link_find_version_dependencies. */
43 struct elf_find_verdep_info
45 /* General link information. */
46 struct bfd_link_info
*info
;
47 /* The number of dependencies. */
49 /* Whether we had a failure. */
53 static bfd_boolean _bfd_elf_fix_symbol_flags
54 (struct elf_link_hash_entry
*, struct elf_info_failed
*);
56 /* Define a symbol in a dynamic linkage section. */
58 struct elf_link_hash_entry
*
59 _bfd_elf_define_linkage_sym (bfd
*abfd
,
60 struct bfd_link_info
*info
,
64 struct elf_link_hash_entry
*h
;
65 struct bfd_link_hash_entry
*bh
;
66 const struct elf_backend_data
*bed
;
68 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
71 /* Zap symbol defined in an as-needed lib that wasn't linked.
72 This is a symptom of a larger problem: Absolute symbols
73 defined in shared libraries can't be overridden, because we
74 lose the link to the bfd which is via the symbol section. */
75 h
->root
.type
= bfd_link_hash_new
;
79 if (!_bfd_generic_link_add_one_symbol (info
, abfd
, name
, BSF_GLOBAL
,
81 get_elf_backend_data (abfd
)->collect
,
84 h
= (struct elf_link_hash_entry
*) bh
;
88 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
89 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
91 bed
= get_elf_backend_data (abfd
);
92 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
97 _bfd_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
101 struct elf_link_hash_entry
*h
;
102 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
103 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
105 /* This function may be called more than once. */
106 s
= bfd_get_linker_section (abfd
, ".got");
110 flags
= bed
->dynamic_sec_flags
;
112 s
= bfd_make_section_anyway_with_flags (abfd
,
113 (bed
->rela_plts_and_copies_p
114 ? ".rela.got" : ".rel.got"),
115 (bed
->dynamic_sec_flags
118 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
122 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
124 || !bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
128 if (bed
->want_got_plt
)
130 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
132 || !bfd_set_section_alignment (abfd
, s
,
133 bed
->s
->log_file_align
))
138 /* The first bit of the global offset table is the header. */
139 s
->size
+= bed
->got_header_size
;
141 if (bed
->want_got_sym
)
143 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
144 (or .got.plt) section. We don't do this in the linker script
145 because we don't want to define the symbol if we are not creating
146 a global offset table. */
147 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
148 "_GLOBAL_OFFSET_TABLE_");
149 elf_hash_table (info
)->hgot
= h
;
157 /* Create a strtab to hold the dynamic symbol names. */
159 _bfd_elf_link_create_dynstrtab (bfd
*abfd
, struct bfd_link_info
*info
)
161 struct elf_link_hash_table
*hash_table
;
163 hash_table
= elf_hash_table (info
);
164 if (hash_table
->dynobj
== NULL
)
165 hash_table
->dynobj
= abfd
;
167 if (hash_table
->dynstr
== NULL
)
169 hash_table
->dynstr
= _bfd_elf_strtab_init ();
170 if (hash_table
->dynstr
== NULL
)
176 /* Create some sections which will be filled in with dynamic linking
177 information. ABFD is an input file which requires dynamic sections
178 to be created. The dynamic sections take up virtual memory space
179 when the final executable is run, so we need to create them before
180 addresses are assigned to the output sections. We work out the
181 actual contents and size of these sections later. */
184 _bfd_elf_link_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
188 const struct elf_backend_data
*bed
;
189 struct elf_link_hash_entry
*h
;
191 if (! is_elf_hash_table (info
->hash
))
194 if (elf_hash_table (info
)->dynamic_sections_created
)
197 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
200 abfd
= elf_hash_table (info
)->dynobj
;
201 bed
= get_elf_backend_data (abfd
);
203 flags
= bed
->dynamic_sec_flags
;
205 /* A dynamically linked executable has a .interp section, but a
206 shared library does not. */
207 if (info
->executable
)
209 s
= bfd_make_section_anyway_with_flags (abfd
, ".interp",
210 flags
| SEC_READONLY
);
215 /* Create sections to hold version informations. These are removed
216 if they are not needed. */
217 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_d",
218 flags
| SEC_READONLY
);
220 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
223 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version",
224 flags
| SEC_READONLY
);
226 || ! bfd_set_section_alignment (abfd
, s
, 1))
229 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.version_r",
230 flags
| SEC_READONLY
);
232 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
235 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynsym",
236 flags
| SEC_READONLY
);
238 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
241 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynstr",
242 flags
| SEC_READONLY
);
246 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic", flags
);
248 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
251 /* The special symbol _DYNAMIC is always set to the start of the
252 .dynamic section. We could set _DYNAMIC in a linker script, but we
253 only want to define it if we are, in fact, creating a .dynamic
254 section. We don't want to define it if there is no .dynamic
255 section, since on some ELF platforms the start up code examines it
256 to decide how to initialize the process. */
257 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_DYNAMIC");
258 elf_hash_table (info
)->hdynamic
= h
;
264 s
= bfd_make_section_anyway_with_flags (abfd
, ".hash",
265 flags
| SEC_READONLY
);
267 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
269 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
272 if (info
->emit_gnu_hash
)
274 s
= bfd_make_section_anyway_with_flags (abfd
, ".gnu.hash",
275 flags
| SEC_READONLY
);
277 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
279 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
280 4 32-bit words followed by variable count of 64-bit words, then
281 variable count of 32-bit words. */
282 if (bed
->s
->arch_size
== 64)
283 elf_section_data (s
)->this_hdr
.sh_entsize
= 0;
285 elf_section_data (s
)->this_hdr
.sh_entsize
= 4;
288 /* Let the backend create the rest of the sections. This lets the
289 backend set the right flags. The backend will normally create
290 the .got and .plt sections. */
291 if (bed
->elf_backend_create_dynamic_sections
== NULL
292 || ! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
295 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
300 /* Create dynamic sections when linking against a dynamic object. */
303 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
305 flagword flags
, pltflags
;
306 struct elf_link_hash_entry
*h
;
308 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
309 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
311 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
312 .rel[a].bss sections. */
313 flags
= bed
->dynamic_sec_flags
;
316 if (bed
->plt_not_loaded
)
317 /* We do not clear SEC_ALLOC here because we still want the OS to
318 allocate space for the section; it's just that there's nothing
319 to read in from the object file. */
320 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
322 pltflags
|= SEC_ALLOC
| SEC_CODE
| SEC_LOAD
;
323 if (bed
->plt_readonly
)
324 pltflags
|= SEC_READONLY
;
326 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
328 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
332 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
334 if (bed
->want_plt_sym
)
336 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
337 "_PROCEDURE_LINKAGE_TABLE_");
338 elf_hash_table (info
)->hplt
= h
;
343 s
= bfd_make_section_anyway_with_flags (abfd
,
344 (bed
->rela_plts_and_copies_p
345 ? ".rela.plt" : ".rel.plt"),
346 flags
| SEC_READONLY
);
348 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
352 if (! _bfd_elf_create_got_section (abfd
, info
))
355 if (bed
->want_dynbss
)
357 /* The .dynbss section is a place to put symbols which are defined
358 by dynamic objects, are referenced by regular objects, and are
359 not functions. We must allocate space for them in the process
360 image and use a R_*_COPY reloc to tell the dynamic linker to
361 initialize them at run time. The linker script puts the .dynbss
362 section into the .bss section of the final image. */
363 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
364 (SEC_ALLOC
| SEC_LINKER_CREATED
));
368 /* The .rel[a].bss section holds copy relocs. This section is not
369 normally needed. We need to create it here, though, so that the
370 linker will map it to an output section. We can't just create it
371 only if we need it, because we will not know whether we need it
372 until we have seen all the input files, and the first time the
373 main linker code calls BFD after examining all the input files
374 (size_dynamic_sections) the input sections have already been
375 mapped to the output sections. If the section turns out not to
376 be needed, we can discard it later. We will never need this
377 section when generating a shared object, since they do not use
381 s
= bfd_make_section_anyway_with_flags (abfd
,
382 (bed
->rela_plts_and_copies_p
383 ? ".rela.bss" : ".rel.bss"),
384 flags
| SEC_READONLY
);
386 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
394 /* Record a new dynamic symbol. We record the dynamic symbols as we
395 read the input files, since we need to have a list of all of them
396 before we can determine the final sizes of the output sections.
397 Note that we may actually call this function even though we are not
398 going to output any dynamic symbols; in some cases we know that a
399 symbol should be in the dynamic symbol table, but only if there is
403 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
404 struct elf_link_hash_entry
*h
)
406 if (h
->dynindx
== -1)
408 struct elf_strtab_hash
*dynstr
;
413 /* XXX: The ABI draft says the linker must turn hidden and
414 internal symbols into STB_LOCAL symbols when producing the
415 DSO. However, if ld.so honors st_other in the dynamic table,
416 this would not be necessary. */
417 switch (ELF_ST_VISIBILITY (h
->other
))
421 if (h
->root
.type
!= bfd_link_hash_undefined
422 && h
->root
.type
!= bfd_link_hash_undefweak
)
425 if (!elf_hash_table (info
)->is_relocatable_executable
)
433 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
434 ++elf_hash_table (info
)->dynsymcount
;
436 dynstr
= elf_hash_table (info
)->dynstr
;
439 /* Create a strtab to hold the dynamic symbol names. */
440 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
445 /* We don't put any version information in the dynamic string
447 name
= h
->root
.root
.string
;
448 p
= strchr (name
, ELF_VER_CHR
);
450 /* We know that the p points into writable memory. In fact,
451 there are only a few symbols that have read-only names, being
452 those like _GLOBAL_OFFSET_TABLE_ that are created specially
453 by the backends. Most symbols will have names pointing into
454 an ELF string table read from a file, or to objalloc memory. */
457 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
462 if (indx
== (bfd_size_type
) -1)
464 h
->dynstr_index
= indx
;
470 /* Mark a symbol dynamic. */
473 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info
*info
,
474 struct elf_link_hash_entry
*h
,
475 Elf_Internal_Sym
*sym
)
477 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
479 /* It may be called more than once on the same H. */
480 if(h
->dynamic
|| info
->relocatable
)
483 if ((info
->dynamic_data
484 && (h
->type
== STT_OBJECT
486 && ELF_ST_TYPE (sym
->st_info
) == STT_OBJECT
)))
488 && h
->root
.type
== bfd_link_hash_new
489 && (*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
)))
493 /* Record an assignment to a symbol made by a linker script. We need
494 this in case some dynamic object refers to this symbol. */
497 bfd_elf_record_link_assignment (bfd
*output_bfd
,
498 struct bfd_link_info
*info
,
503 struct elf_link_hash_entry
*h
, *hv
;
504 struct elf_link_hash_table
*htab
;
505 const struct elf_backend_data
*bed
;
507 if (!is_elf_hash_table (info
->hash
))
510 htab
= elf_hash_table (info
);
511 h
= elf_link_hash_lookup (htab
, name
, !provide
, TRUE
, FALSE
);
515 switch (h
->root
.type
)
517 case bfd_link_hash_defined
:
518 case bfd_link_hash_defweak
:
519 case bfd_link_hash_common
:
521 case bfd_link_hash_undefweak
:
522 case bfd_link_hash_undefined
:
523 /* Since we're defining the symbol, don't let it seem to have not
524 been defined. record_dynamic_symbol and size_dynamic_sections
525 may depend on this. */
526 h
->root
.type
= bfd_link_hash_new
;
527 if (h
->root
.u
.undef
.next
!= NULL
|| htab
->root
.undefs_tail
== &h
->root
)
528 bfd_link_repair_undef_list (&htab
->root
);
530 case bfd_link_hash_new
:
531 bfd_elf_link_mark_dynamic_symbol (info
, h
, NULL
);
534 case bfd_link_hash_indirect
:
535 /* We had a versioned symbol in a dynamic library. We make the
536 the versioned symbol point to this one. */
537 bed
= get_elf_backend_data (output_bfd
);
539 while (hv
->root
.type
== bfd_link_hash_indirect
540 || hv
->root
.type
== bfd_link_hash_warning
)
541 hv
= (struct elf_link_hash_entry
*) hv
->root
.u
.i
.link
;
542 /* We don't need to update h->root.u since linker will set them
544 h
->root
.type
= bfd_link_hash_undefined
;
545 hv
->root
.type
= bfd_link_hash_indirect
;
546 hv
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
547 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hv
);
549 case bfd_link_hash_warning
:
554 /* If this symbol is being provided by the linker script, and it is
555 currently defined by a dynamic object, but not by a regular
556 object, then mark it as undefined so that the generic linker will
557 force the correct value. */
561 h
->root
.type
= bfd_link_hash_undefined
;
563 /* If this symbol is not being provided by the linker script, and it is
564 currently defined by a dynamic object, but not by a regular object,
565 then clear out any version information because the symbol will not be
566 associated with the dynamic object any more. */
570 h
->verinfo
.verdef
= NULL
;
576 bed
= get_elf_backend_data (output_bfd
);
577 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
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 /* This function is called when we want to merge a new symbol with an
899 existing symbol. It handles the various cases which arise when we
900 find a definition in a dynamic object, or when there is already a
901 definition in a dynamic object. The new symbol is described by
902 NAME, SYM, PSEC, and PVALUE. We set SYM_HASH to the hash table
903 entry. We set POLDBFD to the old symbol's BFD. We set POLD_WEAK
904 if the old symbol was weak. We set POLD_ALIGNMENT to the alignment
905 of an old common symbol. We set OVERRIDE if the old symbol is
906 overriding a new definition. We set TYPE_CHANGE_OK if it is OK for
907 the type to change. We set SIZE_CHANGE_OK if it is OK for the size
908 to change. By OK to change, we mean that we shouldn't warn if the
909 type or size does change. */
912 _bfd_elf_merge_symbol (bfd
*abfd
,
913 struct bfd_link_info
*info
,
915 Elf_Internal_Sym
*sym
,
918 struct elf_link_hash_entry
**sym_hash
,
920 bfd_boolean
*pold_weak
,
921 unsigned int *pold_alignment
,
923 bfd_boolean
*override
,
924 bfd_boolean
*type_change_ok
,
925 bfd_boolean
*size_change_ok
)
927 asection
*sec
, *oldsec
;
928 struct elf_link_hash_entry
*h
;
929 struct elf_link_hash_entry
*hi
;
930 struct elf_link_hash_entry
*flip
;
933 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
934 bfd_boolean newweak
, oldweak
, newfunc
, oldfunc
;
935 const struct elf_backend_data
*bed
;
941 bind
= ELF_ST_BIND (sym
->st_info
);
943 if (! bfd_is_und_section (sec
))
944 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
946 h
= ((struct elf_link_hash_entry
*)
947 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
952 bed
= get_elf_backend_data (abfd
);
954 /* For merging, we only care about real symbols. But we need to make
955 sure that indirect symbol dynamic flags are updated. */
957 while (h
->root
.type
== bfd_link_hash_indirect
958 || h
->root
.type
== bfd_link_hash_warning
)
959 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
961 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
966 switch (h
->root
.type
)
971 case bfd_link_hash_undefined
:
972 case bfd_link_hash_undefweak
:
973 oldbfd
= h
->root
.u
.undef
.abfd
;
976 case bfd_link_hash_defined
:
977 case bfd_link_hash_defweak
:
978 oldbfd
= h
->root
.u
.def
.section
->owner
;
979 oldsec
= h
->root
.u
.def
.section
;
982 case bfd_link_hash_common
:
983 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
984 oldsec
= h
->root
.u
.c
.p
->section
;
986 *pold_alignment
= h
->root
.u
.c
.p
->alignment_power
;
989 if (poldbfd
&& *poldbfd
== NULL
)
992 /* Differentiate strong and weak symbols. */
993 newweak
= bind
== STB_WEAK
;
994 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
995 || h
->root
.type
== bfd_link_hash_undefweak
);
997 *pold_weak
= oldweak
;
999 /* This code is for coping with dynamic objects, and is only useful
1000 if we are doing an ELF link. */
1001 if (!(*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
1004 /* We have to check it for every instance since the first few may be
1005 references and not all compilers emit symbol type for undefined
1007 bfd_elf_link_mark_dynamic_symbol (info
, h
, sym
);
1009 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1010 respectively, is from a dynamic object. */
1012 newdyn
= (abfd
->flags
& DYNAMIC
) != 0;
1014 /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
1015 syms and defined syms in dynamic libraries respectively.
1016 ref_dynamic on the other hand can be set for a symbol defined in
1017 a dynamic library, and def_dynamic may not be set; When the
1018 definition in a dynamic lib is overridden by a definition in the
1019 executable use of the symbol in the dynamic lib becomes a
1020 reference to the executable symbol. */
1023 if (bfd_is_und_section (sec
))
1025 if (bind
!= STB_WEAK
)
1027 h
->ref_dynamic_nonweak
= 1;
1028 hi
->ref_dynamic_nonweak
= 1;
1034 hi
->dynamic_def
= 1;
1038 /* If we just created the symbol, mark it as being an ELF symbol.
1039 Other than that, there is nothing to do--there is no merge issue
1040 with a newly defined symbol--so we just return. */
1042 if (h
->root
.type
== bfd_link_hash_new
)
1048 /* In cases involving weak versioned symbols, we may wind up trying
1049 to merge a symbol with itself. Catch that here, to avoid the
1050 confusion that results if we try to override a symbol with
1051 itself. The additional tests catch cases like
1052 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1053 dynamic object, which we do want to handle here. */
1055 && (newweak
|| oldweak
)
1056 && ((abfd
->flags
& DYNAMIC
) == 0
1057 || !h
->def_regular
))
1062 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
1063 else if (oldsec
!= NULL
)
1065 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1066 indices used by MIPS ELF. */
1067 olddyn
= (oldsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
1070 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1071 respectively, appear to be a definition rather than reference. */
1073 newdef
= !bfd_is_und_section (sec
) && !bfd_is_com_section (sec
);
1075 olddef
= (h
->root
.type
!= bfd_link_hash_undefined
1076 && h
->root
.type
!= bfd_link_hash_undefweak
1077 && h
->root
.type
!= bfd_link_hash_common
);
1079 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1080 respectively, appear to be a function. */
1082 newfunc
= (ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1083 && bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)));
1085 oldfunc
= (h
->type
!= STT_NOTYPE
1086 && bed
->is_function_type (h
->type
));
1088 /* When we try to create a default indirect symbol from the dynamic
1089 definition with the default version, we skip it if its type and
1090 the type of existing regular definition mismatch. We only do it
1091 if the existing regular definition won't be dynamic. */
1092 if (pold_alignment
== NULL
1094 && !info
->export_dynamic
1099 && (olddef
|| h
->root
.type
== bfd_link_hash_common
)
1100 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1101 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
1102 && h
->type
!= STT_NOTYPE
1103 && !(newfunc
&& oldfunc
))
1109 /* Plugin symbol type isn't currently set. Stop bogus errors. */
1110 if (oldbfd
!= NULL
&& (oldbfd
->flags
& BFD_PLUGIN
) != 0)
1111 *type_change_ok
= TRUE
;
1113 /* Check TLS symbol. We don't check undefined symbol introduced by
1115 else if (oldbfd
!= NULL
1116 && ELF_ST_TYPE (sym
->st_info
) != h
->type
1117 && (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
|| h
->type
== STT_TLS
))
1120 bfd_boolean ntdef
, tdef
;
1121 asection
*ntsec
, *tsec
;
1123 if (h
->type
== STT_TLS
)
1143 (*_bfd_error_handler
)
1144 (_("%s: TLS definition in %B section %A "
1145 "mismatches non-TLS definition in %B section %A"),
1146 tbfd
, tsec
, ntbfd
, ntsec
, h
->root
.root
.string
);
1147 else if (!tdef
&& !ntdef
)
1148 (*_bfd_error_handler
)
1149 (_("%s: TLS reference in %B "
1150 "mismatches non-TLS reference in %B"),
1151 tbfd
, ntbfd
, h
->root
.root
.string
);
1153 (*_bfd_error_handler
)
1154 (_("%s: TLS definition in %B section %A "
1155 "mismatches non-TLS reference in %B"),
1156 tbfd
, tsec
, ntbfd
, h
->root
.root
.string
);
1158 (*_bfd_error_handler
)
1159 (_("%s: TLS reference in %B "
1160 "mismatches non-TLS definition in %B section %A"),
1161 tbfd
, ntbfd
, ntsec
, h
->root
.root
.string
);
1163 bfd_set_error (bfd_error_bad_value
);
1167 /* If the old symbol has non-default visibility, we ignore the new
1168 definition from a dynamic object. */
1170 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1171 && !bfd_is_und_section (sec
))
1174 /* Make sure this symbol is dynamic. */
1176 hi
->ref_dynamic
= 1;
1177 /* A protected symbol has external availability. Make sure it is
1178 recorded as dynamic.
1180 FIXME: Should we check type and size for protected symbol? */
1181 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1182 return bfd_elf_link_record_dynamic_symbol (info
, h
);
1187 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
1190 /* If the new symbol with non-default visibility comes from a
1191 relocatable file and the old definition comes from a dynamic
1192 object, we remove the old definition. */
1193 if (hi
->root
.type
== bfd_link_hash_indirect
)
1195 /* Handle the case where the old dynamic definition is
1196 default versioned. We need to copy the symbol info from
1197 the symbol with default version to the normal one if it
1198 was referenced before. */
1201 hi
->root
.type
= h
->root
.type
;
1202 h
->root
.type
= bfd_link_hash_indirect
;
1203 (*bed
->elf_backend_copy_indirect_symbol
) (info
, hi
, h
);
1205 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1206 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1208 /* If the new symbol is hidden or internal, completely undo
1209 any dynamic link state. */
1210 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1211 h
->forced_local
= 0;
1218 /* FIXME: Should we check type and size for protected symbol? */
1228 /* If the old symbol was undefined before, then it will still be
1229 on the undefs list. If the new symbol is undefined or
1230 common, we can't make it bfd_link_hash_new here, because new
1231 undefined or common symbols will be added to the undefs list
1232 by _bfd_generic_link_add_one_symbol. Symbols may not be
1233 added twice to the undefs list. Also, if the new symbol is
1234 undefweak then we don't want to lose the strong undef. */
1235 if (h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1237 h
->root
.type
= bfd_link_hash_undefined
;
1238 h
->root
.u
.undef
.abfd
= abfd
;
1242 h
->root
.type
= bfd_link_hash_new
;
1243 h
->root
.u
.undef
.abfd
= NULL
;
1246 if (ELF_ST_VISIBILITY (sym
->st_other
) != STV_PROTECTED
)
1248 /* If the new symbol is hidden or internal, completely undo
1249 any dynamic link state. */
1250 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1251 h
->forced_local
= 0;
1257 /* FIXME: Should we check type and size for protected symbol? */
1263 /* If a new weak symbol definition comes from a regular file and the
1264 old symbol comes from a dynamic library, we treat the new one as
1265 strong. Similarly, an old weak symbol definition from a regular
1266 file is treated as strong when the new symbol comes from a dynamic
1267 library. Further, an old weak symbol from a dynamic library is
1268 treated as strong if the new symbol is from a dynamic library.
1269 This reflects the way glibc's ld.so works.
1271 Do this before setting *type_change_ok or *size_change_ok so that
1272 we warn properly when dynamic library symbols are overridden. */
1274 if (newdef
&& !newdyn
&& olddyn
)
1276 if (olddef
&& newdyn
)
1279 /* Allow changes between different types of function symbol. */
1280 if (newfunc
&& oldfunc
)
1281 *type_change_ok
= TRUE
;
1283 /* It's OK to change the type if either the existing symbol or the
1284 new symbol is weak. A type change is also OK if the old symbol
1285 is undefined and the new symbol is defined. */
1290 && h
->root
.type
== bfd_link_hash_undefined
))
1291 *type_change_ok
= TRUE
;
1293 /* It's OK to change the size if either the existing symbol or the
1294 new symbol is weak, or if the old symbol is undefined. */
1297 || h
->root
.type
== bfd_link_hash_undefined
)
1298 *size_change_ok
= TRUE
;
1300 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1301 symbol, respectively, appears to be a common symbol in a dynamic
1302 object. If a symbol appears in an uninitialized section, and is
1303 not weak, and is not a function, then it may be a common symbol
1304 which was resolved when the dynamic object was created. We want
1305 to treat such symbols specially, because they raise special
1306 considerations when setting the symbol size: if the symbol
1307 appears as a common symbol in a regular object, and the size in
1308 the regular object is larger, we must make sure that we use the
1309 larger size. This problematic case can always be avoided in C,
1310 but it must be handled correctly when using Fortran shared
1313 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1314 likewise for OLDDYNCOMMON and OLDDEF.
1316 Note that this test is just a heuristic, and that it is quite
1317 possible to have an uninitialized symbol in a shared object which
1318 is really a definition, rather than a common symbol. This could
1319 lead to some minor confusion when the symbol really is a common
1320 symbol in some regular object. However, I think it will be
1326 && (sec
->flags
& SEC_ALLOC
) != 0
1327 && (sec
->flags
& SEC_LOAD
) == 0
1330 newdyncommon
= TRUE
;
1332 newdyncommon
= FALSE
;
1336 && h
->root
.type
== bfd_link_hash_defined
1338 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1339 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
1342 olddyncommon
= TRUE
;
1344 olddyncommon
= FALSE
;
1346 /* We now know everything about the old and new symbols. We ask the
1347 backend to check if we can merge them. */
1348 if (bed
->merge_symbol
!= NULL
)
1350 if (!bed
->merge_symbol (h
, sym
, psec
, newdef
, olddef
, oldbfd
, oldsec
))
1355 /* If both the old and the new symbols look like common symbols in a
1356 dynamic object, set the size of the symbol to the larger of the
1361 && sym
->st_size
!= h
->size
)
1363 /* Since we think we have two common symbols, issue a multiple
1364 common warning if desired. Note that we only warn if the
1365 size is different. If the size is the same, we simply let
1366 the old symbol override the new one as normally happens with
1367 symbols defined in dynamic objects. */
1369 if (! ((*info
->callbacks
->multiple_common
)
1370 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1373 if (sym
->st_size
> h
->size
)
1374 h
->size
= sym
->st_size
;
1376 *size_change_ok
= TRUE
;
1379 /* If we are looking at a dynamic object, and we have found a
1380 definition, we need to see if the symbol was already defined by
1381 some other object. If so, we want to use the existing
1382 definition, and we do not want to report a multiple symbol
1383 definition error; we do this by clobbering *PSEC to be
1384 bfd_und_section_ptr.
1386 We treat a common symbol as a definition if the symbol in the
1387 shared library is a function, since common symbols always
1388 represent variables; this can cause confusion in principle, but
1389 any such confusion would seem to indicate an erroneous program or
1390 shared library. We also permit a common symbol in a regular
1391 object to override a weak symbol in a shared object. */
1396 || (h
->root
.type
== bfd_link_hash_common
1397 && (newweak
|| newfunc
))))
1401 newdyncommon
= FALSE
;
1403 *psec
= sec
= bfd_und_section_ptr
;
1404 *size_change_ok
= TRUE
;
1406 /* If we get here when the old symbol is a common symbol, then
1407 we are explicitly letting it override a weak symbol or
1408 function in a dynamic object, and we don't want to warn about
1409 a type change. If the old symbol is a defined symbol, a type
1410 change warning may still be appropriate. */
1412 if (h
->root
.type
== bfd_link_hash_common
)
1413 *type_change_ok
= TRUE
;
1416 /* Handle the special case of an old common symbol merging with a
1417 new symbol which looks like a common symbol in a shared object.
1418 We change *PSEC and *PVALUE to make the new symbol look like a
1419 common symbol, and let _bfd_generic_link_add_one_symbol do the
1423 && h
->root
.type
== bfd_link_hash_common
)
1427 newdyncommon
= FALSE
;
1428 *pvalue
= sym
->st_size
;
1429 *psec
= sec
= bed
->common_section (oldsec
);
1430 *size_change_ok
= TRUE
;
1433 /* Skip weak definitions of symbols that are already defined. */
1434 if (newdef
&& olddef
&& newweak
)
1436 /* Don't skip new non-IR weak syms. */
1437 if (!(oldbfd
!= NULL
1438 && (oldbfd
->flags
& BFD_PLUGIN
) != 0
1439 && (abfd
->flags
& BFD_PLUGIN
) == 0))
1445 /* Merge st_other. If the symbol already has a dynamic index,
1446 but visibility says it should not be visible, turn it into a
1448 elf_merge_st_other (abfd
, h
, sym
, newdef
, newdyn
);
1449 if (h
->dynindx
!= -1)
1450 switch (ELF_ST_VISIBILITY (h
->other
))
1454 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1459 /* If the old symbol is from a dynamic object, and the new symbol is
1460 a definition which is not from a dynamic object, then the new
1461 symbol overrides the old symbol. Symbols from regular files
1462 always take precedence over symbols from dynamic objects, even if
1463 they are defined after the dynamic object in the link.
1465 As above, we again permit a common symbol in a regular object to
1466 override a definition in a shared object if the shared object
1467 symbol is a function or is weak. */
1472 || (bfd_is_com_section (sec
)
1473 && (oldweak
|| oldfunc
)))
1478 /* Change the hash table entry to undefined, and let
1479 _bfd_generic_link_add_one_symbol do the right thing with the
1482 h
->root
.type
= bfd_link_hash_undefined
;
1483 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1484 *size_change_ok
= TRUE
;
1487 olddyncommon
= FALSE
;
1489 /* We again permit a type change when a common symbol may be
1490 overriding a function. */
1492 if (bfd_is_com_section (sec
))
1496 /* If a common symbol overrides a function, make sure
1497 that it isn't defined dynamically nor has type
1500 h
->type
= STT_NOTYPE
;
1502 *type_change_ok
= TRUE
;
1505 if (hi
->root
.type
== bfd_link_hash_indirect
)
1508 /* This union may have been set to be non-NULL when this symbol
1509 was seen in a dynamic object. We must force the union to be
1510 NULL, so that it is correct for a regular symbol. */
1511 h
->verinfo
.vertree
= NULL
;
1514 /* Handle the special case of a new common symbol merging with an
1515 old symbol that looks like it might be a common symbol defined in
1516 a shared object. Note that we have already handled the case in
1517 which a new common symbol should simply override the definition
1518 in the shared library. */
1521 && bfd_is_com_section (sec
)
1524 /* It would be best if we could set the hash table entry to a
1525 common symbol, but we don't know what to use for the section
1526 or the alignment. */
1527 if (! ((*info
->callbacks
->multiple_common
)
1528 (info
, &h
->root
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1531 /* If the presumed common symbol in the dynamic object is
1532 larger, pretend that the new symbol has its size. */
1534 if (h
->size
> *pvalue
)
1537 /* We need to remember the alignment required by the symbol
1538 in the dynamic object. */
1539 BFD_ASSERT (pold_alignment
);
1540 *pold_alignment
= h
->root
.u
.def
.section
->alignment_power
;
1543 olddyncommon
= FALSE
;
1545 h
->root
.type
= bfd_link_hash_undefined
;
1546 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1548 *size_change_ok
= TRUE
;
1549 *type_change_ok
= TRUE
;
1551 if (hi
->root
.type
== bfd_link_hash_indirect
)
1554 h
->verinfo
.vertree
= NULL
;
1559 /* Handle the case where we had a versioned symbol in a dynamic
1560 library and now find a definition in a normal object. In this
1561 case, we make the versioned symbol point to the normal one. */
1562 flip
->root
.type
= h
->root
.type
;
1563 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1564 h
->root
.type
= bfd_link_hash_indirect
;
1565 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1566 (*bed
->elf_backend_copy_indirect_symbol
) (info
, flip
, h
);
1570 flip
->ref_dynamic
= 1;
1577 /* This function is called to create an indirect symbol from the
1578 default for the symbol with the default version if needed. The
1579 symbol is described by H, NAME, SYM, SEC, and VALUE. We
1580 set DYNSYM if the new indirect symbol is dynamic. */
1583 _bfd_elf_add_default_symbol (bfd
*abfd
,
1584 struct bfd_link_info
*info
,
1585 struct elf_link_hash_entry
*h
,
1587 Elf_Internal_Sym
*sym
,
1591 bfd_boolean
*dynsym
)
1593 bfd_boolean type_change_ok
;
1594 bfd_boolean size_change_ok
;
1597 struct elf_link_hash_entry
*hi
;
1598 struct bfd_link_hash_entry
*bh
;
1599 const struct elf_backend_data
*bed
;
1600 bfd_boolean collect
;
1601 bfd_boolean dynamic
;
1602 bfd_boolean override
;
1604 size_t len
, shortlen
;
1607 /* If this symbol has a version, and it is the default version, we
1608 create an indirect symbol from the default name to the fully
1609 decorated name. This will cause external references which do not
1610 specify a version to be bound to this version of the symbol. */
1611 p
= strchr (name
, ELF_VER_CHR
);
1612 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
1615 bed
= get_elf_backend_data (abfd
);
1616 collect
= bed
->collect
;
1617 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1619 shortlen
= p
- name
;
1620 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1621 if (shortname
== NULL
)
1623 memcpy (shortname
, name
, shortlen
);
1624 shortname
[shortlen
] = '\0';
1626 /* We are going to create a new symbol. Merge it with any existing
1627 symbol with this name. For the purposes of the merge, act as
1628 though we were defining the symbol we just defined, although we
1629 actually going to define an indirect symbol. */
1630 type_change_ok
= FALSE
;
1631 size_change_ok
= FALSE
;
1633 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &tmp_sec
, &value
,
1634 &hi
, poldbfd
, NULL
, NULL
, &skip
, &override
,
1635 &type_change_ok
, &size_change_ok
))
1644 if (! (_bfd_generic_link_add_one_symbol
1645 (info
, abfd
, shortname
, BSF_INDIRECT
, bfd_ind_section_ptr
,
1646 0, name
, FALSE
, collect
, &bh
)))
1648 hi
= (struct elf_link_hash_entry
*) bh
;
1652 /* In this case the symbol named SHORTNAME is overriding the
1653 indirect symbol we want to add. We were planning on making
1654 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1655 is the name without a version. NAME is the fully versioned
1656 name, and it is the default version.
1658 Overriding means that we already saw a definition for the
1659 symbol SHORTNAME in a regular object, and it is overriding
1660 the symbol defined in the dynamic object.
1662 When this happens, we actually want to change NAME, the
1663 symbol we just added, to refer to SHORTNAME. This will cause
1664 references to NAME in the shared object to become references
1665 to SHORTNAME in the regular object. This is what we expect
1666 when we override a function in a shared object: that the
1667 references in the shared object will be mapped to the
1668 definition in the regular object. */
1670 while (hi
->root
.type
== bfd_link_hash_indirect
1671 || hi
->root
.type
== bfd_link_hash_warning
)
1672 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1674 h
->root
.type
= bfd_link_hash_indirect
;
1675 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1679 hi
->ref_dynamic
= 1;
1683 if (! bfd_elf_link_record_dynamic_symbol (info
, hi
))
1688 /* Now set HI to H, so that the following code will set the
1689 other fields correctly. */
1693 /* Check if HI is a warning symbol. */
1694 if (hi
->root
.type
== bfd_link_hash_warning
)
1695 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1697 /* If there is a duplicate definition somewhere, then HI may not
1698 point to an indirect symbol. We will have reported an error to
1699 the user in that case. */
1701 if (hi
->root
.type
== bfd_link_hash_indirect
)
1703 struct elf_link_hash_entry
*ht
;
1705 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1706 (*bed
->elf_backend_copy_indirect_symbol
) (info
, ht
, hi
);
1708 /* A reference to the SHORTNAME symbol from a dynamic library
1709 will be satisfied by the versioned symbol at runtime. In
1710 effect, we have a reference to the versioned symbol. */
1711 ht
->ref_dynamic_nonweak
|= hi
->ref_dynamic_nonweak
;
1712 hi
->dynamic_def
|= ht
->dynamic_def
;
1714 /* See if the new flags lead us to realize that the symbol must
1720 if (! info
->executable
1727 if (hi
->ref_regular
)
1733 /* We also need to define an indirection from the nondefault version
1737 len
= strlen (name
);
1738 shortname
= (char *) bfd_hash_allocate (&info
->hash
->table
, len
);
1739 if (shortname
== NULL
)
1741 memcpy (shortname
, name
, shortlen
);
1742 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1744 /* Once again, merge with any existing symbol. */
1745 type_change_ok
= FALSE
;
1746 size_change_ok
= FALSE
;
1748 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &tmp_sec
, &value
,
1749 &hi
, NULL
, NULL
, NULL
, &skip
, &override
,
1750 &type_change_ok
, &size_change_ok
))
1758 /* Here SHORTNAME is a versioned name, so we don't expect to see
1759 the type of override we do in the case above unless it is
1760 overridden by a versioned definition. */
1761 if (hi
->root
.type
!= bfd_link_hash_defined
1762 && hi
->root
.type
!= bfd_link_hash_defweak
)
1763 (*_bfd_error_handler
)
1764 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1770 if (! (_bfd_generic_link_add_one_symbol
1771 (info
, abfd
, shortname
, BSF_INDIRECT
,
1772 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
1774 hi
= (struct elf_link_hash_entry
*) bh
;
1776 /* If there is a duplicate definition somewhere, then HI may not
1777 point to an indirect symbol. We will have reported an error
1778 to the user in that case. */
1780 if (hi
->root
.type
== bfd_link_hash_indirect
)
1782 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
1783 h
->ref_dynamic_nonweak
|= hi
->ref_dynamic_nonweak
;
1784 hi
->dynamic_def
|= h
->dynamic_def
;
1786 /* See if the new flags lead us to realize that the symbol
1792 if (! info
->executable
1798 if (hi
->ref_regular
)
1808 /* This routine is used to export all defined symbols into the dynamic
1809 symbol table. It is called via elf_link_hash_traverse. */
1812 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
1814 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1816 /* Ignore indirect symbols. These are added by the versioning code. */
1817 if (h
->root
.type
== bfd_link_hash_indirect
)
1820 /* Ignore this if we won't export it. */
1821 if (!eif
->info
->export_dynamic
&& !h
->dynamic
)
1824 if (h
->dynindx
== -1
1825 && (h
->def_regular
|| h
->ref_regular
)
1826 && ! bfd_hide_sym_by_version (eif
->info
->version_info
,
1827 h
->root
.root
.string
))
1829 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1839 /* Look through the symbols which are defined in other shared
1840 libraries and referenced here. Update the list of version
1841 dependencies. This will be put into the .gnu.version_r section.
1842 This function is called via elf_link_hash_traverse. */
1845 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1848 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
1849 Elf_Internal_Verneed
*t
;
1850 Elf_Internal_Vernaux
*a
;
1853 /* We only care about symbols defined in shared objects with version
1858 || h
->verinfo
.verdef
== NULL
)
1861 /* See if we already know about this version. */
1862 for (t
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1866 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1869 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1870 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1876 /* This is a new version. Add it to tree we are building. */
1881 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1884 rinfo
->failed
= TRUE
;
1888 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1889 t
->vn_nextref
= elf_tdata (rinfo
->info
->output_bfd
)->verref
;
1890 elf_tdata (rinfo
->info
->output_bfd
)->verref
= t
;
1894 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->info
->output_bfd
, amt
);
1897 rinfo
->failed
= TRUE
;
1901 /* Note that we are copying a string pointer here, and testing it
1902 above. If bfd_elf_string_from_elf_section is ever changed to
1903 discard the string data when low in memory, this will have to be
1905 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1907 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1908 a
->vna_nextptr
= t
->vn_auxptr
;
1910 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1913 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1920 /* Figure out appropriate versions for all the symbols. We may not
1921 have the version number script until we have read all of the input
1922 files, so until that point we don't know which symbols should be
1923 local. This function is called via elf_link_hash_traverse. */
1926 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1928 struct elf_info_failed
*sinfo
;
1929 struct bfd_link_info
*info
;
1930 const struct elf_backend_data
*bed
;
1931 struct elf_info_failed eif
;
1935 sinfo
= (struct elf_info_failed
*) data
;
1938 /* Fix the symbol flags. */
1941 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1944 sinfo
->failed
= TRUE
;
1948 /* We only need version numbers for symbols defined in regular
1950 if (!h
->def_regular
)
1953 bed
= get_elf_backend_data (info
->output_bfd
);
1954 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1955 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1957 struct bfd_elf_version_tree
*t
;
1962 /* There are two consecutive ELF_VER_CHR characters if this is
1963 not a hidden symbol. */
1965 if (*p
== ELF_VER_CHR
)
1971 /* If there is no version string, we can just return out. */
1979 /* Look for the version. If we find it, it is no longer weak. */
1980 for (t
= sinfo
->info
->version_info
; t
!= NULL
; t
= t
->next
)
1982 if (strcmp (t
->name
, p
) == 0)
1986 struct bfd_elf_version_expr
*d
;
1988 len
= p
- h
->root
.root
.string
;
1989 alc
= (char *) bfd_malloc (len
);
1992 sinfo
->failed
= TRUE
;
1995 memcpy (alc
, h
->root
.root
.string
, len
- 1);
1996 alc
[len
- 1] = '\0';
1997 if (alc
[len
- 2] == ELF_VER_CHR
)
1998 alc
[len
- 2] = '\0';
2000 h
->verinfo
.vertree
= t
;
2004 if (t
->globals
.list
!= NULL
)
2005 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
2007 /* See if there is anything to force this symbol to
2009 if (d
== NULL
&& t
->locals
.list
!= NULL
)
2011 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
2014 && ! info
->export_dynamic
)
2015 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2023 /* If we are building an application, we need to create a
2024 version node for this version. */
2025 if (t
== NULL
&& info
->executable
)
2027 struct bfd_elf_version_tree
**pp
;
2030 /* If we aren't going to export this symbol, we don't need
2031 to worry about it. */
2032 if (h
->dynindx
== -1)
2036 t
= (struct bfd_elf_version_tree
*) bfd_zalloc (info
->output_bfd
, amt
);
2039 sinfo
->failed
= TRUE
;
2044 t
->name_indx
= (unsigned int) -1;
2048 /* Don't count anonymous version tag. */
2049 if (sinfo
->info
->version_info
!= NULL
2050 && sinfo
->info
->version_info
->vernum
== 0)
2052 for (pp
= &sinfo
->info
->version_info
;
2056 t
->vernum
= version_index
;
2060 h
->verinfo
.vertree
= t
;
2064 /* We could not find the version for a symbol when
2065 generating a shared archive. Return an error. */
2066 (*_bfd_error_handler
)
2067 (_("%B: version node not found for symbol %s"),
2068 info
->output_bfd
, h
->root
.root
.string
);
2069 bfd_set_error (bfd_error_bad_value
);
2070 sinfo
->failed
= TRUE
;
2078 /* If we don't have a version for this symbol, see if we can find
2080 if (h
->verinfo
.vertree
== NULL
&& sinfo
->info
->version_info
!= NULL
)
2085 = bfd_find_version_for_sym (sinfo
->info
->version_info
,
2086 h
->root
.root
.string
, &hide
);
2087 if (h
->verinfo
.vertree
!= NULL
&& hide
)
2088 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2094 /* Read and swap the relocs from the section indicated by SHDR. This
2095 may be either a REL or a RELA section. The relocations are
2096 translated into RELA relocations and stored in INTERNAL_RELOCS,
2097 which should have already been allocated to contain enough space.
2098 The EXTERNAL_RELOCS are a buffer where the external form of the
2099 relocations should be stored.
2101 Returns FALSE if something goes wrong. */
2104 elf_link_read_relocs_from_section (bfd
*abfd
,
2106 Elf_Internal_Shdr
*shdr
,
2107 void *external_relocs
,
2108 Elf_Internal_Rela
*internal_relocs
)
2110 const struct elf_backend_data
*bed
;
2111 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2112 const bfd_byte
*erela
;
2113 const bfd_byte
*erelaend
;
2114 Elf_Internal_Rela
*irela
;
2115 Elf_Internal_Shdr
*symtab_hdr
;
2118 /* Position ourselves at the start of the section. */
2119 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2122 /* Read the relocations. */
2123 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
2126 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2127 nsyms
= NUM_SHDR_ENTRIES (symtab_hdr
);
2129 bed
= get_elf_backend_data (abfd
);
2131 /* Convert the external relocations to the internal format. */
2132 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2133 swap_in
= bed
->s
->swap_reloc_in
;
2134 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2135 swap_in
= bed
->s
->swap_reloca_in
;
2138 bfd_set_error (bfd_error_wrong_format
);
2142 erela
= (const bfd_byte
*) external_relocs
;
2143 erelaend
= erela
+ shdr
->sh_size
;
2144 irela
= internal_relocs
;
2145 while (erela
< erelaend
)
2149 (*swap_in
) (abfd
, erela
, irela
);
2150 r_symndx
= ELF32_R_SYM (irela
->r_info
);
2151 if (bed
->s
->arch_size
== 64)
2155 if ((size_t) r_symndx
>= nsyms
)
2157 (*_bfd_error_handler
)
2158 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2159 " for offset 0x%lx in section `%A'"),
2161 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2162 bfd_set_error (bfd_error_bad_value
);
2166 else if (r_symndx
!= STN_UNDEF
)
2168 (*_bfd_error_handler
)
2169 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2170 " when the object file has no symbol table"),
2172 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2173 bfd_set_error (bfd_error_bad_value
);
2176 irela
+= bed
->s
->int_rels_per_ext_rel
;
2177 erela
+= shdr
->sh_entsize
;
2183 /* Read and swap the relocs for a section O. They may have been
2184 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2185 not NULL, they are used as buffers to read into. They are known to
2186 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2187 the return value is allocated using either malloc or bfd_alloc,
2188 according to the KEEP_MEMORY argument. If O has two relocation
2189 sections (both REL and RELA relocations), then the REL_HDR
2190 relocations will appear first in INTERNAL_RELOCS, followed by the
2191 RELA_HDR relocations. */
2194 _bfd_elf_link_read_relocs (bfd
*abfd
,
2196 void *external_relocs
,
2197 Elf_Internal_Rela
*internal_relocs
,
2198 bfd_boolean keep_memory
)
2200 void *alloc1
= NULL
;
2201 Elf_Internal_Rela
*alloc2
= NULL
;
2202 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2203 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
2204 Elf_Internal_Rela
*internal_rela_relocs
;
2206 if (esdo
->relocs
!= NULL
)
2207 return esdo
->relocs
;
2209 if (o
->reloc_count
== 0)
2212 if (internal_relocs
== NULL
)
2216 size
= o
->reloc_count
;
2217 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
2219 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2221 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2222 if (internal_relocs
== NULL
)
2226 if (external_relocs
== NULL
)
2228 bfd_size_type size
= 0;
2231 size
+= esdo
->rel
.hdr
->sh_size
;
2233 size
+= esdo
->rela
.hdr
->sh_size
;
2235 alloc1
= bfd_malloc (size
);
2238 external_relocs
= alloc1
;
2241 internal_rela_relocs
= internal_relocs
;
2244 if (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rel
.hdr
,
2248 external_relocs
= (((bfd_byte
*) external_relocs
)
2249 + esdo
->rel
.hdr
->sh_size
);
2250 internal_rela_relocs
+= (NUM_SHDR_ENTRIES (esdo
->rel
.hdr
)
2251 * bed
->s
->int_rels_per_ext_rel
);
2255 && (!elf_link_read_relocs_from_section (abfd
, o
, esdo
->rela
.hdr
,
2257 internal_rela_relocs
)))
2260 /* Cache the results for next time, if we can. */
2262 esdo
->relocs
= internal_relocs
;
2267 /* Don't free alloc2, since if it was allocated we are passing it
2268 back (under the name of internal_relocs). */
2270 return internal_relocs
;
2278 bfd_release (abfd
, alloc2
);
2285 /* Compute the size of, and allocate space for, REL_HDR which is the
2286 section header for a section containing relocations for O. */
2289 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2290 struct bfd_elf_section_reloc_data
*reldata
)
2292 Elf_Internal_Shdr
*rel_hdr
= reldata
->hdr
;
2294 /* That allows us to calculate the size of the section. */
2295 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reldata
->count
;
2297 /* The contents field must last into write_object_contents, so we
2298 allocate it with bfd_alloc rather than malloc. Also since we
2299 cannot be sure that the contents will actually be filled in,
2300 we zero the allocated space. */
2301 rel_hdr
->contents
= (unsigned char *) bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2302 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2305 if (reldata
->hashes
== NULL
&& reldata
->count
)
2307 struct elf_link_hash_entry
**p
;
2309 p
= (struct elf_link_hash_entry
**)
2310 bfd_zmalloc (reldata
->count
* sizeof (struct elf_link_hash_entry
*));
2314 reldata
->hashes
= p
;
2320 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2321 originated from the section given by INPUT_REL_HDR) to the
2325 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2326 asection
*input_section
,
2327 Elf_Internal_Shdr
*input_rel_hdr
,
2328 Elf_Internal_Rela
*internal_relocs
,
2329 struct elf_link_hash_entry
**rel_hash
2332 Elf_Internal_Rela
*irela
;
2333 Elf_Internal_Rela
*irelaend
;
2335 struct bfd_elf_section_reloc_data
*output_reldata
;
2336 asection
*output_section
;
2337 const struct elf_backend_data
*bed
;
2338 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2339 struct bfd_elf_section_data
*esdo
;
2341 output_section
= input_section
->output_section
;
2343 bed
= get_elf_backend_data (output_bfd
);
2344 esdo
= elf_section_data (output_section
);
2345 if (esdo
->rel
.hdr
&& esdo
->rel
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2347 output_reldata
= &esdo
->rel
;
2348 swap_out
= bed
->s
->swap_reloc_out
;
2350 else if (esdo
->rela
.hdr
2351 && esdo
->rela
.hdr
->sh_entsize
== input_rel_hdr
->sh_entsize
)
2353 output_reldata
= &esdo
->rela
;
2354 swap_out
= bed
->s
->swap_reloca_out
;
2358 (*_bfd_error_handler
)
2359 (_("%B: relocation size mismatch in %B section %A"),
2360 output_bfd
, input_section
->owner
, input_section
);
2361 bfd_set_error (bfd_error_wrong_format
);
2365 erel
= output_reldata
->hdr
->contents
;
2366 erel
+= output_reldata
->count
* input_rel_hdr
->sh_entsize
;
2367 irela
= internal_relocs
;
2368 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2369 * bed
->s
->int_rels_per_ext_rel
);
2370 while (irela
< irelaend
)
2372 (*swap_out
) (output_bfd
, irela
, erel
);
2373 irela
+= bed
->s
->int_rels_per_ext_rel
;
2374 erel
+= input_rel_hdr
->sh_entsize
;
2377 /* Bump the counter, so that we know where to add the next set of
2379 output_reldata
->count
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2384 /* Make weak undefined symbols in PIE dynamic. */
2387 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info
*info
,
2388 struct elf_link_hash_entry
*h
)
2392 && h
->root
.type
== bfd_link_hash_undefweak
)
2393 return bfd_elf_link_record_dynamic_symbol (info
, h
);
2398 /* Fix up the flags for a symbol. This handles various cases which
2399 can only be fixed after all the input files are seen. This is
2400 currently called by both adjust_dynamic_symbol and
2401 assign_sym_version, which is unnecessary but perhaps more robust in
2402 the face of future changes. */
2405 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2406 struct elf_info_failed
*eif
)
2408 const struct elf_backend_data
*bed
;
2410 /* If this symbol was mentioned in a non-ELF file, try to set
2411 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2412 permit a non-ELF file to correctly refer to a symbol defined in
2413 an ELF dynamic object. */
2416 while (h
->root
.type
== bfd_link_hash_indirect
)
2417 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2419 if (h
->root
.type
!= bfd_link_hash_defined
2420 && h
->root
.type
!= bfd_link_hash_defweak
)
2423 h
->ref_regular_nonweak
= 1;
2427 if (h
->root
.u
.def
.section
->owner
!= NULL
2428 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2429 == bfd_target_elf_flavour
))
2432 h
->ref_regular_nonweak
= 1;
2438 if (h
->dynindx
== -1
2442 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2451 /* Unfortunately, NON_ELF is only correct if the symbol
2452 was first seen in a non-ELF file. Fortunately, if the symbol
2453 was first seen in an ELF file, we're probably OK unless the
2454 symbol was defined in a non-ELF file. Catch that case here.
2455 FIXME: We're still in trouble if the symbol was first seen in
2456 a dynamic object, and then later in a non-ELF regular object. */
2457 if ((h
->root
.type
== bfd_link_hash_defined
2458 || h
->root
.type
== bfd_link_hash_defweak
)
2460 && (h
->root
.u
.def
.section
->owner
!= NULL
2461 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2462 != bfd_target_elf_flavour
)
2463 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2464 && !h
->def_dynamic
)))
2468 /* Backend specific symbol fixup. */
2469 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2470 if (bed
->elf_backend_fixup_symbol
2471 && !(*bed
->elf_backend_fixup_symbol
) (eif
->info
, h
))
2474 /* If this is a final link, and the symbol was defined as a common
2475 symbol in a regular object file, and there was no definition in
2476 any dynamic object, then the linker will have allocated space for
2477 the symbol in a common section but the DEF_REGULAR
2478 flag will not have been set. */
2479 if (h
->root
.type
== bfd_link_hash_defined
2483 && (h
->root
.u
.def
.section
->owner
->flags
& (DYNAMIC
| BFD_PLUGIN
)) == 0)
2486 /* If -Bsymbolic was used (which means to bind references to global
2487 symbols to the definition within the shared object), and this
2488 symbol was defined in a regular object, then it actually doesn't
2489 need a PLT entry. Likewise, if the symbol has non-default
2490 visibility. If the symbol has hidden or internal visibility, we
2491 will force it local. */
2493 && eif
->info
->shared
2494 && is_elf_hash_table (eif
->info
->hash
)
2495 && (SYMBOLIC_BIND (eif
->info
, h
)
2496 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2499 bfd_boolean force_local
;
2501 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2502 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2503 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2506 /* If a weak undefined symbol has non-default visibility, we also
2507 hide it from the dynamic linker. */
2508 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2509 && h
->root
.type
== bfd_link_hash_undefweak
)
2510 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2512 /* If this is a weak defined symbol in a dynamic object, and we know
2513 the real definition in the dynamic object, copy interesting flags
2514 over to the real definition. */
2515 if (h
->u
.weakdef
!= NULL
)
2517 /* If the real definition is defined by a regular object file,
2518 don't do anything special. See the longer description in
2519 _bfd_elf_adjust_dynamic_symbol, below. */
2520 if (h
->u
.weakdef
->def_regular
)
2521 h
->u
.weakdef
= NULL
;
2524 struct elf_link_hash_entry
*weakdef
= h
->u
.weakdef
;
2526 while (h
->root
.type
== bfd_link_hash_indirect
)
2527 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2529 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2530 || h
->root
.type
== bfd_link_hash_defweak
);
2531 BFD_ASSERT (weakdef
->def_dynamic
);
2532 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2533 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2534 (*bed
->elf_backend_copy_indirect_symbol
) (eif
->info
, weakdef
, h
);
2541 /* Make the backend pick a good value for a dynamic symbol. This is
2542 called via elf_link_hash_traverse, and also calls itself
2546 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2548 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2550 const struct elf_backend_data
*bed
;
2552 if (! is_elf_hash_table (eif
->info
->hash
))
2555 /* Ignore indirect symbols. These are added by the versioning code. */
2556 if (h
->root
.type
== bfd_link_hash_indirect
)
2559 /* Fix the symbol flags. */
2560 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2563 /* If this symbol does not require a PLT entry, and it is not
2564 defined by a dynamic object, or is not referenced by a regular
2565 object, ignore it. We do have to handle a weak defined symbol,
2566 even if no regular object refers to it, if we decided to add it
2567 to the dynamic symbol table. FIXME: Do we normally need to worry
2568 about symbols which are defined by one dynamic object and
2569 referenced by another one? */
2571 && h
->type
!= STT_GNU_IFUNC
2575 && (h
->u
.weakdef
== NULL
|| h
->u
.weakdef
->dynindx
== -1))))
2577 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
2581 /* If we've already adjusted this symbol, don't do it again. This
2582 can happen via a recursive call. */
2583 if (h
->dynamic_adjusted
)
2586 /* Don't look at this symbol again. Note that we must set this
2587 after checking the above conditions, because we may look at a
2588 symbol once, decide not to do anything, and then get called
2589 recursively later after REF_REGULAR is set below. */
2590 h
->dynamic_adjusted
= 1;
2592 /* If this is a weak definition, and we know a real definition, and
2593 the real symbol is not itself defined by a regular object file,
2594 then get a good value for the real definition. We handle the
2595 real symbol first, for the convenience of the backend routine.
2597 Note that there is a confusing case here. If the real definition
2598 is defined by a regular object file, we don't get the real symbol
2599 from the dynamic object, but we do get the weak symbol. If the
2600 processor backend uses a COPY reloc, then if some routine in the
2601 dynamic object changes the real symbol, we will not see that
2602 change in the corresponding weak symbol. This is the way other
2603 ELF linkers work as well, and seems to be a result of the shared
2606 I will clarify this issue. Most SVR4 shared libraries define the
2607 variable _timezone and define timezone as a weak synonym. The
2608 tzset call changes _timezone. If you write
2609 extern int timezone;
2611 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2612 you might expect that, since timezone is a synonym for _timezone,
2613 the same number will print both times. However, if the processor
2614 backend uses a COPY reloc, then actually timezone will be copied
2615 into your process image, and, since you define _timezone
2616 yourself, _timezone will not. Thus timezone and _timezone will
2617 wind up at different memory locations. The tzset call will set
2618 _timezone, leaving timezone unchanged. */
2620 if (h
->u
.weakdef
!= NULL
)
2622 /* If we get to this point, there is an implicit reference to
2623 H->U.WEAKDEF by a regular object file via the weak symbol H. */
2624 h
->u
.weakdef
->ref_regular
= 1;
2626 /* Ensure that the backend adjust_dynamic_symbol function sees
2627 H->U.WEAKDEF before H by recursively calling ourselves. */
2628 if (! _bfd_elf_adjust_dynamic_symbol (h
->u
.weakdef
, eif
))
2632 /* If a symbol has no type and no size and does not require a PLT
2633 entry, then we are probably about to do the wrong thing here: we
2634 are probably going to create a COPY reloc for an empty object.
2635 This case can arise when a shared object is built with assembly
2636 code, and the assembly code fails to set the symbol type. */
2638 && h
->type
== STT_NOTYPE
2640 (*_bfd_error_handler
)
2641 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2642 h
->root
.root
.string
);
2644 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2645 bed
= get_elf_backend_data (dynobj
);
2647 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2656 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2660 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry
*h
,
2663 unsigned int power_of_two
;
2665 asection
*sec
= h
->root
.u
.def
.section
;
2667 /* The section aligment of definition is the maximum alignment
2668 requirement of symbols defined in the section. Since we don't
2669 know the symbol alignment requirement, we start with the
2670 maximum alignment and check low bits of the symbol address
2671 for the minimum alignment. */
2672 power_of_two
= bfd_get_section_alignment (sec
->owner
, sec
);
2673 mask
= ((bfd_vma
) 1 << power_of_two
) - 1;
2674 while ((h
->root
.u
.def
.value
& mask
) != 0)
2680 if (power_of_two
> bfd_get_section_alignment (dynbss
->owner
,
2683 /* Adjust the section alignment if needed. */
2684 if (! bfd_set_section_alignment (dynbss
->owner
, dynbss
,
2689 /* We make sure that the symbol will be aligned properly. */
2690 dynbss
->size
= BFD_ALIGN (dynbss
->size
, mask
+ 1);
2692 /* Define the symbol as being at this point in DYNBSS. */
2693 h
->root
.u
.def
.section
= dynbss
;
2694 h
->root
.u
.def
.value
= dynbss
->size
;
2696 /* Increment the size of DYNBSS to make room for the symbol. */
2697 dynbss
->size
+= h
->size
;
2702 /* Adjust all external symbols pointing into SEC_MERGE sections
2703 to reflect the object merging within the sections. */
2706 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2710 if ((h
->root
.type
== bfd_link_hash_defined
2711 || h
->root
.type
== bfd_link_hash_defweak
)
2712 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2713 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
2715 bfd
*output_bfd
= (bfd
*) data
;
2717 h
->root
.u
.def
.value
=
2718 _bfd_merged_section_offset (output_bfd
,
2719 &h
->root
.u
.def
.section
,
2720 elf_section_data (sec
)->sec_info
,
2721 h
->root
.u
.def
.value
);
2727 /* Returns false if the symbol referred to by H should be considered
2728 to resolve local to the current module, and true if it should be
2729 considered to bind dynamically. */
2732 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2733 struct bfd_link_info
*info
,
2734 bfd_boolean not_local_protected
)
2736 bfd_boolean binding_stays_local_p
;
2737 const struct elf_backend_data
*bed
;
2738 struct elf_link_hash_table
*hash_table
;
2743 while (h
->root
.type
== bfd_link_hash_indirect
2744 || h
->root
.type
== bfd_link_hash_warning
)
2745 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2747 /* If it was forced local, then clearly it's not dynamic. */
2748 if (h
->dynindx
== -1)
2750 if (h
->forced_local
)
2753 /* Identify the cases where name binding rules say that a
2754 visible symbol resolves locally. */
2755 binding_stays_local_p
= info
->executable
|| SYMBOLIC_BIND (info
, h
);
2757 switch (ELF_ST_VISIBILITY (h
->other
))
2764 hash_table
= elf_hash_table (info
);
2765 if (!is_elf_hash_table (hash_table
))
2768 bed
= get_elf_backend_data (hash_table
->dynobj
);
2770 /* Proper resolution for function pointer equality may require
2771 that these symbols perhaps be resolved dynamically, even though
2772 we should be resolving them to the current module. */
2773 if (!not_local_protected
|| !bed
->is_function_type (h
->type
))
2774 binding_stays_local_p
= TRUE
;
2781 /* If it isn't defined locally, then clearly it's dynamic. */
2782 if (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
2785 /* Otherwise, the symbol is dynamic if binding rules don't tell
2786 us that it remains local. */
2787 return !binding_stays_local_p
;
2790 /* Return true if the symbol referred to by H should be considered
2791 to resolve local to the current module, and false otherwise. Differs
2792 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2793 undefined symbols. The two functions are virtually identical except
2794 for the place where forced_local and dynindx == -1 are tested. If
2795 either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2796 the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2797 the symbol is local only for defined symbols.
2798 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2799 !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2800 treatment of undefined weak symbols. For those that do not make
2801 undefined weak symbols dynamic, both functions may return false. */
2804 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2805 struct bfd_link_info
*info
,
2806 bfd_boolean local_protected
)
2808 const struct elf_backend_data
*bed
;
2809 struct elf_link_hash_table
*hash_table
;
2811 /* If it's a local sym, of course we resolve locally. */
2815 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
2816 if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
2817 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
2820 /* Common symbols that become definitions don't get the DEF_REGULAR
2821 flag set, so test it first, and don't bail out. */
2822 if (ELF_COMMON_DEF_P (h
))
2824 /* If we don't have a definition in a regular file, then we can't
2825 resolve locally. The sym is either undefined or dynamic. */
2826 else if (!h
->def_regular
)
2829 /* Forced local symbols resolve locally. */
2830 if (h
->forced_local
)
2833 /* As do non-dynamic symbols. */
2834 if (h
->dynindx
== -1)
2837 /* At this point, we know the symbol is defined and dynamic. In an
2838 executable it must resolve locally, likewise when building symbolic
2839 shared libraries. */
2840 if (info
->executable
|| SYMBOLIC_BIND (info
, h
))
2843 /* Now deal with defined dynamic symbols in shared libraries. Ones
2844 with default visibility might not resolve locally. */
2845 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2848 hash_table
= elf_hash_table (info
);
2849 if (!is_elf_hash_table (hash_table
))
2852 bed
= get_elf_backend_data (hash_table
->dynobj
);
2854 /* STV_PROTECTED non-function symbols are local. */
2855 if (!bed
->is_function_type (h
->type
))
2858 /* Function pointer equality tests may require that STV_PROTECTED
2859 symbols be treated as dynamic symbols. If the address of a
2860 function not defined in an executable is set to that function's
2861 plt entry in the executable, then the address of the function in
2862 a shared library must also be the plt entry in the executable. */
2863 return local_protected
;
2866 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2867 aligned. Returns the first TLS output section. */
2869 struct bfd_section
*
2870 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
2872 struct bfd_section
*sec
, *tls
;
2873 unsigned int align
= 0;
2875 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2876 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
2880 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
2881 if (sec
->alignment_power
> align
)
2882 align
= sec
->alignment_power
;
2884 elf_hash_table (info
)->tls_sec
= tls
;
2886 /* Ensure the alignment of the first section is the largest alignment,
2887 so that the tls segment starts aligned. */
2889 tls
->alignment_power
= align
;
2894 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2896 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
2897 Elf_Internal_Sym
*sym
)
2899 const struct elf_backend_data
*bed
;
2901 /* Local symbols do not count, but target specific ones might. */
2902 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
2903 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
2906 bed
= get_elf_backend_data (abfd
);
2907 /* Function symbols do not count. */
2908 if (bed
->is_function_type (ELF_ST_TYPE (sym
->st_info
)))
2911 /* If the section is undefined, then so is the symbol. */
2912 if (sym
->st_shndx
== SHN_UNDEF
)
2915 /* If the symbol is defined in the common section, then
2916 it is a common definition and so does not count. */
2917 if (bed
->common_definition (sym
))
2920 /* If the symbol is in a target specific section then we
2921 must rely upon the backend to tell us what it is. */
2922 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
2923 /* FIXME - this function is not coded yet:
2925 return _bfd_is_global_symbol_definition (abfd, sym);
2927 Instead for now assume that the definition is not global,
2928 Even if this is wrong, at least the linker will behave
2929 in the same way that it used to do. */
2935 /* Search the symbol table of the archive element of the archive ABFD
2936 whose archive map contains a mention of SYMDEF, and determine if
2937 the symbol is defined in this element. */
2939 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
2941 Elf_Internal_Shdr
* hdr
;
2942 bfd_size_type symcount
;
2943 bfd_size_type extsymcount
;
2944 bfd_size_type extsymoff
;
2945 Elf_Internal_Sym
*isymbuf
;
2946 Elf_Internal_Sym
*isym
;
2947 Elf_Internal_Sym
*isymend
;
2950 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
2954 if (! bfd_check_format (abfd
, bfd_object
))
2957 /* If we have already included the element containing this symbol in the
2958 link then we do not need to include it again. Just claim that any symbol
2959 it contains is not a definition, so that our caller will not decide to
2960 (re)include this element. */
2961 if (abfd
->archive_pass
)
2964 /* Select the appropriate symbol table. */
2965 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
2966 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2968 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2970 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2972 /* The sh_info field of the symtab header tells us where the
2973 external symbols start. We don't care about the local symbols. */
2974 if (elf_bad_symtab (abfd
))
2976 extsymcount
= symcount
;
2981 extsymcount
= symcount
- hdr
->sh_info
;
2982 extsymoff
= hdr
->sh_info
;
2985 if (extsymcount
== 0)
2988 /* Read in the symbol table. */
2989 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
2991 if (isymbuf
== NULL
)
2994 /* Scan the symbol table looking for SYMDEF. */
2996 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
3000 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3005 if (strcmp (name
, symdef
->name
) == 0)
3007 result
= is_global_data_symbol_definition (abfd
, isym
);
3017 /* Add an entry to the .dynamic table. */
3020 _bfd_elf_add_dynamic_entry (struct bfd_link_info
*info
,
3024 struct elf_link_hash_table
*hash_table
;
3025 const struct elf_backend_data
*bed
;
3027 bfd_size_type newsize
;
3028 bfd_byte
*newcontents
;
3029 Elf_Internal_Dyn dyn
;
3031 hash_table
= elf_hash_table (info
);
3032 if (! is_elf_hash_table (hash_table
))
3035 bed
= get_elf_backend_data (hash_table
->dynobj
);
3036 s
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3037 BFD_ASSERT (s
!= NULL
);
3039 newsize
= s
->size
+ bed
->s
->sizeof_dyn
;
3040 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
3041 if (newcontents
== NULL
)
3045 dyn
.d_un
.d_val
= val
;
3046 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
, newcontents
+ s
->size
);
3049 s
->contents
= newcontents
;
3054 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3055 otherwise just check whether one already exists. Returns -1 on error,
3056 1 if a DT_NEEDED tag already exists, and 0 on success. */
3059 elf_add_dt_needed_tag (bfd
*abfd
,
3060 struct bfd_link_info
*info
,
3064 struct elf_link_hash_table
*hash_table
;
3065 bfd_size_type strindex
;
3067 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
3070 hash_table
= elf_hash_table (info
);
3071 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, soname
, FALSE
);
3072 if (strindex
== (bfd_size_type
) -1)
3075 if (_bfd_elf_strtab_refcount (hash_table
->dynstr
, strindex
) != 1)
3078 const struct elf_backend_data
*bed
;
3081 bed
= get_elf_backend_data (hash_table
->dynobj
);
3082 sdyn
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
3084 for (extdyn
= sdyn
->contents
;
3085 extdyn
< sdyn
->contents
+ sdyn
->size
;
3086 extdyn
+= bed
->s
->sizeof_dyn
)
3088 Elf_Internal_Dyn dyn
;
3090 bed
->s
->swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
3091 if (dyn
.d_tag
== DT_NEEDED
3092 && dyn
.d_un
.d_val
== strindex
)
3094 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3102 if (!_bfd_elf_link_create_dynamic_sections (hash_table
->dynobj
, info
))
3105 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
3109 /* We were just checking for existence of the tag. */
3110 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
3116 on_needed_list (const char *soname
, struct bfd_link_needed_list
*needed
)
3118 for (; needed
!= NULL
; needed
= needed
->next
)
3119 if (strcmp (soname
, needed
->name
) == 0)
3125 /* Sort symbol by value, section, and size. */
3127 elf_sort_symbol (const void *arg1
, const void *arg2
)
3129 const struct elf_link_hash_entry
*h1
;
3130 const struct elf_link_hash_entry
*h2
;
3131 bfd_signed_vma vdiff
;
3133 h1
= *(const struct elf_link_hash_entry
**) arg1
;
3134 h2
= *(const struct elf_link_hash_entry
**) arg2
;
3135 vdiff
= h1
->root
.u
.def
.value
- h2
->root
.u
.def
.value
;
3137 return vdiff
> 0 ? 1 : -1;
3140 long sdiff
= h1
->root
.u
.def
.section
->id
- h2
->root
.u
.def
.section
->id
;
3142 return sdiff
> 0 ? 1 : -1;
3144 vdiff
= h1
->size
- h2
->size
;
3145 return vdiff
== 0 ? 0 : vdiff
> 0 ? 1 : -1;
3148 /* This function is used to adjust offsets into .dynstr for
3149 dynamic symbols. This is called via elf_link_hash_traverse. */
3152 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
3154 struct elf_strtab_hash
*dynstr
= (struct elf_strtab_hash
*) data
;
3156 if (h
->dynindx
!= -1)
3157 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
3161 /* Assign string offsets in .dynstr, update all structures referencing
3165 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
3167 struct elf_link_hash_table
*hash_table
= elf_hash_table (info
);
3168 struct elf_link_local_dynamic_entry
*entry
;
3169 struct elf_strtab_hash
*dynstr
= hash_table
->dynstr
;
3170 bfd
*dynobj
= hash_table
->dynobj
;
3173 const struct elf_backend_data
*bed
;
3176 _bfd_elf_strtab_finalize (dynstr
);
3177 size
= _bfd_elf_strtab_size (dynstr
);
3179 bed
= get_elf_backend_data (dynobj
);
3180 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3181 BFD_ASSERT (sdyn
!= NULL
);
3183 /* Update all .dynamic entries referencing .dynstr strings. */
3184 for (extdyn
= sdyn
->contents
;
3185 extdyn
< sdyn
->contents
+ sdyn
->size
;
3186 extdyn
+= bed
->s
->sizeof_dyn
)
3188 Elf_Internal_Dyn dyn
;
3190 bed
->s
->swap_dyn_in (dynobj
, extdyn
, &dyn
);
3194 dyn
.d_un
.d_val
= size
;
3204 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
3209 bed
->s
->swap_dyn_out (dynobj
, &dyn
, extdyn
);
3212 /* Now update local dynamic symbols. */
3213 for (entry
= hash_table
->dynlocal
; entry
; entry
= entry
->next
)
3214 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
3215 entry
->isym
.st_name
);
3217 /* And the rest of dynamic symbols. */
3218 elf_link_hash_traverse (hash_table
, elf_adjust_dynstr_offsets
, dynstr
);
3220 /* Adjust version definitions. */
3221 if (elf_tdata (output_bfd
)->cverdefs
)
3226 Elf_Internal_Verdef def
;
3227 Elf_Internal_Verdaux defaux
;
3229 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
3233 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
3235 p
+= sizeof (Elf_External_Verdef
);
3236 if (def
.vd_aux
!= sizeof (Elf_External_Verdef
))
3238 for (i
= 0; i
< def
.vd_cnt
; ++i
)
3240 _bfd_elf_swap_verdaux_in (output_bfd
,
3241 (Elf_External_Verdaux
*) p
, &defaux
);
3242 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
3244 _bfd_elf_swap_verdaux_out (output_bfd
,
3245 &defaux
, (Elf_External_Verdaux
*) p
);
3246 p
+= sizeof (Elf_External_Verdaux
);
3249 while (def
.vd_next
);
3252 /* Adjust version references. */
3253 if (elf_tdata (output_bfd
)->verref
)
3258 Elf_Internal_Verneed need
;
3259 Elf_Internal_Vernaux needaux
;
3261 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
3265 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
3267 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
3268 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
3269 (Elf_External_Verneed
*) p
);
3270 p
+= sizeof (Elf_External_Verneed
);
3271 for (i
= 0; i
< need
.vn_cnt
; ++i
)
3273 _bfd_elf_swap_vernaux_in (output_bfd
,
3274 (Elf_External_Vernaux
*) p
, &needaux
);
3275 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
3277 _bfd_elf_swap_vernaux_out (output_bfd
,
3279 (Elf_External_Vernaux
*) p
);
3280 p
+= sizeof (Elf_External_Vernaux
);
3283 while (need
.vn_next
);
3289 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3290 The default is to only match when the INPUT and OUTPUT are exactly
3294 _bfd_elf_default_relocs_compatible (const bfd_target
*input
,
3295 const bfd_target
*output
)
3297 return input
== output
;
3300 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3301 This version is used when different targets for the same architecture
3302 are virtually identical. */
3305 _bfd_elf_relocs_compatible (const bfd_target
*input
,
3306 const bfd_target
*output
)
3308 const struct elf_backend_data
*obed
, *ibed
;
3310 if (input
== output
)
3313 ibed
= xvec_get_elf_backend_data (input
);
3314 obed
= xvec_get_elf_backend_data (output
);
3316 if (ibed
->arch
!= obed
->arch
)
3319 /* If both backends are using this function, deem them compatible. */
3320 return ibed
->relocs_compatible
== obed
->relocs_compatible
;
3323 /* Make a special call to the linker "notice" function to tell it that
3324 we are about to handle an as-needed lib, or have finished
3325 processing the lib. */
3328 _bfd_elf_notice_as_needed (bfd
*ibfd
,
3329 struct bfd_link_info
*info
,
3330 enum notice_asneeded_action act
)
3332 return (*info
->callbacks
->notice
) (info
, NULL
, ibfd
, NULL
, act
, 0, NULL
);
3335 /* Add symbols from an ELF object file to the linker hash table. */
3338 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3340 Elf_Internal_Ehdr
*ehdr
;
3341 Elf_Internal_Shdr
*hdr
;
3342 bfd_size_type symcount
;
3343 bfd_size_type extsymcount
;
3344 bfd_size_type extsymoff
;
3345 struct elf_link_hash_entry
**sym_hash
;
3346 bfd_boolean dynamic
;
3347 Elf_External_Versym
*extversym
= NULL
;
3348 Elf_External_Versym
*ever
;
3349 struct elf_link_hash_entry
*weaks
;
3350 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
3351 bfd_size_type nondeflt_vers_cnt
= 0;
3352 Elf_Internal_Sym
*isymbuf
= NULL
;
3353 Elf_Internal_Sym
*isym
;
3354 Elf_Internal_Sym
*isymend
;
3355 const struct elf_backend_data
*bed
;
3356 bfd_boolean add_needed
;
3357 struct elf_link_hash_table
*htab
;
3359 void *alloc_mark
= NULL
;
3360 struct bfd_hash_entry
**old_table
= NULL
;
3361 unsigned int old_size
= 0;
3362 unsigned int old_count
= 0;
3363 void *old_tab
= NULL
;
3365 struct bfd_link_hash_entry
*old_undefs
= NULL
;
3366 struct bfd_link_hash_entry
*old_undefs_tail
= NULL
;
3367 long old_dynsymcount
= 0;
3368 bfd_size_type old_dynstr_size
= 0;
3372 htab
= elf_hash_table (info
);
3373 bed
= get_elf_backend_data (abfd
);
3375 if ((abfd
->flags
& DYNAMIC
) == 0)
3381 /* You can't use -r against a dynamic object. Also, there's no
3382 hope of using a dynamic object which does not exactly match
3383 the format of the output file. */
3384 if (info
->relocatable
3385 || !is_elf_hash_table (htab
)
3386 || info
->output_bfd
->xvec
!= abfd
->xvec
)
3388 if (info
->relocatable
)
3389 bfd_set_error (bfd_error_invalid_operation
);
3391 bfd_set_error (bfd_error_wrong_format
);
3396 ehdr
= elf_elfheader (abfd
);
3397 if (info
->warn_alternate_em
3398 && bed
->elf_machine_code
!= ehdr
->e_machine
3399 && ((bed
->elf_machine_alt1
!= 0
3400 && ehdr
->e_machine
== bed
->elf_machine_alt1
)
3401 || (bed
->elf_machine_alt2
!= 0
3402 && ehdr
->e_machine
== bed
->elf_machine_alt2
)))
3403 info
->callbacks
->einfo
3404 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3405 ehdr
->e_machine
, abfd
, bed
->elf_machine_code
);
3407 /* As a GNU extension, any input sections which are named
3408 .gnu.warning.SYMBOL are treated as warning symbols for the given
3409 symbol. This differs from .gnu.warning sections, which generate
3410 warnings when they are included in an output file. */
3411 /* PR 12761: Also generate this warning when building shared libraries. */
3412 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3416 name
= bfd_get_section_name (abfd
, s
);
3417 if (CONST_STRNEQ (name
, ".gnu.warning."))
3422 name
+= sizeof ".gnu.warning." - 1;
3424 /* If this is a shared object, then look up the symbol
3425 in the hash table. If it is there, and it is already
3426 been defined, then we will not be using the entry
3427 from this shared object, so we don't need to warn.
3428 FIXME: If we see the definition in a regular object
3429 later on, we will warn, but we shouldn't. The only
3430 fix is to keep track of what warnings we are supposed
3431 to emit, and then handle them all at the end of the
3435 struct elf_link_hash_entry
*h
;
3437 h
= elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
3439 /* FIXME: What about bfd_link_hash_common? */
3441 && (h
->root
.type
== bfd_link_hash_defined
3442 || h
->root
.type
== bfd_link_hash_defweak
))
3447 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
3451 if (! bfd_get_section_contents (abfd
, s
, msg
, 0, sz
))
3456 if (! (_bfd_generic_link_add_one_symbol
3457 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
3458 FALSE
, bed
->collect
, NULL
)))
3461 if (!info
->relocatable
&& info
->executable
)
3463 /* Clobber the section size so that the warning does
3464 not get copied into the output file. */
3467 /* Also set SEC_EXCLUDE, so that symbols defined in
3468 the warning section don't get copied to the output. */
3469 s
->flags
|= SEC_EXCLUDE
;
3477 /* If we are creating a shared library, create all the dynamic
3478 sections immediately. We need to attach them to something,
3479 so we attach them to this BFD, provided it is the right
3480 format. FIXME: If there are no input BFD's of the same
3481 format as the output, we can't make a shared library. */
3483 && is_elf_hash_table (htab
)
3484 && info
->output_bfd
->xvec
== abfd
->xvec
3485 && !htab
->dynamic_sections_created
)
3487 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
3491 else if (!is_elf_hash_table (htab
))
3495 const char *soname
= NULL
;
3497 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
3500 /* ld --just-symbols and dynamic objects don't mix very well.
3501 ld shouldn't allow it. */
3502 if ((s
= abfd
->sections
) != NULL
3503 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
3506 /* If this dynamic lib was specified on the command line with
3507 --as-needed in effect, then we don't want to add a DT_NEEDED
3508 tag unless the lib is actually used. Similary for libs brought
3509 in by another lib's DT_NEEDED. When --no-add-needed is used
3510 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3511 any dynamic library in DT_NEEDED tags in the dynamic lib at
3513 add_needed
= (elf_dyn_lib_class (abfd
)
3514 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
3515 | DYN_NO_NEEDED
)) == 0;
3517 s
= bfd_get_section_by_name (abfd
, ".dynamic");
3522 unsigned int elfsec
;
3523 unsigned long shlink
;
3525 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
3532 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
3533 if (elfsec
== SHN_BAD
)
3534 goto error_free_dyn
;
3535 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
3537 for (extdyn
= dynbuf
;
3538 extdyn
< dynbuf
+ s
->size
;
3539 extdyn
+= bed
->s
->sizeof_dyn
)
3541 Elf_Internal_Dyn dyn
;
3543 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
3544 if (dyn
.d_tag
== DT_SONAME
)
3546 unsigned int tagv
= dyn
.d_un
.d_val
;
3547 soname
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3549 goto error_free_dyn
;
3551 if (dyn
.d_tag
== DT_NEEDED
)
3553 struct bfd_link_needed_list
*n
, **pn
;
3555 unsigned int tagv
= dyn
.d_un
.d_val
;
3557 amt
= sizeof (struct bfd_link_needed_list
);
3558 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3559 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3560 if (n
== NULL
|| fnm
== NULL
)
3561 goto error_free_dyn
;
3562 amt
= strlen (fnm
) + 1;
3563 anm
= (char *) bfd_alloc (abfd
, amt
);
3565 goto error_free_dyn
;
3566 memcpy (anm
, fnm
, amt
);
3570 for (pn
= &htab
->needed
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3574 if (dyn
.d_tag
== DT_RUNPATH
)
3576 struct bfd_link_needed_list
*n
, **pn
;
3578 unsigned int tagv
= dyn
.d_un
.d_val
;
3580 amt
= sizeof (struct bfd_link_needed_list
);
3581 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3582 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3583 if (n
== NULL
|| fnm
== NULL
)
3584 goto error_free_dyn
;
3585 amt
= strlen (fnm
) + 1;
3586 anm
= (char *) bfd_alloc (abfd
, amt
);
3588 goto error_free_dyn
;
3589 memcpy (anm
, fnm
, amt
);
3593 for (pn
= & runpath
;
3599 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3600 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
3602 struct bfd_link_needed_list
*n
, **pn
;
3604 unsigned int tagv
= dyn
.d_un
.d_val
;
3606 amt
= sizeof (struct bfd_link_needed_list
);
3607 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
3608 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3609 if (n
== NULL
|| fnm
== NULL
)
3610 goto error_free_dyn
;
3611 amt
= strlen (fnm
) + 1;
3612 anm
= (char *) bfd_alloc (abfd
, amt
);
3614 goto error_free_dyn
;
3615 memcpy (anm
, fnm
, amt
);
3625 if (dyn
.d_tag
== DT_AUDIT
)
3627 unsigned int tagv
= dyn
.d_un
.d_val
;
3628 audit
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3635 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3636 frees all more recently bfd_alloc'd blocks as well. */
3642 struct bfd_link_needed_list
**pn
;
3643 for (pn
= &htab
->runpath
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3648 /* We do not want to include any of the sections in a dynamic
3649 object in the output file. We hack by simply clobbering the
3650 list of sections in the BFD. This could be handled more
3651 cleanly by, say, a new section flag; the existing
3652 SEC_NEVER_LOAD flag is not the one we want, because that one
3653 still implies that the section takes up space in the output
3655 bfd_section_list_clear (abfd
);
3657 /* Find the name to use in a DT_NEEDED entry that refers to this
3658 object. If the object has a DT_SONAME entry, we use it.
3659 Otherwise, if the generic linker stuck something in
3660 elf_dt_name, we use that. Otherwise, we just use the file
3662 if (soname
== NULL
|| *soname
== '\0')
3664 soname
= elf_dt_name (abfd
);
3665 if (soname
== NULL
|| *soname
== '\0')
3666 soname
= bfd_get_filename (abfd
);
3669 /* Save the SONAME because sometimes the linker emulation code
3670 will need to know it. */
3671 elf_dt_name (abfd
) = soname
;
3673 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
3677 /* If we have already included this dynamic object in the
3678 link, just ignore it. There is no reason to include a
3679 particular dynamic object more than once. */
3683 /* Save the DT_AUDIT entry for the linker emulation code. */
3684 elf_dt_audit (abfd
) = audit
;
3687 /* If this is a dynamic object, we always link against the .dynsym
3688 symbol table, not the .symtab symbol table. The dynamic linker
3689 will only see the .dynsym symbol table, so there is no reason to
3690 look at .symtab for a dynamic object. */
3692 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
3693 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3695 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3697 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
3699 /* The sh_info field of the symtab header tells us where the
3700 external symbols start. We don't care about the local symbols at
3702 if (elf_bad_symtab (abfd
))
3704 extsymcount
= symcount
;
3709 extsymcount
= symcount
- hdr
->sh_info
;
3710 extsymoff
= hdr
->sh_info
;
3713 sym_hash
= elf_sym_hashes (abfd
);
3714 if (extsymcount
!= 0)
3716 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3718 if (isymbuf
== NULL
)
3721 if (sym_hash
== NULL
)
3723 /* We store a pointer to the hash table entry for each
3725 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3726 sym_hash
= (struct elf_link_hash_entry
**) bfd_zalloc (abfd
, amt
);
3727 if (sym_hash
== NULL
)
3728 goto error_free_sym
;
3729 elf_sym_hashes (abfd
) = sym_hash
;
3735 /* Read in any version definitions. */
3736 if (!_bfd_elf_slurp_version_tables (abfd
,
3737 info
->default_imported_symver
))
3738 goto error_free_sym
;
3740 /* Read in the symbol versions, but don't bother to convert them
3741 to internal format. */
3742 if (elf_dynversym (abfd
) != 0)
3744 Elf_Internal_Shdr
*versymhdr
;
3746 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
3747 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
3748 if (extversym
== NULL
)
3749 goto error_free_sym
;
3750 amt
= versymhdr
->sh_size
;
3751 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
3752 || bfd_bread (extversym
, amt
, abfd
) != amt
)
3753 goto error_free_vers
;
3757 /* If we are loading an as-needed shared lib, save the symbol table
3758 state before we start adding symbols. If the lib turns out
3759 to be unneeded, restore the state. */
3760 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
3765 for (entsize
= 0, i
= 0; i
< htab
->root
.table
.size
; i
++)
3767 struct bfd_hash_entry
*p
;
3768 struct elf_link_hash_entry
*h
;
3770 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3772 h
= (struct elf_link_hash_entry
*) p
;
3773 entsize
+= htab
->root
.table
.entsize
;
3774 if (h
->root
.type
== bfd_link_hash_warning
)
3775 entsize
+= htab
->root
.table
.entsize
;
3779 tabsize
= htab
->root
.table
.size
* sizeof (struct bfd_hash_entry
*);
3780 old_tab
= bfd_malloc (tabsize
+ entsize
);
3781 if (old_tab
== NULL
)
3782 goto error_free_vers
;
3784 /* Remember the current objalloc pointer, so that all mem for
3785 symbols added can later be reclaimed. */
3786 alloc_mark
= bfd_hash_allocate (&htab
->root
.table
, 1);
3787 if (alloc_mark
== NULL
)
3788 goto error_free_vers
;
3790 /* Make a special call to the linker "notice" function to
3791 tell it that we are about to handle an as-needed lib. */
3792 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_as_needed
))
3793 goto error_free_vers
;
3795 /* Clone the symbol table. Remember some pointers into the
3796 symbol table, and dynamic symbol count. */
3797 old_ent
= (char *) old_tab
+ tabsize
;
3798 memcpy (old_tab
, htab
->root
.table
.table
, tabsize
);
3799 old_undefs
= htab
->root
.undefs
;
3800 old_undefs_tail
= htab
->root
.undefs_tail
;
3801 old_table
= htab
->root
.table
.table
;
3802 old_size
= htab
->root
.table
.size
;
3803 old_count
= htab
->root
.table
.count
;
3804 old_dynsymcount
= htab
->dynsymcount
;
3805 old_dynstr_size
= _bfd_elf_strtab_size (htab
->dynstr
);
3807 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
3809 struct bfd_hash_entry
*p
;
3810 struct elf_link_hash_entry
*h
;
3812 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3814 memcpy (old_ent
, p
, htab
->root
.table
.entsize
);
3815 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3816 h
= (struct elf_link_hash_entry
*) p
;
3817 if (h
->root
.type
== bfd_link_hash_warning
)
3819 memcpy (old_ent
, h
->root
.u
.i
.link
, htab
->root
.table
.entsize
);
3820 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3827 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
3828 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
3830 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
3834 asection
*sec
, *new_sec
;
3837 struct elf_link_hash_entry
*h
;
3838 struct elf_link_hash_entry
*hi
;
3839 bfd_boolean definition
;
3840 bfd_boolean size_change_ok
;
3841 bfd_boolean type_change_ok
;
3842 bfd_boolean new_weakdef
;
3843 bfd_boolean new_weak
;
3844 bfd_boolean old_weak
;
3845 bfd_boolean override
;
3847 unsigned int old_alignment
;
3852 flags
= BSF_NO_FLAGS
;
3854 value
= isym
->st_value
;
3855 common
= bed
->common_definition (isym
);
3857 bind
= ELF_ST_BIND (isym
->st_info
);
3861 /* This should be impossible, since ELF requires that all
3862 global symbols follow all local symbols, and that sh_info
3863 point to the first global symbol. Unfortunately, Irix 5
3868 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
3876 case STB_GNU_UNIQUE
:
3877 flags
= BSF_GNU_UNIQUE
;
3881 /* Leave it up to the processor backend. */
3885 if (isym
->st_shndx
== SHN_UNDEF
)
3886 sec
= bfd_und_section_ptr
;
3887 else if (isym
->st_shndx
== SHN_ABS
)
3888 sec
= bfd_abs_section_ptr
;
3889 else if (isym
->st_shndx
== SHN_COMMON
)
3891 sec
= bfd_com_section_ptr
;
3892 /* What ELF calls the size we call the value. What ELF
3893 calls the value we call the alignment. */
3894 value
= isym
->st_size
;
3898 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3900 sec
= bfd_abs_section_ptr
;
3901 else if (discarded_section (sec
))
3903 /* Symbols from discarded section are undefined. We keep
3905 sec
= bfd_und_section_ptr
;
3906 isym
->st_shndx
= SHN_UNDEF
;
3908 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
3912 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3915 goto error_free_vers
;
3917 if (isym
->st_shndx
== SHN_COMMON
3918 && (abfd
->flags
& BFD_PLUGIN
) != 0)
3920 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
3924 flagword sflags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
3926 xc
= bfd_make_section_with_flags (abfd
, "COMMON", sflags
);
3928 goto error_free_vers
;
3932 else if (isym
->st_shndx
== SHN_COMMON
3933 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
3934 && !info
->relocatable
)
3936 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
3940 flagword sflags
= (SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_IS_COMMON
3941 | SEC_LINKER_CREATED
);
3942 tcomm
= bfd_make_section_with_flags (abfd
, ".tcommon", sflags
);
3944 goto error_free_vers
;
3948 else if (bed
->elf_add_symbol_hook
)
3950 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
3952 goto error_free_vers
;
3954 /* The hook function sets the name to NULL if this symbol
3955 should be skipped for some reason. */
3960 /* Sanity check that all possibilities were handled. */
3963 bfd_set_error (bfd_error_bad_value
);
3964 goto error_free_vers
;
3967 /* Silently discard TLS symbols from --just-syms. There's
3968 no way to combine a static TLS block with a new TLS block
3969 for this executable. */
3970 if (ELF_ST_TYPE (isym
->st_info
) == STT_TLS
3971 && sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
3974 if (bfd_is_und_section (sec
)
3975 || bfd_is_com_section (sec
))
3980 size_change_ok
= FALSE
;
3981 type_change_ok
= bed
->type_change_ok
;
3987 if (is_elf_hash_table (htab
))
3989 Elf_Internal_Versym iver
;
3990 unsigned int vernum
= 0;
3995 if (info
->default_imported_symver
)
3996 /* Use the default symbol version created earlier. */
3997 iver
.vs_vers
= elf_tdata (abfd
)->cverdefs
;
4002 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
4004 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
4006 /* If this is a hidden symbol, or if it is not version
4007 1, we append the version name to the symbol name.
4008 However, we do not modify a non-hidden absolute symbol
4009 if it is not a function, because it might be the version
4010 symbol itself. FIXME: What if it isn't? */
4011 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
4013 && (!bfd_is_abs_section (sec
)
4014 || bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
)))))
4017 size_t namelen
, verlen
, newlen
;
4020 if (isym
->st_shndx
!= SHN_UNDEF
)
4022 if (vernum
> elf_tdata (abfd
)->cverdefs
)
4024 else if (vernum
> 1)
4026 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
4032 (*_bfd_error_handler
)
4033 (_("%B: %s: invalid version %u (max %d)"),
4035 elf_tdata (abfd
)->cverdefs
);
4036 bfd_set_error (bfd_error_bad_value
);
4037 goto error_free_vers
;
4042 /* We cannot simply test for the number of
4043 entries in the VERNEED section since the
4044 numbers for the needed versions do not start
4046 Elf_Internal_Verneed
*t
;
4049 for (t
= elf_tdata (abfd
)->verref
;
4053 Elf_Internal_Vernaux
*a
;
4055 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
4057 if (a
->vna_other
== vernum
)
4059 verstr
= a
->vna_nodename
;
4068 (*_bfd_error_handler
)
4069 (_("%B: %s: invalid needed version %d"),
4070 abfd
, name
, vernum
);
4071 bfd_set_error (bfd_error_bad_value
);
4072 goto error_free_vers
;
4076 namelen
= strlen (name
);
4077 verlen
= strlen (verstr
);
4078 newlen
= namelen
+ verlen
+ 2;
4079 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4080 && isym
->st_shndx
!= SHN_UNDEF
)
4083 newname
= (char *) bfd_hash_allocate (&htab
->root
.table
, newlen
);
4084 if (newname
== NULL
)
4085 goto error_free_vers
;
4086 memcpy (newname
, name
, namelen
);
4087 p
= newname
+ namelen
;
4089 /* If this is a defined non-hidden version symbol,
4090 we add another @ to the name. This indicates the
4091 default version of the symbol. */
4092 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
4093 && isym
->st_shndx
!= SHN_UNDEF
)
4095 memcpy (p
, verstr
, verlen
+ 1);
4100 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
, &value
,
4101 sym_hash
, &old_bfd
, &old_weak
,
4102 &old_alignment
, &skip
, &override
,
4103 &type_change_ok
, &size_change_ok
))
4104 goto error_free_vers
;
4113 while (h
->root
.type
== bfd_link_hash_indirect
4114 || h
->root
.type
== bfd_link_hash_warning
)
4115 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4117 if (elf_tdata (abfd
)->verdef
!= NULL
4120 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
4123 if (! (_bfd_generic_link_add_one_symbol
4124 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
4125 (struct bfd_link_hash_entry
**) sym_hash
)))
4126 goto error_free_vers
;
4129 /* We need to make sure that indirect symbol dynamic flags are
4132 while (h
->root
.type
== bfd_link_hash_indirect
4133 || h
->root
.type
== bfd_link_hash_warning
)
4134 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4138 new_weak
= (flags
& BSF_WEAK
) != 0;
4139 new_weakdef
= FALSE
;
4143 && !bed
->is_function_type (ELF_ST_TYPE (isym
->st_info
))
4144 && is_elf_hash_table (htab
)
4145 && h
->u
.weakdef
== NULL
)
4147 /* Keep a list of all weak defined non function symbols from
4148 a dynamic object, using the weakdef field. Later in this
4149 function we will set the weakdef field to the correct
4150 value. We only put non-function symbols from dynamic
4151 objects on this list, because that happens to be the only
4152 time we need to know the normal symbol corresponding to a
4153 weak symbol, and the information is time consuming to
4154 figure out. If the weakdef field is not already NULL,
4155 then this symbol was already defined by some previous
4156 dynamic object, and we will be using that previous
4157 definition anyhow. */
4159 h
->u
.weakdef
= weaks
;
4164 /* Set the alignment of a common symbol. */
4165 if ((common
|| bfd_is_com_section (sec
))
4166 && h
->root
.type
== bfd_link_hash_common
)
4171 align
= bfd_log2 (isym
->st_value
);
4174 /* The new symbol is a common symbol in a shared object.
4175 We need to get the alignment from the section. */
4176 align
= new_sec
->alignment_power
;
4178 if (align
> old_alignment
)
4179 h
->root
.u
.c
.p
->alignment_power
= align
;
4181 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
4184 if (is_elf_hash_table (htab
))
4186 /* Set a flag in the hash table entry indicating the type of
4187 reference or definition we just found. A dynamic symbol
4188 is one which is referenced or defined by both a regular
4189 object and a shared object. */
4190 bfd_boolean dynsym
= FALSE
;
4192 /* Plugin symbols aren't normal. Don't set def_regular or
4193 ref_regular for them, or make them dynamic. */
4194 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
4201 if (bind
!= STB_WEAK
)
4202 h
->ref_regular_nonweak
= 1;
4214 /* If the indirect symbol has been forced local, don't
4215 make the real symbol dynamic. */
4216 if ((h
== hi
|| !hi
->forced_local
)
4217 && (! info
->executable
4227 hi
->ref_dynamic
= 1;
4232 hi
->def_dynamic
= 1;
4235 /* If the indirect symbol has been forced local, don't
4236 make the real symbol dynamic. */
4237 if ((h
== hi
|| !hi
->forced_local
)
4240 || (h
->u
.weakdef
!= NULL
4242 && h
->u
.weakdef
->dynindx
!= -1)))
4246 /* Check to see if we need to add an indirect symbol for
4247 the default name. */
4249 || (!override
&& h
->root
.type
== bfd_link_hash_common
))
4250 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
4251 sec
, value
, &old_bfd
, &dynsym
))
4252 goto error_free_vers
;
4254 /* Check the alignment when a common symbol is involved. This
4255 can change when a common symbol is overridden by a normal
4256 definition or a common symbol is ignored due to the old
4257 normal definition. We need to make sure the maximum
4258 alignment is maintained. */
4259 if ((old_alignment
|| common
)
4260 && h
->root
.type
!= bfd_link_hash_common
)
4262 unsigned int common_align
;
4263 unsigned int normal_align
;
4264 unsigned int symbol_align
;
4268 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
4269 || h
->root
.type
== bfd_link_hash_defweak
);
4271 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
4272 if (h
->root
.u
.def
.section
->owner
!= NULL
4273 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
4275 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
4276 if (normal_align
> symbol_align
)
4277 normal_align
= symbol_align
;
4280 normal_align
= symbol_align
;
4284 common_align
= old_alignment
;
4285 common_bfd
= old_bfd
;
4290 common_align
= bfd_log2 (isym
->st_value
);
4292 normal_bfd
= old_bfd
;
4295 if (normal_align
< common_align
)
4297 /* PR binutils/2735 */
4298 if (normal_bfd
== NULL
)
4299 (*_bfd_error_handler
)
4300 (_("Warning: alignment %u of common symbol `%s' in %B is"
4301 " greater than the alignment (%u) of its section %A"),
4302 common_bfd
, h
->root
.u
.def
.section
,
4303 1 << common_align
, name
, 1 << normal_align
);
4305 (*_bfd_error_handler
)
4306 (_("Warning: alignment %u of symbol `%s' in %B"
4307 " is smaller than %u in %B"),
4308 normal_bfd
, common_bfd
,
4309 1 << normal_align
, name
, 1 << common_align
);
4313 /* Remember the symbol size if it isn't undefined. */
4314 if (isym
->st_size
!= 0
4315 && isym
->st_shndx
!= SHN_UNDEF
4316 && (definition
|| h
->size
== 0))
4319 && h
->size
!= isym
->st_size
4320 && ! size_change_ok
)
4321 (*_bfd_error_handler
)
4322 (_("Warning: size of symbol `%s' changed"
4323 " from %lu in %B to %lu in %B"),
4325 name
, (unsigned long) h
->size
,
4326 (unsigned long) isym
->st_size
);
4328 h
->size
= isym
->st_size
;
4331 /* If this is a common symbol, then we always want H->SIZE
4332 to be the size of the common symbol. The code just above
4333 won't fix the size if a common symbol becomes larger. We
4334 don't warn about a size change here, because that is
4335 covered by --warn-common. Allow changes between different
4337 if (h
->root
.type
== bfd_link_hash_common
)
4338 h
->size
= h
->root
.u
.c
.size
;
4340 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
4341 && ((definition
&& !new_weak
)
4342 || (old_weak
&& h
->root
.type
== bfd_link_hash_common
)
4343 || h
->type
== STT_NOTYPE
))
4345 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
4347 /* Turn an IFUNC symbol from a DSO into a normal FUNC
4349 if (type
== STT_GNU_IFUNC
4350 && (abfd
->flags
& DYNAMIC
) != 0)
4353 if (h
->type
!= type
)
4355 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
4356 (*_bfd_error_handler
)
4357 (_("Warning: type of symbol `%s' changed"
4358 " from %d to %d in %B"),
4359 abfd
, name
, h
->type
, type
);
4365 /* Merge st_other field. */
4366 elf_merge_st_other (abfd
, h
, isym
, definition
, dynamic
);
4368 /* We don't want to make debug symbol dynamic. */
4369 if (definition
&& (sec
->flags
& SEC_DEBUGGING
) && !info
->relocatable
)
4372 /* Nor should we make plugin symbols dynamic. */
4373 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
4378 h
->target_internal
= isym
->st_target_internal
;
4379 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
4382 if (definition
&& !dynamic
)
4384 char *p
= strchr (name
, ELF_VER_CHR
);
4385 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
4387 /* Queue non-default versions so that .symver x, x@FOO
4388 aliases can be checked. */
4391 amt
= ((isymend
- isym
+ 1)
4392 * sizeof (struct elf_link_hash_entry
*));
4394 (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4396 goto error_free_vers
;
4398 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
4402 if (dynsym
&& h
->dynindx
== -1)
4404 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4405 goto error_free_vers
;
4406 if (h
->u
.weakdef
!= NULL
4408 && h
->u
.weakdef
->dynindx
== -1)
4410 if (!bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
4411 goto error_free_vers
;
4414 else if (dynsym
&& h
->dynindx
!= -1)
4415 /* If the symbol already has a dynamic index, but
4416 visibility says it should not be visible, turn it into
4418 switch (ELF_ST_VISIBILITY (h
->other
))
4422 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
4427 /* Don't add DT_NEEDED for references from the dummy bfd. */
4431 && h
->ref_regular_nonweak
4433 || (old_bfd
->flags
& BFD_PLUGIN
) == 0))
4434 || (h
->ref_dynamic_nonweak
4435 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0
4436 && !on_needed_list (elf_dt_name (abfd
), htab
->needed
))))
4439 const char *soname
= elf_dt_name (abfd
);
4441 /* A symbol from a library loaded via DT_NEEDED of some
4442 other library is referenced by a regular object.
4443 Add a DT_NEEDED entry for it. Issue an error if
4444 --no-add-needed is used and the reference was not
4447 && (elf_dyn_lib_class (abfd
) & DYN_NO_NEEDED
) != 0)
4449 (*_bfd_error_handler
)
4450 (_("%B: undefined reference to symbol '%s'"),
4452 bfd_set_error (bfd_error_missing_dso
);
4453 goto error_free_vers
;
4456 elf_dyn_lib_class (abfd
) = (enum dynamic_lib_link_class
)
4457 (elf_dyn_lib_class (abfd
) & ~DYN_AS_NEEDED
);
4460 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
4462 goto error_free_vers
;
4464 BFD_ASSERT (ret
== 0);
4469 if (extversym
!= NULL
)
4475 if (isymbuf
!= NULL
)
4481 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4485 /* Restore the symbol table. */
4486 old_ent
= (char *) old_tab
+ tabsize
;
4487 memset (elf_sym_hashes (abfd
), 0,
4488 extsymcount
* sizeof (struct elf_link_hash_entry
*));
4489 htab
->root
.table
.table
= old_table
;
4490 htab
->root
.table
.size
= old_size
;
4491 htab
->root
.table
.count
= old_count
;
4492 memcpy (htab
->root
.table
.table
, old_tab
, tabsize
);
4493 htab
->root
.undefs
= old_undefs
;
4494 htab
->root
.undefs_tail
= old_undefs_tail
;
4495 _bfd_elf_strtab_restore_size (htab
->dynstr
, old_dynstr_size
);
4496 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4498 struct bfd_hash_entry
*p
;
4499 struct elf_link_hash_entry
*h
;
4501 unsigned int alignment_power
;
4503 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4505 h
= (struct elf_link_hash_entry
*) p
;
4506 if (h
->root
.type
== bfd_link_hash_warning
)
4507 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4508 if (h
->dynindx
>= old_dynsymcount
4509 && h
->dynstr_index
< old_dynstr_size
)
4510 _bfd_elf_strtab_delref (htab
->dynstr
, h
->dynstr_index
);
4512 /* Preserve the maximum alignment and size for common
4513 symbols even if this dynamic lib isn't on DT_NEEDED
4514 since it can still be loaded at run time by another
4516 if (h
->root
.type
== bfd_link_hash_common
)
4518 size
= h
->root
.u
.c
.size
;
4519 alignment_power
= h
->root
.u
.c
.p
->alignment_power
;
4524 alignment_power
= 0;
4526 memcpy (p
, old_ent
, htab
->root
.table
.entsize
);
4527 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4528 h
= (struct elf_link_hash_entry
*) p
;
4529 if (h
->root
.type
== bfd_link_hash_warning
)
4531 memcpy (h
->root
.u
.i
.link
, old_ent
, htab
->root
.table
.entsize
);
4532 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4533 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4535 if (h
->root
.type
== bfd_link_hash_common
)
4537 if (size
> h
->root
.u
.c
.size
)
4538 h
->root
.u
.c
.size
= size
;
4539 if (alignment_power
> h
->root
.u
.c
.p
->alignment_power
)
4540 h
->root
.u
.c
.p
->alignment_power
= alignment_power
;
4545 /* Make a special call to the linker "notice" function to
4546 tell it that symbols added for crefs may need to be removed. */
4547 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_not_needed
))
4548 goto error_free_vers
;
4551 objalloc_free_block ((struct objalloc
*) htab
->root
.table
.memory
,
4553 if (nondeflt_vers
!= NULL
)
4554 free (nondeflt_vers
);
4558 if (old_tab
!= NULL
)
4560 if (!(*bed
->notice_as_needed
) (abfd
, info
, notice_needed
))
4561 goto error_free_vers
;
4566 /* Now that all the symbols from this input file are created, handle
4567 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4568 if (nondeflt_vers
!= NULL
)
4570 bfd_size_type cnt
, symidx
;
4572 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
4574 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
4575 char *shortname
, *p
;
4577 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
4579 || (h
->root
.type
!= bfd_link_hash_defined
4580 && h
->root
.type
!= bfd_link_hash_defweak
))
4583 amt
= p
- h
->root
.root
.string
;
4584 shortname
= (char *) bfd_malloc (amt
+ 1);
4586 goto error_free_vers
;
4587 memcpy (shortname
, h
->root
.root
.string
, amt
);
4588 shortname
[amt
] = '\0';
4590 hi
= (struct elf_link_hash_entry
*)
4591 bfd_link_hash_lookup (&htab
->root
, shortname
,
4592 FALSE
, FALSE
, FALSE
);
4594 && hi
->root
.type
== h
->root
.type
4595 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
4596 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
4598 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
4599 hi
->root
.type
= bfd_link_hash_indirect
;
4600 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
4601 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
4602 sym_hash
= elf_sym_hashes (abfd
);
4604 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
4605 if (sym_hash
[symidx
] == hi
)
4607 sym_hash
[symidx
] = h
;
4613 free (nondeflt_vers
);
4614 nondeflt_vers
= NULL
;
4617 /* Now set the weakdefs field correctly for all the weak defined
4618 symbols we found. The only way to do this is to search all the
4619 symbols. Since we only need the information for non functions in
4620 dynamic objects, that's the only time we actually put anything on
4621 the list WEAKS. We need this information so that if a regular
4622 object refers to a symbol defined weakly in a dynamic object, the
4623 real symbol in the dynamic object is also put in the dynamic
4624 symbols; we also must arrange for both symbols to point to the
4625 same memory location. We could handle the general case of symbol
4626 aliasing, but a general symbol alias can only be generated in
4627 assembler code, handling it correctly would be very time
4628 consuming, and other ELF linkers don't handle general aliasing
4632 struct elf_link_hash_entry
**hpp
;
4633 struct elf_link_hash_entry
**hppend
;
4634 struct elf_link_hash_entry
**sorted_sym_hash
;
4635 struct elf_link_hash_entry
*h
;
4638 /* Since we have to search the whole symbol list for each weak
4639 defined symbol, search time for N weak defined symbols will be
4640 O(N^2). Binary search will cut it down to O(NlogN). */
4641 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4642 sorted_sym_hash
= (struct elf_link_hash_entry
**) bfd_malloc (amt
);
4643 if (sorted_sym_hash
== NULL
)
4645 sym_hash
= sorted_sym_hash
;
4646 hpp
= elf_sym_hashes (abfd
);
4647 hppend
= hpp
+ extsymcount
;
4649 for (; hpp
< hppend
; hpp
++)
4653 && h
->root
.type
== bfd_link_hash_defined
4654 && !bed
->is_function_type (h
->type
))
4662 qsort (sorted_sym_hash
, sym_count
,
4663 sizeof (struct elf_link_hash_entry
*),
4666 while (weaks
!= NULL
)
4668 struct elf_link_hash_entry
*hlook
;
4671 size_t i
, j
, idx
= 0;
4674 weaks
= hlook
->u
.weakdef
;
4675 hlook
->u
.weakdef
= NULL
;
4677 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4678 || hlook
->root
.type
== bfd_link_hash_defweak
4679 || hlook
->root
.type
== bfd_link_hash_common
4680 || hlook
->root
.type
== bfd_link_hash_indirect
);
4681 slook
= hlook
->root
.u
.def
.section
;
4682 vlook
= hlook
->root
.u
.def
.value
;
4688 bfd_signed_vma vdiff
;
4690 h
= sorted_sym_hash
[idx
];
4691 vdiff
= vlook
- h
->root
.u
.def
.value
;
4698 long sdiff
= slook
->id
- h
->root
.u
.def
.section
->id
;
4708 /* We didn't find a value/section match. */
4712 /* With multiple aliases, or when the weak symbol is already
4713 strongly defined, we have multiple matching symbols and
4714 the binary search above may land on any of them. Step
4715 one past the matching symbol(s). */
4718 h
= sorted_sym_hash
[idx
];
4719 if (h
->root
.u
.def
.section
!= slook
4720 || h
->root
.u
.def
.value
!= vlook
)
4724 /* Now look back over the aliases. Since we sorted by size
4725 as well as value and section, we'll choose the one with
4726 the largest size. */
4729 h
= sorted_sym_hash
[idx
];
4731 /* Stop if value or section doesn't match. */
4732 if (h
->root
.u
.def
.section
!= slook
4733 || h
->root
.u
.def
.value
!= vlook
)
4735 else if (h
!= hlook
)
4737 hlook
->u
.weakdef
= h
;
4739 /* If the weak definition is in the list of dynamic
4740 symbols, make sure the real definition is put
4742 if (hlook
->dynindx
!= -1 && h
->dynindx
== -1)
4744 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4747 free (sorted_sym_hash
);
4752 /* If the real definition is in the list of dynamic
4753 symbols, make sure the weak definition is put
4754 there as well. If we don't do this, then the
4755 dynamic loader might not merge the entries for the
4756 real definition and the weak definition. */
4757 if (h
->dynindx
!= -1 && hlook
->dynindx
== -1)
4759 if (! bfd_elf_link_record_dynamic_symbol (info
, hlook
))
4760 goto err_free_sym_hash
;
4767 free (sorted_sym_hash
);
4770 if (bed
->check_directives
4771 && !(*bed
->check_directives
) (abfd
, info
))
4774 /* If this object is the same format as the output object, and it is
4775 not a shared library, then let the backend look through the
4778 This is required to build global offset table entries and to
4779 arrange for dynamic relocs. It is not required for the
4780 particular common case of linking non PIC code, even when linking
4781 against shared libraries, but unfortunately there is no way of
4782 knowing whether an object file has been compiled PIC or not.
4783 Looking through the relocs is not particularly time consuming.
4784 The problem is that we must either (1) keep the relocs in memory,
4785 which causes the linker to require additional runtime memory or
4786 (2) read the relocs twice from the input file, which wastes time.
4787 This would be a good case for using mmap.
4789 I have no idea how to handle linking PIC code into a file of a
4790 different format. It probably can't be done. */
4792 && is_elf_hash_table (htab
)
4793 && bed
->check_relocs
!= NULL
4794 && elf_object_id (abfd
) == elf_hash_table_id (htab
)
4795 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
4799 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4801 Elf_Internal_Rela
*internal_relocs
;
4804 if ((o
->flags
& SEC_RELOC
) == 0
4805 || o
->reloc_count
== 0
4806 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
4807 && (o
->flags
& SEC_DEBUGGING
) != 0)
4808 || bfd_is_abs_section (o
->output_section
))
4811 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
4813 if (internal_relocs
== NULL
)
4816 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
4818 if (elf_section_data (o
)->relocs
!= internal_relocs
)
4819 free (internal_relocs
);
4826 /* If this is a non-traditional link, try to optimize the handling
4827 of the .stab/.stabstr sections. */
4829 && ! info
->traditional_format
4830 && is_elf_hash_table (htab
)
4831 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
4835 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
4836 if (stabstr
!= NULL
)
4838 bfd_size_type string_offset
= 0;
4841 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
4842 if (CONST_STRNEQ (stab
->name
, ".stab")
4843 && (!stab
->name
[5] ||
4844 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
4845 && (stab
->flags
& SEC_MERGE
) == 0
4846 && !bfd_is_abs_section (stab
->output_section
))
4848 struct bfd_elf_section_data
*secdata
;
4850 secdata
= elf_section_data (stab
);
4851 if (! _bfd_link_section_stabs (abfd
, &htab
->stab_info
, stab
,
4852 stabstr
, &secdata
->sec_info
,
4855 if (secdata
->sec_info
)
4856 stab
->sec_info_type
= SEC_INFO_TYPE_STABS
;
4861 if (is_elf_hash_table (htab
) && add_needed
)
4863 /* Add this bfd to the loaded list. */
4864 struct elf_link_loaded_list
*n
;
4866 n
= (struct elf_link_loaded_list
*)
4867 bfd_alloc (abfd
, sizeof (struct elf_link_loaded_list
));
4871 n
->next
= htab
->loaded
;
4878 if (old_tab
!= NULL
)
4880 if (nondeflt_vers
!= NULL
)
4881 free (nondeflt_vers
);
4882 if (extversym
!= NULL
)
4885 if (isymbuf
!= NULL
)
4891 /* Return the linker hash table entry of a symbol that might be
4892 satisfied by an archive symbol. Return -1 on error. */
4894 struct elf_link_hash_entry
*
4895 _bfd_elf_archive_symbol_lookup (bfd
*abfd
,
4896 struct bfd_link_info
*info
,
4899 struct elf_link_hash_entry
*h
;
4903 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, TRUE
);
4907 /* If this is a default version (the name contains @@), look up the
4908 symbol again with only one `@' as well as without the version.
4909 The effect is that references to the symbol with and without the
4910 version will be matched by the default symbol in the archive. */
4912 p
= strchr (name
, ELF_VER_CHR
);
4913 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
4916 /* First check with only one `@'. */
4917 len
= strlen (name
);
4918 copy
= (char *) bfd_alloc (abfd
, len
);
4920 return (struct elf_link_hash_entry
*) 0 - 1;
4922 first
= p
- name
+ 1;
4923 memcpy (copy
, name
, first
);
4924 memcpy (copy
+ first
, name
+ first
+ 1, len
- first
);
4926 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
, FALSE
, FALSE
, TRUE
);
4929 /* We also need to check references to the symbol without the
4931 copy
[first
- 1] = '\0';
4932 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
4933 FALSE
, FALSE
, TRUE
);
4936 bfd_release (abfd
, copy
);
4940 /* Add symbols from an ELF archive file to the linker hash table. We
4941 don't use _bfd_generic_link_add_archive_symbols because of a
4942 problem which arises on UnixWare. The UnixWare libc.so is an
4943 archive which includes an entry libc.so.1 which defines a bunch of
4944 symbols. The libc.so archive also includes a number of other
4945 object files, which also define symbols, some of which are the same
4946 as those defined in libc.so.1. Correct linking requires that we
4947 consider each object file in turn, and include it if it defines any
4948 symbols we need. _bfd_generic_link_add_archive_symbols does not do
4949 this; it looks through the list of undefined symbols, and includes
4950 any object file which defines them. When this algorithm is used on
4951 UnixWare, it winds up pulling in libc.so.1 early and defining a
4952 bunch of symbols. This means that some of the other objects in the
4953 archive are not included in the link, which is incorrect since they
4954 precede libc.so.1 in the archive.
4956 Fortunately, ELF archive handling is simpler than that done by
4957 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4958 oddities. In ELF, if we find a symbol in the archive map, and the
4959 symbol is currently undefined, we know that we must pull in that
4962 Unfortunately, we do have to make multiple passes over the symbol
4963 table until nothing further is resolved. */
4966 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4969 bfd_boolean
*defined
= NULL
;
4970 bfd_boolean
*included
= NULL
;
4974 const struct elf_backend_data
*bed
;
4975 struct elf_link_hash_entry
* (*archive_symbol_lookup
)
4976 (bfd
*, struct bfd_link_info
*, const char *);
4978 if (! bfd_has_map (abfd
))
4980 /* An empty archive is a special case. */
4981 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
4983 bfd_set_error (bfd_error_no_armap
);
4987 /* Keep track of all symbols we know to be already defined, and all
4988 files we know to be already included. This is to speed up the
4989 second and subsequent passes. */
4990 c
= bfd_ardata (abfd
)->symdef_count
;
4994 amt
*= sizeof (bfd_boolean
);
4995 defined
= (bfd_boolean
*) bfd_zmalloc (amt
);
4996 included
= (bfd_boolean
*) bfd_zmalloc (amt
);
4997 if (defined
== NULL
|| included
== NULL
)
5000 symdefs
= bfd_ardata (abfd
)->symdefs
;
5001 bed
= get_elf_backend_data (abfd
);
5002 archive_symbol_lookup
= bed
->elf_backend_archive_symbol_lookup
;
5015 symdefend
= symdef
+ c
;
5016 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
5018 struct elf_link_hash_entry
*h
;
5020 struct bfd_link_hash_entry
*undefs_tail
;
5023 if (defined
[i
] || included
[i
])
5025 if (symdef
->file_offset
== last
)
5031 h
= archive_symbol_lookup (abfd
, info
, symdef
->name
);
5032 if (h
== (struct elf_link_hash_entry
*) 0 - 1)
5038 if (h
->root
.type
== bfd_link_hash_common
)
5040 /* We currently have a common symbol. The archive map contains
5041 a reference to this symbol, so we may want to include it. We
5042 only want to include it however, if this archive element
5043 contains a definition of the symbol, not just another common
5046 Unfortunately some archivers (including GNU ar) will put
5047 declarations of common symbols into their archive maps, as
5048 well as real definitions, so we cannot just go by the archive
5049 map alone. Instead we must read in the element's symbol
5050 table and check that to see what kind of symbol definition
5052 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
5055 else if (h
->root
.type
!= bfd_link_hash_undefined
)
5057 if (h
->root
.type
!= bfd_link_hash_undefweak
)
5062 /* We need to include this archive member. */
5063 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
5064 if (element
== NULL
)
5067 if (! bfd_check_format (element
, bfd_object
))
5070 /* Doublecheck that we have not included this object
5071 already--it should be impossible, but there may be
5072 something wrong with the archive. */
5073 if (element
->archive_pass
!= 0)
5075 bfd_set_error (bfd_error_bad_value
);
5078 element
->archive_pass
= 1;
5080 undefs_tail
= info
->hash
->undefs_tail
;
5082 if (!(*info
->callbacks
5083 ->add_archive_element
) (info
, element
, symdef
->name
, &element
))
5085 if (!bfd_link_add_symbols (element
, info
))
5088 /* If there are any new undefined symbols, we need to make
5089 another pass through the archive in order to see whether
5090 they can be defined. FIXME: This isn't perfect, because
5091 common symbols wind up on undefs_tail and because an
5092 undefined symbol which is defined later on in this pass
5093 does not require another pass. This isn't a bug, but it
5094 does make the code less efficient than it could be. */
5095 if (undefs_tail
!= info
->hash
->undefs_tail
)
5098 /* Look backward to mark all symbols from this object file
5099 which we have already seen in this pass. */
5103 included
[mark
] = TRUE
;
5108 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
5110 /* We mark subsequent symbols from this object file as we go
5111 on through the loop. */
5112 last
= symdef
->file_offset
;
5123 if (defined
!= NULL
)
5125 if (included
!= NULL
)
5130 /* Given an ELF BFD, add symbols to the global hash table as
5134 bfd_elf_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5136 switch (bfd_get_format (abfd
))
5139 return elf_link_add_object_symbols (abfd
, info
);
5141 return elf_link_add_archive_symbols (abfd
, info
);
5143 bfd_set_error (bfd_error_wrong_format
);
5148 struct hash_codes_info
5150 unsigned long *hashcodes
;
5154 /* This function will be called though elf_link_hash_traverse to store
5155 all hash value of the exported symbols in an array. */
5158 elf_collect_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5160 struct hash_codes_info
*inf
= (struct hash_codes_info
*) data
;
5166 /* Ignore indirect symbols. These are added by the versioning code. */
5167 if (h
->dynindx
== -1)
5170 name
= h
->root
.root
.string
;
5171 p
= strchr (name
, ELF_VER_CHR
);
5174 alc
= (char *) bfd_malloc (p
- name
+ 1);
5180 memcpy (alc
, name
, p
- name
);
5181 alc
[p
- name
] = '\0';
5185 /* Compute the hash value. */
5186 ha
= bfd_elf_hash (name
);
5188 /* Store the found hash value in the array given as the argument. */
5189 *(inf
->hashcodes
)++ = ha
;
5191 /* And store it in the struct so that we can put it in the hash table
5193 h
->u
.elf_hash_value
= ha
;
5201 struct collect_gnu_hash_codes
5204 const struct elf_backend_data
*bed
;
5205 unsigned long int nsyms
;
5206 unsigned long int maskbits
;
5207 unsigned long int *hashcodes
;
5208 unsigned long int *hashval
;
5209 unsigned long int *indx
;
5210 unsigned long int *counts
;
5213 long int min_dynindx
;
5214 unsigned long int bucketcount
;
5215 unsigned long int symindx
;
5216 long int local_indx
;
5217 long int shift1
, shift2
;
5218 unsigned long int mask
;
5222 /* This function will be called though elf_link_hash_traverse to store
5223 all hash value of the exported symbols in an array. */
5226 elf_collect_gnu_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
5228 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5234 /* Ignore indirect symbols. These are added by the versioning code. */
5235 if (h
->dynindx
== -1)
5238 /* Ignore also local symbols and undefined symbols. */
5239 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5242 name
= h
->root
.root
.string
;
5243 p
= strchr (name
, ELF_VER_CHR
);
5246 alc
= (char *) bfd_malloc (p
- name
+ 1);
5252 memcpy (alc
, name
, p
- name
);
5253 alc
[p
- name
] = '\0';
5257 /* Compute the hash value. */
5258 ha
= bfd_elf_gnu_hash (name
);
5260 /* Store the found hash value in the array for compute_bucket_count,
5261 and also for .dynsym reordering purposes. */
5262 s
->hashcodes
[s
->nsyms
] = ha
;
5263 s
->hashval
[h
->dynindx
] = ha
;
5265 if (s
->min_dynindx
< 0 || s
->min_dynindx
> h
->dynindx
)
5266 s
->min_dynindx
= h
->dynindx
;
5274 /* This function will be called though elf_link_hash_traverse to do
5275 final dynaminc symbol renumbering. */
5278 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry
*h
, void *data
)
5280 struct collect_gnu_hash_codes
*s
= (struct collect_gnu_hash_codes
*) data
;
5281 unsigned long int bucket
;
5282 unsigned long int val
;
5284 /* Ignore indirect symbols. */
5285 if (h
->dynindx
== -1)
5288 /* Ignore also local symbols and undefined symbols. */
5289 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5291 if (h
->dynindx
>= s
->min_dynindx
)
5292 h
->dynindx
= s
->local_indx
++;
5296 bucket
= s
->hashval
[h
->dynindx
] % s
->bucketcount
;
5297 val
= (s
->hashval
[h
->dynindx
] >> s
->shift1
)
5298 & ((s
->maskbits
>> s
->shift1
) - 1);
5299 s
->bitmask
[val
] |= ((bfd_vma
) 1) << (s
->hashval
[h
->dynindx
] & s
->mask
);
5301 |= ((bfd_vma
) 1) << ((s
->hashval
[h
->dynindx
] >> s
->shift2
) & s
->mask
);
5302 val
= s
->hashval
[h
->dynindx
] & ~(unsigned long int) 1;
5303 if (s
->counts
[bucket
] == 1)
5304 /* Last element terminates the chain. */
5306 bfd_put_32 (s
->output_bfd
, val
,
5307 s
->contents
+ (s
->indx
[bucket
] - s
->symindx
) * 4);
5308 --s
->counts
[bucket
];
5309 h
->dynindx
= s
->indx
[bucket
]++;
5313 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5316 _bfd_elf_hash_symbol (struct elf_link_hash_entry
*h
)
5318 return !(h
->forced_local
5319 || h
->root
.type
== bfd_link_hash_undefined
5320 || h
->root
.type
== bfd_link_hash_undefweak
5321 || ((h
->root
.type
== bfd_link_hash_defined
5322 || h
->root
.type
== bfd_link_hash_defweak
)
5323 && h
->root
.u
.def
.section
->output_section
== NULL
));
5326 /* Array used to determine the number of hash table buckets to use
5327 based on the number of symbols there are. If there are fewer than
5328 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5329 fewer than 37 we use 17 buckets, and so forth. We never use more
5330 than 32771 buckets. */
5332 static const size_t elf_buckets
[] =
5334 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5338 /* Compute bucket count for hashing table. We do not use a static set
5339 of possible tables sizes anymore. Instead we determine for all
5340 possible reasonable sizes of the table the outcome (i.e., the
5341 number of collisions etc) and choose the best solution. The
5342 weighting functions are not too simple to allow the table to grow
5343 without bounds. Instead one of the weighting factors is the size.
5344 Therefore the result is always a good payoff between few collisions
5345 (= short chain lengths) and table size. */
5347 compute_bucket_count (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5348 unsigned long int *hashcodes ATTRIBUTE_UNUSED
,
5349 unsigned long int nsyms
,
5352 size_t best_size
= 0;
5353 unsigned long int i
;
5355 /* We have a problem here. The following code to optimize the table
5356 size requires an integer type with more the 32 bits. If
5357 BFD_HOST_U_64_BIT is set we know about such a type. */
5358 #ifdef BFD_HOST_U_64_BIT
5363 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
5364 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
5365 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5366 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
5367 unsigned long int *counts
;
5369 unsigned int no_improvement_count
= 0;
5371 /* Possible optimization parameters: if we have NSYMS symbols we say
5372 that the hashing table must at least have NSYMS/4 and at most
5374 minsize
= nsyms
/ 4;
5377 best_size
= maxsize
= nsyms
* 2;
5382 if ((best_size
& 31) == 0)
5386 /* Create array where we count the collisions in. We must use bfd_malloc
5387 since the size could be large. */
5389 amt
*= sizeof (unsigned long int);
5390 counts
= (unsigned long int *) bfd_malloc (amt
);
5394 /* Compute the "optimal" size for the hash table. The criteria is a
5395 minimal chain length. The minor criteria is (of course) the size
5397 for (i
= minsize
; i
< maxsize
; ++i
)
5399 /* Walk through the array of hashcodes and count the collisions. */
5400 BFD_HOST_U_64_BIT max
;
5401 unsigned long int j
;
5402 unsigned long int fact
;
5404 if (gnu_hash
&& (i
& 31) == 0)
5407 memset (counts
, '\0', i
* sizeof (unsigned long int));
5409 /* Determine how often each hash bucket is used. */
5410 for (j
= 0; j
< nsyms
; ++j
)
5411 ++counts
[hashcodes
[j
] % i
];
5413 /* For the weight function we need some information about the
5414 pagesize on the target. This is information need not be 100%
5415 accurate. Since this information is not available (so far) we
5416 define it here to a reasonable default value. If it is crucial
5417 to have a better value some day simply define this value. */
5418 # ifndef BFD_TARGET_PAGESIZE
5419 # define BFD_TARGET_PAGESIZE (4096)
5422 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5424 max
= (2 + dynsymcount
) * bed
->s
->sizeof_hash_entry
;
5427 /* Variant 1: optimize for short chains. We add the squares
5428 of all the chain lengths (which favors many small chain
5429 over a few long chains). */
5430 for (j
= 0; j
< i
; ++j
)
5431 max
+= counts
[j
] * counts
[j
];
5433 /* This adds penalties for the overall size of the table. */
5434 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5437 /* Variant 2: Optimize a lot more for small table. Here we
5438 also add squares of the size but we also add penalties for
5439 empty slots (the +1 term). */
5440 for (j
= 0; j
< i
; ++j
)
5441 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
5443 /* The overall size of the table is considered, but not as
5444 strong as in variant 1, where it is squared. */
5445 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5449 /* Compare with current best results. */
5450 if (max
< best_chlen
)
5454 no_improvement_count
= 0;
5456 /* PR 11843: Avoid futile long searches for the best bucket size
5457 when there are a large number of symbols. */
5458 else if (++no_improvement_count
== 100)
5465 #endif /* defined (BFD_HOST_U_64_BIT) */
5467 /* This is the fallback solution if no 64bit type is available or if we
5468 are not supposed to spend much time on optimizations. We select the
5469 bucket count using a fixed set of numbers. */
5470 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5472 best_size
= elf_buckets
[i
];
5473 if (nsyms
< elf_buckets
[i
+ 1])
5476 if (gnu_hash
&& best_size
< 2)
5483 /* Size any SHT_GROUP section for ld -r. */
5486 _bfd_elf_size_group_sections (struct bfd_link_info
*info
)
5490 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
5491 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
5492 && !_bfd_elf_fixup_group_sections (ibfd
, bfd_abs_section_ptr
))
5497 /* Set a default stack segment size. The value in INFO wins. If it
5498 is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5499 undefined it is initialized. */
5502 bfd_elf_stack_segment_size (bfd
*output_bfd
,
5503 struct bfd_link_info
*info
,
5504 const char *legacy_symbol
,
5505 bfd_vma default_size
)
5507 struct elf_link_hash_entry
*h
= NULL
;
5509 /* Look for legacy symbol. */
5511 h
= elf_link_hash_lookup (elf_hash_table (info
), legacy_symbol
,
5512 FALSE
, FALSE
, FALSE
);
5513 if (h
&& (h
->root
.type
== bfd_link_hash_defined
5514 || h
->root
.type
== bfd_link_hash_defweak
)
5516 && (h
->type
== STT_NOTYPE
|| h
->type
== STT_OBJECT
))
5518 /* The symbol has no type if specified on the command line. */
5519 h
->type
= STT_OBJECT
;
5520 if (info
->stacksize
)
5521 (*_bfd_error_handler
) (_("%B: stack size specified and %s set"),
5522 output_bfd
, legacy_symbol
);
5523 else if (h
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
5524 (*_bfd_error_handler
) (_("%B: %s not absolute"),
5525 output_bfd
, legacy_symbol
);
5527 info
->stacksize
= h
->root
.u
.def
.value
;
5530 if (!info
->stacksize
)
5531 /* If the user didn't set a size, or explicitly inhibit the
5532 size, set it now. */
5533 info
->stacksize
= default_size
;
5535 /* Provide the legacy symbol, if it is referenced. */
5536 if (h
&& (h
->root
.type
== bfd_link_hash_undefined
5537 || h
->root
.type
== bfd_link_hash_undefweak
))
5539 struct bfd_link_hash_entry
*bh
= NULL
;
5541 if (!(_bfd_generic_link_add_one_symbol
5542 (info
, output_bfd
, legacy_symbol
,
5543 BSF_GLOBAL
, bfd_abs_section_ptr
,
5544 info
->stacksize
>= 0 ? info
->stacksize
: 0,
5545 NULL
, FALSE
, get_elf_backend_data (output_bfd
)->collect
, &bh
)))
5548 h
= (struct elf_link_hash_entry
*) bh
;
5550 h
->type
= STT_OBJECT
;
5556 /* Set up the sizes and contents of the ELF dynamic sections. This is
5557 called by the ELF linker emulation before_allocation routine. We
5558 must set the sizes of the sections before the linker sets the
5559 addresses of the various sections. */
5562 bfd_elf_size_dynamic_sections (bfd
*output_bfd
,
5565 const char *filter_shlib
,
5567 const char *depaudit
,
5568 const char * const *auxiliary_filters
,
5569 struct bfd_link_info
*info
,
5570 asection
**sinterpptr
)
5572 bfd_size_type soname_indx
;
5574 const struct elf_backend_data
*bed
;
5575 struct elf_info_failed asvinfo
;
5579 soname_indx
= (bfd_size_type
) -1;
5581 if (!is_elf_hash_table (info
->hash
))
5584 bed
= get_elf_backend_data (output_bfd
);
5586 /* Any syms created from now on start with -1 in
5587 got.refcount/offset and plt.refcount/offset. */
5588 elf_hash_table (info
)->init_got_refcount
5589 = elf_hash_table (info
)->init_got_offset
;
5590 elf_hash_table (info
)->init_plt_refcount
5591 = elf_hash_table (info
)->init_plt_offset
;
5593 if (info
->relocatable
5594 && !_bfd_elf_size_group_sections (info
))
5597 /* The backend may have to create some sections regardless of whether
5598 we're dynamic or not. */
5599 if (bed
->elf_backend_always_size_sections
5600 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
5603 /* Determine any GNU_STACK segment requirements, after the backend
5604 has had a chance to set a default segment size. */
5605 if (info
->execstack
)
5606 elf_stack_flags (output_bfd
) = PF_R
| PF_W
| PF_X
;
5607 else if (info
->noexecstack
)
5608 elf_stack_flags (output_bfd
) = PF_R
| PF_W
;
5612 asection
*notesec
= NULL
;
5615 for (inputobj
= info
->input_bfds
;
5617 inputobj
= inputobj
->link_next
)
5622 & (DYNAMIC
| EXEC_P
| BFD_PLUGIN
| BFD_LINKER_CREATED
))
5624 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
5627 if (s
->flags
& SEC_CODE
)
5631 else if (bed
->default_execstack
)
5634 if (notesec
|| info
->stacksize
> 0)
5635 elf_stack_flags (output_bfd
) = PF_R
| PF_W
| exec
;
5636 if (notesec
&& exec
&& info
->relocatable
5637 && notesec
->output_section
!= bfd_abs_section_ptr
)
5638 notesec
->output_section
->flags
|= SEC_CODE
;
5641 dynobj
= elf_hash_table (info
)->dynobj
;
5643 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
5645 struct elf_info_failed eif
;
5646 struct elf_link_hash_entry
*h
;
5648 struct bfd_elf_version_tree
*t
;
5649 struct bfd_elf_version_expr
*d
;
5651 bfd_boolean all_defined
;
5653 *sinterpptr
= bfd_get_linker_section (dynobj
, ".interp");
5654 BFD_ASSERT (*sinterpptr
!= NULL
|| !info
->executable
);
5658 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5660 if (soname_indx
== (bfd_size_type
) -1
5661 || !_bfd_elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
5667 if (!_bfd_elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
5669 info
->flags
|= DF_SYMBOLIC
;
5677 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5679 if (indx
== (bfd_size_type
) -1)
5682 tag
= info
->new_dtags
? DT_RUNPATH
: DT_RPATH
;
5683 if (!_bfd_elf_add_dynamic_entry (info
, tag
, indx
))
5687 if (filter_shlib
!= NULL
)
5691 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5692 filter_shlib
, TRUE
);
5693 if (indx
== (bfd_size_type
) -1
5694 || !_bfd_elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
5698 if (auxiliary_filters
!= NULL
)
5700 const char * const *p
;
5702 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
5706 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5708 if (indx
== (bfd_size_type
) -1
5709 || !_bfd_elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
5718 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, audit
,
5720 if (indx
== (bfd_size_type
) -1
5721 || !_bfd_elf_add_dynamic_entry (info
, DT_AUDIT
, indx
))
5725 if (depaudit
!= NULL
)
5729 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, depaudit
,
5731 if (indx
== (bfd_size_type
) -1
5732 || !_bfd_elf_add_dynamic_entry (info
, DT_DEPAUDIT
, indx
))
5739 /* If we are supposed to export all symbols into the dynamic symbol
5740 table (this is not the normal case), then do so. */
5741 if (info
->export_dynamic
5742 || (info
->executable
&& info
->dynamic
))
5744 elf_link_hash_traverse (elf_hash_table (info
),
5745 _bfd_elf_export_symbol
,
5751 /* Make all global versions with definition. */
5752 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
5753 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5754 if (!d
->symver
&& d
->literal
)
5756 const char *verstr
, *name
;
5757 size_t namelen
, verlen
, newlen
;
5758 char *newname
, *p
, leading_char
;
5759 struct elf_link_hash_entry
*newh
;
5761 leading_char
= bfd_get_symbol_leading_char (output_bfd
);
5763 namelen
= strlen (name
) + (leading_char
!= '\0');
5765 verlen
= strlen (verstr
);
5766 newlen
= namelen
+ verlen
+ 3;
5768 newname
= (char *) bfd_malloc (newlen
);
5769 if (newname
== NULL
)
5771 newname
[0] = leading_char
;
5772 memcpy (newname
+ (leading_char
!= '\0'), name
, namelen
);
5774 /* Check the hidden versioned definition. */
5775 p
= newname
+ namelen
;
5777 memcpy (p
, verstr
, verlen
+ 1);
5778 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5779 newname
, FALSE
, FALSE
,
5782 || (newh
->root
.type
!= bfd_link_hash_defined
5783 && newh
->root
.type
!= bfd_link_hash_defweak
))
5785 /* Check the default versioned definition. */
5787 memcpy (p
, verstr
, verlen
+ 1);
5788 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5789 newname
, FALSE
, FALSE
,
5794 /* Mark this version if there is a definition and it is
5795 not defined in a shared object. */
5797 && !newh
->def_dynamic
5798 && (newh
->root
.type
== bfd_link_hash_defined
5799 || newh
->root
.type
== bfd_link_hash_defweak
))
5803 /* Attach all the symbols to their version information. */
5804 asvinfo
.info
= info
;
5805 asvinfo
.failed
= FALSE
;
5807 elf_link_hash_traverse (elf_hash_table (info
),
5808 _bfd_elf_link_assign_sym_version
,
5813 if (!info
->allow_undefined_version
)
5815 /* Check if all global versions have a definition. */
5817 for (t
= info
->version_info
; t
!= NULL
; t
= t
->next
)
5818 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5819 if (d
->literal
&& !d
->symver
&& !d
->script
)
5821 (*_bfd_error_handler
)
5822 (_("%s: undefined version: %s"),
5823 d
->pattern
, t
->name
);
5824 all_defined
= FALSE
;
5829 bfd_set_error (bfd_error_bad_value
);
5834 /* Find all symbols which were defined in a dynamic object and make
5835 the backend pick a reasonable value for them. */
5836 elf_link_hash_traverse (elf_hash_table (info
),
5837 _bfd_elf_adjust_dynamic_symbol
,
5842 /* Add some entries to the .dynamic section. We fill in some of the
5843 values later, in bfd_elf_final_link, but we must add the entries
5844 now so that we know the final size of the .dynamic section. */
5846 /* If there are initialization and/or finalization functions to
5847 call then add the corresponding DT_INIT/DT_FINI entries. */
5848 h
= (info
->init_function
5849 ? elf_link_hash_lookup (elf_hash_table (info
),
5850 info
->init_function
, FALSE
,
5857 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT
, 0))
5860 h
= (info
->fini_function
5861 ? elf_link_hash_lookup (elf_hash_table (info
),
5862 info
->fini_function
, FALSE
,
5869 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI
, 0))
5873 s
= bfd_get_section_by_name (output_bfd
, ".preinit_array");
5874 if (s
!= NULL
&& s
->linker_has_input
)
5876 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5877 if (! info
->executable
)
5882 for (sub
= info
->input_bfds
; sub
!= NULL
;
5883 sub
= sub
->link_next
)
5884 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
)
5885 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5886 if (elf_section_data (o
)->this_hdr
.sh_type
5887 == SHT_PREINIT_ARRAY
)
5889 (*_bfd_error_handler
)
5890 (_("%B: .preinit_array section is not allowed in DSO"),
5895 bfd_set_error (bfd_error_nonrepresentable_section
);
5899 if (!_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
5900 || !_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
5903 s
= bfd_get_section_by_name (output_bfd
, ".init_array");
5904 if (s
!= NULL
&& s
->linker_has_input
)
5906 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
5907 || !_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
5910 s
= bfd_get_section_by_name (output_bfd
, ".fini_array");
5911 if (s
!= NULL
&& s
->linker_has_input
)
5913 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
5914 || !_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
5918 dynstr
= bfd_get_linker_section (dynobj
, ".dynstr");
5919 /* If .dynstr is excluded from the link, we don't want any of
5920 these tags. Strictly, we should be checking each section
5921 individually; This quick check covers for the case where
5922 someone does a /DISCARD/ : { *(*) }. */
5923 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
5925 bfd_size_type strsize
;
5927 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
5928 if ((info
->emit_hash
5929 && !_bfd_elf_add_dynamic_entry (info
, DT_HASH
, 0))
5930 || (info
->emit_gnu_hash
5931 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_HASH
, 0))
5932 || !_bfd_elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5933 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5934 || !_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5935 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMENT
,
5936 bed
->s
->sizeof_sym
))
5941 /* The backend must work out the sizes of all the other dynamic
5944 && bed
->elf_backend_size_dynamic_sections
!= NULL
5945 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5948 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
5951 if (dynobj
!= NULL
&& elf_hash_table (info
)->dynamic_sections_created
)
5953 unsigned long section_sym_count
;
5954 struct bfd_elf_version_tree
*verdefs
;
5957 /* Set up the version definition section. */
5958 s
= bfd_get_linker_section (dynobj
, ".gnu.version_d");
5959 BFD_ASSERT (s
!= NULL
);
5961 /* We may have created additional version definitions if we are
5962 just linking a regular application. */
5963 verdefs
= info
->version_info
;
5965 /* Skip anonymous version tag. */
5966 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
5967 verdefs
= verdefs
->next
;
5969 if (verdefs
== NULL
&& !info
->create_default_symver
)
5970 s
->flags
|= SEC_EXCLUDE
;
5975 struct bfd_elf_version_tree
*t
;
5977 Elf_Internal_Verdef def
;
5978 Elf_Internal_Verdaux defaux
;
5979 struct bfd_link_hash_entry
*bh
;
5980 struct elf_link_hash_entry
*h
;
5986 /* Make space for the base version. */
5987 size
+= sizeof (Elf_External_Verdef
);
5988 size
+= sizeof (Elf_External_Verdaux
);
5991 /* Make space for the default version. */
5992 if (info
->create_default_symver
)
5994 size
+= sizeof (Elf_External_Verdef
);
5998 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6000 struct bfd_elf_version_deps
*n
;
6002 /* Don't emit base version twice. */
6006 size
+= sizeof (Elf_External_Verdef
);
6007 size
+= sizeof (Elf_External_Verdaux
);
6010 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6011 size
+= sizeof (Elf_External_Verdaux
);
6015 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6016 if (s
->contents
== NULL
&& s
->size
!= 0)
6019 /* Fill in the version definition section. */
6023 def
.vd_version
= VER_DEF_CURRENT
;
6024 def
.vd_flags
= VER_FLG_BASE
;
6027 if (info
->create_default_symver
)
6029 def
.vd_aux
= 2 * sizeof (Elf_External_Verdef
);
6030 def
.vd_next
= sizeof (Elf_External_Verdef
);
6034 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6035 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6036 + sizeof (Elf_External_Verdaux
));
6039 if (soname_indx
!= (bfd_size_type
) -1)
6041 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6043 def
.vd_hash
= bfd_elf_hash (soname
);
6044 defaux
.vda_name
= soname_indx
;
6051 name
= lbasename (output_bfd
->filename
);
6052 def
.vd_hash
= bfd_elf_hash (name
);
6053 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6055 if (indx
== (bfd_size_type
) -1)
6057 defaux
.vda_name
= indx
;
6059 defaux
.vda_next
= 0;
6061 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6062 (Elf_External_Verdef
*) p
);
6063 p
+= sizeof (Elf_External_Verdef
);
6064 if (info
->create_default_symver
)
6066 /* Add a symbol representing this version. */
6068 if (! (_bfd_generic_link_add_one_symbol
6069 (info
, dynobj
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6071 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6073 h
= (struct elf_link_hash_entry
*) bh
;
6076 h
->type
= STT_OBJECT
;
6077 h
->verinfo
.vertree
= NULL
;
6079 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6082 /* Create a duplicate of the base version with the same
6083 aux block, but different flags. */
6086 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6088 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6089 + sizeof (Elf_External_Verdaux
));
6092 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6093 (Elf_External_Verdef
*) p
);
6094 p
+= sizeof (Elf_External_Verdef
);
6096 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6097 (Elf_External_Verdaux
*) p
);
6098 p
+= sizeof (Elf_External_Verdaux
);
6100 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
6103 struct bfd_elf_version_deps
*n
;
6105 /* Don't emit the base version twice. */
6110 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6113 /* Add a symbol representing this version. */
6115 if (! (_bfd_generic_link_add_one_symbol
6116 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
6118 get_elf_backend_data (dynobj
)->collect
, &bh
)))
6120 h
= (struct elf_link_hash_entry
*) bh
;
6123 h
->type
= STT_OBJECT
;
6124 h
->verinfo
.vertree
= t
;
6126 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6129 def
.vd_version
= VER_DEF_CURRENT
;
6131 if (t
->globals
.list
== NULL
6132 && t
->locals
.list
== NULL
6134 def
.vd_flags
|= VER_FLG_WEAK
;
6135 def
.vd_ndx
= t
->vernum
+ (info
->create_default_symver
? 2 : 1);
6136 def
.vd_cnt
= cdeps
+ 1;
6137 def
.vd_hash
= bfd_elf_hash (t
->name
);
6138 def
.vd_aux
= sizeof (Elf_External_Verdef
);
6141 /* If a basever node is next, it *must* be the last node in
6142 the chain, otherwise Verdef construction breaks. */
6143 if (t
->next
!= NULL
&& t
->next
->vernum
== 0)
6144 BFD_ASSERT (t
->next
->next
== NULL
);
6146 if (t
->next
!= NULL
&& t
->next
->vernum
!= 0)
6147 def
.vd_next
= (sizeof (Elf_External_Verdef
)
6148 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
6150 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
6151 (Elf_External_Verdef
*) p
);
6152 p
+= sizeof (Elf_External_Verdef
);
6154 defaux
.vda_name
= h
->dynstr_index
;
6155 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6157 defaux
.vda_next
= 0;
6158 if (t
->deps
!= NULL
)
6159 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6160 t
->name_indx
= defaux
.vda_name
;
6162 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6163 (Elf_External_Verdaux
*) p
);
6164 p
+= sizeof (Elf_External_Verdaux
);
6166 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
6168 if (n
->version_needed
== NULL
)
6170 /* This can happen if there was an error in the
6172 defaux
.vda_name
= 0;
6176 defaux
.vda_name
= n
->version_needed
->name_indx
;
6177 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
6180 if (n
->next
== NULL
)
6181 defaux
.vda_next
= 0;
6183 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
6185 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
6186 (Elf_External_Verdaux
*) p
);
6187 p
+= sizeof (Elf_External_Verdaux
);
6191 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
6192 || !_bfd_elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
6195 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
6198 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
6200 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
6203 else if (info
->flags
& DF_BIND_NOW
)
6205 if (!_bfd_elf_add_dynamic_entry (info
, DT_BIND_NOW
, 0))
6211 if (info
->executable
)
6212 info
->flags_1
&= ~ (DF_1_INITFIRST
6215 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
6219 /* Work out the size of the version reference section. */
6221 s
= bfd_get_linker_section (dynobj
, ".gnu.version_r");
6222 BFD_ASSERT (s
!= NULL
);
6224 struct elf_find_verdep_info sinfo
;
6227 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
6228 if (sinfo
.vers
== 0)
6230 sinfo
.failed
= FALSE
;
6232 elf_link_hash_traverse (elf_hash_table (info
),
6233 _bfd_elf_link_find_version_dependencies
,
6238 if (elf_tdata (output_bfd
)->verref
== NULL
)
6239 s
->flags
|= SEC_EXCLUDE
;
6242 Elf_Internal_Verneed
*t
;
6247 /* Build the version dependency section. */
6250 for (t
= elf_tdata (output_bfd
)->verref
;
6254 Elf_Internal_Vernaux
*a
;
6256 size
+= sizeof (Elf_External_Verneed
);
6258 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6259 size
+= sizeof (Elf_External_Vernaux
);
6263 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6264 if (s
->contents
== NULL
)
6268 for (t
= elf_tdata (output_bfd
)->verref
;
6273 Elf_Internal_Vernaux
*a
;
6277 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6280 t
->vn_version
= VER_NEED_CURRENT
;
6282 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6283 elf_dt_name (t
->vn_bfd
) != NULL
6284 ? elf_dt_name (t
->vn_bfd
)
6285 : lbasename (t
->vn_bfd
->filename
),
6287 if (indx
== (bfd_size_type
) -1)
6290 t
->vn_aux
= sizeof (Elf_External_Verneed
);
6291 if (t
->vn_nextref
== NULL
)
6294 t
->vn_next
= (sizeof (Elf_External_Verneed
)
6295 + caux
* sizeof (Elf_External_Vernaux
));
6297 _bfd_elf_swap_verneed_out (output_bfd
, t
,
6298 (Elf_External_Verneed
*) p
);
6299 p
+= sizeof (Elf_External_Verneed
);
6301 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
6303 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
6304 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
6305 a
->vna_nodename
, FALSE
);
6306 if (indx
== (bfd_size_type
) -1)
6309 if (a
->vna_nextptr
== NULL
)
6312 a
->vna_next
= sizeof (Elf_External_Vernaux
);
6314 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
6315 (Elf_External_Vernaux
*) p
);
6316 p
+= sizeof (Elf_External_Vernaux
);
6320 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
6321 || !_bfd_elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
6324 elf_tdata (output_bfd
)->cverrefs
= crefs
;
6328 if ((elf_tdata (output_bfd
)->cverrefs
== 0
6329 && elf_tdata (output_bfd
)->cverdefs
== 0)
6330 || _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6331 §ion_sym_count
) == 0)
6333 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6334 s
->flags
|= SEC_EXCLUDE
;
6340 /* Find the first non-excluded output section. We'll use its
6341 section symbol for some emitted relocs. */
6343 _bfd_elf_init_1_index_section (bfd
*output_bfd
, struct bfd_link_info
*info
)
6347 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6348 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
6349 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6351 elf_hash_table (info
)->text_index_section
= s
;
6356 /* Find two non-excluded output sections, one for code, one for data.
6357 We'll use their section symbols for some emitted relocs. */
6359 _bfd_elf_init_2_index_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
6363 /* Data first, since setting text_index_section changes
6364 _bfd_elf_link_omit_section_dynsym. */
6365 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6366 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
)) == SEC_ALLOC
)
6367 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6369 elf_hash_table (info
)->data_index_section
= s
;
6373 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6374 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
))
6375 == (SEC_ALLOC
| SEC_READONLY
))
6376 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
6378 elf_hash_table (info
)->text_index_section
= s
;
6382 if (elf_hash_table (info
)->text_index_section
== NULL
)
6383 elf_hash_table (info
)->text_index_section
6384 = elf_hash_table (info
)->data_index_section
;
6388 bfd_elf_size_dynsym_hash_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
6390 const struct elf_backend_data
*bed
;
6392 if (!is_elf_hash_table (info
->hash
))
6395 bed
= get_elf_backend_data (output_bfd
);
6396 (*bed
->elf_backend_init_index_section
) (output_bfd
, info
);
6398 if (elf_hash_table (info
)->dynamic_sections_created
)
6402 bfd_size_type dynsymcount
;
6403 unsigned long section_sym_count
;
6404 unsigned int dtagcount
;
6406 dynobj
= elf_hash_table (info
)->dynobj
;
6408 /* Assign dynsym indicies. In a shared library we generate a
6409 section symbol for each output section, which come first.
6410 Next come all of the back-end allocated local dynamic syms,
6411 followed by the rest of the global symbols. */
6413 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6414 §ion_sym_count
);
6416 /* Work out the size of the symbol version section. */
6417 s
= bfd_get_linker_section (dynobj
, ".gnu.version");
6418 BFD_ASSERT (s
!= NULL
);
6419 if (dynsymcount
!= 0
6420 && (s
->flags
& SEC_EXCLUDE
) == 0)
6422 s
->size
= dynsymcount
* sizeof (Elf_External_Versym
);
6423 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6424 if (s
->contents
== NULL
)
6427 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
6431 /* Set the size of the .dynsym and .hash sections. We counted
6432 the number of dynamic symbols in elf_link_add_object_symbols.
6433 We will build the contents of .dynsym and .hash when we build
6434 the final symbol table, because until then we do not know the
6435 correct value to give the symbols. We built the .dynstr
6436 section as we went along in elf_link_add_object_symbols. */
6437 s
= bfd_get_linker_section (dynobj
, ".dynsym");
6438 BFD_ASSERT (s
!= NULL
);
6439 s
->size
= dynsymcount
* bed
->s
->sizeof_sym
;
6441 if (dynsymcount
!= 0)
6443 s
->contents
= (unsigned char *) bfd_alloc (output_bfd
, s
->size
);
6444 if (s
->contents
== NULL
)
6447 /* The first entry in .dynsym is a dummy symbol.
6448 Clear all the section syms, in case we don't output them all. */
6449 ++section_sym_count
;
6450 memset (s
->contents
, 0, section_sym_count
* bed
->s
->sizeof_sym
);
6453 elf_hash_table (info
)->bucketcount
= 0;
6455 /* Compute the size of the hashing table. As a side effect this
6456 computes the hash values for all the names we export. */
6457 if (info
->emit_hash
)
6459 unsigned long int *hashcodes
;
6460 struct hash_codes_info hashinf
;
6462 unsigned long int nsyms
;
6464 size_t hash_entry_size
;
6466 /* Compute the hash values for all exported symbols. At the same
6467 time store the values in an array so that we could use them for
6469 amt
= dynsymcount
* sizeof (unsigned long int);
6470 hashcodes
= (unsigned long int *) bfd_malloc (amt
);
6471 if (hashcodes
== NULL
)
6473 hashinf
.hashcodes
= hashcodes
;
6474 hashinf
.error
= FALSE
;
6476 /* Put all hash values in HASHCODES. */
6477 elf_link_hash_traverse (elf_hash_table (info
),
6478 elf_collect_hash_codes
, &hashinf
);
6485 nsyms
= hashinf
.hashcodes
- hashcodes
;
6487 = compute_bucket_count (info
, hashcodes
, nsyms
, 0);
6490 if (bucketcount
== 0)
6493 elf_hash_table (info
)->bucketcount
= bucketcount
;
6495 s
= bfd_get_linker_section (dynobj
, ".hash");
6496 BFD_ASSERT (s
!= NULL
);
6497 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
6498 s
->size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
6499 s
->contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6500 if (s
->contents
== NULL
)
6503 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
6504 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
6505 s
->contents
+ hash_entry_size
);
6508 if (info
->emit_gnu_hash
)
6511 unsigned char *contents
;
6512 struct collect_gnu_hash_codes cinfo
;
6516 memset (&cinfo
, 0, sizeof (cinfo
));
6518 /* Compute the hash values for all exported symbols. At the same
6519 time store the values in an array so that we could use them for
6521 amt
= dynsymcount
* 2 * sizeof (unsigned long int);
6522 cinfo
.hashcodes
= (long unsigned int *) bfd_malloc (amt
);
6523 if (cinfo
.hashcodes
== NULL
)
6526 cinfo
.hashval
= cinfo
.hashcodes
+ dynsymcount
;
6527 cinfo
.min_dynindx
= -1;
6528 cinfo
.output_bfd
= output_bfd
;
6531 /* Put all hash values in HASHCODES. */
6532 elf_link_hash_traverse (elf_hash_table (info
),
6533 elf_collect_gnu_hash_codes
, &cinfo
);
6536 free (cinfo
.hashcodes
);
6541 = compute_bucket_count (info
, cinfo
.hashcodes
, cinfo
.nsyms
, 1);
6543 if (bucketcount
== 0)
6545 free (cinfo
.hashcodes
);
6549 s
= bfd_get_linker_section (dynobj
, ".gnu.hash");
6550 BFD_ASSERT (s
!= NULL
);
6552 if (cinfo
.nsyms
== 0)
6554 /* Empty .gnu.hash section is special. */
6555 BFD_ASSERT (cinfo
.min_dynindx
== -1);
6556 free (cinfo
.hashcodes
);
6557 s
->size
= 5 * 4 + bed
->s
->arch_size
/ 8;
6558 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6559 if (contents
== NULL
)
6561 s
->contents
= contents
;
6562 /* 1 empty bucket. */
6563 bfd_put_32 (output_bfd
, 1, contents
);
6564 /* SYMIDX above the special symbol 0. */
6565 bfd_put_32 (output_bfd
, 1, contents
+ 4);
6566 /* Just one word for bitmask. */
6567 bfd_put_32 (output_bfd
, 1, contents
+ 8);
6568 /* Only hash fn bloom filter. */
6569 bfd_put_32 (output_bfd
, 0, contents
+ 12);
6570 /* No hashes are valid - empty bitmask. */
6571 bfd_put (bed
->s
->arch_size
, output_bfd
, 0, contents
+ 16);
6572 /* No hashes in the only bucket. */
6573 bfd_put_32 (output_bfd
, 0,
6574 contents
+ 16 + bed
->s
->arch_size
/ 8);
6578 unsigned long int maskwords
, maskbitslog2
, x
;
6579 BFD_ASSERT (cinfo
.min_dynindx
!= -1);
6583 while ((x
>>= 1) != 0)
6585 if (maskbitslog2
< 3)
6587 else if ((1 << (maskbitslog2
- 2)) & cinfo
.nsyms
)
6588 maskbitslog2
= maskbitslog2
+ 3;
6590 maskbitslog2
= maskbitslog2
+ 2;
6591 if (bed
->s
->arch_size
== 64)
6593 if (maskbitslog2
== 5)
6599 cinfo
.mask
= (1 << cinfo
.shift1
) - 1;
6600 cinfo
.shift2
= maskbitslog2
;
6601 cinfo
.maskbits
= 1 << maskbitslog2
;
6602 maskwords
= 1 << (maskbitslog2
- cinfo
.shift1
);
6603 amt
= bucketcount
* sizeof (unsigned long int) * 2;
6604 amt
+= maskwords
* sizeof (bfd_vma
);
6605 cinfo
.bitmask
= (bfd_vma
*) bfd_malloc (amt
);
6606 if (cinfo
.bitmask
== NULL
)
6608 free (cinfo
.hashcodes
);
6612 cinfo
.counts
= (long unsigned int *) (cinfo
.bitmask
+ maskwords
);
6613 cinfo
.indx
= cinfo
.counts
+ bucketcount
;
6614 cinfo
.symindx
= dynsymcount
- cinfo
.nsyms
;
6615 memset (cinfo
.bitmask
, 0, maskwords
* sizeof (bfd_vma
));
6617 /* Determine how often each hash bucket is used. */
6618 memset (cinfo
.counts
, 0, bucketcount
* sizeof (cinfo
.counts
[0]));
6619 for (i
= 0; i
< cinfo
.nsyms
; ++i
)
6620 ++cinfo
.counts
[cinfo
.hashcodes
[i
] % bucketcount
];
6622 for (i
= 0, cnt
= cinfo
.symindx
; i
< bucketcount
; ++i
)
6623 if (cinfo
.counts
[i
] != 0)
6625 cinfo
.indx
[i
] = cnt
;
6626 cnt
+= cinfo
.counts
[i
];
6628 BFD_ASSERT (cnt
== dynsymcount
);
6629 cinfo
.bucketcount
= bucketcount
;
6630 cinfo
.local_indx
= cinfo
.min_dynindx
;
6632 s
->size
= (4 + bucketcount
+ cinfo
.nsyms
) * 4;
6633 s
->size
+= cinfo
.maskbits
/ 8;
6634 contents
= (unsigned char *) bfd_zalloc (output_bfd
, s
->size
);
6635 if (contents
== NULL
)
6637 free (cinfo
.bitmask
);
6638 free (cinfo
.hashcodes
);
6642 s
->contents
= contents
;
6643 bfd_put_32 (output_bfd
, bucketcount
, contents
);
6644 bfd_put_32 (output_bfd
, cinfo
.symindx
, contents
+ 4);
6645 bfd_put_32 (output_bfd
, maskwords
, contents
+ 8);
6646 bfd_put_32 (output_bfd
, cinfo
.shift2
, contents
+ 12);
6647 contents
+= 16 + cinfo
.maskbits
/ 8;
6649 for (i
= 0; i
< bucketcount
; ++i
)
6651 if (cinfo
.counts
[i
] == 0)
6652 bfd_put_32 (output_bfd
, 0, contents
);
6654 bfd_put_32 (output_bfd
, cinfo
.indx
[i
], contents
);
6658 cinfo
.contents
= contents
;
6660 /* Renumber dynamic symbols, populate .gnu.hash section. */
6661 elf_link_hash_traverse (elf_hash_table (info
),
6662 elf_renumber_gnu_hash_syms
, &cinfo
);
6664 contents
= s
->contents
+ 16;
6665 for (i
= 0; i
< maskwords
; ++i
)
6667 bfd_put (bed
->s
->arch_size
, output_bfd
, cinfo
.bitmask
[i
],
6669 contents
+= bed
->s
->arch_size
/ 8;
6672 free (cinfo
.bitmask
);
6673 free (cinfo
.hashcodes
);
6677 s
= bfd_get_linker_section (dynobj
, ".dynstr");
6678 BFD_ASSERT (s
!= NULL
);
6680 elf_finalize_dynstr (output_bfd
, info
);
6682 s
->size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6684 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
6685 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0))
6692 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
6695 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
6698 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
);
6699 sec
->sec_info_type
= SEC_INFO_TYPE_NONE
;
6702 /* Finish SHF_MERGE section merging. */
6705 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6710 if (!is_elf_hash_table (info
->hash
))
6713 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
6714 if ((ibfd
->flags
& DYNAMIC
) == 0)
6715 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6716 if ((sec
->flags
& SEC_MERGE
) != 0
6717 && !bfd_is_abs_section (sec
->output_section
))
6719 struct bfd_elf_section_data
*secdata
;
6721 secdata
= elf_section_data (sec
);
6722 if (! _bfd_add_merge_section (abfd
,
6723 &elf_hash_table (info
)->merge_info
,
6724 sec
, &secdata
->sec_info
))
6726 else if (secdata
->sec_info
)
6727 sec
->sec_info_type
= SEC_INFO_TYPE_MERGE
;
6730 if (elf_hash_table (info
)->merge_info
!= NULL
)
6731 _bfd_merge_sections (abfd
, info
, elf_hash_table (info
)->merge_info
,
6732 merge_sections_remove_hook
);
6736 /* Create an entry in an ELF linker hash table. */
6738 struct bfd_hash_entry
*
6739 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
6740 struct bfd_hash_table
*table
,
6743 /* Allocate the structure if it has not already been allocated by a
6747 entry
= (struct bfd_hash_entry
*)
6748 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
6753 /* Call the allocation method of the superclass. */
6754 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
6757 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
6758 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
6760 /* Set local fields. */
6763 ret
->got
= htab
->init_got_refcount
;
6764 ret
->plt
= htab
->init_plt_refcount
;
6765 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
6766 - offsetof (struct elf_link_hash_entry
, size
)));
6767 /* Assume that we have been called by a non-ELF symbol reader.
6768 This flag is then reset by the code which reads an ELF input
6769 file. This ensures that a symbol created by a non-ELF symbol
6770 reader will have the flag set correctly. */
6777 /* Copy data from an indirect symbol to its direct symbol, hiding the
6778 old indirect symbol. Also used for copying flags to a weakdef. */
6781 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info
*info
,
6782 struct elf_link_hash_entry
*dir
,
6783 struct elf_link_hash_entry
*ind
)
6785 struct elf_link_hash_table
*htab
;
6787 /* Copy down any references that we may have already seen to the
6788 symbol which just became indirect. */
6790 dir
->ref_dynamic
|= ind
->ref_dynamic
;
6791 dir
->ref_regular
|= ind
->ref_regular
;
6792 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
6793 dir
->non_got_ref
|= ind
->non_got_ref
;
6794 dir
->needs_plt
|= ind
->needs_plt
;
6795 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
6797 if (ind
->root
.type
!= bfd_link_hash_indirect
)
6800 /* Copy over the global and procedure linkage table refcount entries.
6801 These may have been already set up by a check_relocs routine. */
6802 htab
= elf_hash_table (info
);
6803 if (ind
->got
.refcount
> htab
->init_got_refcount
.refcount
)
6805 if (dir
->got
.refcount
< 0)
6806 dir
->got
.refcount
= 0;
6807 dir
->got
.refcount
+= ind
->got
.refcount
;
6808 ind
->got
.refcount
= htab
->init_got_refcount
.refcount
;
6811 if (ind
->plt
.refcount
> htab
->init_plt_refcount
.refcount
)
6813 if (dir
->plt
.refcount
< 0)
6814 dir
->plt
.refcount
= 0;
6815 dir
->plt
.refcount
+= ind
->plt
.refcount
;
6816 ind
->plt
.refcount
= htab
->init_plt_refcount
.refcount
;
6819 if (ind
->dynindx
!= -1)
6821 if (dir
->dynindx
!= -1)
6822 _bfd_elf_strtab_delref (htab
->dynstr
, dir
->dynstr_index
);
6823 dir
->dynindx
= ind
->dynindx
;
6824 dir
->dynstr_index
= ind
->dynstr_index
;
6826 ind
->dynstr_index
= 0;
6831 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
6832 struct elf_link_hash_entry
*h
,
6833 bfd_boolean force_local
)
6835 /* STT_GNU_IFUNC symbol must go through PLT. */
6836 if (h
->type
!= STT_GNU_IFUNC
)
6838 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
6843 h
->forced_local
= 1;
6844 if (h
->dynindx
!= -1)
6847 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
6853 /* Initialize an ELF linker hash table. *TABLE has been zeroed by our
6857 _bfd_elf_link_hash_table_init
6858 (struct elf_link_hash_table
*table
,
6860 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
6861 struct bfd_hash_table
*,
6863 unsigned int entsize
,
6864 enum elf_target_id target_id
)
6867 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
6869 table
->init_got_refcount
.refcount
= can_refcount
- 1;
6870 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
6871 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
6872 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
6873 /* The first dynamic symbol is a dummy. */
6874 table
->dynsymcount
= 1;
6876 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
6878 table
->root
.type
= bfd_link_elf_hash_table
;
6879 table
->hash_table_id
= target_id
;
6884 /* Create an ELF linker hash table. */
6886 struct bfd_link_hash_table
*
6887 _bfd_elf_link_hash_table_create (bfd
*abfd
)
6889 struct elf_link_hash_table
*ret
;
6890 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
6892 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
6896 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
,
6897 sizeof (struct elf_link_hash_entry
),
6907 /* Destroy an ELF linker hash table. */
6910 _bfd_elf_link_hash_table_free (struct bfd_link_hash_table
*hash
)
6912 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) hash
;
6913 if (htab
->dynstr
!= NULL
)
6914 _bfd_elf_strtab_free (htab
->dynstr
);
6915 _bfd_merge_sections_free (htab
->merge_info
);
6916 _bfd_generic_link_hash_table_free (hash
);
6919 /* This is a hook for the ELF emulation code in the generic linker to
6920 tell the backend linker what file name to use for the DT_NEEDED
6921 entry for a dynamic object. */
6924 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
6926 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6927 && bfd_get_format (abfd
) == bfd_object
)
6928 elf_dt_name (abfd
) = name
;
6932 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
6935 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6936 && bfd_get_format (abfd
) == bfd_object
)
6937 lib_class
= elf_dyn_lib_class (abfd
);
6944 bfd_elf_set_dyn_lib_class (bfd
*abfd
, enum dynamic_lib_link_class lib_class
)
6946 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6947 && bfd_get_format (abfd
) == bfd_object
)
6948 elf_dyn_lib_class (abfd
) = lib_class
;
6951 /* Get the list of DT_NEEDED entries for a link. This is a hook for
6952 the linker ELF emulation code. */
6954 struct bfd_link_needed_list
*
6955 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
6956 struct bfd_link_info
*info
)
6958 if (! is_elf_hash_table (info
->hash
))
6960 return elf_hash_table (info
)->needed
;
6963 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
6964 hook for the linker ELF emulation code. */
6966 struct bfd_link_needed_list
*
6967 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
6968 struct bfd_link_info
*info
)
6970 if (! is_elf_hash_table (info
->hash
))
6972 return elf_hash_table (info
)->runpath
;
6975 /* Get the name actually used for a dynamic object for a link. This
6976 is the SONAME entry if there is one. Otherwise, it is the string
6977 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
6980 bfd_elf_get_dt_soname (bfd
*abfd
)
6982 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
6983 && bfd_get_format (abfd
) == bfd_object
)
6984 return elf_dt_name (abfd
);
6988 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
6989 the ELF linker emulation code. */
6992 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
6993 struct bfd_link_needed_list
**pneeded
)
6996 bfd_byte
*dynbuf
= NULL
;
6997 unsigned int elfsec
;
6998 unsigned long shlink
;
6999 bfd_byte
*extdyn
, *extdynend
;
7001 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
7005 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
7006 || bfd_get_format (abfd
) != bfd_object
)
7009 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7010 if (s
== NULL
|| s
->size
== 0)
7013 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
7016 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
7017 if (elfsec
== SHN_BAD
)
7020 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
7022 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
7023 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
7026 extdynend
= extdyn
+ s
->size
;
7027 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
7029 Elf_Internal_Dyn dyn
;
7031 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
7033 if (dyn
.d_tag
== DT_NULL
)
7036 if (dyn
.d_tag
== DT_NEEDED
)
7039 struct bfd_link_needed_list
*l
;
7040 unsigned int tagv
= dyn
.d_un
.d_val
;
7043 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
7048 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
7069 struct elf_symbuf_symbol
7071 unsigned long st_name
; /* Symbol name, index in string tbl */
7072 unsigned char st_info
; /* Type and binding attributes */
7073 unsigned char st_other
; /* Visibilty, and target specific */
7076 struct elf_symbuf_head
7078 struct elf_symbuf_symbol
*ssym
;
7079 bfd_size_type count
;
7080 unsigned int st_shndx
;
7087 Elf_Internal_Sym
*isym
;
7088 struct elf_symbuf_symbol
*ssym
;
7093 /* Sort references to symbols by ascending section number. */
7096 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
7098 const Elf_Internal_Sym
*s1
= *(const Elf_Internal_Sym
**) arg1
;
7099 const Elf_Internal_Sym
*s2
= *(const Elf_Internal_Sym
**) arg2
;
7101 return s1
->st_shndx
- s2
->st_shndx
;
7105 elf_sym_name_compare (const void *arg1
, const void *arg2
)
7107 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
7108 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
7109 return strcmp (s1
->name
, s2
->name
);
7112 static struct elf_symbuf_head
*
7113 elf_create_symbuf (bfd_size_type symcount
, Elf_Internal_Sym
*isymbuf
)
7115 Elf_Internal_Sym
**ind
, **indbufend
, **indbuf
;
7116 struct elf_symbuf_symbol
*ssym
;
7117 struct elf_symbuf_head
*ssymbuf
, *ssymhead
;
7118 bfd_size_type i
, shndx_count
, total_size
;
7120 indbuf
= (Elf_Internal_Sym
**) bfd_malloc2 (symcount
, sizeof (*indbuf
));
7124 for (ind
= indbuf
, i
= 0; i
< symcount
; i
++)
7125 if (isymbuf
[i
].st_shndx
!= SHN_UNDEF
)
7126 *ind
++ = &isymbuf
[i
];
7129 qsort (indbuf
, indbufend
- indbuf
, sizeof (Elf_Internal_Sym
*),
7130 elf_sort_elf_symbol
);
7133 if (indbufend
> indbuf
)
7134 for (ind
= indbuf
, shndx_count
++; ind
< indbufend
- 1; ind
++)
7135 if (ind
[0]->st_shndx
!= ind
[1]->st_shndx
)
7138 total_size
= ((shndx_count
+ 1) * sizeof (*ssymbuf
)
7139 + (indbufend
- indbuf
) * sizeof (*ssym
));
7140 ssymbuf
= (struct elf_symbuf_head
*) bfd_malloc (total_size
);
7141 if (ssymbuf
== NULL
)
7147 ssym
= (struct elf_symbuf_symbol
*) (ssymbuf
+ shndx_count
+ 1);
7148 ssymbuf
->ssym
= NULL
;
7149 ssymbuf
->count
= shndx_count
;
7150 ssymbuf
->st_shndx
= 0;
7151 for (ssymhead
= ssymbuf
, ind
= indbuf
; ind
< indbufend
; ssym
++, ind
++)
7153 if (ind
== indbuf
|| ssymhead
->st_shndx
!= (*ind
)->st_shndx
)
7156 ssymhead
->ssym
= ssym
;
7157 ssymhead
->count
= 0;
7158 ssymhead
->st_shndx
= (*ind
)->st_shndx
;
7160 ssym
->st_name
= (*ind
)->st_name
;
7161 ssym
->st_info
= (*ind
)->st_info
;
7162 ssym
->st_other
= (*ind
)->st_other
;
7165 BFD_ASSERT ((bfd_size_type
) (ssymhead
- ssymbuf
) == shndx_count
7166 && (((bfd_hostptr_t
) ssym
- (bfd_hostptr_t
) ssymbuf
)
7173 /* Check if 2 sections define the same set of local and global
7177 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
,
7178 struct bfd_link_info
*info
)
7181 const struct elf_backend_data
*bed1
, *bed2
;
7182 Elf_Internal_Shdr
*hdr1
, *hdr2
;
7183 bfd_size_type symcount1
, symcount2
;
7184 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
7185 struct elf_symbuf_head
*ssymbuf1
, *ssymbuf2
;
7186 Elf_Internal_Sym
*isym
, *isymend
;
7187 struct elf_symbol
*symtable1
= NULL
, *symtable2
= NULL
;
7188 bfd_size_type count1
, count2
, i
;
7189 unsigned int shndx1
, shndx2
;
7195 /* Both sections have to be in ELF. */
7196 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
7197 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
7200 if (elf_section_type (sec1
) != elf_section_type (sec2
))
7203 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
7204 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
7205 if (shndx1
== SHN_BAD
|| shndx2
== SHN_BAD
)
7208 bed1
= get_elf_backend_data (bfd1
);
7209 bed2
= get_elf_backend_data (bfd2
);
7210 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
7211 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
7212 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
7213 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
7215 if (symcount1
== 0 || symcount2
== 0)
7221 ssymbuf1
= (struct elf_symbuf_head
*) elf_tdata (bfd1
)->symbuf
;
7222 ssymbuf2
= (struct elf_symbuf_head
*) elf_tdata (bfd2
)->symbuf
;
7224 if (ssymbuf1
== NULL
)
7226 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
7228 if (isymbuf1
== NULL
)
7231 if (!info
->reduce_memory_overheads
)
7232 elf_tdata (bfd1
)->symbuf
= ssymbuf1
7233 = elf_create_symbuf (symcount1
, isymbuf1
);
7236 if (ssymbuf1
== NULL
|| ssymbuf2
== NULL
)
7238 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
7240 if (isymbuf2
== NULL
)
7243 if (ssymbuf1
!= NULL
&& !info
->reduce_memory_overheads
)
7244 elf_tdata (bfd2
)->symbuf
= ssymbuf2
7245 = elf_create_symbuf (symcount2
, isymbuf2
);
7248 if (ssymbuf1
!= NULL
&& ssymbuf2
!= NULL
)
7250 /* Optimized faster version. */
7251 bfd_size_type lo
, hi
, mid
;
7252 struct elf_symbol
*symp
;
7253 struct elf_symbuf_symbol
*ssym
, *ssymend
;
7256 hi
= ssymbuf1
->count
;
7261 mid
= (lo
+ hi
) / 2;
7262 if (shndx1
< ssymbuf1
[mid
].st_shndx
)
7264 else if (shndx1
> ssymbuf1
[mid
].st_shndx
)
7268 count1
= ssymbuf1
[mid
].count
;
7275 hi
= ssymbuf2
->count
;
7280 mid
= (lo
+ hi
) / 2;
7281 if (shndx2
< ssymbuf2
[mid
].st_shndx
)
7283 else if (shndx2
> ssymbuf2
[mid
].st_shndx
)
7287 count2
= ssymbuf2
[mid
].count
;
7293 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7296 symtable1
= (struct elf_symbol
*)
7297 bfd_malloc (count1
* sizeof (struct elf_symbol
));
7298 symtable2
= (struct elf_symbol
*)
7299 bfd_malloc (count2
* sizeof (struct elf_symbol
));
7300 if (symtable1
== NULL
|| symtable2
== NULL
)
7304 for (ssym
= ssymbuf1
->ssym
, ssymend
= ssym
+ count1
;
7305 ssym
< ssymend
; ssym
++, symp
++)
7307 symp
->u
.ssym
= ssym
;
7308 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
7314 for (ssym
= ssymbuf2
->ssym
, ssymend
= ssym
+ count2
;
7315 ssym
< ssymend
; ssym
++, symp
++)
7317 symp
->u
.ssym
= ssym
;
7318 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
7323 /* Sort symbol by name. */
7324 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7325 elf_sym_name_compare
);
7326 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7327 elf_sym_name_compare
);
7329 for (i
= 0; i
< count1
; i
++)
7330 /* Two symbols must have the same binding, type and name. */
7331 if (symtable1
[i
].u
.ssym
->st_info
!= symtable2
[i
].u
.ssym
->st_info
7332 || symtable1
[i
].u
.ssym
->st_other
!= symtable2
[i
].u
.ssym
->st_other
7333 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7340 symtable1
= (struct elf_symbol
*)
7341 bfd_malloc (symcount1
* sizeof (struct elf_symbol
));
7342 symtable2
= (struct elf_symbol
*)
7343 bfd_malloc (symcount2
* sizeof (struct elf_symbol
));
7344 if (symtable1
== NULL
|| symtable2
== NULL
)
7347 /* Count definitions in the section. */
7349 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
; isym
< isymend
; isym
++)
7350 if (isym
->st_shndx
== shndx1
)
7351 symtable1
[count1
++].u
.isym
= isym
;
7354 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
; isym
< isymend
; isym
++)
7355 if (isym
->st_shndx
== shndx2
)
7356 symtable2
[count2
++].u
.isym
= isym
;
7358 if (count1
== 0 || count2
== 0 || count1
!= count2
)
7361 for (i
= 0; i
< count1
; i
++)
7363 = bfd_elf_string_from_elf_section (bfd1
, hdr1
->sh_link
,
7364 symtable1
[i
].u
.isym
->st_name
);
7366 for (i
= 0; i
< count2
; i
++)
7368 = bfd_elf_string_from_elf_section (bfd2
, hdr2
->sh_link
,
7369 symtable2
[i
].u
.isym
->st_name
);
7371 /* Sort symbol by name. */
7372 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
7373 elf_sym_name_compare
);
7374 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
7375 elf_sym_name_compare
);
7377 for (i
= 0; i
< count1
; i
++)
7378 /* Two symbols must have the same binding, type and name. */
7379 if (symtable1
[i
].u
.isym
->st_info
!= symtable2
[i
].u
.isym
->st_info
7380 || symtable1
[i
].u
.isym
->st_other
!= symtable2
[i
].u
.isym
->st_other
7381 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
7399 /* Return TRUE if 2 section types are compatible. */
7402 _bfd_elf_match_sections_by_type (bfd
*abfd
, const asection
*asec
,
7403 bfd
*bbfd
, const asection
*bsec
)
7407 || abfd
->xvec
->flavour
!= bfd_target_elf_flavour
7408 || bbfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7411 return elf_section_type (asec
) == elf_section_type (bsec
);
7414 /* Final phase of ELF linker. */
7416 /* A structure we use to avoid passing large numbers of arguments. */
7418 struct elf_final_link_info
7420 /* General link information. */
7421 struct bfd_link_info
*info
;
7424 /* Symbol string table. */
7425 struct bfd_strtab_hash
*symstrtab
;
7426 /* .dynsym section. */
7427 asection
*dynsym_sec
;
7428 /* .hash section. */
7430 /* symbol version section (.gnu.version). */
7431 asection
*symver_sec
;
7432 /* Buffer large enough to hold contents of any section. */
7434 /* Buffer large enough to hold external relocs of any section. */
7435 void *external_relocs
;
7436 /* Buffer large enough to hold internal relocs of any section. */
7437 Elf_Internal_Rela
*internal_relocs
;
7438 /* Buffer large enough to hold external local symbols of any input
7440 bfd_byte
*external_syms
;
7441 /* And a buffer for symbol section indices. */
7442 Elf_External_Sym_Shndx
*locsym_shndx
;
7443 /* Buffer large enough to hold internal local symbols of any input
7445 Elf_Internal_Sym
*internal_syms
;
7446 /* Array large enough to hold a symbol index for each local symbol
7447 of any input BFD. */
7449 /* Array large enough to hold a section pointer for each local
7450 symbol of any input BFD. */
7451 asection
**sections
;
7452 /* Buffer to hold swapped out symbols. */
7454 /* And one for symbol section indices. */
7455 Elf_External_Sym_Shndx
*symshndxbuf
;
7456 /* Number of swapped out symbols in buffer. */
7457 size_t symbuf_count
;
7458 /* Number of symbols which fit in symbuf. */
7460 /* And same for symshndxbuf. */
7461 size_t shndxbuf_size
;
7462 /* Number of STT_FILE syms seen. */
7463 size_t filesym_count
;
7466 /* This struct is used to pass information to elf_link_output_extsym. */
7468 struct elf_outext_info
7471 bfd_boolean localsyms
;
7472 bfd_boolean need_second_pass
;
7473 bfd_boolean second_pass
;
7474 bfd_boolean file_sym_done
;
7475 struct elf_final_link_info
*flinfo
;
7479 /* Support for evaluating a complex relocation.
7481 Complex relocations are generalized, self-describing relocations. The
7482 implementation of them consists of two parts: complex symbols, and the
7483 relocations themselves.
7485 The relocations are use a reserved elf-wide relocation type code (R_RELC
7486 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7487 information (start bit, end bit, word width, etc) into the addend. This
7488 information is extracted from CGEN-generated operand tables within gas.
7490 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7491 internal) representing prefix-notation expressions, including but not
7492 limited to those sorts of expressions normally encoded as addends in the
7493 addend field. The symbol mangling format is:
7496 | <unary-operator> ':' <node>
7497 | <binary-operator> ':' <node> ':' <node>
7500 <literal> := 's' <digits=N> ':' <N character symbol name>
7501 | 'S' <digits=N> ':' <N character section name>
7505 <binary-operator> := as in C
7506 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7509 set_symbol_value (bfd
*bfd_with_globals
,
7510 Elf_Internal_Sym
*isymbuf
,
7515 struct elf_link_hash_entry
**sym_hashes
;
7516 struct elf_link_hash_entry
*h
;
7517 size_t extsymoff
= locsymcount
;
7519 if (symidx
< locsymcount
)
7521 Elf_Internal_Sym
*sym
;
7523 sym
= isymbuf
+ symidx
;
7524 if (ELF_ST_BIND (sym
->st_info
) == STB_LOCAL
)
7526 /* It is a local symbol: move it to the
7527 "absolute" section and give it a value. */
7528 sym
->st_shndx
= SHN_ABS
;
7529 sym
->st_value
= val
;
7532 BFD_ASSERT (elf_bad_symtab (bfd_with_globals
));
7536 /* It is a global symbol: set its link type
7537 to "defined" and give it a value. */
7539 sym_hashes
= elf_sym_hashes (bfd_with_globals
);
7540 h
= sym_hashes
[symidx
- extsymoff
];
7541 while (h
->root
.type
== bfd_link_hash_indirect
7542 || h
->root
.type
== bfd_link_hash_warning
)
7543 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7544 h
->root
.type
= bfd_link_hash_defined
;
7545 h
->root
.u
.def
.value
= val
;
7546 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
7550 resolve_symbol (const char *name
,
7552 struct elf_final_link_info
*flinfo
,
7554 Elf_Internal_Sym
*isymbuf
,
7557 Elf_Internal_Sym
*sym
;
7558 struct bfd_link_hash_entry
*global_entry
;
7559 const char *candidate
= NULL
;
7560 Elf_Internal_Shdr
*symtab_hdr
;
7563 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
7565 for (i
= 0; i
< locsymcount
; ++ i
)
7569 if (ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7572 candidate
= bfd_elf_string_from_elf_section (input_bfd
,
7573 symtab_hdr
->sh_link
,
7576 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7577 name
, candidate
, (unsigned long) sym
->st_value
);
7579 if (candidate
&& strcmp (candidate
, name
) == 0)
7581 asection
*sec
= flinfo
->sections
[i
];
7583 *result
= _bfd_elf_rel_local_sym (input_bfd
, sym
, &sec
, 0);
7584 *result
+= sec
->output_offset
+ sec
->output_section
->vma
;
7586 printf ("Found symbol with value %8.8lx\n",
7587 (unsigned long) *result
);
7593 /* Hmm, haven't found it yet. perhaps it is a global. */
7594 global_entry
= bfd_link_hash_lookup (flinfo
->info
->hash
, name
,
7595 FALSE
, FALSE
, TRUE
);
7599 if (global_entry
->type
== bfd_link_hash_defined
7600 || global_entry
->type
== bfd_link_hash_defweak
)
7602 *result
= (global_entry
->u
.def
.value
7603 + global_entry
->u
.def
.section
->output_section
->vma
7604 + global_entry
->u
.def
.section
->output_offset
);
7606 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7607 global_entry
->root
.string
, (unsigned long) *result
);
7616 resolve_section (const char *name
,
7623 for (curr
= sections
; curr
; curr
= curr
->next
)
7624 if (strcmp (curr
->name
, name
) == 0)
7626 *result
= curr
->vma
;
7630 /* Hmm. still haven't found it. try pseudo-section names. */
7631 for (curr
= sections
; curr
; curr
= curr
->next
)
7633 len
= strlen (curr
->name
);
7634 if (len
> strlen (name
))
7637 if (strncmp (curr
->name
, name
, len
) == 0)
7639 if (strncmp (".end", name
+ len
, 4) == 0)
7641 *result
= curr
->vma
+ curr
->size
;
7645 /* Insert more pseudo-section names here, if you like. */
7653 undefined_reference (const char *reftype
, const char *name
)
7655 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7660 eval_symbol (bfd_vma
*result
,
7663 struct elf_final_link_info
*flinfo
,
7665 Elf_Internal_Sym
*isymbuf
,
7674 const char *sym
= *symp
;
7676 bfd_boolean symbol_is_section
= FALSE
;
7681 if (len
< 1 || len
> sizeof (symbuf
))
7683 bfd_set_error (bfd_error_invalid_operation
);
7696 *result
= strtoul (sym
, (char **) symp
, 16);
7700 symbol_is_section
= TRUE
;
7703 symlen
= strtol (sym
, (char **) symp
, 10);
7704 sym
= *symp
+ 1; /* Skip the trailing ':'. */
7706 if (symend
< sym
|| symlen
+ 1 > sizeof (symbuf
))
7708 bfd_set_error (bfd_error_invalid_operation
);
7712 memcpy (symbuf
, sym
, symlen
);
7713 symbuf
[symlen
] = '\0';
7714 *symp
= sym
+ symlen
;
7716 /* Is it always possible, with complex symbols, that gas "mis-guessed"
7717 the symbol as a section, or vice-versa. so we're pretty liberal in our
7718 interpretation here; section means "try section first", not "must be a
7719 section", and likewise with symbol. */
7721 if (symbol_is_section
)
7723 if (!resolve_section (symbuf
, flinfo
->output_bfd
->sections
, result
)
7724 && !resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
7725 isymbuf
, locsymcount
))
7727 undefined_reference ("section", symbuf
);
7733 if (!resolve_symbol (symbuf
, input_bfd
, flinfo
, result
,
7734 isymbuf
, locsymcount
)
7735 && !resolve_section (symbuf
, flinfo
->output_bfd
->sections
,
7738 undefined_reference ("symbol", symbuf
);
7745 /* All that remains are operators. */
7747 #define UNARY_OP(op) \
7748 if (strncmp (sym, #op, strlen (#op)) == 0) \
7750 sym += strlen (#op); \
7754 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7755 isymbuf, locsymcount, signed_p)) \
7758 *result = op ((bfd_signed_vma) a); \
7764 #define BINARY_OP(op) \
7765 if (strncmp (sym, #op, strlen (#op)) == 0) \
7767 sym += strlen (#op); \
7771 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7772 isymbuf, locsymcount, signed_p)) \
7775 if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
7776 isymbuf, locsymcount, signed_p)) \
7779 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7809 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym
);
7810 bfd_set_error (bfd_error_invalid_operation
);
7816 put_value (bfd_vma size
,
7817 unsigned long chunksz
,
7822 location
+= (size
- chunksz
);
7824 for (; size
; size
-= chunksz
, location
-= chunksz
, x
>>= (chunksz
* 8))
7832 bfd_put_8 (input_bfd
, x
, location
);
7835 bfd_put_16 (input_bfd
, x
, location
);
7838 bfd_put_32 (input_bfd
, x
, location
);
7842 bfd_put_64 (input_bfd
, x
, location
);
7852 get_value (bfd_vma size
,
7853 unsigned long chunksz
,
7860 /* Sanity checks. */
7861 BFD_ASSERT (chunksz
<= sizeof (x
)
7864 && (size
% chunksz
) == 0
7865 && input_bfd
!= NULL
7866 && location
!= NULL
);
7868 if (chunksz
== sizeof (x
))
7870 BFD_ASSERT (size
== chunksz
);
7872 /* Make sure that we do not perform an undefined shift operation.
7873 We know that size == chunksz so there will only be one iteration
7874 of the loop below. */
7878 shift
= 8 * chunksz
;
7880 for (; size
; size
-= chunksz
, location
+= chunksz
)
7885 x
= (x
<< shift
) | bfd_get_8 (input_bfd
, location
);
7888 x
= (x
<< shift
) | bfd_get_16 (input_bfd
, location
);
7891 x
= (x
<< shift
) | bfd_get_32 (input_bfd
, location
);
7895 x
= (x
<< shift
) | bfd_get_64 (input_bfd
, location
);
7906 decode_complex_addend (unsigned long *start
, /* in bits */
7907 unsigned long *oplen
, /* in bits */
7908 unsigned long *len
, /* in bits */
7909 unsigned long *wordsz
, /* in bytes */
7910 unsigned long *chunksz
, /* in bytes */
7911 unsigned long *lsb0_p
,
7912 unsigned long *signed_p
,
7913 unsigned long *trunc_p
,
7914 unsigned long encoded
)
7916 * start
= encoded
& 0x3F;
7917 * len
= (encoded
>> 6) & 0x3F;
7918 * oplen
= (encoded
>> 12) & 0x3F;
7919 * wordsz
= (encoded
>> 18) & 0xF;
7920 * chunksz
= (encoded
>> 22) & 0xF;
7921 * lsb0_p
= (encoded
>> 27) & 1;
7922 * signed_p
= (encoded
>> 28) & 1;
7923 * trunc_p
= (encoded
>> 29) & 1;
7926 bfd_reloc_status_type
7927 bfd_elf_perform_complex_relocation (bfd
*input_bfd
,
7928 asection
*input_section ATTRIBUTE_UNUSED
,
7930 Elf_Internal_Rela
*rel
,
7933 bfd_vma shift
, x
, mask
;
7934 unsigned long start
, oplen
, len
, wordsz
, chunksz
, lsb0_p
, signed_p
, trunc_p
;
7935 bfd_reloc_status_type r
;
7937 /* Perform this reloc, since it is complex.
7938 (this is not to say that it necessarily refers to a complex
7939 symbol; merely that it is a self-describing CGEN based reloc.
7940 i.e. the addend has the complete reloc information (bit start, end,
7941 word size, etc) encoded within it.). */
7943 decode_complex_addend (&start
, &oplen
, &len
, &wordsz
,
7944 &chunksz
, &lsb0_p
, &signed_p
,
7945 &trunc_p
, rel
->r_addend
);
7947 mask
= (((1L << (len
- 1)) - 1) << 1) | 1;
7950 shift
= (start
+ 1) - len
;
7952 shift
= (8 * wordsz
) - (start
+ len
);
7954 /* FIXME: octets_per_byte. */
7955 x
= get_value (wordsz
, chunksz
, input_bfd
, contents
+ rel
->r_offset
);
7958 printf ("Doing complex reloc: "
7959 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7960 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7961 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7962 lsb0_p
, signed_p
, trunc_p
, wordsz
, chunksz
, start
, len
,
7963 oplen
, (unsigned long) x
, (unsigned long) mask
,
7964 (unsigned long) relocation
);
7969 /* Now do an overflow check. */
7970 r
= bfd_check_overflow ((signed_p
7971 ? complain_overflow_signed
7972 : complain_overflow_unsigned
),
7973 len
, 0, (8 * wordsz
),
7977 x
= (x
& ~(mask
<< shift
)) | ((relocation
& mask
) << shift
);
7980 printf (" relocation: %8.8lx\n"
7981 " shifted mask: %8.8lx\n"
7982 " shifted/masked reloc: %8.8lx\n"
7983 " result: %8.8lx\n",
7984 (unsigned long) relocation
, (unsigned long) (mask
<< shift
),
7985 (unsigned long) ((relocation
& mask
) << shift
), (unsigned long) x
);
7987 /* FIXME: octets_per_byte. */
7988 put_value (wordsz
, chunksz
, input_bfd
, x
, contents
+ rel
->r_offset
);
7992 /* When performing a relocatable link, the input relocations are
7993 preserved. But, if they reference global symbols, the indices
7994 referenced must be updated. Update all the relocations found in
7998 elf_link_adjust_relocs (bfd
*abfd
,
7999 struct bfd_elf_section_reloc_data
*reldata
)
8002 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8004 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8005 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8006 bfd_vma r_type_mask
;
8008 unsigned int count
= reldata
->count
;
8009 struct elf_link_hash_entry
**rel_hash
= reldata
->hashes
;
8011 if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
8013 swap_in
= bed
->s
->swap_reloc_in
;
8014 swap_out
= bed
->s
->swap_reloc_out
;
8016 else if (reldata
->hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
8018 swap_in
= bed
->s
->swap_reloca_in
;
8019 swap_out
= bed
->s
->swap_reloca_out
;
8024 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
8027 if (bed
->s
->arch_size
== 32)
8034 r_type_mask
= 0xffffffff;
8038 erela
= reldata
->hdr
->contents
;
8039 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= reldata
->hdr
->sh_entsize
)
8041 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
8044 if (*rel_hash
== NULL
)
8047 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
8049 (*swap_in
) (abfd
, erela
, irela
);
8050 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
8051 irela
[j
].r_info
= ((bfd_vma
) (*rel_hash
)->indx
<< r_sym_shift
8052 | (irela
[j
].r_info
& r_type_mask
));
8053 (*swap_out
) (abfd
, irela
, erela
);
8057 struct elf_link_sort_rela
8063 enum elf_reloc_type_class type
;
8064 /* We use this as an array of size int_rels_per_ext_rel. */
8065 Elf_Internal_Rela rela
[1];
8069 elf_link_sort_cmp1 (const void *A
, const void *B
)
8071 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8072 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8073 int relativea
, relativeb
;
8075 relativea
= a
->type
== reloc_class_relative
;
8076 relativeb
= b
->type
== reloc_class_relative
;
8078 if (relativea
< relativeb
)
8080 if (relativea
> relativeb
)
8082 if ((a
->rela
->r_info
& a
->u
.sym_mask
) < (b
->rela
->r_info
& b
->u
.sym_mask
))
8084 if ((a
->rela
->r_info
& a
->u
.sym_mask
) > (b
->rela
->r_info
& b
->u
.sym_mask
))
8086 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8088 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8094 elf_link_sort_cmp2 (const void *A
, const void *B
)
8096 const struct elf_link_sort_rela
*a
= (const struct elf_link_sort_rela
*) A
;
8097 const struct elf_link_sort_rela
*b
= (const struct elf_link_sort_rela
*) B
;
8099 if (a
->type
< b
->type
)
8101 if (a
->type
> b
->type
)
8103 if (a
->u
.offset
< b
->u
.offset
)
8105 if (a
->u
.offset
> b
->u
.offset
)
8107 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
8109 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
8115 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
8117 asection
*dynamic_relocs
;
8120 bfd_size_type count
, size
;
8121 size_t i
, ret
, sort_elt
, ext_size
;
8122 bfd_byte
*sort
, *s_non_relative
, *p
;
8123 struct elf_link_sort_rela
*sq
;
8124 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8125 int i2e
= bed
->s
->int_rels_per_ext_rel
;
8126 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
8127 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
8128 struct bfd_link_order
*lo
;
8130 bfd_boolean use_rela
;
8132 /* Find a dynamic reloc section. */
8133 rela_dyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
8134 rel_dyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
8135 if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0
8136 && rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8138 bfd_boolean use_rela_initialised
= FALSE
;
8140 /* This is just here to stop gcc from complaining.
8141 It's initialization checking code is not perfect. */
8144 /* Both sections are present. Examine the sizes
8145 of the indirect sections to help us choose. */
8146 for (lo
= rela_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8147 if (lo
->type
== bfd_indirect_link_order
)
8149 asection
*o
= lo
->u
.indirect
.section
;
8151 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8153 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8154 /* Section size is divisible by both rel and rela sizes.
8155 It is of no help to us. */
8159 /* Section size is only divisible by rela. */
8160 if (use_rela_initialised
&& (use_rela
== FALSE
))
8163 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8164 bfd_set_error (bfd_error_invalid_operation
);
8170 use_rela_initialised
= TRUE
;
8174 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8176 /* Section size is only divisible by rel. */
8177 if (use_rela_initialised
&& (use_rela
== TRUE
))
8180 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8181 bfd_set_error (bfd_error_invalid_operation
);
8187 use_rela_initialised
= TRUE
;
8192 /* The section size is not divisible by either - something is wrong. */
8194 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8195 bfd_set_error (bfd_error_invalid_operation
);
8200 for (lo
= rel_dyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8201 if (lo
->type
== bfd_indirect_link_order
)
8203 asection
*o
= lo
->u
.indirect
.section
;
8205 if ((o
->size
% bed
->s
->sizeof_rela
) == 0)
8207 if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8208 /* Section size is divisible by both rel and rela sizes.
8209 It is of no help to us. */
8213 /* Section size is only divisible by rela. */
8214 if (use_rela_initialised
&& (use_rela
== FALSE
))
8217 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8218 bfd_set_error (bfd_error_invalid_operation
);
8224 use_rela_initialised
= TRUE
;
8228 else if ((o
->size
% bed
->s
->sizeof_rel
) == 0)
8230 /* Section size is only divisible by rel. */
8231 if (use_rela_initialised
&& (use_rela
== TRUE
))
8234 (_("%B: Unable to sort relocs - they are in more than one size"), abfd
);
8235 bfd_set_error (bfd_error_invalid_operation
);
8241 use_rela_initialised
= TRUE
;
8246 /* The section size is not divisible by either - something is wrong. */
8248 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd
);
8249 bfd_set_error (bfd_error_invalid_operation
);
8254 if (! use_rela_initialised
)
8258 else if (rela_dyn
!= NULL
&& rela_dyn
->size
> 0)
8260 else if (rel_dyn
!= NULL
&& rel_dyn
->size
> 0)
8267 dynamic_relocs
= rela_dyn
;
8268 ext_size
= bed
->s
->sizeof_rela
;
8269 swap_in
= bed
->s
->swap_reloca_in
;
8270 swap_out
= bed
->s
->swap_reloca_out
;
8274 dynamic_relocs
= rel_dyn
;
8275 ext_size
= bed
->s
->sizeof_rel
;
8276 swap_in
= bed
->s
->swap_reloc_in
;
8277 swap_out
= bed
->s
->swap_reloc_out
;
8281 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8282 if (lo
->type
== bfd_indirect_link_order
)
8283 size
+= lo
->u
.indirect
.section
->size
;
8285 if (size
!= dynamic_relocs
->size
)
8288 sort_elt
= (sizeof (struct elf_link_sort_rela
)
8289 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
8291 count
= dynamic_relocs
->size
/ ext_size
;
8294 sort
= (bfd_byte
*) bfd_zmalloc (sort_elt
* count
);
8298 (*info
->callbacks
->warning
)
8299 (info
, _("Not enough memory to sort relocations"), 0, abfd
, 0, 0);
8303 if (bed
->s
->arch_size
== 32)
8304 r_sym_mask
= ~(bfd_vma
) 0xff;
8306 r_sym_mask
= ~(bfd_vma
) 0xffffffff;
8308 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8309 if (lo
->type
== bfd_indirect_link_order
)
8311 bfd_byte
*erel
, *erelend
;
8312 asection
*o
= lo
->u
.indirect
.section
;
8314 if (o
->contents
== NULL
&& o
->size
!= 0)
8316 /* This is a reloc section that is being handled as a normal
8317 section. See bfd_section_from_shdr. We can't combine
8318 relocs in this case. */
8323 erelend
= o
->contents
+ o
->size
;
8324 /* FIXME: octets_per_byte. */
8325 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8327 while (erel
< erelend
)
8329 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8331 (*swap_in
) (abfd
, erel
, s
->rela
);
8332 s
->type
= (*bed
->elf_backend_reloc_type_class
) (info
, o
, s
->rela
);
8333 s
->u
.sym_mask
= r_sym_mask
;
8339 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
8341 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
8343 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8344 if (s
->type
!= reloc_class_relative
)
8350 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
8351 for (; i
< count
; i
++, p
+= sort_elt
)
8353 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
8354 if (((sp
->rela
->r_info
^ sq
->rela
->r_info
) & r_sym_mask
) != 0)
8356 sp
->u
.offset
= sq
->rela
->r_offset
;
8359 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
8361 for (lo
= dynamic_relocs
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
8362 if (lo
->type
== bfd_indirect_link_order
)
8364 bfd_byte
*erel
, *erelend
;
8365 asection
*o
= lo
->u
.indirect
.section
;
8368 erelend
= o
->contents
+ o
->size
;
8369 /* FIXME: octets_per_byte. */
8370 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
8371 while (erel
< erelend
)
8373 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
8374 (*swap_out
) (abfd
, s
->rela
, erel
);
8381 *psec
= dynamic_relocs
;
8385 /* Flush the output symbols to the file. */
8388 elf_link_flush_output_syms (struct elf_final_link_info
*flinfo
,
8389 const struct elf_backend_data
*bed
)
8391 if (flinfo
->symbuf_count
> 0)
8393 Elf_Internal_Shdr
*hdr
;
8397 hdr
= &elf_tdata (flinfo
->output_bfd
)->symtab_hdr
;
8398 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
8399 amt
= flinfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8400 if (bfd_seek (flinfo
->output_bfd
, pos
, SEEK_SET
) != 0
8401 || bfd_bwrite (flinfo
->symbuf
, amt
, flinfo
->output_bfd
) != amt
)
8404 hdr
->sh_size
+= amt
;
8405 flinfo
->symbuf_count
= 0;
8411 /* Add a symbol to the output symbol table. */
8414 elf_link_output_sym (struct elf_final_link_info
*flinfo
,
8416 Elf_Internal_Sym
*elfsym
,
8417 asection
*input_sec
,
8418 struct elf_link_hash_entry
*h
)
8421 Elf_External_Sym_Shndx
*destshndx
;
8422 int (*output_symbol_hook
)
8423 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*, asection
*,
8424 struct elf_link_hash_entry
*);
8425 const struct elf_backend_data
*bed
;
8427 bed
= get_elf_backend_data (flinfo
->output_bfd
);
8428 output_symbol_hook
= bed
->elf_backend_link_output_symbol_hook
;
8429 if (output_symbol_hook
!= NULL
)
8431 int ret
= (*output_symbol_hook
) (flinfo
->info
, name
, elfsym
, input_sec
, h
);
8436 if (name
== NULL
|| *name
== '\0')
8437 elfsym
->st_name
= 0;
8438 else if (input_sec
->flags
& SEC_EXCLUDE
)
8439 elfsym
->st_name
= 0;
8442 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (flinfo
->symstrtab
,
8444 if (elfsym
->st_name
== (unsigned long) -1)
8448 if (flinfo
->symbuf_count
>= flinfo
->symbuf_size
)
8450 if (! elf_link_flush_output_syms (flinfo
, bed
))
8454 dest
= flinfo
->symbuf
+ flinfo
->symbuf_count
* bed
->s
->sizeof_sym
;
8455 destshndx
= flinfo
->symshndxbuf
;
8456 if (destshndx
!= NULL
)
8458 if (bfd_get_symcount (flinfo
->output_bfd
) >= flinfo
->shndxbuf_size
)
8462 amt
= flinfo
->shndxbuf_size
* sizeof (Elf_External_Sym_Shndx
);
8463 destshndx
= (Elf_External_Sym_Shndx
*) bfd_realloc (destshndx
,
8465 if (destshndx
== NULL
)
8467 flinfo
->symshndxbuf
= destshndx
;
8468 memset ((char *) destshndx
+ amt
, 0, amt
);
8469 flinfo
->shndxbuf_size
*= 2;
8471 destshndx
+= bfd_get_symcount (flinfo
->output_bfd
);
8474 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, elfsym
, dest
, destshndx
);
8475 flinfo
->symbuf_count
+= 1;
8476 bfd_get_symcount (flinfo
->output_bfd
) += 1;
8481 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8484 check_dynsym (bfd
*abfd
, Elf_Internal_Sym
*sym
)
8486 if (sym
->st_shndx
>= (SHN_LORESERVE
& 0xffff)
8487 && sym
->st_shndx
< SHN_LORESERVE
)
8489 /* The gABI doesn't support dynamic symbols in output sections
8491 (*_bfd_error_handler
)
8492 (_("%B: Too many sections: %d (>= %d)"),
8493 abfd
, bfd_count_sections (abfd
), SHN_LORESERVE
& 0xffff);
8494 bfd_set_error (bfd_error_nonrepresentable_section
);
8500 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8501 allowing an unsatisfied unversioned symbol in the DSO to match a
8502 versioned symbol that would normally require an explicit version.
8503 We also handle the case that a DSO references a hidden symbol
8504 which may be satisfied by a versioned symbol in another DSO. */
8507 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
8508 const struct elf_backend_data
*bed
,
8509 struct elf_link_hash_entry
*h
)
8512 struct elf_link_loaded_list
*loaded
;
8514 if (!is_elf_hash_table (info
->hash
))
8517 /* Check indirect symbol. */
8518 while (h
->root
.type
== bfd_link_hash_indirect
)
8519 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8521 switch (h
->root
.type
)
8527 case bfd_link_hash_undefined
:
8528 case bfd_link_hash_undefweak
:
8529 abfd
= h
->root
.u
.undef
.abfd
;
8530 if ((abfd
->flags
& DYNAMIC
) == 0
8531 || (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) == 0)
8535 case bfd_link_hash_defined
:
8536 case bfd_link_hash_defweak
:
8537 abfd
= h
->root
.u
.def
.section
->owner
;
8540 case bfd_link_hash_common
:
8541 abfd
= h
->root
.u
.c
.p
->section
->owner
;
8544 BFD_ASSERT (abfd
!= NULL
);
8546 for (loaded
= elf_hash_table (info
)->loaded
;
8548 loaded
= loaded
->next
)
8551 Elf_Internal_Shdr
*hdr
;
8552 bfd_size_type symcount
;
8553 bfd_size_type extsymcount
;
8554 bfd_size_type extsymoff
;
8555 Elf_Internal_Shdr
*versymhdr
;
8556 Elf_Internal_Sym
*isym
;
8557 Elf_Internal_Sym
*isymend
;
8558 Elf_Internal_Sym
*isymbuf
;
8559 Elf_External_Versym
*ever
;
8560 Elf_External_Versym
*extversym
;
8562 input
= loaded
->abfd
;
8564 /* We check each DSO for a possible hidden versioned definition. */
8566 || (input
->flags
& DYNAMIC
) == 0
8567 || elf_dynversym (input
) == 0)
8570 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
8572 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
8573 if (elf_bad_symtab (input
))
8575 extsymcount
= symcount
;
8580 extsymcount
= symcount
- hdr
->sh_info
;
8581 extsymoff
= hdr
->sh_info
;
8584 if (extsymcount
== 0)
8587 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
8589 if (isymbuf
== NULL
)
8592 /* Read in any version definitions. */
8593 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
8594 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
8595 if (extversym
== NULL
)
8598 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
8599 || (bfd_bread (extversym
, versymhdr
->sh_size
, input
)
8600 != versymhdr
->sh_size
))
8608 ever
= extversym
+ extsymoff
;
8609 isymend
= isymbuf
+ extsymcount
;
8610 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
8613 Elf_Internal_Versym iver
;
8614 unsigned short version_index
;
8616 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
8617 || isym
->st_shndx
== SHN_UNDEF
)
8620 name
= bfd_elf_string_from_elf_section (input
,
8623 if (strcmp (name
, h
->root
.root
.string
) != 0)
8626 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
8628 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
8630 && h
->forced_local
))
8632 /* If we have a non-hidden versioned sym, then it should
8633 have provided a definition for the undefined sym unless
8634 it is defined in a non-shared object and forced local.
8639 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
8640 if (version_index
== 1 || version_index
== 2)
8642 /* This is the base or first version. We can use it. */
8656 /* Add an external symbol to the symbol table. This is called from
8657 the hash table traversal routine. When generating a shared object,
8658 we go through the symbol table twice. The first time we output
8659 anything that might have been forced to local scope in a version
8660 script. The second time we output the symbols that are still
8664 elf_link_output_extsym (struct bfd_hash_entry
*bh
, void *data
)
8666 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
8667 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
8668 struct elf_final_link_info
*flinfo
= eoinfo
->flinfo
;
8670 Elf_Internal_Sym sym
;
8671 asection
*input_sec
;
8672 const struct elf_backend_data
*bed
;
8676 if (h
->root
.type
== bfd_link_hash_warning
)
8678 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8679 if (h
->root
.type
== bfd_link_hash_new
)
8683 /* Decide whether to output this symbol in this pass. */
8684 if (eoinfo
->localsyms
)
8686 if (!h
->forced_local
)
8688 if (eoinfo
->second_pass
8689 && !((h
->root
.type
== bfd_link_hash_defined
8690 || h
->root
.type
== bfd_link_hash_defweak
)
8691 && h
->root
.u
.def
.section
->output_section
!= NULL
))
8694 if (!eoinfo
->file_sym_done
8695 && (eoinfo
->second_pass
? eoinfo
->flinfo
->filesym_count
== 1
8696 : eoinfo
->flinfo
->filesym_count
> 1))
8698 /* Output a FILE symbol so that following locals are not associated
8699 with the wrong input file. */
8700 memset (&sym
, 0, sizeof (sym
));
8701 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8702 sym
.st_shndx
= SHN_ABS
;
8703 if (!elf_link_output_sym (eoinfo
->flinfo
, NULL
, &sym
,
8704 bfd_und_section_ptr
, NULL
))
8707 eoinfo
->file_sym_done
= TRUE
;
8712 if (h
->forced_local
)
8716 bed
= get_elf_backend_data (flinfo
->output_bfd
);
8718 if (h
->root
.type
== bfd_link_hash_undefined
)
8720 /* If we have an undefined symbol reference here then it must have
8721 come from a shared library that is being linked in. (Undefined
8722 references in regular files have already been handled unless
8723 they are in unreferenced sections which are removed by garbage
8725 bfd_boolean ignore_undef
= FALSE
;
8727 /* Some symbols may be special in that the fact that they're
8728 undefined can be safely ignored - let backend determine that. */
8729 if (bed
->elf_backend_ignore_undef_symbol
)
8730 ignore_undef
= bed
->elf_backend_ignore_undef_symbol (h
);
8732 /* If we are reporting errors for this situation then do so now. */
8735 && (!h
->ref_regular
|| flinfo
->info
->gc_sections
)
8736 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
)
8737 && flinfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
8739 if (!(flinfo
->info
->callbacks
->undefined_symbol
8740 (flinfo
->info
, h
->root
.root
.string
,
8741 h
->ref_regular
? NULL
: h
->root
.u
.undef
.abfd
,
8743 (flinfo
->info
->unresolved_syms_in_shared_libs
8744 == RM_GENERATE_ERROR
))))
8746 bfd_set_error (bfd_error_bad_value
);
8747 eoinfo
->failed
= TRUE
;
8753 /* We should also warn if a forced local symbol is referenced from
8754 shared libraries. */
8755 if (!flinfo
->info
->relocatable
8756 && flinfo
->info
->executable
8761 && h
->ref_dynamic_nonweak
8762 && !elf_link_check_versioned_symbol (flinfo
->info
, bed
, h
))
8766 struct elf_link_hash_entry
*hi
= h
;
8768 /* Check indirect symbol. */
8769 while (hi
->root
.type
== bfd_link_hash_indirect
)
8770 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
8772 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
)
8773 msg
= _("%B: internal symbol `%s' in %B is referenced by DSO");
8774 else if (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
8775 msg
= _("%B: hidden symbol `%s' in %B is referenced by DSO");
8777 msg
= _("%B: local symbol `%s' in %B is referenced by DSO");
8778 def_bfd
= flinfo
->output_bfd
;
8779 if (hi
->root
.u
.def
.section
!= bfd_abs_section_ptr
)
8780 def_bfd
= hi
->root
.u
.def
.section
->owner
;
8781 (*_bfd_error_handler
) (msg
, flinfo
->output_bfd
, def_bfd
,
8782 h
->root
.root
.string
);
8783 bfd_set_error (bfd_error_bad_value
);
8784 eoinfo
->failed
= TRUE
;
8788 /* We don't want to output symbols that have never been mentioned by
8789 a regular file, or that we have been told to strip. However, if
8790 h->indx is set to -2, the symbol is used by a reloc and we must
8794 else if ((h
->def_dynamic
8796 || h
->root
.type
== bfd_link_hash_new
)
8800 else if (flinfo
->info
->strip
== strip_all
)
8802 else if (flinfo
->info
->strip
== strip_some
8803 && bfd_hash_lookup (flinfo
->info
->keep_hash
,
8804 h
->root
.root
.string
, FALSE
, FALSE
) == NULL
)
8806 else if ((h
->root
.type
== bfd_link_hash_defined
8807 || h
->root
.type
== bfd_link_hash_defweak
)
8808 && ((flinfo
->info
->strip_discarded
8809 && discarded_section (h
->root
.u
.def
.section
))
8810 || (h
->root
.u
.def
.section
->owner
!= NULL
8811 && (h
->root
.u
.def
.section
->owner
->flags
& BFD_PLUGIN
) != 0)))
8813 else if ((h
->root
.type
== bfd_link_hash_undefined
8814 || h
->root
.type
== bfd_link_hash_undefweak
)
8815 && h
->root
.u
.undef
.abfd
!= NULL
8816 && (h
->root
.u
.undef
.abfd
->flags
& BFD_PLUGIN
) != 0)
8821 /* If we're stripping it, and it's not a dynamic symbol, there's
8822 nothing else to do unless it is a forced local symbol or a
8823 STT_GNU_IFUNC symbol. */
8826 && h
->type
!= STT_GNU_IFUNC
8827 && !h
->forced_local
)
8831 sym
.st_size
= h
->size
;
8832 sym
.st_other
= h
->other
;
8833 if (h
->forced_local
)
8835 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
8836 /* Turn off visibility on local symbol. */
8837 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
8839 /* Set STB_GNU_UNIQUE only if symbol is defined in regular object. */
8840 else if (h
->unique_global
&& h
->def_regular
)
8841 sym
.st_info
= ELF_ST_INFO (STB_GNU_UNIQUE
, h
->type
);
8842 else if (h
->root
.type
== bfd_link_hash_undefweak
8843 || h
->root
.type
== bfd_link_hash_defweak
)
8844 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
8846 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
8847 sym
.st_target_internal
= h
->target_internal
;
8849 switch (h
->root
.type
)
8852 case bfd_link_hash_new
:
8853 case bfd_link_hash_warning
:
8857 case bfd_link_hash_undefined
:
8858 case bfd_link_hash_undefweak
:
8859 input_sec
= bfd_und_section_ptr
;
8860 sym
.st_shndx
= SHN_UNDEF
;
8863 case bfd_link_hash_defined
:
8864 case bfd_link_hash_defweak
:
8866 input_sec
= h
->root
.u
.def
.section
;
8867 if (input_sec
->output_section
!= NULL
)
8869 if (eoinfo
->localsyms
&& flinfo
->filesym_count
== 1)
8871 bfd_boolean second_pass_sym
8872 = (input_sec
->owner
== flinfo
->output_bfd
8873 || input_sec
->owner
== NULL
8874 || (input_sec
->flags
& SEC_LINKER_CREATED
) != 0
8875 || (input_sec
->owner
->flags
& BFD_LINKER_CREATED
) != 0);
8877 eoinfo
->need_second_pass
|= second_pass_sym
;
8878 if (eoinfo
->second_pass
!= second_pass_sym
)
8883 _bfd_elf_section_from_bfd_section (flinfo
->output_bfd
,
8884 input_sec
->output_section
);
8885 if (sym
.st_shndx
== SHN_BAD
)
8887 (*_bfd_error_handler
)
8888 (_("%B: could not find output section %A for input section %A"),
8889 flinfo
->output_bfd
, input_sec
->output_section
, input_sec
);
8890 bfd_set_error (bfd_error_nonrepresentable_section
);
8891 eoinfo
->failed
= TRUE
;
8895 /* ELF symbols in relocatable files are section relative,
8896 but in nonrelocatable files they are virtual
8898 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
8899 if (!flinfo
->info
->relocatable
)
8901 sym
.st_value
+= input_sec
->output_section
->vma
;
8902 if (h
->type
== STT_TLS
)
8904 asection
*tls_sec
= elf_hash_table (flinfo
->info
)->tls_sec
;
8905 if (tls_sec
!= NULL
)
8906 sym
.st_value
-= tls_sec
->vma
;
8909 /* The TLS section may have been garbage collected. */
8910 BFD_ASSERT (flinfo
->info
->gc_sections
8911 && !input_sec
->gc_mark
);
8918 BFD_ASSERT (input_sec
->owner
== NULL
8919 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
8920 sym
.st_shndx
= SHN_UNDEF
;
8921 input_sec
= bfd_und_section_ptr
;
8926 case bfd_link_hash_common
:
8927 input_sec
= h
->root
.u
.c
.p
->section
;
8928 sym
.st_shndx
= bed
->common_section_index (input_sec
);
8929 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
8932 case bfd_link_hash_indirect
:
8933 /* These symbols are created by symbol versioning. They point
8934 to the decorated version of the name. For example, if the
8935 symbol foo@@GNU_1.2 is the default, which should be used when
8936 foo is used with no version, then we add an indirect symbol
8937 foo which points to foo@@GNU_1.2. We ignore these symbols,
8938 since the indirected symbol is already in the hash table. */
8942 /* Give the processor backend a chance to tweak the symbol value,
8943 and also to finish up anything that needs to be done for this
8944 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
8945 forced local syms when non-shared is due to a historical quirk.
8946 STT_GNU_IFUNC symbol must go through PLT. */
8947 if ((h
->type
== STT_GNU_IFUNC
8949 && !flinfo
->info
->relocatable
)
8950 || ((h
->dynindx
!= -1
8952 && ((flinfo
->info
->shared
8953 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
8954 || h
->root
.type
!= bfd_link_hash_undefweak
))
8955 || !h
->forced_local
)
8956 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
))
8958 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
8959 (flinfo
->output_bfd
, flinfo
->info
, h
, &sym
)))
8961 eoinfo
->failed
= TRUE
;
8966 /* If we are marking the symbol as undefined, and there are no
8967 non-weak references to this symbol from a regular object, then
8968 mark the symbol as weak undefined; if there are non-weak
8969 references, mark the symbol as strong. We can't do this earlier,
8970 because it might not be marked as undefined until the
8971 finish_dynamic_symbol routine gets through with it. */
8972 if (sym
.st_shndx
== SHN_UNDEF
8974 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
8975 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
8978 unsigned int type
= ELF_ST_TYPE (sym
.st_info
);
8980 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
8981 if (type
== STT_GNU_IFUNC
)
8984 if (h
->ref_regular_nonweak
)
8985 bindtype
= STB_GLOBAL
;
8987 bindtype
= STB_WEAK
;
8988 sym
.st_info
= ELF_ST_INFO (bindtype
, type
);
8991 /* If this is a symbol defined in a dynamic library, don't use the
8992 symbol size from the dynamic library. Relinking an executable
8993 against a new library may introduce gratuitous changes in the
8994 executable's symbols if we keep the size. */
8995 if (sym
.st_shndx
== SHN_UNDEF
9000 /* If a non-weak symbol with non-default visibility is not defined
9001 locally, it is a fatal error. */
9002 if (!flinfo
->info
->relocatable
9003 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
9004 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
9005 && h
->root
.type
== bfd_link_hash_undefined
9010 if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
)
9011 msg
= _("%B: protected symbol `%s' isn't defined");
9012 else if (ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
)
9013 msg
= _("%B: internal symbol `%s' isn't defined");
9015 msg
= _("%B: hidden symbol `%s' isn't defined");
9016 (*_bfd_error_handler
) (msg
, flinfo
->output_bfd
, h
->root
.root
.string
);
9017 bfd_set_error (bfd_error_bad_value
);
9018 eoinfo
->failed
= TRUE
;
9022 /* If this symbol should be put in the .dynsym section, then put it
9023 there now. We already know the symbol index. We also fill in
9024 the entry in the .hash section. */
9025 if (flinfo
->dynsym_sec
!= NULL
9027 && elf_hash_table (flinfo
->info
)->dynamic_sections_created
)
9031 /* Since there is no version information in the dynamic string,
9032 if there is no version info in symbol version section, we will
9033 have a run-time problem. */
9034 if (h
->verinfo
.verdef
== NULL
)
9036 char *p
= strrchr (h
->root
.root
.string
, ELF_VER_CHR
);
9038 if (p
&& p
[1] != '\0')
9040 (*_bfd_error_handler
)
9041 (_("%B: No symbol version section for versioned symbol `%s'"),
9042 flinfo
->output_bfd
, h
->root
.root
.string
);
9043 eoinfo
->failed
= TRUE
;
9048 sym
.st_name
= h
->dynstr_index
;
9049 esym
= flinfo
->dynsym_sec
->contents
+ h
->dynindx
* bed
->s
->sizeof_sym
;
9050 if (!check_dynsym (flinfo
->output_bfd
, &sym
))
9052 eoinfo
->failed
= TRUE
;
9055 bed
->s
->swap_symbol_out (flinfo
->output_bfd
, &sym
, esym
, 0);
9057 if (flinfo
->hash_sec
!= NULL
)
9059 size_t hash_entry_size
;
9060 bfd_byte
*bucketpos
;
9065 bucketcount
= elf_hash_table (flinfo
->info
)->bucketcount
;
9066 bucket
= h
->u
.elf_hash_value
% bucketcount
;
9069 = elf_section_data (flinfo
->hash_sec
)->this_hdr
.sh_entsize
;
9070 bucketpos
= ((bfd_byte
*) flinfo
->hash_sec
->contents
9071 + (bucket
+ 2) * hash_entry_size
);
9072 chain
= bfd_get (8 * hash_entry_size
, flinfo
->output_bfd
, bucketpos
);
9073 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, h
->dynindx
,
9075 bfd_put (8 * hash_entry_size
, flinfo
->output_bfd
, chain
,
9076 ((bfd_byte
*) flinfo
->hash_sec
->contents
9077 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
9080 if (flinfo
->symver_sec
!= NULL
&& flinfo
->symver_sec
->contents
!= NULL
)
9082 Elf_Internal_Versym iversym
;
9083 Elf_External_Versym
*eversym
;
9085 if (!h
->def_regular
)
9087 if (h
->verinfo
.verdef
== NULL
)
9088 iversym
.vs_vers
= 0;
9090 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
9094 if (h
->verinfo
.vertree
== NULL
)
9095 iversym
.vs_vers
= 1;
9097 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
9098 if (flinfo
->info
->create_default_symver
)
9103 iversym
.vs_vers
|= VERSYM_HIDDEN
;
9105 eversym
= (Elf_External_Versym
*) flinfo
->symver_sec
->contents
;
9106 eversym
+= h
->dynindx
;
9107 _bfd_elf_swap_versym_out (flinfo
->output_bfd
, &iversym
, eversym
);
9111 /* If we're stripping it, then it was just a dynamic symbol, and
9112 there's nothing else to do. */
9113 if (strip
|| (input_sec
->flags
& SEC_EXCLUDE
) != 0)
9116 indx
= bfd_get_symcount (flinfo
->output_bfd
);
9117 ret
= elf_link_output_sym (flinfo
, h
->root
.root
.string
, &sym
, input_sec
, h
);
9120 eoinfo
->failed
= TRUE
;
9125 else if (h
->indx
== -2)
9131 /* Return TRUE if special handling is done for relocs in SEC against
9132 symbols defined in discarded sections. */
9135 elf_section_ignore_discarded_relocs (asection
*sec
)
9137 const struct elf_backend_data
*bed
;
9139 switch (sec
->sec_info_type
)
9141 case SEC_INFO_TYPE_STABS
:
9142 case SEC_INFO_TYPE_EH_FRAME
:
9148 bed
= get_elf_backend_data (sec
->owner
);
9149 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
9150 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))
9156 /* Return a mask saying how ld should treat relocations in SEC against
9157 symbols defined in discarded sections. If this function returns
9158 COMPLAIN set, ld will issue a warning message. If this function
9159 returns PRETEND set, and the discarded section was link-once and the
9160 same size as the kept link-once section, ld will pretend that the
9161 symbol was actually defined in the kept section. Otherwise ld will
9162 zero the reloc (at least that is the intent, but some cooperation by
9163 the target dependent code is needed, particularly for REL targets). */
9166 _bfd_elf_default_action_discarded (asection
*sec
)
9168 if (sec
->flags
& SEC_DEBUGGING
)
9171 if (strcmp (".eh_frame", sec
->name
) == 0)
9174 if (strcmp (".gcc_except_table", sec
->name
) == 0)
9177 return COMPLAIN
| PRETEND
;
9180 /* Find a match between a section and a member of a section group. */
9183 match_group_member (asection
*sec
, asection
*group
,
9184 struct bfd_link_info
*info
)
9186 asection
*first
= elf_next_in_group (group
);
9187 asection
*s
= first
;
9191 if (bfd_elf_match_symbols_in_sections (s
, sec
, info
))
9194 s
= elf_next_in_group (s
);
9202 /* Check if the kept section of a discarded section SEC can be used
9203 to replace it. Return the replacement if it is OK. Otherwise return
9207 _bfd_elf_check_kept_section (asection
*sec
, struct bfd_link_info
*info
)
9211 kept
= sec
->kept_section
;
9214 if ((kept
->flags
& SEC_GROUP
) != 0)
9215 kept
= match_group_member (sec
, kept
, info
);
9217 && ((sec
->rawsize
!= 0 ? sec
->rawsize
: sec
->size
)
9218 != (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9220 sec
->kept_section
= kept
;
9225 /* Link an input file into the linker output file. This function
9226 handles all the sections and relocations of the input file at once.
9227 This is so that we only have to read the local symbols once, and
9228 don't have to keep them in memory. */
9231 elf_link_input_bfd (struct elf_final_link_info
*flinfo
, bfd
*input_bfd
)
9233 int (*relocate_section
)
9234 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
9235 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
9237 Elf_Internal_Shdr
*symtab_hdr
;
9240 Elf_Internal_Sym
*isymbuf
;
9241 Elf_Internal_Sym
*isym
;
9242 Elf_Internal_Sym
*isymend
;
9244 asection
**ppsection
;
9246 const struct elf_backend_data
*bed
;
9247 struct elf_link_hash_entry
**sym_hashes
;
9248 bfd_size_type address_size
;
9249 bfd_vma r_type_mask
;
9251 bfd_boolean have_file_sym
= FALSE
;
9253 output_bfd
= flinfo
->output_bfd
;
9254 bed
= get_elf_backend_data (output_bfd
);
9255 relocate_section
= bed
->elf_backend_relocate_section
;
9257 /* If this is a dynamic object, we don't want to do anything here:
9258 we don't want the local symbols, and we don't want the section
9260 if ((input_bfd
->flags
& DYNAMIC
) != 0)
9263 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
9264 if (elf_bad_symtab (input_bfd
))
9266 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
9271 locsymcount
= symtab_hdr
->sh_info
;
9272 extsymoff
= symtab_hdr
->sh_info
;
9275 /* Read the local symbols. */
9276 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
9277 if (isymbuf
== NULL
&& locsymcount
!= 0)
9279 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
9280 flinfo
->internal_syms
,
9281 flinfo
->external_syms
,
9282 flinfo
->locsym_shndx
);
9283 if (isymbuf
== NULL
)
9287 /* Find local symbol sections and adjust values of symbols in
9288 SEC_MERGE sections. Write out those local symbols we know are
9289 going into the output file. */
9290 isymend
= isymbuf
+ locsymcount
;
9291 for (isym
= isymbuf
, pindex
= flinfo
->indices
, ppsection
= flinfo
->sections
;
9293 isym
++, pindex
++, ppsection
++)
9297 Elf_Internal_Sym osym
;
9303 if (elf_bad_symtab (input_bfd
))
9305 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
9312 if (isym
->st_shndx
== SHN_UNDEF
)
9313 isec
= bfd_und_section_ptr
;
9314 else if (isym
->st_shndx
== SHN_ABS
)
9315 isec
= bfd_abs_section_ptr
;
9316 else if (isym
->st_shndx
== SHN_COMMON
)
9317 isec
= bfd_com_section_ptr
;
9320 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
9323 /* Don't attempt to output symbols with st_shnx in the
9324 reserved range other than SHN_ABS and SHN_COMMON. */
9328 else if (isec
->sec_info_type
== SEC_INFO_TYPE_MERGE
9329 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
9331 _bfd_merged_section_offset (output_bfd
, &isec
,
9332 elf_section_data (isec
)->sec_info
,
9338 /* Don't output the first, undefined, symbol. */
9339 if (ppsection
== flinfo
->sections
)
9342 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
9344 /* We never output section symbols. Instead, we use the
9345 section symbol of the corresponding section in the output
9350 /* If we are stripping all symbols, we don't want to output this
9352 if (flinfo
->info
->strip
== strip_all
)
9355 /* If we are discarding all local symbols, we don't want to
9356 output this one. If we are generating a relocatable output
9357 file, then some of the local symbols may be required by
9358 relocs; we output them below as we discover that they are
9360 if (flinfo
->info
->discard
== discard_all
)
9363 /* If this symbol is defined in a section which we are
9364 discarding, we don't need to keep it. */
9365 if (isym
->st_shndx
!= SHN_UNDEF
9366 && isym
->st_shndx
< SHN_LORESERVE
9367 && bfd_section_removed_from_list (output_bfd
,
9368 isec
->output_section
))
9371 /* Get the name of the symbol. */
9372 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
9377 /* See if we are discarding symbols with this name. */
9378 if ((flinfo
->info
->strip
== strip_some
9379 && (bfd_hash_lookup (flinfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
9381 || (((flinfo
->info
->discard
== discard_sec_merge
9382 && (isec
->flags
& SEC_MERGE
) && !flinfo
->info
->relocatable
)
9383 || flinfo
->info
->discard
== discard_l
)
9384 && bfd_is_local_label_name (input_bfd
, name
)))
9387 if (ELF_ST_TYPE (isym
->st_info
) == STT_FILE
)
9389 have_file_sym
= TRUE
;
9390 flinfo
->filesym_count
+= 1;
9394 /* In the absence of debug info, bfd_find_nearest_line uses
9395 FILE symbols to determine the source file for local
9396 function symbols. Provide a FILE symbol here if input
9397 files lack such, so that their symbols won't be
9398 associated with a previous input file. It's not the
9399 source file, but the best we can do. */
9400 have_file_sym
= TRUE
;
9401 flinfo
->filesym_count
+= 1;
9402 memset (&osym
, 0, sizeof (osym
));
9403 osym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
9404 osym
.st_shndx
= SHN_ABS
;
9405 if (!elf_link_output_sym (flinfo
, input_bfd
->filename
, &osym
,
9406 bfd_abs_section_ptr
, NULL
))
9412 /* Adjust the section index for the output file. */
9413 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9414 isec
->output_section
);
9415 if (osym
.st_shndx
== SHN_BAD
)
9418 /* ELF symbols in relocatable files are section relative, but
9419 in executable files they are virtual addresses. Note that
9420 this code assumes that all ELF sections have an associated
9421 BFD section with a reasonable value for output_offset; below
9422 we assume that they also have a reasonable value for
9423 output_section. Any special sections must be set up to meet
9424 these requirements. */
9425 osym
.st_value
+= isec
->output_offset
;
9426 if (!flinfo
->info
->relocatable
)
9428 osym
.st_value
+= isec
->output_section
->vma
;
9429 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
9431 /* STT_TLS symbols are relative to PT_TLS segment base. */
9432 BFD_ASSERT (elf_hash_table (flinfo
->info
)->tls_sec
!= NULL
);
9433 osym
.st_value
-= elf_hash_table (flinfo
->info
)->tls_sec
->vma
;
9437 indx
= bfd_get_symcount (output_bfd
);
9438 ret
= elf_link_output_sym (flinfo
, name
, &osym
, isec
, NULL
);
9445 if (bed
->s
->arch_size
== 32)
9453 r_type_mask
= 0xffffffff;
9458 /* Relocate the contents of each section. */
9459 sym_hashes
= elf_sym_hashes (input_bfd
);
9460 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
9464 if (! o
->linker_mark
)
9466 /* This section was omitted from the link. */
9470 if (flinfo
->info
->relocatable
9471 && (o
->flags
& (SEC_LINKER_CREATED
| SEC_GROUP
)) == SEC_GROUP
)
9473 /* Deal with the group signature symbol. */
9474 struct bfd_elf_section_data
*sec_data
= elf_section_data (o
);
9475 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
9476 asection
*osec
= o
->output_section
;
9478 if (symndx
>= locsymcount
9479 || (elf_bad_symtab (input_bfd
)
9480 && flinfo
->sections
[symndx
] == NULL
))
9482 struct elf_link_hash_entry
*h
= sym_hashes
[symndx
- extsymoff
];
9483 while (h
->root
.type
== bfd_link_hash_indirect
9484 || h
->root
.type
== bfd_link_hash_warning
)
9485 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9486 /* Arrange for symbol to be output. */
9488 elf_section_data (osec
)->this_hdr
.sh_info
= -2;
9490 else if (ELF_ST_TYPE (isymbuf
[symndx
].st_info
) == STT_SECTION
)
9492 /* We'll use the output section target_index. */
9493 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
9494 elf_section_data (osec
)->this_hdr
.sh_info
= sec
->target_index
;
9498 if (flinfo
->indices
[symndx
] == -1)
9500 /* Otherwise output the local symbol now. */
9501 Elf_Internal_Sym sym
= isymbuf
[symndx
];
9502 asection
*sec
= flinfo
->sections
[symndx
]->output_section
;
9507 name
= bfd_elf_string_from_elf_section (input_bfd
,
9508 symtab_hdr
->sh_link
,
9513 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
9515 if (sym
.st_shndx
== SHN_BAD
)
9518 sym
.st_value
+= o
->output_offset
;
9520 indx
= bfd_get_symcount (output_bfd
);
9521 ret
= elf_link_output_sym (flinfo
, name
, &sym
, o
, NULL
);
9525 flinfo
->indices
[symndx
] = indx
;
9529 elf_section_data (osec
)->this_hdr
.sh_info
9530 = flinfo
->indices
[symndx
];
9534 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
9535 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
9538 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
9540 /* Section was created by _bfd_elf_link_create_dynamic_sections
9545 /* Get the contents of the section. They have been cached by a
9546 relaxation routine. Note that o is a section in an input
9547 file, so the contents field will not have been set by any of
9548 the routines which work on output files. */
9549 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
9550 contents
= elf_section_data (o
)->this_hdr
.contents
;
9553 contents
= flinfo
->contents
;
9554 if (! bfd_get_full_section_contents (input_bfd
, o
, &contents
))
9558 if ((o
->flags
& SEC_RELOC
) != 0)
9560 Elf_Internal_Rela
*internal_relocs
;
9561 Elf_Internal_Rela
*rel
, *relend
;
9562 int action_discarded
;
9565 /* Get the swapped relocs. */
9567 = _bfd_elf_link_read_relocs (input_bfd
, o
, flinfo
->external_relocs
,
9568 flinfo
->internal_relocs
, FALSE
);
9569 if (internal_relocs
== NULL
9570 && o
->reloc_count
> 0)
9573 /* We need to reverse-copy input .ctors/.dtors sections if
9574 they are placed in .init_array/.finit_array for output. */
9575 if (o
->size
> address_size
9576 && ((strncmp (o
->name
, ".ctors", 6) == 0
9577 && strcmp (o
->output_section
->name
,
9578 ".init_array") == 0)
9579 || (strncmp (o
->name
, ".dtors", 6) == 0
9580 && strcmp (o
->output_section
->name
,
9581 ".fini_array") == 0))
9582 && (o
->name
[6] == 0 || o
->name
[6] == '.'))
9584 if (o
->size
!= o
->reloc_count
* address_size
)
9586 (*_bfd_error_handler
)
9587 (_("error: %B: size of section %A is not "
9588 "multiple of address size"),
9590 bfd_set_error (bfd_error_on_input
);
9593 o
->flags
|= SEC_ELF_REVERSE_COPY
;
9596 action_discarded
= -1;
9597 if (!elf_section_ignore_discarded_relocs (o
))
9598 action_discarded
= (*bed
->action_discarded
) (o
);
9600 /* Run through the relocs evaluating complex reloc symbols and
9601 looking for relocs against symbols from discarded sections
9602 or section symbols from removed link-once sections.
9603 Complain about relocs against discarded sections. Zero
9604 relocs against removed link-once sections. */
9606 rel
= internal_relocs
;
9607 relend
= rel
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9608 for ( ; rel
< relend
; rel
++)
9610 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
9611 unsigned int s_type
;
9612 asection
**ps
, *sec
;
9613 struct elf_link_hash_entry
*h
= NULL
;
9614 const char *sym_name
;
9616 if (r_symndx
== STN_UNDEF
)
9619 if (r_symndx
>= locsymcount
9620 || (elf_bad_symtab (input_bfd
)
9621 && flinfo
->sections
[r_symndx
] == NULL
))
9623 h
= sym_hashes
[r_symndx
- extsymoff
];
9625 /* Badly formatted input files can contain relocs that
9626 reference non-existant symbols. Check here so that
9627 we do not seg fault. */
9632 sprintf_vma (buffer
, rel
->r_info
);
9633 (*_bfd_error_handler
)
9634 (_("error: %B contains a reloc (0x%s) for section %A "
9635 "that references a non-existent global symbol"),
9636 input_bfd
, o
, buffer
);
9637 bfd_set_error (bfd_error_bad_value
);
9641 while (h
->root
.type
== bfd_link_hash_indirect
9642 || h
->root
.type
== bfd_link_hash_warning
)
9643 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9648 if (h
->root
.type
== bfd_link_hash_defined
9649 || h
->root
.type
== bfd_link_hash_defweak
)
9650 ps
= &h
->root
.u
.def
.section
;
9652 sym_name
= h
->root
.root
.string
;
9656 Elf_Internal_Sym
*sym
= isymbuf
+ r_symndx
;
9658 s_type
= ELF_ST_TYPE (sym
->st_info
);
9659 ps
= &flinfo
->sections
[r_symndx
];
9660 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
9664 if ((s_type
== STT_RELC
|| s_type
== STT_SRELC
)
9665 && !flinfo
->info
->relocatable
)
9668 bfd_vma dot
= (rel
->r_offset
9669 + o
->output_offset
+ o
->output_section
->vma
);
9671 printf ("Encountered a complex symbol!");
9672 printf (" (input_bfd %s, section %s, reloc %ld\n",
9673 input_bfd
->filename
, o
->name
,
9674 (long) (rel
- internal_relocs
));
9675 printf (" symbol: idx %8.8lx, name %s\n",
9676 r_symndx
, sym_name
);
9677 printf (" reloc : info %8.8lx, addr %8.8lx\n",
9678 (unsigned long) rel
->r_info
,
9679 (unsigned long) rel
->r_offset
);
9681 if (!eval_symbol (&val
, &sym_name
, input_bfd
, flinfo
, dot
,
9682 isymbuf
, locsymcount
, s_type
== STT_SRELC
))
9685 /* Symbol evaluated OK. Update to absolute value. */
9686 set_symbol_value (input_bfd
, isymbuf
, locsymcount
,
9691 if (action_discarded
!= -1 && ps
!= NULL
)
9693 /* Complain if the definition comes from a
9694 discarded section. */
9695 if ((sec
= *ps
) != NULL
&& discarded_section (sec
))
9697 BFD_ASSERT (r_symndx
!= STN_UNDEF
);
9698 if (action_discarded
& COMPLAIN
)
9699 (*flinfo
->info
->callbacks
->einfo
)
9700 (_("%X`%s' referenced in section `%A' of %B: "
9701 "defined in discarded section `%A' of %B\n"),
9702 sym_name
, o
, input_bfd
, sec
, sec
->owner
);
9704 /* Try to do the best we can to support buggy old
9705 versions of gcc. Pretend that the symbol is
9706 really defined in the kept linkonce section.
9707 FIXME: This is quite broken. Modifying the
9708 symbol here means we will be changing all later
9709 uses of the symbol, not just in this section. */
9710 if (action_discarded
& PRETEND
)
9714 kept
= _bfd_elf_check_kept_section (sec
,
9726 /* Relocate the section by invoking a back end routine.
9728 The back end routine is responsible for adjusting the
9729 section contents as necessary, and (if using Rela relocs
9730 and generating a relocatable output file) adjusting the
9731 reloc addend as necessary.
9733 The back end routine does not have to worry about setting
9734 the reloc address or the reloc symbol index.
9736 The back end routine is given a pointer to the swapped in
9737 internal symbols, and can access the hash table entries
9738 for the external symbols via elf_sym_hashes (input_bfd).
9740 When generating relocatable output, the back end routine
9741 must handle STB_LOCAL/STT_SECTION symbols specially. The
9742 output symbol is going to be a section symbol
9743 corresponding to the output section, which will require
9744 the addend to be adjusted. */
9746 ret
= (*relocate_section
) (output_bfd
, flinfo
->info
,
9747 input_bfd
, o
, contents
,
9755 || flinfo
->info
->relocatable
9756 || flinfo
->info
->emitrelocations
)
9758 Elf_Internal_Rela
*irela
;
9759 Elf_Internal_Rela
*irelaend
, *irelamid
;
9760 bfd_vma last_offset
;
9761 struct elf_link_hash_entry
**rel_hash
;
9762 struct elf_link_hash_entry
**rel_hash_list
, **rela_hash_list
;
9763 Elf_Internal_Shdr
*input_rel_hdr
, *input_rela_hdr
;
9764 unsigned int next_erel
;
9765 bfd_boolean rela_normal
;
9766 struct bfd_elf_section_data
*esdi
, *esdo
;
9768 esdi
= elf_section_data (o
);
9769 esdo
= elf_section_data (o
->output_section
);
9770 rela_normal
= FALSE
;
9772 /* Adjust the reloc addresses and symbol indices. */
9774 irela
= internal_relocs
;
9775 irelaend
= irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9776 rel_hash
= esdo
->rel
.hashes
+ esdo
->rel
.count
;
9777 /* We start processing the REL relocs, if any. When we reach
9778 IRELAMID in the loop, we switch to the RELA relocs. */
9780 if (esdi
->rel
.hdr
!= NULL
)
9781 irelamid
+= (NUM_SHDR_ENTRIES (esdi
->rel
.hdr
)
9782 * bed
->s
->int_rels_per_ext_rel
);
9783 rel_hash_list
= rel_hash
;
9784 rela_hash_list
= NULL
;
9785 last_offset
= o
->output_offset
;
9786 if (!flinfo
->info
->relocatable
)
9787 last_offset
+= o
->output_section
->vma
;
9788 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
9790 unsigned long r_symndx
;
9792 Elf_Internal_Sym sym
;
9794 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
9800 if (irela
== irelamid
)
9802 rel_hash
= esdo
->rela
.hashes
+ esdo
->rela
.count
;
9803 rela_hash_list
= rel_hash
;
9804 rela_normal
= bed
->rela_normal
;
9807 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
9810 if (irela
->r_offset
>= (bfd_vma
) -2)
9812 /* This is a reloc for a deleted entry or somesuch.
9813 Turn it into an R_*_NONE reloc, at the same
9814 offset as the last reloc. elf_eh_frame.c and
9815 bfd_elf_discard_info rely on reloc offsets
9817 irela
->r_offset
= last_offset
;
9819 irela
->r_addend
= 0;
9823 irela
->r_offset
+= o
->output_offset
;
9825 /* Relocs in an executable have to be virtual addresses. */
9826 if (!flinfo
->info
->relocatable
)
9827 irela
->r_offset
+= o
->output_section
->vma
;
9829 last_offset
= irela
->r_offset
;
9831 r_symndx
= irela
->r_info
>> r_sym_shift
;
9832 if (r_symndx
== STN_UNDEF
)
9835 if (r_symndx
>= locsymcount
9836 || (elf_bad_symtab (input_bfd
)
9837 && flinfo
->sections
[r_symndx
] == NULL
))
9839 struct elf_link_hash_entry
*rh
;
9842 /* This is a reloc against a global symbol. We
9843 have not yet output all the local symbols, so
9844 we do not know the symbol index of any global
9845 symbol. We set the rel_hash entry for this
9846 reloc to point to the global hash table entry
9847 for this symbol. The symbol index is then
9848 set at the end of bfd_elf_final_link. */
9849 indx
= r_symndx
- extsymoff
;
9850 rh
= elf_sym_hashes (input_bfd
)[indx
];
9851 while (rh
->root
.type
== bfd_link_hash_indirect
9852 || rh
->root
.type
== bfd_link_hash_warning
)
9853 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
9855 /* Setting the index to -2 tells
9856 elf_link_output_extsym that this symbol is
9858 BFD_ASSERT (rh
->indx
< 0);
9866 /* This is a reloc against a local symbol. */
9869 sym
= isymbuf
[r_symndx
];
9870 sec
= flinfo
->sections
[r_symndx
];
9871 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
9873 /* I suppose the backend ought to fill in the
9874 section of any STT_SECTION symbol against a
9875 processor specific section. */
9876 r_symndx
= STN_UNDEF
;
9877 if (bfd_is_abs_section (sec
))
9879 else if (sec
== NULL
|| sec
->owner
== NULL
)
9881 bfd_set_error (bfd_error_bad_value
);
9886 asection
*osec
= sec
->output_section
;
9888 /* If we have discarded a section, the output
9889 section will be the absolute section. In
9890 case of discarded SEC_MERGE sections, use
9891 the kept section. relocate_section should
9892 have already handled discarded linkonce
9894 if (bfd_is_abs_section (osec
)
9895 && sec
->kept_section
!= NULL
9896 && sec
->kept_section
->output_section
!= NULL
)
9898 osec
= sec
->kept_section
->output_section
;
9899 irela
->r_addend
-= osec
->vma
;
9902 if (!bfd_is_abs_section (osec
))
9904 r_symndx
= osec
->target_index
;
9905 if (r_symndx
== STN_UNDEF
)
9907 irela
->r_addend
+= osec
->vma
;
9908 osec
= _bfd_nearby_section (output_bfd
, osec
,
9910 irela
->r_addend
-= osec
->vma
;
9911 r_symndx
= osec
->target_index
;
9916 /* Adjust the addend according to where the
9917 section winds up in the output section. */
9919 irela
->r_addend
+= sec
->output_offset
;
9923 if (flinfo
->indices
[r_symndx
] == -1)
9925 unsigned long shlink
;
9930 if (flinfo
->info
->strip
== strip_all
)
9932 /* You can't do ld -r -s. */
9933 bfd_set_error (bfd_error_invalid_operation
);
9937 /* This symbol was skipped earlier, but
9938 since it is needed by a reloc, we
9939 must output it now. */
9940 shlink
= symtab_hdr
->sh_link
;
9941 name
= (bfd_elf_string_from_elf_section
9942 (input_bfd
, shlink
, sym
.st_name
));
9946 osec
= sec
->output_section
;
9948 _bfd_elf_section_from_bfd_section (output_bfd
,
9950 if (sym
.st_shndx
== SHN_BAD
)
9953 sym
.st_value
+= sec
->output_offset
;
9954 if (!flinfo
->info
->relocatable
)
9956 sym
.st_value
+= osec
->vma
;
9957 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
9959 /* STT_TLS symbols are relative to PT_TLS
9961 BFD_ASSERT (elf_hash_table (flinfo
->info
)
9963 sym
.st_value
-= (elf_hash_table (flinfo
->info
)
9968 indx
= bfd_get_symcount (output_bfd
);
9969 ret
= elf_link_output_sym (flinfo
, name
, &sym
, sec
,
9974 flinfo
->indices
[r_symndx
] = indx
;
9979 r_symndx
= flinfo
->indices
[r_symndx
];
9982 irela
->r_info
= ((bfd_vma
) r_symndx
<< r_sym_shift
9983 | (irela
->r_info
& r_type_mask
));
9986 /* Swap out the relocs. */
9987 input_rel_hdr
= esdi
->rel
.hdr
;
9988 if (input_rel_hdr
&& input_rel_hdr
->sh_size
!= 0)
9990 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
9995 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
9996 * bed
->s
->int_rels_per_ext_rel
);
9997 rel_hash_list
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
10000 input_rela_hdr
= esdi
->rela
.hdr
;
10001 if (input_rela_hdr
&& input_rela_hdr
->sh_size
!= 0)
10003 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
10012 /* Write out the modified section contents. */
10013 if (bed
->elf_backend_write_section
10014 && (*bed
->elf_backend_write_section
) (output_bfd
, flinfo
->info
, o
,
10017 /* Section written out. */
10019 else switch (o
->sec_info_type
)
10021 case SEC_INFO_TYPE_STABS
:
10022 if (! (_bfd_write_section_stabs
10024 &elf_hash_table (flinfo
->info
)->stab_info
,
10025 o
, &elf_section_data (o
)->sec_info
, contents
)))
10028 case SEC_INFO_TYPE_MERGE
:
10029 if (! _bfd_write_merged_section (output_bfd
, o
,
10030 elf_section_data (o
)->sec_info
))
10033 case SEC_INFO_TYPE_EH_FRAME
:
10035 if (! _bfd_elf_write_section_eh_frame (output_bfd
, flinfo
->info
,
10042 /* FIXME: octets_per_byte. */
10043 if (! (o
->flags
& SEC_EXCLUDE
))
10045 file_ptr offset
= (file_ptr
) o
->output_offset
;
10046 bfd_size_type todo
= o
->size
;
10047 if ((o
->flags
& SEC_ELF_REVERSE_COPY
))
10049 /* Reverse-copy input section to output. */
10052 todo
-= address_size
;
10053 if (! bfd_set_section_contents (output_bfd
,
10061 offset
+= address_size
;
10065 else if (! bfd_set_section_contents (output_bfd
,
10079 /* Generate a reloc when linking an ELF file. This is a reloc
10080 requested by the linker, and does not come from any input file. This
10081 is used to build constructor and destructor tables when linking
10085 elf_reloc_link_order (bfd
*output_bfd
,
10086 struct bfd_link_info
*info
,
10087 asection
*output_section
,
10088 struct bfd_link_order
*link_order
)
10090 reloc_howto_type
*howto
;
10094 struct bfd_elf_section_reloc_data
*reldata
;
10095 struct elf_link_hash_entry
**rel_hash_ptr
;
10096 Elf_Internal_Shdr
*rel_hdr
;
10097 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
10098 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
10101 struct bfd_elf_section_data
*esdo
= elf_section_data (output_section
);
10103 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
10106 bfd_set_error (bfd_error_bad_value
);
10110 addend
= link_order
->u
.reloc
.p
->addend
;
10113 reldata
= &esdo
->rel
;
10114 else if (esdo
->rela
.hdr
)
10115 reldata
= &esdo
->rela
;
10122 /* Figure out the symbol index. */
10123 rel_hash_ptr
= reldata
->hashes
+ reldata
->count
;
10124 if (link_order
->type
== bfd_section_reloc_link_order
)
10126 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
10127 BFD_ASSERT (indx
!= 0);
10128 *rel_hash_ptr
= NULL
;
10132 struct elf_link_hash_entry
*h
;
10134 /* Treat a reloc against a defined symbol as though it were
10135 actually against the section. */
10136 h
= ((struct elf_link_hash_entry
*)
10137 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
10138 link_order
->u
.reloc
.p
->u
.name
,
10139 FALSE
, FALSE
, TRUE
));
10141 && (h
->root
.type
== bfd_link_hash_defined
10142 || h
->root
.type
== bfd_link_hash_defweak
))
10146 section
= h
->root
.u
.def
.section
;
10147 indx
= section
->output_section
->target_index
;
10148 *rel_hash_ptr
= NULL
;
10149 /* It seems that we ought to add the symbol value to the
10150 addend here, but in practice it has already been added
10151 because it was passed to constructor_callback. */
10152 addend
+= section
->output_section
->vma
+ section
->output_offset
;
10154 else if (h
!= NULL
)
10156 /* Setting the index to -2 tells elf_link_output_extsym that
10157 this symbol is used by a reloc. */
10164 if (! ((*info
->callbacks
->unattached_reloc
)
10165 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0)))
10171 /* If this is an inplace reloc, we must write the addend into the
10173 if (howto
->partial_inplace
&& addend
!= 0)
10175 bfd_size_type size
;
10176 bfd_reloc_status_type rstat
;
10179 const char *sym_name
;
10181 size
= (bfd_size_type
) bfd_get_reloc_size (howto
);
10182 buf
= (bfd_byte
*) bfd_zmalloc (size
);
10185 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
10192 case bfd_reloc_outofrange
:
10195 case bfd_reloc_overflow
:
10196 if (link_order
->type
== bfd_section_reloc_link_order
)
10197 sym_name
= bfd_section_name (output_bfd
,
10198 link_order
->u
.reloc
.p
->u
.section
);
10200 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
10201 if (! ((*info
->callbacks
->reloc_overflow
)
10202 (info
, NULL
, sym_name
, howto
->name
, addend
, NULL
,
10203 NULL
, (bfd_vma
) 0)))
10210 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
10211 link_order
->offset
, size
);
10217 /* The address of a reloc is relative to the section in a
10218 relocatable file, and is a virtual address in an executable
10220 offset
= link_order
->offset
;
10221 if (! info
->relocatable
)
10222 offset
+= output_section
->vma
;
10224 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
10226 irel
[i
].r_offset
= offset
;
10227 irel
[i
].r_info
= 0;
10228 irel
[i
].r_addend
= 0;
10230 if (bed
->s
->arch_size
== 32)
10231 irel
[0].r_info
= ELF32_R_INFO (indx
, howto
->type
);
10233 irel
[0].r_info
= ELF64_R_INFO (indx
, howto
->type
);
10235 rel_hdr
= reldata
->hdr
;
10236 erel
= rel_hdr
->contents
;
10237 if (rel_hdr
->sh_type
== SHT_REL
)
10239 erel
+= reldata
->count
* bed
->s
->sizeof_rel
;
10240 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
10244 irel
[0].r_addend
= addend
;
10245 erel
+= reldata
->count
* bed
->s
->sizeof_rela
;
10246 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
10255 /* Get the output vma of the section pointed to by the sh_link field. */
10258 elf_get_linked_section_vma (struct bfd_link_order
*p
)
10260 Elf_Internal_Shdr
**elf_shdrp
;
10264 s
= p
->u
.indirect
.section
;
10265 elf_shdrp
= elf_elfsections (s
->owner
);
10266 elfsec
= _bfd_elf_section_from_bfd_section (s
->owner
, s
);
10267 elfsec
= elf_shdrp
[elfsec
]->sh_link
;
10269 The Intel C compiler generates SHT_IA_64_UNWIND with
10270 SHF_LINK_ORDER. But it doesn't set the sh_link or
10271 sh_info fields. Hence we could get the situation
10272 where elfsec is 0. */
10275 const struct elf_backend_data
*bed
10276 = get_elf_backend_data (s
->owner
);
10277 if (bed
->link_order_error_handler
)
10278 bed
->link_order_error_handler
10279 (_("%B: warning: sh_link not set for section `%A'"), s
->owner
, s
);
10284 s
= elf_shdrp
[elfsec
]->bfd_section
;
10285 return s
->output_section
->vma
+ s
->output_offset
;
10290 /* Compare two sections based on the locations of the sections they are
10291 linked to. Used by elf_fixup_link_order. */
10294 compare_link_order (const void * a
, const void * b
)
10299 apos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)a
);
10300 bpos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)b
);
10303 return apos
> bpos
;
10307 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
10308 order as their linked sections. Returns false if this could not be done
10309 because an output section includes both ordered and unordered
10310 sections. Ideally we'd do this in the linker proper. */
10313 elf_fixup_link_order (bfd
*abfd
, asection
*o
)
10315 int seen_linkorder
;
10318 struct bfd_link_order
*p
;
10320 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10322 struct bfd_link_order
**sections
;
10323 asection
*s
, *other_sec
, *linkorder_sec
;
10327 linkorder_sec
= NULL
;
10329 seen_linkorder
= 0;
10330 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10332 if (p
->type
== bfd_indirect_link_order
)
10334 s
= p
->u
.indirect
.section
;
10336 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
10337 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
10338 && (elfsec
= _bfd_elf_section_from_bfd_section (sub
, s
))
10339 && elfsec
< elf_numsections (sub
)
10340 && elf_elfsections (sub
)[elfsec
]->sh_flags
& SHF_LINK_ORDER
10341 && elf_elfsections (sub
)[elfsec
]->sh_link
< elf_numsections (sub
))
10355 if (seen_other
&& seen_linkorder
)
10357 if (other_sec
&& linkorder_sec
)
10358 (*_bfd_error_handler
) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10360 linkorder_sec
->owner
, other_sec
,
10363 (*_bfd_error_handler
) (_("%A has both ordered and unordered sections"),
10365 bfd_set_error (bfd_error_bad_value
);
10370 if (!seen_linkorder
)
10373 sections
= (struct bfd_link_order
**)
10374 bfd_malloc (seen_linkorder
* sizeof (struct bfd_link_order
*));
10375 if (sections
== NULL
)
10377 seen_linkorder
= 0;
10379 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10381 sections
[seen_linkorder
++] = p
;
10383 /* Sort the input sections in the order of their linked section. */
10384 qsort (sections
, seen_linkorder
, sizeof (struct bfd_link_order
*),
10385 compare_link_order
);
10387 /* Change the offsets of the sections. */
10389 for (n
= 0; n
< seen_linkorder
; n
++)
10391 s
= sections
[n
]->u
.indirect
.section
;
10392 offset
&= ~(bfd_vma
) 0 << s
->alignment_power
;
10393 s
->output_offset
= offset
;
10394 sections
[n
]->offset
= offset
;
10395 /* FIXME: octets_per_byte. */
10396 offset
+= sections
[n
]->size
;
10404 elf_final_link_free (bfd
*obfd
, struct elf_final_link_info
*flinfo
)
10408 if (flinfo
->symstrtab
!= NULL
)
10409 _bfd_stringtab_free (flinfo
->symstrtab
);
10410 if (flinfo
->contents
!= NULL
)
10411 free (flinfo
->contents
);
10412 if (flinfo
->external_relocs
!= NULL
)
10413 free (flinfo
->external_relocs
);
10414 if (flinfo
->internal_relocs
!= NULL
)
10415 free (flinfo
->internal_relocs
);
10416 if (flinfo
->external_syms
!= NULL
)
10417 free (flinfo
->external_syms
);
10418 if (flinfo
->locsym_shndx
!= NULL
)
10419 free (flinfo
->locsym_shndx
);
10420 if (flinfo
->internal_syms
!= NULL
)
10421 free (flinfo
->internal_syms
);
10422 if (flinfo
->indices
!= NULL
)
10423 free (flinfo
->indices
);
10424 if (flinfo
->sections
!= NULL
)
10425 free (flinfo
->sections
);
10426 if (flinfo
->symbuf
!= NULL
)
10427 free (flinfo
->symbuf
);
10428 if (flinfo
->symshndxbuf
!= NULL
)
10429 free (flinfo
->symshndxbuf
);
10430 for (o
= obfd
->sections
; o
!= NULL
; o
= o
->next
)
10432 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10433 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rel
.hashes
!= NULL
)
10434 free (esdo
->rel
.hashes
);
10435 if ((o
->flags
& SEC_RELOC
) != 0 && esdo
->rela
.hashes
!= NULL
)
10436 free (esdo
->rela
.hashes
);
10440 /* Do the final step of an ELF link. */
10443 bfd_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10445 bfd_boolean dynamic
;
10446 bfd_boolean emit_relocs
;
10448 struct elf_final_link_info flinfo
;
10450 struct bfd_link_order
*p
;
10452 bfd_size_type max_contents_size
;
10453 bfd_size_type max_external_reloc_size
;
10454 bfd_size_type max_internal_reloc_count
;
10455 bfd_size_type max_sym_count
;
10456 bfd_size_type max_sym_shndx_count
;
10458 Elf_Internal_Sym elfsym
;
10460 Elf_Internal_Shdr
*symtab_hdr
;
10461 Elf_Internal_Shdr
*symtab_shndx_hdr
;
10462 Elf_Internal_Shdr
*symstrtab_hdr
;
10463 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10464 struct elf_outext_info eoinfo
;
10465 bfd_boolean merged
;
10466 size_t relativecount
= 0;
10467 asection
*reldyn
= 0;
10469 asection
*attr_section
= NULL
;
10470 bfd_vma attr_size
= 0;
10471 const char *std_attrs_section
;
10473 if (! is_elf_hash_table (info
->hash
))
10477 abfd
->flags
|= DYNAMIC
;
10479 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
10480 dynobj
= elf_hash_table (info
)->dynobj
;
10482 emit_relocs
= (info
->relocatable
10483 || info
->emitrelocations
);
10485 flinfo
.info
= info
;
10486 flinfo
.output_bfd
= abfd
;
10487 flinfo
.symstrtab
= _bfd_elf_stringtab_init ();
10488 if (flinfo
.symstrtab
== NULL
)
10493 flinfo
.dynsym_sec
= NULL
;
10494 flinfo
.hash_sec
= NULL
;
10495 flinfo
.symver_sec
= NULL
;
10499 flinfo
.dynsym_sec
= bfd_get_linker_section (dynobj
, ".dynsym");
10500 flinfo
.hash_sec
= bfd_get_linker_section (dynobj
, ".hash");
10501 /* Note that dynsym_sec can be NULL (on VMS). */
10502 flinfo
.symver_sec
= bfd_get_linker_section (dynobj
, ".gnu.version");
10503 /* Note that it is OK if symver_sec is NULL. */
10506 flinfo
.contents
= NULL
;
10507 flinfo
.external_relocs
= NULL
;
10508 flinfo
.internal_relocs
= NULL
;
10509 flinfo
.external_syms
= NULL
;
10510 flinfo
.locsym_shndx
= NULL
;
10511 flinfo
.internal_syms
= NULL
;
10512 flinfo
.indices
= NULL
;
10513 flinfo
.sections
= NULL
;
10514 flinfo
.symbuf
= NULL
;
10515 flinfo
.symshndxbuf
= NULL
;
10516 flinfo
.symbuf_count
= 0;
10517 flinfo
.shndxbuf_size
= 0;
10518 flinfo
.filesym_count
= 0;
10520 /* The object attributes have been merged. Remove the input
10521 sections from the link, and set the contents of the output
10523 std_attrs_section
= get_elf_backend_data (abfd
)->obj_attrs_section
;
10524 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10526 if ((std_attrs_section
&& strcmp (o
->name
, std_attrs_section
) == 0)
10527 || strcmp (o
->name
, ".gnu.attributes") == 0)
10529 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10531 asection
*input_section
;
10533 if (p
->type
!= bfd_indirect_link_order
)
10535 input_section
= p
->u
.indirect
.section
;
10536 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10537 elf_link_input_bfd ignores this section. */
10538 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10541 attr_size
= bfd_elf_obj_attr_size (abfd
);
10544 bfd_set_section_size (abfd
, o
, attr_size
);
10546 /* Skip this section later on. */
10547 o
->map_head
.link_order
= NULL
;
10550 o
->flags
|= SEC_EXCLUDE
;
10554 /* Count up the number of relocations we will output for each output
10555 section, so that we know the sizes of the reloc sections. We
10556 also figure out some maximum sizes. */
10557 max_contents_size
= 0;
10558 max_external_reloc_size
= 0;
10559 max_internal_reloc_count
= 0;
10561 max_sym_shndx_count
= 0;
10563 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10565 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10566 o
->reloc_count
= 0;
10568 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10570 unsigned int reloc_count
= 0;
10571 struct bfd_elf_section_data
*esdi
= NULL
;
10573 if (p
->type
== bfd_section_reloc_link_order
10574 || p
->type
== bfd_symbol_reloc_link_order
)
10576 else if (p
->type
== bfd_indirect_link_order
)
10580 sec
= p
->u
.indirect
.section
;
10581 esdi
= elf_section_data (sec
);
10583 /* Mark all sections which are to be included in the
10584 link. This will normally be every section. We need
10585 to do this so that we can identify any sections which
10586 the linker has decided to not include. */
10587 sec
->linker_mark
= TRUE
;
10589 if (sec
->flags
& SEC_MERGE
)
10592 if (esdo
->this_hdr
.sh_type
== SHT_REL
10593 || esdo
->this_hdr
.sh_type
== SHT_RELA
)
10594 /* Some backends use reloc_count in relocation sections
10595 to count particular types of relocs. Of course,
10596 reloc sections themselves can't have relocations. */
10598 else if (info
->relocatable
|| info
->emitrelocations
)
10599 reloc_count
= sec
->reloc_count
;
10600 else if (bed
->elf_backend_count_relocs
)
10601 reloc_count
= (*bed
->elf_backend_count_relocs
) (info
, sec
);
10603 if (sec
->rawsize
> max_contents_size
)
10604 max_contents_size
= sec
->rawsize
;
10605 if (sec
->size
> max_contents_size
)
10606 max_contents_size
= sec
->size
;
10608 /* We are interested in just local symbols, not all
10610 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
10611 && (sec
->owner
->flags
& DYNAMIC
) == 0)
10615 if (elf_bad_symtab (sec
->owner
))
10616 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
10617 / bed
->s
->sizeof_sym
);
10619 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
10621 if (sym_count
> max_sym_count
)
10622 max_sym_count
= sym_count
;
10624 if (sym_count
> max_sym_shndx_count
10625 && elf_symtab_shndx (sec
->owner
) != 0)
10626 max_sym_shndx_count
= sym_count
;
10628 if ((sec
->flags
& SEC_RELOC
) != 0)
10630 size_t ext_size
= 0;
10632 if (esdi
->rel
.hdr
!= NULL
)
10633 ext_size
= esdi
->rel
.hdr
->sh_size
;
10634 if (esdi
->rela
.hdr
!= NULL
)
10635 ext_size
+= esdi
->rela
.hdr
->sh_size
;
10637 if (ext_size
> max_external_reloc_size
)
10638 max_external_reloc_size
= ext_size
;
10639 if (sec
->reloc_count
> max_internal_reloc_count
)
10640 max_internal_reloc_count
= sec
->reloc_count
;
10645 if (reloc_count
== 0)
10648 o
->reloc_count
+= reloc_count
;
10650 if (p
->type
== bfd_indirect_link_order
10651 && (info
->relocatable
|| info
->emitrelocations
))
10654 esdo
->rel
.count
+= NUM_SHDR_ENTRIES (esdi
->rel
.hdr
);
10655 if (esdi
->rela
.hdr
)
10656 esdo
->rela
.count
+= NUM_SHDR_ENTRIES (esdi
->rela
.hdr
);
10661 esdo
->rela
.count
+= reloc_count
;
10663 esdo
->rel
.count
+= reloc_count
;
10667 if (o
->reloc_count
> 0)
10668 o
->flags
|= SEC_RELOC
;
10671 /* Explicitly clear the SEC_RELOC flag. The linker tends to
10672 set it (this is probably a bug) and if it is set
10673 assign_section_numbers will create a reloc section. */
10674 o
->flags
&=~ SEC_RELOC
;
10677 /* If the SEC_ALLOC flag is not set, force the section VMA to
10678 zero. This is done in elf_fake_sections as well, but forcing
10679 the VMA to 0 here will ensure that relocs against these
10680 sections are handled correctly. */
10681 if ((o
->flags
& SEC_ALLOC
) == 0
10682 && ! o
->user_set_vma
)
10686 if (! info
->relocatable
&& merged
)
10687 elf_link_hash_traverse (elf_hash_table (info
),
10688 _bfd_elf_link_sec_merge_syms
, abfd
);
10690 /* Figure out the file positions for everything but the symbol table
10691 and the relocs. We set symcount to force assign_section_numbers
10692 to create a symbol table. */
10693 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
10694 BFD_ASSERT (! abfd
->output_has_begun
);
10695 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
10698 /* Set sizes, and assign file positions for reloc sections. */
10699 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10701 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
10702 if ((o
->flags
& SEC_RELOC
) != 0)
10705 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rel
)))
10709 && !(_bfd_elf_link_size_reloc_section (abfd
, &esdo
->rela
)))
10713 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10714 to count upwards while actually outputting the relocations. */
10715 esdo
->rel
.count
= 0;
10716 esdo
->rela
.count
= 0;
10719 _bfd_elf_assign_file_positions_for_relocs (abfd
);
10721 /* We have now assigned file positions for all the sections except
10722 .symtab and .strtab. We start the .symtab section at the current
10723 file position, and write directly to it. We build the .strtab
10724 section in memory. */
10725 bfd_get_symcount (abfd
) = 0;
10726 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10727 /* sh_name is set in prep_headers. */
10728 symtab_hdr
->sh_type
= SHT_SYMTAB
;
10729 /* sh_flags, sh_addr and sh_size all start off zero. */
10730 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
10731 /* sh_link is set in assign_section_numbers. */
10732 /* sh_info is set below. */
10733 /* sh_offset is set just below. */
10734 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
10736 off
= elf_next_file_pos (abfd
);
10737 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, TRUE
);
10739 /* Note that at this point elf_next_file_pos (abfd) is
10740 incorrect. We do not yet know the size of the .symtab section.
10741 We correct next_file_pos below, after we do know the size. */
10743 /* Allocate a buffer to hold swapped out symbols. This is to avoid
10744 continuously seeking to the right position in the file. */
10745 if (! info
->keep_memory
|| max_sym_count
< 20)
10746 flinfo
.symbuf_size
= 20;
10748 flinfo
.symbuf_size
= max_sym_count
;
10749 amt
= flinfo
.symbuf_size
;
10750 amt
*= bed
->s
->sizeof_sym
;
10751 flinfo
.symbuf
= (bfd_byte
*) bfd_malloc (amt
);
10752 if (flinfo
.symbuf
== NULL
)
10754 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
10756 /* Wild guess at number of output symbols. realloc'd as needed. */
10757 amt
= 2 * max_sym_count
+ elf_numsections (abfd
) + 1000;
10758 flinfo
.shndxbuf_size
= amt
;
10759 amt
*= sizeof (Elf_External_Sym_Shndx
);
10760 flinfo
.symshndxbuf
= (Elf_External_Sym_Shndx
*) bfd_zmalloc (amt
);
10761 if (flinfo
.symshndxbuf
== NULL
)
10765 /* Start writing out the symbol table. The first symbol is always a
10767 if (info
->strip
!= strip_all
10770 elfsym
.st_value
= 0;
10771 elfsym
.st_size
= 0;
10772 elfsym
.st_info
= 0;
10773 elfsym
.st_other
= 0;
10774 elfsym
.st_shndx
= SHN_UNDEF
;
10775 elfsym
.st_target_internal
= 0;
10776 if (elf_link_output_sym (&flinfo
, NULL
, &elfsym
, bfd_und_section_ptr
,
10781 /* Output a symbol for each section. We output these even if we are
10782 discarding local symbols, since they are used for relocs. These
10783 symbols have no names. We store the index of each one in the
10784 index field of the section, so that we can find it again when
10785 outputting relocs. */
10786 if (info
->strip
!= strip_all
10789 elfsym
.st_size
= 0;
10790 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
10791 elfsym
.st_other
= 0;
10792 elfsym
.st_value
= 0;
10793 elfsym
.st_target_internal
= 0;
10794 for (i
= 1; i
< elf_numsections (abfd
); i
++)
10796 o
= bfd_section_from_elf_index (abfd
, i
);
10799 o
->target_index
= bfd_get_symcount (abfd
);
10800 elfsym
.st_shndx
= i
;
10801 if (!info
->relocatable
)
10802 elfsym
.st_value
= o
->vma
;
10803 if (elf_link_output_sym (&flinfo
, NULL
, &elfsym
, o
, NULL
) != 1)
10809 /* Allocate some memory to hold information read in from the input
10811 if (max_contents_size
!= 0)
10813 flinfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
10814 if (flinfo
.contents
== NULL
)
10818 if (max_external_reloc_size
!= 0)
10820 flinfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
10821 if (flinfo
.external_relocs
== NULL
)
10825 if (max_internal_reloc_count
!= 0)
10827 amt
= max_internal_reloc_count
* bed
->s
->int_rels_per_ext_rel
;
10828 amt
*= sizeof (Elf_Internal_Rela
);
10829 flinfo
.internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
10830 if (flinfo
.internal_relocs
== NULL
)
10834 if (max_sym_count
!= 0)
10836 amt
= max_sym_count
* bed
->s
->sizeof_sym
;
10837 flinfo
.external_syms
= (bfd_byte
*) bfd_malloc (amt
);
10838 if (flinfo
.external_syms
== NULL
)
10841 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
10842 flinfo
.internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
10843 if (flinfo
.internal_syms
== NULL
)
10846 amt
= max_sym_count
* sizeof (long);
10847 flinfo
.indices
= (long int *) bfd_malloc (amt
);
10848 if (flinfo
.indices
== NULL
)
10851 amt
= max_sym_count
* sizeof (asection
*);
10852 flinfo
.sections
= (asection
**) bfd_malloc (amt
);
10853 if (flinfo
.sections
== NULL
)
10857 if (max_sym_shndx_count
!= 0)
10859 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
10860 flinfo
.locsym_shndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
10861 if (flinfo
.locsym_shndx
== NULL
)
10865 if (elf_hash_table (info
)->tls_sec
)
10867 bfd_vma base
, end
= 0;
10870 for (sec
= elf_hash_table (info
)->tls_sec
;
10871 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
10874 bfd_size_type size
= sec
->size
;
10877 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
10879 struct bfd_link_order
*ord
= sec
->map_tail
.link_order
;
10882 size
= ord
->offset
+ ord
->size
;
10884 end
= sec
->vma
+ size
;
10886 base
= elf_hash_table (info
)->tls_sec
->vma
;
10887 /* Only align end of TLS section if static TLS doesn't have special
10888 alignment requirements. */
10889 if (bed
->static_tls_alignment
== 1)
10890 end
= align_power (end
,
10891 elf_hash_table (info
)->tls_sec
->alignment_power
);
10892 elf_hash_table (info
)->tls_size
= end
- base
;
10895 /* Reorder SHF_LINK_ORDER sections. */
10896 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10898 if (!elf_fixup_link_order (abfd
, o
))
10902 /* Since ELF permits relocations to be against local symbols, we
10903 must have the local symbols available when we do the relocations.
10904 Since we would rather only read the local symbols once, and we
10905 would rather not keep them in memory, we handle all the
10906 relocations for a single input file at the same time.
10908 Unfortunately, there is no way to know the total number of local
10909 symbols until we have seen all of them, and the local symbol
10910 indices precede the global symbol indices. This means that when
10911 we are generating relocatable output, and we see a reloc against
10912 a global symbol, we can not know the symbol index until we have
10913 finished examining all the local symbols to see which ones we are
10914 going to output. To deal with this, we keep the relocations in
10915 memory, and don't output them until the end of the link. This is
10916 an unfortunate waste of memory, but I don't see a good way around
10917 it. Fortunately, it only happens when performing a relocatable
10918 link, which is not the common case. FIXME: If keep_memory is set
10919 we could write the relocs out and then read them again; I don't
10920 know how bad the memory loss will be. */
10922 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
10923 sub
->output_has_begun
= FALSE
;
10924 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10926 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10928 if (p
->type
== bfd_indirect_link_order
10929 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
10930 == bfd_target_elf_flavour
)
10931 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
10933 if (! sub
->output_has_begun
)
10935 if (! elf_link_input_bfd (&flinfo
, sub
))
10937 sub
->output_has_begun
= TRUE
;
10940 else if (p
->type
== bfd_section_reloc_link_order
10941 || p
->type
== bfd_symbol_reloc_link_order
)
10943 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
10948 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
10950 if (p
->type
== bfd_indirect_link_order
10951 && (bfd_get_flavour (sub
)
10952 == bfd_target_elf_flavour
)
10953 && (elf_elfheader (sub
)->e_ident
[EI_CLASS
]
10954 != bed
->s
->elfclass
))
10956 const char *iclass
, *oclass
;
10958 if (bed
->s
->elfclass
== ELFCLASS64
)
10960 iclass
= "ELFCLASS32";
10961 oclass
= "ELFCLASS64";
10965 iclass
= "ELFCLASS64";
10966 oclass
= "ELFCLASS32";
10969 bfd_set_error (bfd_error_wrong_format
);
10970 (*_bfd_error_handler
)
10971 (_("%B: file class %s incompatible with %s"),
10972 sub
, iclass
, oclass
);
10981 /* Free symbol buffer if needed. */
10982 if (!info
->reduce_memory_overheads
)
10984 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
10985 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
10986 && elf_tdata (sub
)->symbuf
)
10988 free (elf_tdata (sub
)->symbuf
);
10989 elf_tdata (sub
)->symbuf
= NULL
;
10993 /* Output any global symbols that got converted to local in a
10994 version script or due to symbol visibility. We do this in a
10995 separate step since ELF requires all local symbols to appear
10996 prior to any global symbols. FIXME: We should only do this if
10997 some global symbols were, in fact, converted to become local.
10998 FIXME: Will this work correctly with the Irix 5 linker? */
10999 eoinfo
.failed
= FALSE
;
11000 eoinfo
.flinfo
= &flinfo
;
11001 eoinfo
.localsyms
= TRUE
;
11002 eoinfo
.need_second_pass
= FALSE
;
11003 eoinfo
.second_pass
= FALSE
;
11004 eoinfo
.file_sym_done
= FALSE
;
11005 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11009 if (eoinfo
.need_second_pass
)
11011 eoinfo
.second_pass
= TRUE
;
11012 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11017 /* If backend needs to output some local symbols not present in the hash
11018 table, do it now. */
11019 if (bed
->elf_backend_output_arch_local_syms
)
11021 typedef int (*out_sym_func
)
11022 (void *, const char *, Elf_Internal_Sym
*, asection
*,
11023 struct elf_link_hash_entry
*);
11025 if (! ((*bed
->elf_backend_output_arch_local_syms
)
11026 (abfd
, info
, &flinfo
, (out_sym_func
) elf_link_output_sym
)))
11030 /* That wrote out all the local symbols. Finish up the symbol table
11031 with the global symbols. Even if we want to strip everything we
11032 can, we still need to deal with those global symbols that got
11033 converted to local in a version script. */
11035 /* The sh_info field records the index of the first non local symbol. */
11036 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
11039 && flinfo
.dynsym_sec
!= NULL
11040 && flinfo
.dynsym_sec
->output_section
!= bfd_abs_section_ptr
)
11042 Elf_Internal_Sym sym
;
11043 bfd_byte
*dynsym
= flinfo
.dynsym_sec
->contents
;
11044 long last_local
= 0;
11046 /* Write out the section symbols for the output sections. */
11047 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
11053 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
11055 sym
.st_target_internal
= 0;
11057 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
11063 dynindx
= elf_section_data (s
)->dynindx
;
11066 indx
= elf_section_data (s
)->this_idx
;
11067 BFD_ASSERT (indx
> 0);
11068 sym
.st_shndx
= indx
;
11069 if (! check_dynsym (abfd
, &sym
))
11071 sym
.st_value
= s
->vma
;
11072 dest
= dynsym
+ dynindx
* bed
->s
->sizeof_sym
;
11073 if (last_local
< dynindx
)
11074 last_local
= dynindx
;
11075 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
11079 /* Write out the local dynsyms. */
11080 if (elf_hash_table (info
)->dynlocal
)
11082 struct elf_link_local_dynamic_entry
*e
;
11083 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
11088 /* Copy the internal symbol and turn off visibility.
11089 Note that we saved a word of storage and overwrote
11090 the original st_name with the dynstr_index. */
11092 sym
.st_other
&= ~ELF_ST_VISIBILITY (-1);
11094 s
= bfd_section_from_elf_index (e
->input_bfd
,
11099 elf_section_data (s
->output_section
)->this_idx
;
11100 if (! check_dynsym (abfd
, &sym
))
11102 sym
.st_value
= (s
->output_section
->vma
11104 + e
->isym
.st_value
);
11107 if (last_local
< e
->dynindx
)
11108 last_local
= e
->dynindx
;
11110 dest
= dynsym
+ e
->dynindx
* bed
->s
->sizeof_sym
;
11111 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
11115 elf_section_data (flinfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
=
11119 /* We get the global symbols from the hash table. */
11120 eoinfo
.failed
= FALSE
;
11121 eoinfo
.localsyms
= FALSE
;
11122 eoinfo
.flinfo
= &flinfo
;
11123 bfd_hash_traverse (&info
->hash
->table
, elf_link_output_extsym
, &eoinfo
);
11127 /* If backend needs to output some symbols not present in the hash
11128 table, do it now. */
11129 if (bed
->elf_backend_output_arch_syms
)
11131 typedef int (*out_sym_func
)
11132 (void *, const char *, Elf_Internal_Sym
*, asection
*,
11133 struct elf_link_hash_entry
*);
11135 if (! ((*bed
->elf_backend_output_arch_syms
)
11136 (abfd
, info
, &flinfo
, (out_sym_func
) elf_link_output_sym
)))
11140 /* Flush all symbols to the file. */
11141 if (! elf_link_flush_output_syms (&flinfo
, bed
))
11144 /* Now we know the size of the symtab section. */
11145 off
+= symtab_hdr
->sh_size
;
11147 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
11148 if (symtab_shndx_hdr
->sh_name
!= 0)
11150 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
11151 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
11152 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
11153 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
11154 symtab_shndx_hdr
->sh_size
= amt
;
11156 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
11159 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
11160 || (bfd_bwrite (flinfo
.symshndxbuf
, amt
, abfd
) != amt
))
11165 /* Finish up and write out the symbol string table (.strtab)
11167 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
11168 /* sh_name was set in prep_headers. */
11169 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
11170 symstrtab_hdr
->sh_flags
= 0;
11171 symstrtab_hdr
->sh_addr
= 0;
11172 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (flinfo
.symstrtab
);
11173 symstrtab_hdr
->sh_entsize
= 0;
11174 symstrtab_hdr
->sh_link
= 0;
11175 symstrtab_hdr
->sh_info
= 0;
11176 /* sh_offset is set just below. */
11177 symstrtab_hdr
->sh_addralign
= 1;
11179 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, TRUE
);
11180 elf_next_file_pos (abfd
) = off
;
11182 if (bfd_get_symcount (abfd
) > 0)
11184 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
11185 || ! _bfd_stringtab_emit (abfd
, flinfo
.symstrtab
))
11189 /* Adjust the relocs to have the correct symbol indices. */
11190 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11192 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
11193 if ((o
->flags
& SEC_RELOC
) == 0)
11196 if (esdo
->rel
.hdr
!= NULL
)
11197 elf_link_adjust_relocs (abfd
, &esdo
->rel
);
11198 if (esdo
->rela
.hdr
!= NULL
)
11199 elf_link_adjust_relocs (abfd
, &esdo
->rela
);
11201 /* Set the reloc_count field to 0 to prevent write_relocs from
11202 trying to swap the relocs out itself. */
11203 o
->reloc_count
= 0;
11206 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
11207 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
11209 /* If we are linking against a dynamic object, or generating a
11210 shared library, finish up the dynamic linking information. */
11213 bfd_byte
*dyncon
, *dynconend
;
11215 /* Fix up .dynamic entries. */
11216 o
= bfd_get_linker_section (dynobj
, ".dynamic");
11217 BFD_ASSERT (o
!= NULL
);
11219 dyncon
= o
->contents
;
11220 dynconend
= o
->contents
+ o
->size
;
11221 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
11223 Elf_Internal_Dyn dyn
;
11227 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11234 if (relativecount
> 0 && dyncon
+ bed
->s
->sizeof_dyn
< dynconend
)
11236 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
11238 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
11239 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
11242 dyn
.d_un
.d_val
= relativecount
;
11249 name
= info
->init_function
;
11252 name
= info
->fini_function
;
11255 struct elf_link_hash_entry
*h
;
11257 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
11258 FALSE
, FALSE
, TRUE
);
11260 && (h
->root
.type
== bfd_link_hash_defined
11261 || h
->root
.type
== bfd_link_hash_defweak
))
11263 dyn
.d_un
.d_ptr
= h
->root
.u
.def
.value
;
11264 o
= h
->root
.u
.def
.section
;
11265 if (o
->output_section
!= NULL
)
11266 dyn
.d_un
.d_ptr
+= (o
->output_section
->vma
11267 + o
->output_offset
);
11270 /* The symbol is imported from another shared
11271 library and does not apply to this one. */
11272 dyn
.d_un
.d_ptr
= 0;
11279 case DT_PREINIT_ARRAYSZ
:
11280 name
= ".preinit_array";
11282 case DT_INIT_ARRAYSZ
:
11283 name
= ".init_array";
11285 case DT_FINI_ARRAYSZ
:
11286 name
= ".fini_array";
11288 o
= bfd_get_section_by_name (abfd
, name
);
11291 (*_bfd_error_handler
)
11292 (_("%B: could not find output section %s"), abfd
, name
);
11296 (*_bfd_error_handler
)
11297 (_("warning: %s section has zero size"), name
);
11298 dyn
.d_un
.d_val
= o
->size
;
11301 case DT_PREINIT_ARRAY
:
11302 name
= ".preinit_array";
11304 case DT_INIT_ARRAY
:
11305 name
= ".init_array";
11307 case DT_FINI_ARRAY
:
11308 name
= ".fini_array";
11315 name
= ".gnu.hash";
11324 name
= ".gnu.version_d";
11327 name
= ".gnu.version_r";
11330 name
= ".gnu.version";
11332 o
= bfd_get_section_by_name (abfd
, name
);
11335 (*_bfd_error_handler
)
11336 (_("%B: could not find output section %s"), abfd
, name
);
11339 if (elf_section_data (o
->output_section
)->this_hdr
.sh_type
== SHT_NOTE
)
11341 (*_bfd_error_handler
)
11342 (_("warning: section '%s' is being made into a note"), name
);
11343 bfd_set_error (bfd_error_nonrepresentable_section
);
11346 dyn
.d_un
.d_ptr
= o
->vma
;
11353 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
11357 dyn
.d_un
.d_val
= 0;
11358 dyn
.d_un
.d_ptr
= 0;
11359 for (i
= 1; i
< elf_numsections (abfd
); i
++)
11361 Elf_Internal_Shdr
*hdr
;
11363 hdr
= elf_elfsections (abfd
)[i
];
11364 if (hdr
->sh_type
== type
11365 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
11367 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
11368 dyn
.d_un
.d_val
+= hdr
->sh_size
;
11371 if (dyn
.d_un
.d_ptr
== 0
11372 || hdr
->sh_addr
< dyn
.d_un
.d_ptr
)
11373 dyn
.d_un
.d_ptr
= hdr
->sh_addr
;
11379 bed
->s
->swap_dyn_out (dynobj
, &dyn
, dyncon
);
11383 /* If we have created any dynamic sections, then output them. */
11384 if (dynobj
!= NULL
)
11386 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
11389 /* Check for DT_TEXTREL (late, in case the backend removes it). */
11390 if (((info
->warn_shared_textrel
&& info
->shared
)
11391 || info
->error_textrel
)
11392 && (o
= bfd_get_linker_section (dynobj
, ".dynamic")) != NULL
)
11394 bfd_byte
*dyncon
, *dynconend
;
11396 dyncon
= o
->contents
;
11397 dynconend
= o
->contents
+ o
->size
;
11398 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
11400 Elf_Internal_Dyn dyn
;
11402 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
11404 if (dyn
.d_tag
== DT_TEXTREL
)
11406 if (info
->error_textrel
)
11407 info
->callbacks
->einfo
11408 (_("%P%X: read-only segment has dynamic relocations.\n"));
11410 info
->callbacks
->einfo
11411 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11417 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
11419 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
11421 || o
->output_section
== bfd_abs_section_ptr
)
11423 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
11425 /* At this point, we are only interested in sections
11426 created by _bfd_elf_link_create_dynamic_sections. */
11429 if (elf_hash_table (info
)->stab_info
.stabstr
== o
)
11431 if (elf_hash_table (info
)->eh_info
.hdr_sec
== o
)
11433 if (strcmp (o
->name
, ".dynstr") != 0)
11435 /* FIXME: octets_per_byte. */
11436 if (! bfd_set_section_contents (abfd
, o
->output_section
,
11438 (file_ptr
) o
->output_offset
,
11444 /* The contents of the .dynstr section are actually in a
11446 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
11447 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
11448 || ! _bfd_elf_strtab_emit (abfd
,
11449 elf_hash_table (info
)->dynstr
))
11455 if (info
->relocatable
)
11457 bfd_boolean failed
= FALSE
;
11459 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
11464 /* If we have optimized stabs strings, output them. */
11465 if (elf_hash_table (info
)->stab_info
.stabstr
!= NULL
)
11467 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
11471 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
11474 elf_final_link_free (abfd
, &flinfo
);
11476 elf_linker (abfd
) = TRUE
;
11480 bfd_byte
*contents
= (bfd_byte
*) bfd_malloc (attr_size
);
11481 if (contents
== NULL
)
11482 return FALSE
; /* Bail out and fail. */
11483 bfd_elf_set_obj_attr_contents (abfd
, contents
, attr_size
);
11484 bfd_set_section_contents (abfd
, attr_section
, contents
, 0, attr_size
);
11491 elf_final_link_free (abfd
, &flinfo
);
11495 /* Initialize COOKIE for input bfd ABFD. */
11498 init_reloc_cookie (struct elf_reloc_cookie
*cookie
,
11499 struct bfd_link_info
*info
, bfd
*abfd
)
11501 Elf_Internal_Shdr
*symtab_hdr
;
11502 const struct elf_backend_data
*bed
;
11504 bed
= get_elf_backend_data (abfd
);
11505 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11507 cookie
->abfd
= abfd
;
11508 cookie
->sym_hashes
= elf_sym_hashes (abfd
);
11509 cookie
->bad_symtab
= elf_bad_symtab (abfd
);
11510 if (cookie
->bad_symtab
)
11512 cookie
->locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
11513 cookie
->extsymoff
= 0;
11517 cookie
->locsymcount
= symtab_hdr
->sh_info
;
11518 cookie
->extsymoff
= symtab_hdr
->sh_info
;
11521 if (bed
->s
->arch_size
== 32)
11522 cookie
->r_sym_shift
= 8;
11524 cookie
->r_sym_shift
= 32;
11526 cookie
->locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
11527 if (cookie
->locsyms
== NULL
&& cookie
->locsymcount
!= 0)
11529 cookie
->locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
11530 cookie
->locsymcount
, 0,
11532 if (cookie
->locsyms
== NULL
)
11534 info
->callbacks
->einfo (_("%P%X: can not read symbols: %E\n"));
11537 if (info
->keep_memory
)
11538 symtab_hdr
->contents
= (bfd_byte
*) cookie
->locsyms
;
11543 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
11546 fini_reloc_cookie (struct elf_reloc_cookie
*cookie
, bfd
*abfd
)
11548 Elf_Internal_Shdr
*symtab_hdr
;
11550 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11551 if (cookie
->locsyms
!= NULL
11552 && symtab_hdr
->contents
!= (unsigned char *) cookie
->locsyms
)
11553 free (cookie
->locsyms
);
11556 /* Initialize the relocation information in COOKIE for input section SEC
11557 of input bfd ABFD. */
11560 init_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11561 struct bfd_link_info
*info
, bfd
*abfd
,
11564 const struct elf_backend_data
*bed
;
11566 if (sec
->reloc_count
== 0)
11568 cookie
->rels
= NULL
;
11569 cookie
->relend
= NULL
;
11573 bed
= get_elf_backend_data (abfd
);
11575 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
11576 info
->keep_memory
);
11577 if (cookie
->rels
== NULL
)
11579 cookie
->rel
= cookie
->rels
;
11580 cookie
->relend
= (cookie
->rels
11581 + sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
);
11583 cookie
->rel
= cookie
->rels
;
11587 /* Free the memory allocated by init_reloc_cookie_rels,
11591 fini_reloc_cookie_rels (struct elf_reloc_cookie
*cookie
,
11594 if (cookie
->rels
&& elf_section_data (sec
)->relocs
!= cookie
->rels
)
11595 free (cookie
->rels
);
11598 /* Initialize the whole of COOKIE for input section SEC. */
11601 init_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11602 struct bfd_link_info
*info
,
11605 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
11607 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
11612 fini_reloc_cookie (cookie
, sec
->owner
);
11617 /* Free the memory allocated by init_reloc_cookie_for_section,
11621 fini_reloc_cookie_for_section (struct elf_reloc_cookie
*cookie
,
11624 fini_reloc_cookie_rels (cookie
, sec
);
11625 fini_reloc_cookie (cookie
, sec
->owner
);
11628 /* Garbage collect unused sections. */
11630 /* Default gc_mark_hook. */
11633 _bfd_elf_gc_mark_hook (asection
*sec
,
11634 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11635 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
11636 struct elf_link_hash_entry
*h
,
11637 Elf_Internal_Sym
*sym
)
11639 const char *sec_name
;
11643 switch (h
->root
.type
)
11645 case bfd_link_hash_defined
:
11646 case bfd_link_hash_defweak
:
11647 return h
->root
.u
.def
.section
;
11649 case bfd_link_hash_common
:
11650 return h
->root
.u
.c
.p
->section
;
11652 case bfd_link_hash_undefined
:
11653 case bfd_link_hash_undefweak
:
11654 /* To work around a glibc bug, keep all XXX input sections
11655 when there is an as yet undefined reference to __start_XXX
11656 or __stop_XXX symbols. The linker will later define such
11657 symbols for orphan input sections that have a name
11658 representable as a C identifier. */
11659 if (strncmp (h
->root
.root
.string
, "__start_", 8) == 0)
11660 sec_name
= h
->root
.root
.string
+ 8;
11661 else if (strncmp (h
->root
.root
.string
, "__stop_", 7) == 0)
11662 sec_name
= h
->root
.root
.string
+ 7;
11666 if (sec_name
&& *sec_name
!= '\0')
11670 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
11672 sec
= bfd_get_section_by_name (i
, sec_name
);
11674 sec
->flags
|= SEC_KEEP
;
11684 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
11689 /* COOKIE->rel describes a relocation against section SEC, which is
11690 a section we've decided to keep. Return the section that contains
11691 the relocation symbol, or NULL if no section contains it. */
11694 _bfd_elf_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
11695 elf_gc_mark_hook_fn gc_mark_hook
,
11696 struct elf_reloc_cookie
*cookie
)
11698 unsigned long r_symndx
;
11699 struct elf_link_hash_entry
*h
;
11701 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
11702 if (r_symndx
== STN_UNDEF
)
11705 if (r_symndx
>= cookie
->locsymcount
11706 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
11708 h
= cookie
->sym_hashes
[r_symndx
- cookie
->extsymoff
];
11709 while (h
->root
.type
== bfd_link_hash_indirect
11710 || h
->root
.type
== bfd_link_hash_warning
)
11711 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11713 /* If this symbol is weak and there is a non-weak definition, we
11714 keep the non-weak definition because many backends put
11715 dynamic reloc info on the non-weak definition for code
11716 handling copy relocs. */
11717 if (h
->u
.weakdef
!= NULL
)
11718 h
->u
.weakdef
->mark
= 1;
11719 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
11722 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
11723 &cookie
->locsyms
[r_symndx
]);
11726 /* COOKIE->rel describes a relocation against section SEC, which is
11727 a section we've decided to keep. Mark the section that contains
11728 the relocation symbol. */
11731 _bfd_elf_gc_mark_reloc (struct bfd_link_info
*info
,
11733 elf_gc_mark_hook_fn gc_mark_hook
,
11734 struct elf_reloc_cookie
*cookie
)
11738 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
11739 if (rsec
&& !rsec
->gc_mark
)
11741 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
11742 || (rsec
->owner
->flags
& DYNAMIC
) != 0)
11744 else if (!_bfd_elf_gc_mark (info
, rsec
, gc_mark_hook
))
11750 /* The mark phase of garbage collection. For a given section, mark
11751 it and any sections in this section's group, and all the sections
11752 which define symbols to which it refers. */
11755 _bfd_elf_gc_mark (struct bfd_link_info
*info
,
11757 elf_gc_mark_hook_fn gc_mark_hook
)
11760 asection
*group_sec
, *eh_frame
;
11764 /* Mark all the sections in the group. */
11765 group_sec
= elf_section_data (sec
)->next_in_group
;
11766 if (group_sec
&& !group_sec
->gc_mark
)
11767 if (!_bfd_elf_gc_mark (info
, group_sec
, gc_mark_hook
))
11770 /* Look through the section relocs. */
11772 eh_frame
= elf_eh_frame_section (sec
->owner
);
11773 if ((sec
->flags
& SEC_RELOC
) != 0
11774 && sec
->reloc_count
> 0
11775 && sec
!= eh_frame
)
11777 struct elf_reloc_cookie cookie
;
11779 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
11783 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
11784 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
11789 fini_reloc_cookie_for_section (&cookie
, sec
);
11793 if (ret
&& eh_frame
&& elf_fde_list (sec
))
11795 struct elf_reloc_cookie cookie
;
11797 if (!init_reloc_cookie_for_section (&cookie
, info
, eh_frame
))
11801 if (!_bfd_elf_gc_mark_fdes (info
, sec
, eh_frame
,
11802 gc_mark_hook
, &cookie
))
11804 fini_reloc_cookie_for_section (&cookie
, eh_frame
);
11811 /* Keep debug and special sections. */
11814 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
11815 elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
11819 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
11822 bfd_boolean some_kept
;
11823 bfd_boolean debug_frag_seen
;
11825 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
11828 /* Ensure all linker created sections are kept,
11829 see if any other section is already marked,
11830 and note if we have any fragmented debug sections. */
11831 debug_frag_seen
= some_kept
= FALSE
;
11832 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
11834 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
11836 else if (isec
->gc_mark
)
11839 if (debug_frag_seen
== FALSE
11840 && (isec
->flags
& SEC_DEBUGGING
)
11841 && CONST_STRNEQ (isec
->name
, ".debug_line."))
11842 debug_frag_seen
= TRUE
;
11845 /* If no section in this file will be kept, then we can
11846 toss out the debug and special sections. */
11850 /* Keep debug and special sections like .comment when they are
11851 not part of a group, or when we have single-member groups. */
11852 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
11853 if ((elf_next_in_group (isec
) == NULL
11854 || elf_next_in_group (isec
) == isec
)
11855 && ((isec
->flags
& SEC_DEBUGGING
) != 0
11856 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0))
11859 if (! debug_frag_seen
)
11862 /* Look for CODE sections which are going to be discarded,
11863 and find and discard any fragmented debug sections which
11864 are associated with that code section. */
11865 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
11866 if ((isec
->flags
& SEC_CODE
) != 0
11867 && isec
->gc_mark
== 0)
11872 ilen
= strlen (isec
->name
);
11874 /* Association is determined by the name of the debug section
11875 containing the name of the code section as a suffix. For
11876 example .debug_line.text.foo is a debug section associated
11878 for (dsec
= ibfd
->sections
; dsec
!= NULL
; dsec
= dsec
->next
)
11882 if (dsec
->gc_mark
== 0
11883 || (dsec
->flags
& SEC_DEBUGGING
) == 0)
11886 dlen
= strlen (dsec
->name
);
11889 && strncmp (dsec
->name
+ (dlen
- ilen
),
11890 isec
->name
, ilen
) == 0)
11901 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
11903 struct elf_gc_sweep_symbol_info
11905 struct bfd_link_info
*info
;
11906 void (*hide_symbol
) (struct bfd_link_info
*, struct elf_link_hash_entry
*,
11911 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *data
)
11914 && (((h
->root
.type
== bfd_link_hash_defined
11915 || h
->root
.type
== bfd_link_hash_defweak
)
11916 && !(h
->def_regular
11917 && h
->root
.u
.def
.section
->gc_mark
))
11918 || h
->root
.type
== bfd_link_hash_undefined
11919 || h
->root
.type
== bfd_link_hash_undefweak
))
11921 struct elf_gc_sweep_symbol_info
*inf
;
11923 inf
= (struct elf_gc_sweep_symbol_info
*) data
;
11924 (*inf
->hide_symbol
) (inf
->info
, h
, TRUE
);
11925 h
->def_regular
= 0;
11926 h
->ref_regular
= 0;
11927 h
->ref_regular_nonweak
= 0;
11933 /* The sweep phase of garbage collection. Remove all garbage sections. */
11935 typedef bfd_boolean (*gc_sweep_hook_fn
)
11936 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
11939 elf_gc_sweep (bfd
*abfd
, struct bfd_link_info
*info
)
11942 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11943 gc_sweep_hook_fn gc_sweep_hook
= bed
->gc_sweep_hook
;
11944 unsigned long section_sym_count
;
11945 struct elf_gc_sweep_symbol_info sweep_info
;
11947 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
11951 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
11954 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
11956 /* When any section in a section group is kept, we keep all
11957 sections in the section group. If the first member of
11958 the section group is excluded, we will also exclude the
11960 if (o
->flags
& SEC_GROUP
)
11962 asection
*first
= elf_next_in_group (o
);
11963 o
->gc_mark
= first
->gc_mark
;
11969 /* Skip sweeping sections already excluded. */
11970 if (o
->flags
& SEC_EXCLUDE
)
11973 /* Since this is early in the link process, it is simple
11974 to remove a section from the output. */
11975 o
->flags
|= SEC_EXCLUDE
;
11977 if (info
->print_gc_sections
&& o
->size
!= 0)
11978 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub
, o
->name
);
11980 /* But we also have to update some of the relocation
11981 info we collected before. */
11983 && (o
->flags
& SEC_RELOC
) != 0
11984 && o
->reloc_count
> 0
11985 && !bfd_is_abs_section (o
->output_section
))
11987 Elf_Internal_Rela
*internal_relocs
;
11991 = _bfd_elf_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
11992 info
->keep_memory
);
11993 if (internal_relocs
== NULL
)
11996 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
11998 if (elf_section_data (o
)->relocs
!= internal_relocs
)
11999 free (internal_relocs
);
12007 /* Remove the symbols that were in the swept sections from the dynamic
12008 symbol table. GCFIXME: Anyone know how to get them out of the
12009 static symbol table as well? */
12010 sweep_info
.info
= info
;
12011 sweep_info
.hide_symbol
= bed
->elf_backend_hide_symbol
;
12012 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
,
12015 _bfd_elf_link_renumber_dynsyms (abfd
, info
, §ion_sym_count
);
12019 /* Propagate collected vtable information. This is called through
12020 elf_link_hash_traverse. */
12023 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
12025 /* Those that are not vtables. */
12026 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
12029 /* Those vtables that do not have parents, we cannot merge. */
12030 if (h
->vtable
->parent
== (struct elf_link_hash_entry
*) -1)
12033 /* If we've already been done, exit. */
12034 if (h
->vtable
->used
&& h
->vtable
->used
[-1])
12037 /* Make sure the parent's table is up to date. */
12038 elf_gc_propagate_vtable_entries_used (h
->vtable
->parent
, okp
);
12040 if (h
->vtable
->used
== NULL
)
12042 /* None of this table's entries were referenced. Re-use the
12044 h
->vtable
->used
= h
->vtable
->parent
->vtable
->used
;
12045 h
->vtable
->size
= h
->vtable
->parent
->vtable
->size
;
12050 bfd_boolean
*cu
, *pu
;
12052 /* Or the parent's entries into ours. */
12053 cu
= h
->vtable
->used
;
12055 pu
= h
->vtable
->parent
->vtable
->used
;
12058 const struct elf_backend_data
*bed
;
12059 unsigned int log_file_align
;
12061 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
12062 log_file_align
= bed
->s
->log_file_align
;
12063 n
= h
->vtable
->parent
->vtable
->size
>> log_file_align
;
12078 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
, void *okp
)
12081 bfd_vma hstart
, hend
;
12082 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
12083 const struct elf_backend_data
*bed
;
12084 unsigned int log_file_align
;
12086 /* Take care of both those symbols that do not describe vtables as
12087 well as those that are not loaded. */
12088 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
12091 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
12092 || h
->root
.type
== bfd_link_hash_defweak
);
12094 sec
= h
->root
.u
.def
.section
;
12095 hstart
= h
->root
.u
.def
.value
;
12096 hend
= hstart
+ h
->size
;
12098 relstart
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, TRUE
);
12100 return *(bfd_boolean
*) okp
= FALSE
;
12101 bed
= get_elf_backend_data (sec
->owner
);
12102 log_file_align
= bed
->s
->log_file_align
;
12104 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
12106 for (rel
= relstart
; rel
< relend
; ++rel
)
12107 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
12109 /* If the entry is in use, do nothing. */
12110 if (h
->vtable
->used
12111 && (rel
->r_offset
- hstart
) < h
->vtable
->size
)
12113 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
12114 if (h
->vtable
->used
[entry
])
12117 /* Otherwise, kill it. */
12118 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
12124 /* Mark sections containing dynamically referenced symbols. When
12125 building shared libraries, we must assume that any visible symbol is
12129 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry
*h
, void *inf
)
12131 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
12133 if ((h
->root
.type
== bfd_link_hash_defined
12134 || h
->root
.type
== bfd_link_hash_defweak
)
12136 || ((!info
->executable
|| info
->export_dynamic
)
12138 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
12139 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
12140 && (strchr (h
->root
.root
.string
, ELF_VER_CHR
) != NULL
12141 || !bfd_hide_sym_by_version (info
->version_info
,
12142 h
->root
.root
.string
)))))
12143 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
12148 /* Keep all sections containing symbols undefined on the command-line,
12149 and the section containing the entry symbol. */
12152 _bfd_elf_gc_keep (struct bfd_link_info
*info
)
12154 struct bfd_sym_chain
*sym
;
12156 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
12158 struct elf_link_hash_entry
*h
;
12160 h
= elf_link_hash_lookup (elf_hash_table (info
), sym
->name
,
12161 FALSE
, FALSE
, FALSE
);
12164 && (h
->root
.type
== bfd_link_hash_defined
12165 || h
->root
.type
== bfd_link_hash_defweak
)
12166 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
12167 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
12171 /* Do mark and sweep of unused sections. */
12174 bfd_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
12176 bfd_boolean ok
= TRUE
;
12178 elf_gc_mark_hook_fn gc_mark_hook
;
12179 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12181 if (!bed
->can_gc_sections
12182 || !is_elf_hash_table (info
->hash
))
12184 (*_bfd_error_handler
)(_("Warning: gc-sections option ignored"));
12188 bed
->gc_keep (info
);
12190 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
12191 at the .eh_frame section if we can mark the FDEs individually. */
12192 _bfd_elf_begin_eh_frame_parsing (info
);
12193 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
12196 struct elf_reloc_cookie cookie
;
12198 sec
= bfd_get_section_by_name (sub
, ".eh_frame");
12199 while (sec
&& init_reloc_cookie_for_section (&cookie
, info
, sec
))
12201 _bfd_elf_parse_eh_frame (sub
, info
, sec
, &cookie
);
12202 if (elf_section_data (sec
)->sec_info
12203 && (sec
->flags
& SEC_LINKER_CREATED
) == 0)
12204 elf_eh_frame_section (sub
) = sec
;
12205 fini_reloc_cookie_for_section (&cookie
, sec
);
12206 sec
= bfd_get_next_section_by_name (sec
);
12209 _bfd_elf_end_eh_frame_parsing (info
);
12211 /* Apply transitive closure to the vtable entry usage info. */
12212 elf_link_hash_traverse (elf_hash_table (info
),
12213 elf_gc_propagate_vtable_entries_used
,
12218 /* Kill the vtable relocations that were not used. */
12219 elf_link_hash_traverse (elf_hash_table (info
),
12220 elf_gc_smash_unused_vtentry_relocs
,
12225 /* Mark dynamically referenced symbols. */
12226 if (elf_hash_table (info
)->dynamic_sections_created
)
12227 elf_link_hash_traverse (elf_hash_table (info
),
12228 bed
->gc_mark_dynamic_ref
,
12231 /* Grovel through relocs to find out who stays ... */
12232 gc_mark_hook
= bed
->gc_mark_hook
;
12233 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
12237 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
12240 /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12241 Also treat note sections as a root, if the section is not part
12243 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
12245 && (o
->flags
& SEC_EXCLUDE
) == 0
12246 && ((o
->flags
& SEC_KEEP
) != 0
12247 || (elf_section_data (o
)->this_hdr
.sh_type
== SHT_NOTE
12248 && elf_next_in_group (o
) == NULL
)))
12250 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
12255 /* Allow the backend to mark additional target specific sections. */
12256 bed
->gc_mark_extra_sections (info
, gc_mark_hook
);
12258 /* ... and mark SEC_EXCLUDE for those that go. */
12259 return elf_gc_sweep (abfd
, info
);
12262 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
12265 bfd_elf_gc_record_vtinherit (bfd
*abfd
,
12267 struct elf_link_hash_entry
*h
,
12270 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
12271 struct elf_link_hash_entry
**search
, *child
;
12272 bfd_size_type extsymcount
;
12273 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12275 /* The sh_info field of the symtab header tells us where the
12276 external symbols start. We don't care about the local symbols at
12278 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/ bed
->s
->sizeof_sym
;
12279 if (!elf_bad_symtab (abfd
))
12280 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
12282 sym_hashes
= elf_sym_hashes (abfd
);
12283 sym_hashes_end
= sym_hashes
+ extsymcount
;
12285 /* Hunt down the child symbol, which is in this section at the same
12286 offset as the relocation. */
12287 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
12289 if ((child
= *search
) != NULL
12290 && (child
->root
.type
== bfd_link_hash_defined
12291 || child
->root
.type
== bfd_link_hash_defweak
)
12292 && child
->root
.u
.def
.section
== sec
12293 && child
->root
.u
.def
.value
== offset
)
12297 (*_bfd_error_handler
) ("%B: %A+%lu: No symbol found for INHERIT",
12298 abfd
, sec
, (unsigned long) offset
);
12299 bfd_set_error (bfd_error_invalid_operation
);
12303 if (!child
->vtable
)
12305 child
->vtable
= (struct elf_link_virtual_table_entry
*)
12306 bfd_zalloc (abfd
, sizeof (*child
->vtable
));
12307 if (!child
->vtable
)
12312 /* This *should* only be the absolute section. It could potentially
12313 be that someone has defined a non-global vtable though, which
12314 would be bad. It isn't worth paging in the local symbols to be
12315 sure though; that case should simply be handled by the assembler. */
12317 child
->vtable
->parent
= (struct elf_link_hash_entry
*) -1;
12320 child
->vtable
->parent
= h
;
12325 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
12328 bfd_elf_gc_record_vtentry (bfd
*abfd ATTRIBUTE_UNUSED
,
12329 asection
*sec ATTRIBUTE_UNUSED
,
12330 struct elf_link_hash_entry
*h
,
12333 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12334 unsigned int log_file_align
= bed
->s
->log_file_align
;
12338 h
->vtable
= (struct elf_link_virtual_table_entry
*)
12339 bfd_zalloc (abfd
, sizeof (*h
->vtable
));
12344 if (addend
>= h
->vtable
->size
)
12346 size_t size
, bytes
, file_align
;
12347 bfd_boolean
*ptr
= h
->vtable
->used
;
12349 /* While the symbol is undefined, we have to be prepared to handle
12351 file_align
= 1 << log_file_align
;
12352 if (h
->root
.type
== bfd_link_hash_undefined
)
12353 size
= addend
+ file_align
;
12357 if (addend
>= size
)
12359 /* Oops! We've got a reference past the defined end of
12360 the table. This is probably a bug -- shall we warn? */
12361 size
= addend
+ file_align
;
12364 size
= (size
+ file_align
- 1) & -file_align
;
12366 /* Allocate one extra entry for use as a "done" flag for the
12367 consolidation pass. */
12368 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bfd_boolean
);
12372 ptr
= (bfd_boolean
*) bfd_realloc (ptr
- 1, bytes
);
12378 oldbytes
= (((h
->vtable
->size
>> log_file_align
) + 1)
12379 * sizeof (bfd_boolean
));
12380 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
12384 ptr
= (bfd_boolean
*) bfd_zmalloc (bytes
);
12389 /* And arrange for that done flag to be at index -1. */
12390 h
->vtable
->used
= ptr
+ 1;
12391 h
->vtable
->size
= size
;
12394 h
->vtable
->used
[addend
>> log_file_align
] = TRUE
;
12399 /* Map an ELF section header flag to its corresponding string. */
12403 flagword flag_value
;
12404 } elf_flags_to_name_table
;
12406 static elf_flags_to_name_table elf_flags_to_names
[] =
12408 { "SHF_WRITE", SHF_WRITE
},
12409 { "SHF_ALLOC", SHF_ALLOC
},
12410 { "SHF_EXECINSTR", SHF_EXECINSTR
},
12411 { "SHF_MERGE", SHF_MERGE
},
12412 { "SHF_STRINGS", SHF_STRINGS
},
12413 { "SHF_INFO_LINK", SHF_INFO_LINK
},
12414 { "SHF_LINK_ORDER", SHF_LINK_ORDER
},
12415 { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING
},
12416 { "SHF_GROUP", SHF_GROUP
},
12417 { "SHF_TLS", SHF_TLS
},
12418 { "SHF_MASKOS", SHF_MASKOS
},
12419 { "SHF_EXCLUDE", SHF_EXCLUDE
},
12422 /* Returns TRUE if the section is to be included, otherwise FALSE. */
12424 bfd_elf_lookup_section_flags (struct bfd_link_info
*info
,
12425 struct flag_info
*flaginfo
,
12428 const bfd_vma sh_flags
= elf_section_flags (section
);
12430 if (!flaginfo
->flags_initialized
)
12432 bfd
*obfd
= info
->output_bfd
;
12433 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
12434 struct flag_info_list
*tf
= flaginfo
->flag_list
;
12436 int without_hex
= 0;
12438 for (tf
= flaginfo
->flag_list
; tf
!= NULL
; tf
= tf
->next
)
12441 flagword (*lookup
) (char *);
12443 lookup
= bed
->elf_backend_lookup_section_flags_hook
;
12444 if (lookup
!= NULL
)
12446 flagword hexval
= (*lookup
) ((char *) tf
->name
);
12450 if (tf
->with
== with_flags
)
12451 with_hex
|= hexval
;
12452 else if (tf
->with
== without_flags
)
12453 without_hex
|= hexval
;
12458 for (i
= 0; i
< ARRAY_SIZE (elf_flags_to_names
); ++i
)
12460 if (strcmp (tf
->name
, elf_flags_to_names
[i
].flag_name
) == 0)
12462 if (tf
->with
== with_flags
)
12463 with_hex
|= elf_flags_to_names
[i
].flag_value
;
12464 else if (tf
->with
== without_flags
)
12465 without_hex
|= elf_flags_to_names
[i
].flag_value
;
12472 info
->callbacks
->einfo
12473 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf
->name
);
12477 flaginfo
->flags_initialized
= TRUE
;
12478 flaginfo
->only_with_flags
|= with_hex
;
12479 flaginfo
->not_with_flags
|= without_hex
;
12482 if ((flaginfo
->only_with_flags
& sh_flags
) != flaginfo
->only_with_flags
)
12485 if ((flaginfo
->not_with_flags
& sh_flags
) != 0)
12491 struct alloc_got_off_arg
{
12493 struct bfd_link_info
*info
;
12496 /* We need a special top-level link routine to convert got reference counts
12497 to real got offsets. */
12500 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *arg
)
12502 struct alloc_got_off_arg
*gofarg
= (struct alloc_got_off_arg
*) arg
;
12503 bfd
*obfd
= gofarg
->info
->output_bfd
;
12504 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
12506 if (h
->got
.refcount
> 0)
12508 h
->got
.offset
= gofarg
->gotoff
;
12509 gofarg
->gotoff
+= bed
->got_elt_size (obfd
, gofarg
->info
, h
, NULL
, 0);
12512 h
->got
.offset
= (bfd_vma
) -1;
12517 /* And an accompanying bit to work out final got entry offsets once
12518 we're done. Should be called from final_link. */
12521 bfd_elf_gc_common_finalize_got_offsets (bfd
*abfd
,
12522 struct bfd_link_info
*info
)
12525 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12527 struct alloc_got_off_arg gofarg
;
12529 BFD_ASSERT (abfd
== info
->output_bfd
);
12531 if (! is_elf_hash_table (info
->hash
))
12534 /* The GOT offset is relative to the .got section, but the GOT header is
12535 put into the .got.plt section, if the backend uses it. */
12536 if (bed
->want_got_plt
)
12539 gotoff
= bed
->got_header_size
;
12541 /* Do the local .got entries first. */
12542 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
12544 bfd_signed_vma
*local_got
;
12545 bfd_size_type j
, locsymcount
;
12546 Elf_Internal_Shdr
*symtab_hdr
;
12548 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
12551 local_got
= elf_local_got_refcounts (i
);
12555 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
12556 if (elf_bad_symtab (i
))
12557 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
12559 locsymcount
= symtab_hdr
->sh_info
;
12561 for (j
= 0; j
< locsymcount
; ++j
)
12563 if (local_got
[j
] > 0)
12565 local_got
[j
] = gotoff
;
12566 gotoff
+= bed
->got_elt_size (abfd
, info
, NULL
, i
, j
);
12569 local_got
[j
] = (bfd_vma
) -1;
12573 /* Then the global .got entries. .plt refcounts are handled by
12574 adjust_dynamic_symbol */
12575 gofarg
.gotoff
= gotoff
;
12576 gofarg
.info
= info
;
12577 elf_link_hash_traverse (elf_hash_table (info
),
12578 elf_gc_allocate_got_offsets
,
12583 /* Many folk need no more in the way of final link than this, once
12584 got entry reference counting is enabled. */
12587 bfd_elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
12589 if (!bfd_elf_gc_common_finalize_got_offsets (abfd
, info
))
12592 /* Invoke the regular ELF backend linker to do all the work. */
12593 return bfd_elf_final_link (abfd
, info
);
12597 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
12599 struct elf_reloc_cookie
*rcookie
= (struct elf_reloc_cookie
*) cookie
;
12601 if (rcookie
->bad_symtab
)
12602 rcookie
->rel
= rcookie
->rels
;
12604 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
12606 unsigned long r_symndx
;
12608 if (! rcookie
->bad_symtab
)
12609 if (rcookie
->rel
->r_offset
> offset
)
12611 if (rcookie
->rel
->r_offset
!= offset
)
12614 r_symndx
= rcookie
->rel
->r_info
>> rcookie
->r_sym_shift
;
12615 if (r_symndx
== STN_UNDEF
)
12618 if (r_symndx
>= rcookie
->locsymcount
12619 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
12621 struct elf_link_hash_entry
*h
;
12623 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
12625 while (h
->root
.type
== bfd_link_hash_indirect
12626 || h
->root
.type
== bfd_link_hash_warning
)
12627 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
12629 if ((h
->root
.type
== bfd_link_hash_defined
12630 || h
->root
.type
== bfd_link_hash_defweak
)
12631 && discarded_section (h
->root
.u
.def
.section
))
12638 /* It's not a relocation against a global symbol,
12639 but it could be a relocation against a local
12640 symbol for a discarded section. */
12642 Elf_Internal_Sym
*isym
;
12644 /* Need to: get the symbol; get the section. */
12645 isym
= &rcookie
->locsyms
[r_symndx
];
12646 isec
= bfd_section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
12647 if (isec
!= NULL
&& discarded_section (isec
))
12655 /* Discard unneeded references to discarded sections.
12656 Returns TRUE if any section's size was changed. */
12657 /* This function assumes that the relocations are in sorted order,
12658 which is true for all known assemblers. */
12661 bfd_elf_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
12663 struct elf_reloc_cookie cookie
;
12664 asection
*stab
, *eh
;
12665 const struct elf_backend_data
*bed
;
12667 bfd_boolean ret
= FALSE
;
12669 if (info
->traditional_format
12670 || !is_elf_hash_table (info
->hash
))
12673 _bfd_elf_begin_eh_frame_parsing (info
);
12674 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
12676 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
12679 bed
= get_elf_backend_data (abfd
);
12682 if (!info
->relocatable
)
12684 eh
= bfd_get_section_by_name (abfd
, ".eh_frame");
12687 || bfd_is_abs_section (eh
->output_section
)))
12688 eh
= bfd_get_next_section_by_name (eh
);
12691 stab
= bfd_get_section_by_name (abfd
, ".stab");
12693 && (stab
->size
== 0
12694 || bfd_is_abs_section (stab
->output_section
)
12695 || stab
->sec_info_type
!= SEC_INFO_TYPE_STABS
))
12700 && bed
->elf_backend_discard_info
== NULL
)
12703 if (!init_reloc_cookie (&cookie
, info
, abfd
))
12707 && stab
->reloc_count
> 0
12708 && init_reloc_cookie_rels (&cookie
, info
, abfd
, stab
))
12710 if (_bfd_discard_section_stabs (abfd
, stab
,
12711 elf_section_data (stab
)->sec_info
,
12712 bfd_elf_reloc_symbol_deleted_p
,
12715 fini_reloc_cookie_rels (&cookie
, stab
);
12719 && init_reloc_cookie_rels (&cookie
, info
, abfd
, eh
))
12721 _bfd_elf_parse_eh_frame (abfd
, info
, eh
, &cookie
);
12722 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, eh
,
12723 bfd_elf_reloc_symbol_deleted_p
,
12726 fini_reloc_cookie_rels (&cookie
, eh
);
12727 eh
= bfd_get_next_section_by_name (eh
);
12730 if (bed
->elf_backend_discard_info
!= NULL
12731 && (*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
12734 fini_reloc_cookie (&cookie
, abfd
);
12736 _bfd_elf_end_eh_frame_parsing (info
);
12738 if (info
->eh_frame_hdr
12739 && !info
->relocatable
12740 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
12747 _bfd_elf_section_already_linked (bfd
*abfd
,
12749 struct bfd_link_info
*info
)
12752 const char *name
, *key
;
12753 struct bfd_section_already_linked
*l
;
12754 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
12756 if (sec
->output_section
== bfd_abs_section_ptr
)
12759 flags
= sec
->flags
;
12761 /* Return if it isn't a linkonce section. A comdat group section
12762 also has SEC_LINK_ONCE set. */
12763 if ((flags
& SEC_LINK_ONCE
) == 0)
12766 /* Don't put group member sections on our list of already linked
12767 sections. They are handled as a group via their group section. */
12768 if (elf_sec_group (sec
) != NULL
)
12771 /* For a SHT_GROUP section, use the group signature as the key. */
12773 if ((flags
& SEC_GROUP
) != 0
12774 && elf_next_in_group (sec
) != NULL
12775 && elf_group_name (elf_next_in_group (sec
)) != NULL
)
12776 key
= elf_group_name (elf_next_in_group (sec
));
12779 /* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */
12780 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
12781 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
12784 /* Must be a user linkonce section that doesn't follow gcc's
12785 naming convention. In this case we won't be matching
12786 single member groups. */
12790 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
12792 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12794 /* We may have 2 different types of sections on the list: group
12795 sections with a signature of <key> (<key> is some string),
12796 and linkonce sections named .gnu.linkonce.<type>.<key>.
12797 Match like sections. LTO plugin sections are an exception.
12798 They are always named .gnu.linkonce.t.<key> and match either
12799 type of section. */
12800 if (((flags
& SEC_GROUP
) == (l
->sec
->flags
& SEC_GROUP
)
12801 && ((flags
& SEC_GROUP
) != 0
12802 || strcmp (name
, l
->sec
->name
) == 0))
12803 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
12805 /* The section has already been linked. See if we should
12806 issue a warning. */
12807 if (!_bfd_handle_already_linked (sec
, l
, info
))
12810 if (flags
& SEC_GROUP
)
12812 asection
*first
= elf_next_in_group (sec
);
12813 asection
*s
= first
;
12817 s
->output_section
= bfd_abs_section_ptr
;
12818 /* Record which group discards it. */
12819 s
->kept_section
= l
->sec
;
12820 s
= elf_next_in_group (s
);
12821 /* These lists are circular. */
12831 /* A single member comdat group section may be discarded by a
12832 linkonce section and vice versa. */
12833 if ((flags
& SEC_GROUP
) != 0)
12835 asection
*first
= elf_next_in_group (sec
);
12837 if (first
!= NULL
&& elf_next_in_group (first
) == first
)
12838 /* Check this single member group against linkonce sections. */
12839 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12840 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12841 && bfd_elf_match_symbols_in_sections (l
->sec
, first
, info
))
12843 first
->output_section
= bfd_abs_section_ptr
;
12844 first
->kept_section
= l
->sec
;
12845 sec
->output_section
= bfd_abs_section_ptr
;
12850 /* Check this linkonce section against single member groups. */
12851 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12852 if (l
->sec
->flags
& SEC_GROUP
)
12854 asection
*first
= elf_next_in_group (l
->sec
);
12857 && elf_next_in_group (first
) == first
12858 && bfd_elf_match_symbols_in_sections (first
, sec
, info
))
12860 sec
->output_section
= bfd_abs_section_ptr
;
12861 sec
->kept_section
= first
;
12866 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12867 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12868 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12869 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
12870 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
12871 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12872 `.gnu.linkonce.t.F' section from a different bfd not requiring any
12873 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
12874 The reverse order cannot happen as there is never a bfd with only the
12875 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
12876 matter as here were are looking only for cross-bfd sections. */
12878 if ((flags
& SEC_GROUP
) == 0 && CONST_STRNEQ (name
, ".gnu.linkonce.r."))
12879 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
12880 if ((l
->sec
->flags
& SEC_GROUP
) == 0
12881 && CONST_STRNEQ (l
->sec
->name
, ".gnu.linkonce.t."))
12883 if (abfd
!= l
->sec
->owner
)
12884 sec
->output_section
= bfd_abs_section_ptr
;
12888 /* This is the first section with this name. Record it. */
12889 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
12890 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
12891 return sec
->output_section
== bfd_abs_section_ptr
;
12895 _bfd_elf_common_definition (Elf_Internal_Sym
*sym
)
12897 return sym
->st_shndx
== SHN_COMMON
;
12901 _bfd_elf_common_section_index (asection
*sec ATTRIBUTE_UNUSED
)
12907 _bfd_elf_common_section (asection
*sec ATTRIBUTE_UNUSED
)
12909 return bfd_com_section_ptr
;
12913 _bfd_elf_default_got_elt_size (bfd
*abfd
,
12914 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12915 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
12916 bfd
*ibfd ATTRIBUTE_UNUSED
,
12917 unsigned long symndx ATTRIBUTE_UNUSED
)
12919 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12920 return bed
->s
->arch_size
/ 8;
12923 /* Routines to support the creation of dynamic relocs. */
12925 /* Returns the name of the dynamic reloc section associated with SEC. */
12927 static const char *
12928 get_dynamic_reloc_section_name (bfd
* abfd
,
12930 bfd_boolean is_rela
)
12933 const char *old_name
= bfd_get_section_name (NULL
, sec
);
12934 const char *prefix
= is_rela
? ".rela" : ".rel";
12936 if (old_name
== NULL
)
12939 name
= bfd_alloc (abfd
, strlen (prefix
) + strlen (old_name
) + 1);
12940 sprintf (name
, "%s%s", prefix
, old_name
);
12945 /* Returns the dynamic reloc section associated with SEC.
12946 If necessary compute the name of the dynamic reloc section based
12947 on SEC's name (looked up in ABFD's string table) and the setting
12951 _bfd_elf_get_dynamic_reloc_section (bfd
* abfd
,
12953 bfd_boolean is_rela
)
12955 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
12957 if (reloc_sec
== NULL
)
12959 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
12963 reloc_sec
= bfd_get_linker_section (abfd
, name
);
12965 if (reloc_sec
!= NULL
)
12966 elf_section_data (sec
)->sreloc
= reloc_sec
;
12973 /* Returns the dynamic reloc section associated with SEC. If the
12974 section does not exist it is created and attached to the DYNOBJ
12975 bfd and stored in the SRELOC field of SEC's elf_section_data
12978 ALIGNMENT is the alignment for the newly created section and
12979 IS_RELA defines whether the name should be .rela.<SEC's name>
12980 or .rel.<SEC's name>. The section name is looked up in the
12981 string table associated with ABFD. */
12984 _bfd_elf_make_dynamic_reloc_section (asection
* sec
,
12986 unsigned int alignment
,
12988 bfd_boolean is_rela
)
12990 asection
* reloc_sec
= elf_section_data (sec
)->sreloc
;
12992 if (reloc_sec
== NULL
)
12994 const char * name
= get_dynamic_reloc_section_name (abfd
, sec
, is_rela
);
12999 reloc_sec
= bfd_get_linker_section (dynobj
, name
);
13001 if (reloc_sec
== NULL
)
13003 flagword flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
13004 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
13005 if ((sec
->flags
& SEC_ALLOC
) != 0)
13006 flags
|= SEC_ALLOC
| SEC_LOAD
;
13008 reloc_sec
= bfd_make_section_anyway_with_flags (dynobj
, name
, flags
);
13009 if (reloc_sec
!= NULL
)
13011 /* _bfd_elf_get_sec_type_attr chooses a section type by
13012 name. Override as it may be wrong, eg. for a user
13013 section named "auto" we'll get ".relauto" which is
13014 seen to be a .rela section. */
13015 elf_section_type (reloc_sec
) = is_rela
? SHT_RELA
: SHT_REL
;
13016 if (! bfd_set_section_alignment (dynobj
, reloc_sec
, alignment
))
13021 elf_section_data (sec
)->sreloc
= reloc_sec
;
13027 /* Copy the ELF symbol type associated with a linker hash entry. */
13029 _bfd_elf_copy_link_hash_symbol_type (bfd
*abfd ATTRIBUTE_UNUSED
,
13030 struct bfd_link_hash_entry
* hdest
,
13031 struct bfd_link_hash_entry
* hsrc
)
13033 struct elf_link_hash_entry
*ehdest
= (struct elf_link_hash_entry
*)hdest
;
13034 struct elf_link_hash_entry
*ehsrc
= (struct elf_link_hash_entry
*)hsrc
;
13036 ehdest
->type
= ehsrc
->type
;
13037 ehdest
->target_internal
= ehsrc
->target_internal
;
13040 /* Append a RELA relocation REL to section S in BFD. */
13043 elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
13045 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13046 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
13047 BFD_ASSERT (loc
+ bed
->s
->sizeof_rela
<= s
->contents
+ s
->size
);
13048 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
13051 /* Append a REL relocation REL to section S in BFD. */
13054 elf_append_rel (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
13056 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
13057 bfd_byte
*loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rel
);
13058 BFD_ASSERT (loc
+ bed
->s
->sizeof_rel
<= s
->contents
+ s
->size
);
13059 bed
->s
->swap_reloc_out (abfd
, rel
, loc
);