1 /* ELF linking support for BFD.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
27 #include "safe-ctype.h"
28 #include "libiberty.h"
31 /* Define a symbol in a dynamic linkage section. */
33 struct elf_link_hash_entry
*
34 _bfd_elf_define_linkage_sym (bfd
*abfd
,
35 struct bfd_link_info
*info
,
39 struct elf_link_hash_entry
*h
;
40 struct bfd_link_hash_entry
*bh
;
41 const struct elf_backend_data
*bed
;
43 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
46 /* Zap symbol defined in an as-needed lib that wasn't linked.
47 This is a symptom of a larger problem: Absolute symbols
48 defined in shared libraries can't be overridden, because we
49 lose the link to the bfd which is via the symbol section. */
50 h
->root
.type
= bfd_link_hash_new
;
54 if (!_bfd_generic_link_add_one_symbol (info
, abfd
, name
, BSF_GLOBAL
,
56 get_elf_backend_data (abfd
)->collect
,
59 h
= (struct elf_link_hash_entry
*) bh
;
62 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
64 bed
= get_elf_backend_data (abfd
);
65 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
70 _bfd_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
74 struct elf_link_hash_entry
*h
;
75 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
78 /* This function may be called more than once. */
79 s
= bfd_get_section_by_name (abfd
, ".got");
80 if (s
!= NULL
&& (s
->flags
& SEC_LINKER_CREATED
) != 0)
83 switch (bed
->s
->arch_size
)
94 bfd_set_error (bfd_error_bad_value
);
98 flags
= bed
->dynamic_sec_flags
;
100 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
102 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
105 if (bed
->want_got_plt
)
107 s
= bfd_make_section_with_flags (abfd
, ".got.plt", flags
);
109 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
113 if (bed
->want_got_sym
)
115 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
116 (or .got.plt) section. We don't do this in the linker script
117 because we don't want to define the symbol if we are not creating
118 a global offset table. */
119 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_GLOBAL_OFFSET_TABLE_");
120 elf_hash_table (info
)->hgot
= h
;
125 /* The first bit of the global offset table is the header. */
126 s
->size
+= bed
->got_header_size
;
131 /* Create a strtab to hold the dynamic symbol names. */
133 _bfd_elf_link_create_dynstrtab (bfd
*abfd
, struct bfd_link_info
*info
)
135 struct elf_link_hash_table
*hash_table
;
137 hash_table
= elf_hash_table (info
);
138 if (hash_table
->dynobj
== NULL
)
139 hash_table
->dynobj
= abfd
;
141 if (hash_table
->dynstr
== NULL
)
143 hash_table
->dynstr
= _bfd_elf_strtab_init ();
144 if (hash_table
->dynstr
== NULL
)
150 /* Create some sections which will be filled in with dynamic linking
151 information. ABFD is an input file which requires dynamic sections
152 to be created. The dynamic sections take up virtual memory space
153 when the final executable is run, so we need to create them before
154 addresses are assigned to the output sections. We work out the
155 actual contents and size of these sections later. */
158 _bfd_elf_link_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
161 register asection
*s
;
162 const struct elf_backend_data
*bed
;
164 if (! is_elf_hash_table (info
->hash
))
167 if (elf_hash_table (info
)->dynamic_sections_created
)
170 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
173 abfd
= elf_hash_table (info
)->dynobj
;
174 bed
= get_elf_backend_data (abfd
);
176 flags
= bed
->dynamic_sec_flags
;
178 /* A dynamically linked executable has a .interp section, but a
179 shared library does not. */
180 if (info
->executable
)
182 s
= bfd_make_section_with_flags (abfd
, ".interp",
183 flags
| SEC_READONLY
);
188 /* Create sections to hold version informations. These are removed
189 if they are not needed. */
190 s
= bfd_make_section_with_flags (abfd
, ".gnu.version_d",
191 flags
| SEC_READONLY
);
193 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
196 s
= bfd_make_section_with_flags (abfd
, ".gnu.version",
197 flags
| SEC_READONLY
);
199 || ! bfd_set_section_alignment (abfd
, s
, 1))
202 s
= bfd_make_section_with_flags (abfd
, ".gnu.version_r",
203 flags
| SEC_READONLY
);
205 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
208 s
= bfd_make_section_with_flags (abfd
, ".dynsym",
209 flags
| SEC_READONLY
);
211 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
214 s
= bfd_make_section_with_flags (abfd
, ".dynstr",
215 flags
| SEC_READONLY
);
219 s
= bfd_make_section_with_flags (abfd
, ".dynamic", flags
);
221 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
224 /* The special symbol _DYNAMIC is always set to the start of the
225 .dynamic section. We could set _DYNAMIC in a linker script, but we
226 only want to define it if we are, in fact, creating a .dynamic
227 section. We don't want to define it if there is no .dynamic
228 section, since on some ELF platforms the start up code examines it
229 to decide how to initialize the process. */
230 if (!_bfd_elf_define_linkage_sym (abfd
, info
, s
, "_DYNAMIC"))
235 s
= bfd_make_section_with_flags (abfd
, ".hash", flags
| SEC_READONLY
);
237 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
239 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
242 if (info
->emit_gnu_hash
)
244 s
= bfd_make_section_with_flags (abfd
, ".gnu.hash",
245 flags
| SEC_READONLY
);
247 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
249 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
250 4 32-bit words followed by variable count of 64-bit words, then
251 variable count of 32-bit words. */
252 if (bed
->s
->arch_size
== 64)
253 elf_section_data (s
)->this_hdr
.sh_entsize
= 0;
255 elf_section_data (s
)->this_hdr
.sh_entsize
= 4;
258 /* Let the backend create the rest of the sections. This lets the
259 backend set the right flags. The backend will normally create
260 the .got and .plt sections. */
261 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
264 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
269 /* Create dynamic sections when linking against a dynamic object. */
272 _bfd_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
274 flagword flags
, pltflags
;
275 struct elf_link_hash_entry
*h
;
277 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
279 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
280 .rel[a].bss sections. */
281 flags
= bed
->dynamic_sec_flags
;
284 if (bed
->plt_not_loaded
)
285 /* We do not clear SEC_ALLOC here because we still want the OS to
286 allocate space for the section; it's just that there's nothing
287 to read in from the object file. */
288 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
290 pltflags
|= SEC_ALLOC
| SEC_CODE
| SEC_LOAD
;
291 if (bed
->plt_readonly
)
292 pltflags
|= SEC_READONLY
;
294 s
= bfd_make_section_with_flags (abfd
, ".plt", pltflags
);
296 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
299 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
301 if (bed
->want_plt_sym
)
303 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
304 "_PROCEDURE_LINKAGE_TABLE_");
305 elf_hash_table (info
)->hplt
= h
;
310 s
= bfd_make_section_with_flags (abfd
,
311 (bed
->default_use_rela_p
312 ? ".rela.plt" : ".rel.plt"),
313 flags
| SEC_READONLY
);
315 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
318 if (! _bfd_elf_create_got_section (abfd
, info
))
321 if (bed
->want_dynbss
)
323 /* The .dynbss section is a place to put symbols which are defined
324 by dynamic objects, are referenced by regular objects, and are
325 not functions. We must allocate space for them in the process
326 image and use a R_*_COPY reloc to tell the dynamic linker to
327 initialize them at run time. The linker script puts the .dynbss
328 section into the .bss section of the final image. */
329 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
331 | SEC_LINKER_CREATED
));
335 /* The .rel[a].bss section holds copy relocs. This section is not
336 normally needed. We need to create it here, though, so that the
337 linker will map it to an output section. We can't just create it
338 only if we need it, because we will not know whether we need it
339 until we have seen all the input files, and the first time the
340 main linker code calls BFD after examining all the input files
341 (size_dynamic_sections) the input sections have already been
342 mapped to the output sections. If the section turns out not to
343 be needed, we can discard it later. We will never need this
344 section when generating a shared object, since they do not use
348 s
= bfd_make_section_with_flags (abfd
,
349 (bed
->default_use_rela_p
350 ? ".rela.bss" : ".rel.bss"),
351 flags
| SEC_READONLY
);
353 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
361 /* Record a new dynamic symbol. We record the dynamic symbols as we
362 read the input files, since we need to have a list of all of them
363 before we can determine the final sizes of the output sections.
364 Note that we may actually call this function even though we are not
365 going to output any dynamic symbols; in some cases we know that a
366 symbol should be in the dynamic symbol table, but only if there is
370 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info
*info
,
371 struct elf_link_hash_entry
*h
)
373 if (h
->dynindx
== -1)
375 struct elf_strtab_hash
*dynstr
;
380 /* XXX: The ABI draft says the linker must turn hidden and
381 internal symbols into STB_LOCAL symbols when producing the
382 DSO. However, if ld.so honors st_other in the dynamic table,
383 this would not be necessary. */
384 switch (ELF_ST_VISIBILITY (h
->other
))
388 if (h
->root
.type
!= bfd_link_hash_undefined
389 && h
->root
.type
!= bfd_link_hash_undefweak
)
392 if (!elf_hash_table (info
)->is_relocatable_executable
)
400 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
401 ++elf_hash_table (info
)->dynsymcount
;
403 dynstr
= elf_hash_table (info
)->dynstr
;
406 /* Create a strtab to hold the dynamic symbol names. */
407 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
412 /* We don't put any version information in the dynamic string
414 name
= h
->root
.root
.string
;
415 p
= strchr (name
, ELF_VER_CHR
);
417 /* We know that the p points into writable memory. In fact,
418 there are only a few symbols that have read-only names, being
419 those like _GLOBAL_OFFSET_TABLE_ that are created specially
420 by the backends. Most symbols will have names pointing into
421 an ELF string table read from a file, or to objalloc memory. */
424 indx
= _bfd_elf_strtab_add (dynstr
, name
, p
!= NULL
);
429 if (indx
== (bfd_size_type
) -1)
431 h
->dynstr_index
= indx
;
437 /* Mark a symbol dynamic. */
440 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info
*info
,
441 struct elf_link_hash_entry
*h
)
443 struct bfd_elf_dynamic_list
*d
= info
->dynamic
;
445 if (d
== NULL
|| info
->relocatable
)
448 if ((*d
->match
) (&d
->head
, NULL
, h
->root
.root
.string
))
452 /* Record an assignment to a symbol made by a linker script. We need
453 this in case some dynamic object refers to this symbol. */
456 bfd_elf_record_link_assignment (bfd
*output_bfd
,
457 struct bfd_link_info
*info
,
462 struct elf_link_hash_entry
*h
;
463 struct elf_link_hash_table
*htab
;
465 if (!is_elf_hash_table (info
->hash
))
468 htab
= elf_hash_table (info
);
469 h
= elf_link_hash_lookup (htab
, name
, !provide
, TRUE
, FALSE
);
473 /* Since we're defining the symbol, don't let it seem to have not
474 been defined. record_dynamic_symbol and size_dynamic_sections
475 may depend on this. */
476 if (h
->root
.type
== bfd_link_hash_undefweak
477 || h
->root
.type
== bfd_link_hash_undefined
)
479 h
->root
.type
= bfd_link_hash_new
;
480 if (h
->root
.u
.undef
.next
!= NULL
|| htab
->root
.undefs_tail
== &h
->root
)
481 bfd_link_repair_undef_list (&htab
->root
);
484 if (h
->root
.type
== bfd_link_hash_new
)
486 bfd_elf_link_mark_dynamic_symbol (info
, h
);
490 /* If this symbol is being provided by the linker script, and it is
491 currently defined by a dynamic object, but not by a regular
492 object, then mark it as undefined so that the generic linker will
493 force the correct value. */
497 h
->root
.type
= bfd_link_hash_undefined
;
499 /* If this symbol is not being provided by the linker script, and it is
500 currently defined by a dynamic object, but not by a regular object,
501 then clear out any version information because the symbol will not be
502 associated with the dynamic object any more. */
506 h
->verinfo
.verdef
= NULL
;
510 if (provide
&& hidden
)
512 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
514 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
515 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
518 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
520 if (!info
->relocatable
522 && (ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
523 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
))
529 || (info
->executable
&& elf_hash_table (info
)->is_relocatable_executable
))
532 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
535 /* If this is a weak defined symbol, and we know a corresponding
536 real symbol from the same dynamic object, make sure the real
537 symbol is also made into a dynamic symbol. */
538 if (h
->u
.weakdef
!= NULL
539 && h
->u
.weakdef
->dynindx
== -1)
541 if (! bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
549 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
550 success, and 2 on a failure caused by attempting to record a symbol
551 in a discarded section, eg. a discarded link-once section symbol. */
554 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info
*info
,
559 struct elf_link_local_dynamic_entry
*entry
;
560 struct elf_link_hash_table
*eht
;
561 struct elf_strtab_hash
*dynstr
;
562 unsigned long dynstr_index
;
564 Elf_External_Sym_Shndx eshndx
;
565 char esym
[sizeof (Elf64_External_Sym
)];
567 if (! is_elf_hash_table (info
->hash
))
570 /* See if the entry exists already. */
571 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
572 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
575 amt
= sizeof (*entry
);
576 entry
= bfd_alloc (input_bfd
, amt
);
580 /* Go find the symbol, so that we can find it's name. */
581 if (!bfd_elf_get_elf_syms (input_bfd
, &elf_tdata (input_bfd
)->symtab_hdr
,
582 1, input_indx
, &entry
->isym
, esym
, &eshndx
))
584 bfd_release (input_bfd
, entry
);
588 if (entry
->isym
.st_shndx
!= SHN_UNDEF
589 && (entry
->isym
.st_shndx
< SHN_LORESERVE
590 || entry
->isym
.st_shndx
> SHN_HIRESERVE
))
594 s
= bfd_section_from_elf_index (input_bfd
, entry
->isym
.st_shndx
);
595 if (s
== NULL
|| bfd_is_abs_section (s
->output_section
))
597 /* We can still bfd_release here as nothing has done another
598 bfd_alloc. We can't do this later in this function. */
599 bfd_release (input_bfd
, entry
);
604 name
= (bfd_elf_string_from_elf_section
605 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
606 entry
->isym
.st_name
));
608 dynstr
= elf_hash_table (info
)->dynstr
;
611 /* Create a strtab to hold the dynamic symbol names. */
612 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_strtab_init ();
617 dynstr_index
= _bfd_elf_strtab_add (dynstr
, name
, FALSE
);
618 if (dynstr_index
== (unsigned long) -1)
620 entry
->isym
.st_name
= dynstr_index
;
622 eht
= elf_hash_table (info
);
624 entry
->next
= eht
->dynlocal
;
625 eht
->dynlocal
= entry
;
626 entry
->input_bfd
= input_bfd
;
627 entry
->input_indx
= input_indx
;
630 /* Whatever binding the symbol had before, it's now local. */
632 = ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (entry
->isym
.st_info
));
634 /* The dynindx will be set at the end of size_dynamic_sections. */
639 /* Return the dynindex of a local dynamic symbol. */
642 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info
*info
,
646 struct elf_link_local_dynamic_entry
*e
;
648 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
649 if (e
->input_bfd
== input_bfd
&& e
->input_indx
== input_indx
)
654 /* This function is used to renumber the dynamic symbols, if some of
655 them are removed because they are marked as local. This is called
656 via elf_link_hash_traverse. */
659 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
662 size_t *count
= data
;
664 if (h
->root
.type
== bfd_link_hash_warning
)
665 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
670 if (h
->dynindx
!= -1)
671 h
->dynindx
= ++(*count
);
677 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
678 STB_LOCAL binding. */
681 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry
*h
,
684 size_t *count
= data
;
686 if (h
->root
.type
== bfd_link_hash_warning
)
687 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
689 if (!h
->forced_local
)
692 if (h
->dynindx
!= -1)
693 h
->dynindx
= ++(*count
);
698 /* Return true if the dynamic symbol for a given section should be
699 omitted when creating a shared library. */
701 _bfd_elf_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
702 struct bfd_link_info
*info
,
705 struct elf_link_hash_table
*htab
;
707 switch (elf_section_data (p
)->this_hdr
.sh_type
)
711 /* If sh_type is yet undecided, assume it could be
712 SHT_PROGBITS/SHT_NOBITS. */
714 htab
= elf_hash_table (info
);
715 if (p
== htab
->tls_sec
)
718 if (htab
->text_index_section
!= NULL
)
719 return p
!= htab
->text_index_section
&& p
!= htab
->data_index_section
;
721 if (strcmp (p
->name
, ".got") == 0
722 || strcmp (p
->name
, ".got.plt") == 0
723 || strcmp (p
->name
, ".plt") == 0)
727 if (htab
->dynobj
!= NULL
728 && (ip
= bfd_get_section_by_name (htab
->dynobj
, p
->name
)) != NULL
729 && (ip
->flags
& SEC_LINKER_CREATED
)
730 && ip
->output_section
== p
)
735 /* There shouldn't be section relative relocations
736 against any other section. */
742 /* Assign dynsym indices. In a shared library we generate a section
743 symbol for each output section, which come first. Next come symbols
744 which have been forced to local binding. Then all of the back-end
745 allocated local dynamic syms, followed by the rest of the global
749 _bfd_elf_link_renumber_dynsyms (bfd
*output_bfd
,
750 struct bfd_link_info
*info
,
751 unsigned long *section_sym_count
)
753 unsigned long dynsymcount
= 0;
755 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
757 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
759 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
760 if ((p
->flags
& SEC_EXCLUDE
) == 0
761 && (p
->flags
& SEC_ALLOC
) != 0
762 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
763 elf_section_data (p
)->dynindx
= ++dynsymcount
;
765 elf_section_data (p
)->dynindx
= 0;
767 *section_sym_count
= dynsymcount
;
769 elf_link_hash_traverse (elf_hash_table (info
),
770 elf_link_renumber_local_hash_table_dynsyms
,
773 if (elf_hash_table (info
)->dynlocal
)
775 struct elf_link_local_dynamic_entry
*p
;
776 for (p
= elf_hash_table (info
)->dynlocal
; p
; p
= p
->next
)
777 p
->dynindx
= ++dynsymcount
;
780 elf_link_hash_traverse (elf_hash_table (info
),
781 elf_link_renumber_hash_table_dynsyms
,
784 /* There is an unused NULL entry at the head of the table which
785 we must account for in our count. Unless there weren't any
786 symbols, which means we'll have no table at all. */
787 if (dynsymcount
!= 0)
790 elf_hash_table (info
)->dynsymcount
= dynsymcount
;
794 /* This function is called when we want to define a new symbol. It
795 handles the various cases which arise when we find a definition in
796 a dynamic object, or when there is already a definition in a
797 dynamic object. The new symbol is described by NAME, SYM, PSEC,
798 and PVALUE. We set SYM_HASH to the hash table entry. We set
799 OVERRIDE if the old symbol is overriding a new definition. We set
800 TYPE_CHANGE_OK if it is OK for the type to change. We set
801 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
802 change, we mean that we shouldn't warn if the type or size does
803 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic
804 object is overridden by a regular object. */
807 _bfd_elf_merge_symbol (bfd
*abfd
,
808 struct bfd_link_info
*info
,
810 Elf_Internal_Sym
*sym
,
813 unsigned int *pold_alignment
,
814 struct elf_link_hash_entry
**sym_hash
,
816 bfd_boolean
*override
,
817 bfd_boolean
*type_change_ok
,
818 bfd_boolean
*size_change_ok
)
820 asection
*sec
, *oldsec
;
821 struct elf_link_hash_entry
*h
;
822 struct elf_link_hash_entry
*flip
;
825 bfd_boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
826 bfd_boolean newweak
, oldweak
;
827 const struct elf_backend_data
*bed
;
833 bind
= ELF_ST_BIND (sym
->st_info
);
835 /* Silently discard TLS symbols from --just-syms. There's no way to
836 combine a static TLS block with a new TLS block for this executable. */
837 if (ELF_ST_TYPE (sym
->st_info
) == STT_TLS
838 && sec
->sec_info_type
== ELF_INFO_TYPE_JUST_SYMS
)
844 if (! bfd_is_und_section (sec
))
845 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
, FALSE
, FALSE
);
847 h
= ((struct elf_link_hash_entry
*)
848 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
853 /* This code is for coping with dynamic objects, and is only useful
854 if we are doing an ELF link. */
855 if (info
->hash
->creator
!= abfd
->xvec
)
858 /* For merging, we only care about real symbols. */
860 while (h
->root
.type
== bfd_link_hash_indirect
861 || h
->root
.type
== bfd_link_hash_warning
)
862 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
864 /* If we just created the symbol, mark it as being an ELF symbol.
865 Other than that, there is nothing to do--there is no merge issue
866 with a newly defined symbol--so we just return. */
868 if (h
->root
.type
== bfd_link_hash_new
)
870 bfd_elf_link_mark_dynamic_symbol (info
, h
);
875 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
878 switch (h
->root
.type
)
885 case bfd_link_hash_undefined
:
886 case bfd_link_hash_undefweak
:
887 oldbfd
= h
->root
.u
.undef
.abfd
;
891 case bfd_link_hash_defined
:
892 case bfd_link_hash_defweak
:
893 oldbfd
= h
->root
.u
.def
.section
->owner
;
894 oldsec
= h
->root
.u
.def
.section
;
897 case bfd_link_hash_common
:
898 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
899 oldsec
= h
->root
.u
.c
.p
->section
;
903 /* In cases involving weak versioned symbols, we may wind up trying
904 to merge a symbol with itself. Catch that here, to avoid the
905 confusion that results if we try to override a symbol with
906 itself. The additional tests catch cases like
907 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
908 dynamic object, which we do want to handle here. */
910 && ((abfd
->flags
& DYNAMIC
) == 0
914 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
915 respectively, is from a dynamic object. */
917 newdyn
= (abfd
->flags
& DYNAMIC
) != 0;
921 olddyn
= (oldbfd
->flags
& DYNAMIC
) != 0;
922 else if (oldsec
!= NULL
)
924 /* This handles the special SHN_MIPS_{TEXT,DATA} section
925 indices used by MIPS ELF. */
926 olddyn
= (oldsec
->symbol
->flags
& BSF_DYNAMIC
) != 0;
929 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
930 respectively, appear to be a definition rather than reference. */
932 newdef
= !bfd_is_und_section (sec
) && !bfd_is_com_section (sec
);
934 olddef
= (h
->root
.type
!= bfd_link_hash_undefined
935 && h
->root
.type
!= bfd_link_hash_undefweak
936 && h
->root
.type
!= bfd_link_hash_common
);
938 /* When we try to create a default indirect symbol from the dynamic
939 definition with the default version, we skip it if its type and
940 the type of existing regular definition mismatch. We only do it
941 if the existing regular definition won't be dynamic. */
942 if (pold_alignment
== NULL
944 && !info
->export_dynamic
949 && (olddef
|| h
->root
.type
== bfd_link_hash_common
)
950 && ELF_ST_TYPE (sym
->st_info
) != h
->type
951 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
952 && h
->type
!= STT_NOTYPE
)
958 /* Check TLS symbol. We don't check undefined symbol introduced by
960 if ((ELF_ST_TYPE (sym
->st_info
) == STT_TLS
|| h
->type
== STT_TLS
)
961 && ELF_ST_TYPE (sym
->st_info
) != h
->type
965 bfd_boolean ntdef
, tdef
;
966 asection
*ntsec
, *tsec
;
968 if (h
->type
== STT_TLS
)
988 (*_bfd_error_handler
)
989 (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
990 tbfd
, tsec
, ntbfd
, ntsec
, h
->root
.root
.string
);
991 else if (!tdef
&& !ntdef
)
992 (*_bfd_error_handler
)
993 (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
994 tbfd
, ntbfd
, h
->root
.root
.string
);
996 (*_bfd_error_handler
)
997 (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
998 tbfd
, tsec
, ntbfd
, h
->root
.root
.string
);
1000 (*_bfd_error_handler
)
1001 (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1002 tbfd
, ntbfd
, ntsec
, h
->root
.root
.string
);
1004 bfd_set_error (bfd_error_bad_value
);
1008 /* We need to remember if a symbol has a definition in a dynamic
1009 object or is weak in all dynamic objects. Internal and hidden
1010 visibility will make it unavailable to dynamic objects. */
1011 if (newdyn
&& !h
->dynamic_def
)
1013 if (!bfd_is_und_section (sec
))
1017 /* Check if this symbol is weak in all dynamic objects. If it
1018 is the first time we see it in a dynamic object, we mark
1019 if it is weak. Otherwise, we clear it. */
1020 if (!h
->ref_dynamic
)
1022 if (bind
== STB_WEAK
)
1023 h
->dynamic_weak
= 1;
1025 else if (bind
!= STB_WEAK
)
1026 h
->dynamic_weak
= 0;
1030 /* If the old symbol has non-default visibility, we ignore the new
1031 definition from a dynamic object. */
1033 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1034 && !bfd_is_und_section (sec
))
1037 /* Make sure this symbol is dynamic. */
1039 /* A protected symbol has external availability. Make sure it is
1040 recorded as dynamic.
1042 FIXME: Should we check type and size for protected symbol? */
1043 if (ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1044 return bfd_elf_link_record_dynamic_symbol (info
, h
);
1049 && ELF_ST_VISIBILITY (sym
->st_other
) != STV_DEFAULT
1052 /* If the new symbol with non-default visibility comes from a
1053 relocatable file and the old definition comes from a dynamic
1054 object, we remove the old definition. */
1055 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1057 /* Handle the case where the old dynamic definition is
1058 default versioned. We need to copy the symbol info from
1059 the symbol with default version to the normal one if it
1060 was referenced before. */
1063 const struct elf_backend_data
*bed
1064 = get_elf_backend_data (abfd
);
1065 struct elf_link_hash_entry
*vh
= *sym_hash
;
1066 vh
->root
.type
= h
->root
.type
;
1067 h
->root
.type
= bfd_link_hash_indirect
;
1068 (*bed
->elf_backend_copy_indirect_symbol
) (info
, vh
, h
);
1069 /* Protected symbols will override the dynamic definition
1070 with default version. */
1071 if (ELF_ST_VISIBILITY (sym
->st_other
) == STV_PROTECTED
)
1073 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) vh
;
1074 vh
->dynamic_def
= 1;
1075 vh
->ref_dynamic
= 1;
1079 h
->root
.type
= vh
->root
.type
;
1080 vh
->ref_dynamic
= 0;
1081 /* We have to hide it here since it was made dynamic
1082 global with extra bits when the symbol info was
1083 copied from the old dynamic definition. */
1084 (*bed
->elf_backend_hide_symbol
) (info
, vh
, TRUE
);
1092 if ((h
->root
.u
.undef
.next
|| info
->hash
->undefs_tail
== &h
->root
)
1093 && bfd_is_und_section (sec
))
1095 /* If the new symbol is undefined and the old symbol was
1096 also undefined before, we need to make sure
1097 _bfd_generic_link_add_one_symbol doesn't mess
1098 up the linker hash table undefs list. Since the old
1099 definition came from a dynamic object, it is still on the
1101 h
->root
.type
= bfd_link_hash_undefined
;
1102 h
->root
.u
.undef
.abfd
= abfd
;
1106 h
->root
.type
= bfd_link_hash_new
;
1107 h
->root
.u
.undef
.abfd
= NULL
;
1116 /* FIXME: Should we check type and size for protected symbol? */
1122 /* Differentiate strong and weak symbols. */
1123 newweak
= bind
== STB_WEAK
;
1124 oldweak
= (h
->root
.type
== bfd_link_hash_defweak
1125 || h
->root
.type
== bfd_link_hash_undefweak
);
1127 /* If a new weak symbol definition comes from a regular file and the
1128 old symbol comes from a dynamic library, we treat the new one as
1129 strong. Similarly, an old weak symbol definition from a regular
1130 file is treated as strong when the new symbol comes from a dynamic
1131 library. Further, an old weak symbol from a dynamic library is
1132 treated as strong if the new symbol is from a dynamic library.
1133 This reflects the way glibc's ld.so works.
1135 Do this before setting *type_change_ok or *size_change_ok so that
1136 we warn properly when dynamic library symbols are overridden. */
1138 if (newdef
&& !newdyn
&& olddyn
)
1140 if (olddef
&& newdyn
)
1143 /* It's OK to change the type if either the existing symbol or the
1144 new symbol is weak. A type change is also OK if the old symbol
1145 is undefined and the new symbol is defined. */
1150 && h
->root
.type
== bfd_link_hash_undefined
))
1151 *type_change_ok
= TRUE
;
1153 /* It's OK to change the size if either the existing symbol or the
1154 new symbol is weak, or if the old symbol is undefined. */
1157 || h
->root
.type
== bfd_link_hash_undefined
)
1158 *size_change_ok
= TRUE
;
1160 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1161 symbol, respectively, appears to be a common symbol in a dynamic
1162 object. If a symbol appears in an uninitialized section, and is
1163 not weak, and is not a function, then it may be a common symbol
1164 which was resolved when the dynamic object was created. We want
1165 to treat such symbols specially, because they raise special
1166 considerations when setting the symbol size: if the symbol
1167 appears as a common symbol in a regular object, and the size in
1168 the regular object is larger, we must make sure that we use the
1169 larger size. This problematic case can always be avoided in C,
1170 but it must be handled correctly when using Fortran shared
1173 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1174 likewise for OLDDYNCOMMON and OLDDEF.
1176 Note that this test is just a heuristic, and that it is quite
1177 possible to have an uninitialized symbol in a shared object which
1178 is really a definition, rather than a common symbol. This could
1179 lead to some minor confusion when the symbol really is a common
1180 symbol in some regular object. However, I think it will be
1186 && (sec
->flags
& SEC_ALLOC
) != 0
1187 && (sec
->flags
& SEC_LOAD
) == 0
1189 && ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
1190 newdyncommon
= TRUE
;
1192 newdyncommon
= FALSE
;
1196 && h
->root
.type
== bfd_link_hash_defined
1198 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1199 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
1201 && h
->type
!= STT_FUNC
)
1202 olddyncommon
= TRUE
;
1204 olddyncommon
= FALSE
;
1206 /* We now know everything about the old and new symbols. We ask the
1207 backend to check if we can merge them. */
1208 bed
= get_elf_backend_data (abfd
);
1209 if (bed
->merge_symbol
1210 && !bed
->merge_symbol (info
, sym_hash
, h
, sym
, psec
, pvalue
,
1211 pold_alignment
, skip
, override
,
1212 type_change_ok
, size_change_ok
,
1213 &newdyn
, &newdef
, &newdyncommon
, &newweak
,
1215 &olddyn
, &olddef
, &olddyncommon
, &oldweak
,
1219 /* If both the old and the new symbols look like common symbols in a
1220 dynamic object, set the size of the symbol to the larger of the
1225 && sym
->st_size
!= h
->size
)
1227 /* Since we think we have two common symbols, issue a multiple
1228 common warning if desired. Note that we only warn if the
1229 size is different. If the size is the same, we simply let
1230 the old symbol override the new one as normally happens with
1231 symbols defined in dynamic objects. */
1233 if (! ((*info
->callbacks
->multiple_common
)
1234 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
1235 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1238 if (sym
->st_size
> h
->size
)
1239 h
->size
= sym
->st_size
;
1241 *size_change_ok
= TRUE
;
1244 /* If we are looking at a dynamic object, and we have found a
1245 definition, we need to see if the symbol was already defined by
1246 some other object. If so, we want to use the existing
1247 definition, and we do not want to report a multiple symbol
1248 definition error; we do this by clobbering *PSEC to be
1249 bfd_und_section_ptr.
1251 We treat a common symbol as a definition if the symbol in the
1252 shared library is a function, since common symbols always
1253 represent variables; this can cause confusion in principle, but
1254 any such confusion would seem to indicate an erroneous program or
1255 shared library. We also permit a common symbol in a regular
1256 object to override a weak symbol in a shared object. */
1261 || (h
->root
.type
== bfd_link_hash_common
1263 || ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
))))
1267 newdyncommon
= FALSE
;
1269 *psec
= sec
= bfd_und_section_ptr
;
1270 *size_change_ok
= TRUE
;
1272 /* If we get here when the old symbol is a common symbol, then
1273 we are explicitly letting it override a weak symbol or
1274 function in a dynamic object, and we don't want to warn about
1275 a type change. If the old symbol is a defined symbol, a type
1276 change warning may still be appropriate. */
1278 if (h
->root
.type
== bfd_link_hash_common
)
1279 *type_change_ok
= TRUE
;
1282 /* Handle the special case of an old common symbol merging with a
1283 new symbol which looks like a common symbol in a shared object.
1284 We change *PSEC and *PVALUE to make the new symbol look like a
1285 common symbol, and let _bfd_generic_link_add_one_symbol do the
1289 && h
->root
.type
== bfd_link_hash_common
)
1293 newdyncommon
= FALSE
;
1294 *pvalue
= sym
->st_size
;
1295 *psec
= sec
= bed
->common_section (oldsec
);
1296 *size_change_ok
= TRUE
;
1299 /* Skip weak definitions of symbols that are already defined. */
1300 if (newdef
&& olddef
&& newweak
)
1303 /* If the old symbol is from a dynamic object, and the new symbol is
1304 a definition which is not from a dynamic object, then the new
1305 symbol overrides the old symbol. Symbols from regular files
1306 always take precedence over symbols from dynamic objects, even if
1307 they are defined after the dynamic object in the link.
1309 As above, we again permit a common symbol in a regular object to
1310 override a definition in a shared object if the shared object
1311 symbol is a function or is weak. */
1316 || (bfd_is_com_section (sec
)
1318 || h
->type
== STT_FUNC
)))
1323 /* Change the hash table entry to undefined, and let
1324 _bfd_generic_link_add_one_symbol do the right thing with the
1327 h
->root
.type
= bfd_link_hash_undefined
;
1328 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1329 *size_change_ok
= TRUE
;
1332 olddyncommon
= FALSE
;
1334 /* We again permit a type change when a common symbol may be
1335 overriding a function. */
1337 if (bfd_is_com_section (sec
))
1338 *type_change_ok
= TRUE
;
1340 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1343 /* This union may have been set to be non-NULL when this symbol
1344 was seen in a dynamic object. We must force the union to be
1345 NULL, so that it is correct for a regular symbol. */
1346 h
->verinfo
.vertree
= NULL
;
1349 /* Handle the special case of a new common symbol merging with an
1350 old symbol that looks like it might be a common symbol defined in
1351 a shared object. Note that we have already handled the case in
1352 which a new common symbol should simply override the definition
1353 in the shared library. */
1356 && bfd_is_com_section (sec
)
1359 /* It would be best if we could set the hash table entry to a
1360 common symbol, but we don't know what to use for the section
1361 or the alignment. */
1362 if (! ((*info
->callbacks
->multiple_common
)
1363 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
1364 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
1367 /* If the presumed common symbol in the dynamic object is
1368 larger, pretend that the new symbol has its size. */
1370 if (h
->size
> *pvalue
)
1373 /* We need to remember the alignment required by the symbol
1374 in the dynamic object. */
1375 BFD_ASSERT (pold_alignment
);
1376 *pold_alignment
= h
->root
.u
.def
.section
->alignment_power
;
1379 olddyncommon
= FALSE
;
1381 h
->root
.type
= bfd_link_hash_undefined
;
1382 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
1384 *size_change_ok
= TRUE
;
1385 *type_change_ok
= TRUE
;
1387 if ((*sym_hash
)->root
.type
== bfd_link_hash_indirect
)
1390 h
->verinfo
.vertree
= NULL
;
1395 /* Handle the case where we had a versioned symbol in a dynamic
1396 library and now find a definition in a normal object. In this
1397 case, we make the versioned symbol point to the normal one. */
1398 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1399 flip
->root
.type
= h
->root
.type
;
1400 h
->root
.type
= bfd_link_hash_indirect
;
1401 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) flip
;
1402 (*bed
->elf_backend_copy_indirect_symbol
) (info
, flip
, h
);
1403 flip
->root
.u
.undef
.abfd
= h
->root
.u
.undef
.abfd
;
1407 flip
->ref_dynamic
= 1;
1414 /* This function is called to create an indirect symbol from the
1415 default for the symbol with the default version if needed. The
1416 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
1417 set DYNSYM if the new indirect symbol is dynamic. */
1420 _bfd_elf_add_default_symbol (bfd
*abfd
,
1421 struct bfd_link_info
*info
,
1422 struct elf_link_hash_entry
*h
,
1424 Elf_Internal_Sym
*sym
,
1427 bfd_boolean
*dynsym
,
1428 bfd_boolean override
)
1430 bfd_boolean type_change_ok
;
1431 bfd_boolean size_change_ok
;
1434 struct elf_link_hash_entry
*hi
;
1435 struct bfd_link_hash_entry
*bh
;
1436 const struct elf_backend_data
*bed
;
1437 bfd_boolean collect
;
1438 bfd_boolean dynamic
;
1440 size_t len
, shortlen
;
1443 /* If this symbol has a version, and it is the default version, we
1444 create an indirect symbol from the default name to the fully
1445 decorated name. This will cause external references which do not
1446 specify a version to be bound to this version of the symbol. */
1447 p
= strchr (name
, ELF_VER_CHR
);
1448 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
1453 /* We are overridden by an old definition. We need to check if we
1454 need to create the indirect symbol from the default name. */
1455 hi
= elf_link_hash_lookup (elf_hash_table (info
), name
, TRUE
,
1457 BFD_ASSERT (hi
!= NULL
);
1460 while (hi
->root
.type
== bfd_link_hash_indirect
1461 || hi
->root
.type
== bfd_link_hash_warning
)
1463 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1469 bed
= get_elf_backend_data (abfd
);
1470 collect
= bed
->collect
;
1471 dynamic
= (abfd
->flags
& DYNAMIC
) != 0;
1473 shortlen
= p
- name
;
1474 shortname
= bfd_hash_allocate (&info
->hash
->table
, shortlen
+ 1);
1475 if (shortname
== NULL
)
1477 memcpy (shortname
, name
, shortlen
);
1478 shortname
[shortlen
] = '\0';
1480 /* We are going to create a new symbol. Merge it with any existing
1481 symbol with this name. For the purposes of the merge, act as
1482 though we were defining the symbol we just defined, although we
1483 actually going to define an indirect symbol. */
1484 type_change_ok
= FALSE
;
1485 size_change_ok
= FALSE
;
1487 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1488 NULL
, &hi
, &skip
, &override
,
1489 &type_change_ok
, &size_change_ok
))
1498 if (! (_bfd_generic_link_add_one_symbol
1499 (info
, abfd
, shortname
, BSF_INDIRECT
, bfd_ind_section_ptr
,
1500 0, name
, FALSE
, collect
, &bh
)))
1502 hi
= (struct elf_link_hash_entry
*) bh
;
1506 /* In this case the symbol named SHORTNAME is overriding the
1507 indirect symbol we want to add. We were planning on making
1508 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1509 is the name without a version. NAME is the fully versioned
1510 name, and it is the default version.
1512 Overriding means that we already saw a definition for the
1513 symbol SHORTNAME in a regular object, and it is overriding
1514 the symbol defined in the dynamic object.
1516 When this happens, we actually want to change NAME, the
1517 symbol we just added, to refer to SHORTNAME. This will cause
1518 references to NAME in the shared object to become references
1519 to SHORTNAME in the regular object. This is what we expect
1520 when we override a function in a shared object: that the
1521 references in the shared object will be mapped to the
1522 definition in the regular object. */
1524 while (hi
->root
.type
== bfd_link_hash_indirect
1525 || hi
->root
.type
== bfd_link_hash_warning
)
1526 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1528 h
->root
.type
= bfd_link_hash_indirect
;
1529 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1533 hi
->ref_dynamic
= 1;
1537 if (! bfd_elf_link_record_dynamic_symbol (info
, hi
))
1542 /* Now set HI to H, so that the following code will set the
1543 other fields correctly. */
1547 /* If there is a duplicate definition somewhere, then HI may not
1548 point to an indirect symbol. We will have reported an error to
1549 the user in that case. */
1551 if (hi
->root
.type
== bfd_link_hash_indirect
)
1553 struct elf_link_hash_entry
*ht
;
1555 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1556 (*bed
->elf_backend_copy_indirect_symbol
) (info
, ht
, hi
);
1558 /* See if the new flags lead us to realize that the symbol must
1570 if (hi
->ref_regular
)
1576 /* We also need to define an indirection from the nondefault version
1580 len
= strlen (name
);
1581 shortname
= bfd_hash_allocate (&info
->hash
->table
, len
);
1582 if (shortname
== NULL
)
1584 memcpy (shortname
, name
, shortlen
);
1585 memcpy (shortname
+ shortlen
, p
+ 1, len
- shortlen
);
1587 /* Once again, merge with any existing symbol. */
1588 type_change_ok
= FALSE
;
1589 size_change_ok
= FALSE
;
1591 if (!_bfd_elf_merge_symbol (abfd
, info
, shortname
, sym
, &sec
, value
,
1592 NULL
, &hi
, &skip
, &override
,
1593 &type_change_ok
, &size_change_ok
))
1601 /* Here SHORTNAME is a versioned name, so we don't expect to see
1602 the type of override we do in the case above unless it is
1603 overridden by a versioned definition. */
1604 if (hi
->root
.type
!= bfd_link_hash_defined
1605 && hi
->root
.type
!= bfd_link_hash_defweak
)
1606 (*_bfd_error_handler
)
1607 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1613 if (! (_bfd_generic_link_add_one_symbol
1614 (info
, abfd
, shortname
, BSF_INDIRECT
,
1615 bfd_ind_section_ptr
, 0, name
, FALSE
, collect
, &bh
)))
1617 hi
= (struct elf_link_hash_entry
*) bh
;
1619 /* If there is a duplicate definition somewhere, then HI may not
1620 point to an indirect symbol. We will have reported an error
1621 to the user in that case. */
1623 if (hi
->root
.type
== bfd_link_hash_indirect
)
1625 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
1627 /* See if the new flags lead us to realize that the symbol
1639 if (hi
->ref_regular
)
1649 /* This routine is used to export all defined symbols into the dynamic
1650 symbol table. It is called via elf_link_hash_traverse. */
1653 _bfd_elf_export_symbol (struct elf_link_hash_entry
*h
, void *data
)
1655 struct elf_info_failed
*eif
= data
;
1657 /* Ignore this if we won't export it. */
1658 if (!eif
->info
->export_dynamic
&& !h
->dynamic
)
1661 /* Ignore indirect symbols. These are added by the versioning code. */
1662 if (h
->root
.type
== bfd_link_hash_indirect
)
1665 if (h
->root
.type
== bfd_link_hash_warning
)
1666 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1668 if (h
->dynindx
== -1
1672 struct bfd_elf_version_tree
*t
;
1673 struct bfd_elf_version_expr
*d
;
1675 for (t
= eif
->verdefs
; t
!= NULL
; t
= t
->next
)
1677 if (t
->globals
.list
!= NULL
)
1679 d
= (*t
->match
) (&t
->globals
, NULL
, h
->root
.root
.string
);
1684 if (t
->locals
.list
!= NULL
)
1686 d
= (*t
->match
) (&t
->locals
, NULL
, h
->root
.root
.string
);
1695 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1706 /* Look through the symbols which are defined in other shared
1707 libraries and referenced here. Update the list of version
1708 dependencies. This will be put into the .gnu.version_r section.
1709 This function is called via elf_link_hash_traverse. */
1712 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry
*h
,
1715 struct elf_find_verdep_info
*rinfo
= data
;
1716 Elf_Internal_Verneed
*t
;
1717 Elf_Internal_Vernaux
*a
;
1720 if (h
->root
.type
== bfd_link_hash_warning
)
1721 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1723 /* We only care about symbols defined in shared objects with version
1728 || h
->verinfo
.verdef
== NULL
)
1731 /* See if we already know about this version. */
1732 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1734 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
1737 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1738 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
1744 /* This is a new version. Add it to tree we are building. */
1749 t
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1752 rinfo
->failed
= TRUE
;
1756 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
1757 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
1758 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
1762 a
= bfd_zalloc (rinfo
->output_bfd
, amt
);
1764 /* Note that we are copying a string pointer here, and testing it
1765 above. If bfd_elf_string_from_elf_section is ever changed to
1766 discard the string data when low in memory, this will have to be
1768 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
1770 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
1771 a
->vna_nextptr
= t
->vn_auxptr
;
1773 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
1776 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
1783 /* Figure out appropriate versions for all the symbols. We may not
1784 have the version number script until we have read all of the input
1785 files, so until that point we don't know which symbols should be
1786 local. This function is called via elf_link_hash_traverse. */
1789 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry
*h
, void *data
)
1791 struct elf_assign_sym_version_info
*sinfo
;
1792 struct bfd_link_info
*info
;
1793 const struct elf_backend_data
*bed
;
1794 struct elf_info_failed eif
;
1801 if (h
->root
.type
== bfd_link_hash_warning
)
1802 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1804 /* Fix the symbol flags. */
1807 if (! _bfd_elf_fix_symbol_flags (h
, &eif
))
1810 sinfo
->failed
= TRUE
;
1814 /* We only need version numbers for symbols defined in regular
1816 if (!h
->def_regular
)
1819 bed
= get_elf_backend_data (sinfo
->output_bfd
);
1820 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1821 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
1823 struct bfd_elf_version_tree
*t
;
1828 /* There are two consecutive ELF_VER_CHR characters if this is
1829 not a hidden symbol. */
1831 if (*p
== ELF_VER_CHR
)
1837 /* If there is no version string, we can just return out. */
1845 /* Look for the version. If we find it, it is no longer weak. */
1846 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1848 if (strcmp (t
->name
, p
) == 0)
1852 struct bfd_elf_version_expr
*d
;
1854 len
= p
- h
->root
.root
.string
;
1855 alc
= bfd_malloc (len
);
1858 memcpy (alc
, h
->root
.root
.string
, len
- 1);
1859 alc
[len
- 1] = '\0';
1860 if (alc
[len
- 2] == ELF_VER_CHR
)
1861 alc
[len
- 2] = '\0';
1863 h
->verinfo
.vertree
= t
;
1867 if (t
->globals
.list
!= NULL
)
1868 d
= (*t
->match
) (&t
->globals
, NULL
, alc
);
1870 /* See if there is anything to force this symbol to
1872 if (d
== NULL
&& t
->locals
.list
!= NULL
)
1874 d
= (*t
->match
) (&t
->locals
, NULL
, alc
);
1877 && ! info
->export_dynamic
)
1878 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1886 /* If we are building an application, we need to create a
1887 version node for this version. */
1888 if (t
== NULL
&& info
->executable
)
1890 struct bfd_elf_version_tree
**pp
;
1893 /* If we aren't going to export this symbol, we don't need
1894 to worry about it. */
1895 if (h
->dynindx
== -1)
1899 t
= bfd_zalloc (sinfo
->output_bfd
, amt
);
1902 sinfo
->failed
= TRUE
;
1907 t
->name_indx
= (unsigned int) -1;
1911 /* Don't count anonymous version tag. */
1912 if (sinfo
->verdefs
!= NULL
&& sinfo
->verdefs
->vernum
== 0)
1914 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1916 t
->vernum
= version_index
;
1920 h
->verinfo
.vertree
= t
;
1924 /* We could not find the version for a symbol when
1925 generating a shared archive. Return an error. */
1926 (*_bfd_error_handler
)
1927 (_("%B: undefined versioned symbol name %s"),
1928 sinfo
->output_bfd
, h
->root
.root
.string
);
1929 bfd_set_error (bfd_error_bad_value
);
1930 sinfo
->failed
= TRUE
;
1938 /* If we don't have a version for this symbol, see if we can find
1940 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
1942 struct bfd_elf_version_tree
*t
;
1943 struct bfd_elf_version_tree
*local_ver
;
1944 struct bfd_elf_version_expr
*d
;
1946 /* See if can find what version this symbol is in. If the
1947 symbol is supposed to be local, then don't actually register
1950 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
1952 if (t
->globals
.list
!= NULL
)
1954 bfd_boolean matched
;
1958 while ((d
= (*t
->match
) (&t
->globals
, d
,
1959 h
->root
.root
.string
)) != NULL
)
1964 /* There is a version without definition. Make
1965 the symbol the default definition for this
1967 h
->verinfo
.vertree
= t
;
1975 /* There is no undefined version for this symbol. Hide the
1977 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1980 if (t
->locals
.list
!= NULL
)
1983 while ((d
= (*t
->match
) (&t
->locals
, d
,
1984 h
->root
.root
.string
)) != NULL
)
1987 /* If the match is "*", keep looking for a more
1988 explicit, perhaps even global, match.
1989 XXX: Shouldn't this be !d->wildcard instead? */
1990 if (d
->pattern
[0] != '*' || d
->pattern
[1] != '\0')
1999 if (local_ver
!= NULL
)
2001 h
->verinfo
.vertree
= local_ver
;
2002 if (h
->dynindx
!= -1
2003 && ! info
->export_dynamic
)
2005 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
2013 /* Read and swap the relocs from the section indicated by SHDR. This
2014 may be either a REL or a RELA section. The relocations are
2015 translated into RELA relocations and stored in INTERNAL_RELOCS,
2016 which should have already been allocated to contain enough space.
2017 The EXTERNAL_RELOCS are a buffer where the external form of the
2018 relocations should be stored.
2020 Returns FALSE if something goes wrong. */
2023 elf_link_read_relocs_from_section (bfd
*abfd
,
2025 Elf_Internal_Shdr
*shdr
,
2026 void *external_relocs
,
2027 Elf_Internal_Rela
*internal_relocs
)
2029 const struct elf_backend_data
*bed
;
2030 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2031 const bfd_byte
*erela
;
2032 const bfd_byte
*erelaend
;
2033 Elf_Internal_Rela
*irela
;
2034 Elf_Internal_Shdr
*symtab_hdr
;
2037 /* Position ourselves at the start of the section. */
2038 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2041 /* Read the relocations. */
2042 if (bfd_bread (external_relocs
, shdr
->sh_size
, abfd
) != shdr
->sh_size
)
2045 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2046 nsyms
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
2048 bed
= get_elf_backend_data (abfd
);
2050 /* Convert the external relocations to the internal format. */
2051 if (shdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2052 swap_in
= bed
->s
->swap_reloc_in
;
2053 else if (shdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2054 swap_in
= bed
->s
->swap_reloca_in
;
2057 bfd_set_error (bfd_error_wrong_format
);
2061 erela
= external_relocs
;
2062 erelaend
= erela
+ shdr
->sh_size
;
2063 irela
= internal_relocs
;
2064 while (erela
< erelaend
)
2068 (*swap_in
) (abfd
, erela
, irela
);
2069 r_symndx
= ELF32_R_SYM (irela
->r_info
);
2070 if (bed
->s
->arch_size
== 64)
2072 if ((size_t) r_symndx
>= nsyms
)
2074 (*_bfd_error_handler
)
2075 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2076 " for offset 0x%lx in section `%A'"),
2078 (unsigned long) r_symndx
, (unsigned long) nsyms
, irela
->r_offset
);
2079 bfd_set_error (bfd_error_bad_value
);
2082 irela
+= bed
->s
->int_rels_per_ext_rel
;
2083 erela
+= shdr
->sh_entsize
;
2089 /* Read and swap the relocs for a section O. They may have been
2090 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2091 not NULL, they are used as buffers to read into. They are known to
2092 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2093 the return value is allocated using either malloc or bfd_alloc,
2094 according to the KEEP_MEMORY argument. If O has two relocation
2095 sections (both REL and RELA relocations), then the REL_HDR
2096 relocations will appear first in INTERNAL_RELOCS, followed by the
2097 REL_HDR2 relocations. */
2100 _bfd_elf_link_read_relocs (bfd
*abfd
,
2102 void *external_relocs
,
2103 Elf_Internal_Rela
*internal_relocs
,
2104 bfd_boolean keep_memory
)
2106 Elf_Internal_Shdr
*rel_hdr
;
2107 void *alloc1
= NULL
;
2108 Elf_Internal_Rela
*alloc2
= NULL
;
2109 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2111 if (elf_section_data (o
)->relocs
!= NULL
)
2112 return elf_section_data (o
)->relocs
;
2114 if (o
->reloc_count
== 0)
2117 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2119 if (internal_relocs
== NULL
)
2123 size
= o
->reloc_count
;
2124 size
*= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
2126 internal_relocs
= bfd_alloc (abfd
, size
);
2128 internal_relocs
= alloc2
= bfd_malloc (size
);
2129 if (internal_relocs
== NULL
)
2133 if (external_relocs
== NULL
)
2135 bfd_size_type size
= rel_hdr
->sh_size
;
2137 if (elf_section_data (o
)->rel_hdr2
)
2138 size
+= elf_section_data (o
)->rel_hdr2
->sh_size
;
2139 alloc1
= bfd_malloc (size
);
2142 external_relocs
= alloc1
;
2145 if (!elf_link_read_relocs_from_section (abfd
, o
, rel_hdr
,
2149 if (elf_section_data (o
)->rel_hdr2
2150 && (!elf_link_read_relocs_from_section
2152 elf_section_data (o
)->rel_hdr2
,
2153 ((bfd_byte
*) external_relocs
) + rel_hdr
->sh_size
,
2154 internal_relocs
+ (NUM_SHDR_ENTRIES (rel_hdr
)
2155 * bed
->s
->int_rels_per_ext_rel
))))
2158 /* Cache the results for next time, if we can. */
2160 elf_section_data (o
)->relocs
= internal_relocs
;
2165 /* Don't free alloc2, since if it was allocated we are passing it
2166 back (under the name of internal_relocs). */
2168 return internal_relocs
;
2178 /* Compute the size of, and allocate space for, REL_HDR which is the
2179 section header for a section containing relocations for O. */
2182 _bfd_elf_link_size_reloc_section (bfd
*abfd
,
2183 Elf_Internal_Shdr
*rel_hdr
,
2186 bfd_size_type reloc_count
;
2187 bfd_size_type num_rel_hashes
;
2189 /* Figure out how many relocations there will be. */
2190 if (rel_hdr
== &elf_section_data (o
)->rel_hdr
)
2191 reloc_count
= elf_section_data (o
)->rel_count
;
2193 reloc_count
= elf_section_data (o
)->rel_count2
;
2195 num_rel_hashes
= o
->reloc_count
;
2196 if (num_rel_hashes
< reloc_count
)
2197 num_rel_hashes
= reloc_count
;
2199 /* That allows us to calculate the size of the section. */
2200 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* reloc_count
;
2202 /* The contents field must last into write_object_contents, so we
2203 allocate it with bfd_alloc rather than malloc. Also since we
2204 cannot be sure that the contents will actually be filled in,
2205 we zero the allocated space. */
2206 rel_hdr
->contents
= bfd_zalloc (abfd
, rel_hdr
->sh_size
);
2207 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2210 /* We only allocate one set of hash entries, so we only do it the
2211 first time we are called. */
2212 if (elf_section_data (o
)->rel_hashes
== NULL
2215 struct elf_link_hash_entry
**p
;
2217 p
= bfd_zmalloc (num_rel_hashes
* sizeof (struct elf_link_hash_entry
*));
2221 elf_section_data (o
)->rel_hashes
= p
;
2227 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2228 originated from the section given by INPUT_REL_HDR) to the
2232 _bfd_elf_link_output_relocs (bfd
*output_bfd
,
2233 asection
*input_section
,
2234 Elf_Internal_Shdr
*input_rel_hdr
,
2235 Elf_Internal_Rela
*internal_relocs
,
2236 struct elf_link_hash_entry
**rel_hash
2239 Elf_Internal_Rela
*irela
;
2240 Elf_Internal_Rela
*irelaend
;
2242 Elf_Internal_Shdr
*output_rel_hdr
;
2243 asection
*output_section
;
2244 unsigned int *rel_countp
= NULL
;
2245 const struct elf_backend_data
*bed
;
2246 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2248 output_section
= input_section
->output_section
;
2249 output_rel_hdr
= NULL
;
2251 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
2252 == input_rel_hdr
->sh_entsize
)
2254 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
2255 rel_countp
= &elf_section_data (output_section
)->rel_count
;
2257 else if (elf_section_data (output_section
)->rel_hdr2
2258 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
2259 == input_rel_hdr
->sh_entsize
))
2261 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
2262 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
2266 (*_bfd_error_handler
)
2267 (_("%B: relocation size mismatch in %B section %A"),
2268 output_bfd
, input_section
->owner
, input_section
);
2269 bfd_set_error (bfd_error_wrong_object_format
);
2273 bed
= get_elf_backend_data (output_bfd
);
2274 if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
2275 swap_out
= bed
->s
->swap_reloc_out
;
2276 else if (input_rel_hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
2277 swap_out
= bed
->s
->swap_reloca_out
;
2281 erel
= output_rel_hdr
->contents
;
2282 erel
+= *rel_countp
* input_rel_hdr
->sh_entsize
;
2283 irela
= internal_relocs
;
2284 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
2285 * bed
->s
->int_rels_per_ext_rel
);
2286 while (irela
< irelaend
)
2288 (*swap_out
) (output_bfd
, irela
, erel
);
2289 irela
+= bed
->s
->int_rels_per_ext_rel
;
2290 erel
+= input_rel_hdr
->sh_entsize
;
2293 /* Bump the counter, so that we know where to add the next set of
2295 *rel_countp
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
2300 /* Make weak undefined symbols in PIE dynamic. */
2303 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info
*info
,
2304 struct elf_link_hash_entry
*h
)
2308 && h
->root
.type
== bfd_link_hash_undefweak
)
2309 return bfd_elf_link_record_dynamic_symbol (info
, h
);
2314 /* Fix up the flags for a symbol. This handles various cases which
2315 can only be fixed after all the input files are seen. This is
2316 currently called by both adjust_dynamic_symbol and
2317 assign_sym_version, which is unnecessary but perhaps more robust in
2318 the face of future changes. */
2321 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry
*h
,
2322 struct elf_info_failed
*eif
)
2324 const struct elf_backend_data
*bed
= NULL
;
2326 /* If this symbol was mentioned in a non-ELF file, try to set
2327 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2328 permit a non-ELF file to correctly refer to a symbol defined in
2329 an ELF dynamic object. */
2332 while (h
->root
.type
== bfd_link_hash_indirect
)
2333 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2335 if (h
->root
.type
!= bfd_link_hash_defined
2336 && h
->root
.type
!= bfd_link_hash_defweak
)
2339 h
->ref_regular_nonweak
= 1;
2343 if (h
->root
.u
.def
.section
->owner
!= NULL
2344 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2345 == bfd_target_elf_flavour
))
2348 h
->ref_regular_nonweak
= 1;
2354 if (h
->dynindx
== -1
2358 if (! bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2367 /* Unfortunately, NON_ELF is only correct if the symbol
2368 was first seen in a non-ELF file. Fortunately, if the symbol
2369 was first seen in an ELF file, we're probably OK unless the
2370 symbol was defined in a non-ELF file. Catch that case here.
2371 FIXME: We're still in trouble if the symbol was first seen in
2372 a dynamic object, and then later in a non-ELF regular object. */
2373 if ((h
->root
.type
== bfd_link_hash_defined
2374 || h
->root
.type
== bfd_link_hash_defweak
)
2376 && (h
->root
.u
.def
.section
->owner
!= NULL
2377 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2378 != bfd_target_elf_flavour
)
2379 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
2380 && !h
->def_dynamic
)))
2384 /* Backend specific symbol fixup. */
2385 if (elf_hash_table (eif
->info
)->dynobj
)
2387 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2388 if (bed
->elf_backend_fixup_symbol
2389 && !(*bed
->elf_backend_fixup_symbol
) (eif
->info
, h
))
2393 /* If this is a final link, and the symbol was defined as a common
2394 symbol in a regular object file, and there was no definition in
2395 any dynamic object, then the linker will have allocated space for
2396 the symbol in a common section but the DEF_REGULAR
2397 flag will not have been set. */
2398 if (h
->root
.type
== bfd_link_hash_defined
2402 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2405 /* If -Bsymbolic was used (which means to bind references to global
2406 symbols to the definition within the shared object), and this
2407 symbol was defined in a regular object, then it actually doesn't
2408 need a PLT entry. Likewise, if the symbol has non-default
2409 visibility. If the symbol has hidden or internal visibility, we
2410 will force it local. */
2412 && eif
->info
->shared
2413 && is_elf_hash_table (eif
->info
->hash
)
2414 && (SYMBOLIC_BIND (eif
->info
, h
)
2415 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2418 bfd_boolean force_local
;
2420 force_local
= (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
2421 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
);
2422 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, force_local
);
2425 /* If a weak undefined symbol has non-default visibility, we also
2426 hide it from the dynamic linker. */
2427 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2428 && h
->root
.type
== bfd_link_hash_undefweak
)
2430 const struct elf_backend_data
*bed
;
2431 bed
= get_elf_backend_data (elf_hash_table (eif
->info
)->dynobj
);
2432 (*bed
->elf_backend_hide_symbol
) (eif
->info
, h
, TRUE
);
2435 /* If this is a weak defined symbol in a dynamic object, and we know
2436 the real definition in the dynamic object, copy interesting flags
2437 over to the real definition. */
2438 if (h
->u
.weakdef
!= NULL
)
2440 struct elf_link_hash_entry
*weakdef
;
2442 weakdef
= h
->u
.weakdef
;
2443 if (h
->root
.type
== bfd_link_hash_indirect
)
2444 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2446 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2447 || h
->root
.type
== bfd_link_hash_defweak
);
2448 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2449 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2450 BFD_ASSERT (weakdef
->def_dynamic
);
2452 /* If the real definition is defined by a regular object file,
2453 don't do anything special. See the longer description in
2454 _bfd_elf_adjust_dynamic_symbol, below. */
2455 if (weakdef
->def_regular
)
2456 h
->u
.weakdef
= NULL
;
2458 (*bed
->elf_backend_copy_indirect_symbol
) (eif
->info
, weakdef
,
2465 /* Make the backend pick a good value for a dynamic symbol. This is
2466 called via elf_link_hash_traverse, and also calls itself
2470 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry
*h
, void *data
)
2472 struct elf_info_failed
*eif
= data
;
2474 const struct elf_backend_data
*bed
;
2476 if (! is_elf_hash_table (eif
->info
->hash
))
2479 if (h
->root
.type
== bfd_link_hash_warning
)
2481 h
->got
= elf_hash_table (eif
->info
)->init_got_offset
;
2482 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
2484 /* When warning symbols are created, they **replace** the "real"
2485 entry in the hash table, thus we never get to see the real
2486 symbol in a hash traversal. So look at it now. */
2487 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2490 /* Ignore indirect symbols. These are added by the versioning code. */
2491 if (h
->root
.type
== bfd_link_hash_indirect
)
2494 /* Fix the symbol flags. */
2495 if (! _bfd_elf_fix_symbol_flags (h
, eif
))
2498 /* If this symbol does not require a PLT entry, and it is not
2499 defined by a dynamic object, or is not referenced by a regular
2500 object, ignore it. We do have to handle a weak defined symbol,
2501 even if no regular object refers to it, if we decided to add it
2502 to the dynamic symbol table. FIXME: Do we normally need to worry
2503 about symbols which are defined by one dynamic object and
2504 referenced by another one? */
2509 && (h
->u
.weakdef
== NULL
|| h
->u
.weakdef
->dynindx
== -1))))
2511 h
->plt
= elf_hash_table (eif
->info
)->init_plt_offset
;
2515 /* If we've already adjusted this symbol, don't do it again. This
2516 can happen via a recursive call. */
2517 if (h
->dynamic_adjusted
)
2520 /* Don't look at this symbol again. Note that we must set this
2521 after checking the above conditions, because we may look at a
2522 symbol once, decide not to do anything, and then get called
2523 recursively later after REF_REGULAR is set below. */
2524 h
->dynamic_adjusted
= 1;
2526 /* If this is a weak definition, and we know a real definition, and
2527 the real symbol is not itself defined by a regular object file,
2528 then get a good value for the real definition. We handle the
2529 real symbol first, for the convenience of the backend routine.
2531 Note that there is a confusing case here. If the real definition
2532 is defined by a regular object file, we don't get the real symbol
2533 from the dynamic object, but we do get the weak symbol. If the
2534 processor backend uses a COPY reloc, then if some routine in the
2535 dynamic object changes the real symbol, we will not see that
2536 change in the corresponding weak symbol. This is the way other
2537 ELF linkers work as well, and seems to be a result of the shared
2540 I will clarify this issue. Most SVR4 shared libraries define the
2541 variable _timezone and define timezone as a weak synonym. The
2542 tzset call changes _timezone. If you write
2543 extern int timezone;
2545 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2546 you might expect that, since timezone is a synonym for _timezone,
2547 the same number will print both times. However, if the processor
2548 backend uses a COPY reloc, then actually timezone will be copied
2549 into your process image, and, since you define _timezone
2550 yourself, _timezone will not. Thus timezone and _timezone will
2551 wind up at different memory locations. The tzset call will set
2552 _timezone, leaving timezone unchanged. */
2554 if (h
->u
.weakdef
!= NULL
)
2556 /* If we get to this point, we know there is an implicit
2557 reference by a regular object file via the weak symbol H.
2558 FIXME: Is this really true? What if the traversal finds
2559 H->U.WEAKDEF before it finds H? */
2560 h
->u
.weakdef
->ref_regular
= 1;
2562 if (! _bfd_elf_adjust_dynamic_symbol (h
->u
.weakdef
, eif
))
2566 /* If a symbol has no type and no size and does not require a PLT
2567 entry, then we are probably about to do the wrong thing here: we
2568 are probably going to create a COPY reloc for an empty object.
2569 This case can arise when a shared object is built with assembly
2570 code, and the assembly code fails to set the symbol type. */
2572 && h
->type
== STT_NOTYPE
2574 (*_bfd_error_handler
)
2575 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2576 h
->root
.root
.string
);
2578 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2579 bed
= get_elf_backend_data (dynobj
);
2580 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2589 /* Adjust all external symbols pointing into SEC_MERGE sections
2590 to reflect the object merging within the sections. */
2593 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry
*h
, void *data
)
2597 if (h
->root
.type
== bfd_link_hash_warning
)
2598 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2600 if ((h
->root
.type
== bfd_link_hash_defined
2601 || h
->root
.type
== bfd_link_hash_defweak
)
2602 && ((sec
= h
->root
.u
.def
.section
)->flags
& SEC_MERGE
)
2603 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
2605 bfd
*output_bfd
= data
;
2607 h
->root
.u
.def
.value
=
2608 _bfd_merged_section_offset (output_bfd
,
2609 &h
->root
.u
.def
.section
,
2610 elf_section_data (sec
)->sec_info
,
2611 h
->root
.u
.def
.value
);
2617 /* Returns false if the symbol referred to by H should be considered
2618 to resolve local to the current module, and true if it should be
2619 considered to bind dynamically. */
2622 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
2623 struct bfd_link_info
*info
,
2624 bfd_boolean ignore_protected
)
2626 bfd_boolean binding_stays_local_p
;
2631 while (h
->root
.type
== bfd_link_hash_indirect
2632 || h
->root
.type
== bfd_link_hash_warning
)
2633 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2635 /* If it was forced local, then clearly it's not dynamic. */
2636 if (h
->dynindx
== -1)
2638 if (h
->forced_local
)
2641 /* Identify the cases where name binding rules say that a
2642 visible symbol resolves locally. */
2643 binding_stays_local_p
= info
->executable
|| SYMBOLIC_BIND (info
, h
);
2645 switch (ELF_ST_VISIBILITY (h
->other
))
2652 /* Proper resolution for function pointer equality may require
2653 that these symbols perhaps be resolved dynamically, even though
2654 we should be resolving them to the current module. */
2655 if (!ignore_protected
|| h
->type
!= STT_FUNC
)
2656 binding_stays_local_p
= TRUE
;
2663 /* If it isn't defined locally, then clearly it's dynamic. */
2664 if (!h
->def_regular
)
2667 /* Otherwise, the symbol is dynamic if binding rules don't tell
2668 us that it remains local. */
2669 return !binding_stays_local_p
;
2672 /* Return true if the symbol referred to by H should be considered
2673 to resolve local to the current module, and false otherwise. Differs
2674 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2675 undefined symbols and weak symbols. */
2678 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry
*h
,
2679 struct bfd_link_info
*info
,
2680 bfd_boolean local_protected
)
2682 /* If it's a local sym, of course we resolve locally. */
2686 /* Common symbols that become definitions don't get the DEF_REGULAR
2687 flag set, so test it first, and don't bail out. */
2688 if (ELF_COMMON_DEF_P (h
))
2690 /* If we don't have a definition in a regular file, then we can't
2691 resolve locally. The sym is either undefined or dynamic. */
2692 else if (!h
->def_regular
)
2695 /* Forced local symbols resolve locally. */
2696 if (h
->forced_local
)
2699 /* As do non-dynamic symbols. */
2700 if (h
->dynindx
== -1)
2703 /* At this point, we know the symbol is defined and dynamic. In an
2704 executable it must resolve locally, likewise when building symbolic
2705 shared libraries. */
2706 if (info
->executable
|| SYMBOLIC_BIND (info
, h
))
2709 /* Now deal with defined dynamic symbols in shared libraries. Ones
2710 with default visibility might not resolve locally. */
2711 if (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2714 /* However, STV_HIDDEN or STV_INTERNAL ones must be local. */
2715 if (ELF_ST_VISIBILITY (h
->other
) != STV_PROTECTED
)
2718 /* STV_PROTECTED non-function symbols are local. */
2719 if (h
->type
!= STT_FUNC
)
2722 /* Function pointer equality tests may require that STV_PROTECTED
2723 symbols be treated as dynamic symbols, even when we know that the
2724 dynamic linker will resolve them locally. */
2725 return local_protected
;
2728 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2729 aligned. Returns the first TLS output section. */
2731 struct bfd_section
*
2732 _bfd_elf_tls_setup (bfd
*obfd
, struct bfd_link_info
*info
)
2734 struct bfd_section
*sec
, *tls
;
2735 unsigned int align
= 0;
2737 for (sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2738 if ((sec
->flags
& SEC_THREAD_LOCAL
) != 0)
2742 for (; sec
!= NULL
&& (sec
->flags
& SEC_THREAD_LOCAL
) != 0; sec
= sec
->next
)
2743 if (sec
->alignment_power
> align
)
2744 align
= sec
->alignment_power
;
2746 elf_hash_table (info
)->tls_sec
= tls
;
2748 /* Ensure the alignment of the first section is the largest alignment,
2749 so that the tls segment starts aligned. */
2751 tls
->alignment_power
= align
;
2756 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2758 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
2759 Elf_Internal_Sym
*sym
)
2761 const struct elf_backend_data
*bed
;
2763 /* Local symbols do not count, but target specific ones might. */
2764 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
2765 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
2768 /* Function symbols do not count. */
2769 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
)
2772 /* If the section is undefined, then so is the symbol. */
2773 if (sym
->st_shndx
== SHN_UNDEF
)
2776 /* If the symbol is defined in the common section, then
2777 it is a common definition and so does not count. */
2778 bed
= get_elf_backend_data (abfd
);
2779 if (bed
->common_definition (sym
))
2782 /* If the symbol is in a target specific section then we
2783 must rely upon the backend to tell us what it is. */
2784 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
2785 /* FIXME - this function is not coded yet:
2787 return _bfd_is_global_symbol_definition (abfd, sym);
2789 Instead for now assume that the definition is not global,
2790 Even if this is wrong, at least the linker will behave
2791 in the same way that it used to do. */
2797 /* Search the symbol table of the archive element of the archive ABFD
2798 whose archive map contains a mention of SYMDEF, and determine if
2799 the symbol is defined in this element. */
2801 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
2803 Elf_Internal_Shdr
* hdr
;
2804 bfd_size_type symcount
;
2805 bfd_size_type extsymcount
;
2806 bfd_size_type extsymoff
;
2807 Elf_Internal_Sym
*isymbuf
;
2808 Elf_Internal_Sym
*isym
;
2809 Elf_Internal_Sym
*isymend
;
2812 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
2816 if (! bfd_check_format (abfd
, bfd_object
))
2819 /* If we have already included the element containing this symbol in the
2820 link then we do not need to include it again. Just claim that any symbol
2821 it contains is not a definition, so that our caller will not decide to
2822 (re)include this element. */
2823 if (abfd
->archive_pass
)
2826 /* Select the appropriate symbol table. */
2827 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
2828 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2830 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2832 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2834 /* The sh_info field of the symtab header tells us where the
2835 external symbols start. We don't care about the local symbols. */
2836 if (elf_bad_symtab (abfd
))
2838 extsymcount
= symcount
;
2843 extsymcount
= symcount
- hdr
->sh_info
;
2844 extsymoff
= hdr
->sh_info
;
2847 if (extsymcount
== 0)
2850 /* Read in the symbol table. */
2851 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
2853 if (isymbuf
== NULL
)
2856 /* Scan the symbol table looking for SYMDEF. */
2858 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
2862 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2867 if (strcmp (name
, symdef
->name
) == 0)
2869 result
= is_global_data_symbol_definition (abfd
, isym
);
2879 /* Add an entry to the .dynamic table. */
2882 _bfd_elf_add_dynamic_entry (struct bfd_link_info
*info
,
2886 struct elf_link_hash_table
*hash_table
;
2887 const struct elf_backend_data
*bed
;
2889 bfd_size_type newsize
;
2890 bfd_byte
*newcontents
;
2891 Elf_Internal_Dyn dyn
;
2893 hash_table
= elf_hash_table (info
);
2894 if (! is_elf_hash_table (hash_table
))
2897 bed
= get_elf_backend_data (hash_table
->dynobj
);
2898 s
= bfd_get_section_by_name (hash_table
->dynobj
, ".dynamic");
2899 BFD_ASSERT (s
!= NULL
);
2901 newsize
= s
->size
+ bed
->s
->sizeof_dyn
;
2902 newcontents
= bfd_realloc (s
->contents
, newsize
);
2903 if (newcontents
== NULL
)
2907 dyn
.d_un
.d_val
= val
;
2908 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
, newcontents
+ s
->size
);
2911 s
->contents
= newcontents
;
2916 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
2917 otherwise just check whether one already exists. Returns -1 on error,
2918 1 if a DT_NEEDED tag already exists, and 0 on success. */
2921 elf_add_dt_needed_tag (bfd
*abfd
,
2922 struct bfd_link_info
*info
,
2926 struct elf_link_hash_table
*hash_table
;
2927 bfd_size_type oldsize
;
2928 bfd_size_type strindex
;
2930 if (!_bfd_elf_link_create_dynstrtab (abfd
, info
))
2933 hash_table
= elf_hash_table (info
);
2934 oldsize
= _bfd_elf_strtab_size (hash_table
->dynstr
);
2935 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, soname
, FALSE
);
2936 if (strindex
== (bfd_size_type
) -1)
2939 if (oldsize
== _bfd_elf_strtab_size (hash_table
->dynstr
))
2942 const struct elf_backend_data
*bed
;
2945 bed
= get_elf_backend_data (hash_table
->dynobj
);
2946 sdyn
= bfd_get_section_by_name (hash_table
->dynobj
, ".dynamic");
2948 for (extdyn
= sdyn
->contents
;
2949 extdyn
< sdyn
->contents
+ sdyn
->size
;
2950 extdyn
+= bed
->s
->sizeof_dyn
)
2952 Elf_Internal_Dyn dyn
;
2954 bed
->s
->swap_dyn_in (hash_table
->dynobj
, extdyn
, &dyn
);
2955 if (dyn
.d_tag
== DT_NEEDED
2956 && dyn
.d_un
.d_val
== strindex
)
2958 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
2966 if (!_bfd_elf_link_create_dynamic_sections (hash_table
->dynobj
, info
))
2969 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
2973 /* We were just checking for existence of the tag. */
2974 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
2979 /* Sort symbol by value and section. */
2981 elf_sort_symbol (const void *arg1
, const void *arg2
)
2983 const struct elf_link_hash_entry
*h1
;
2984 const struct elf_link_hash_entry
*h2
;
2985 bfd_signed_vma vdiff
;
2987 h1
= *(const struct elf_link_hash_entry
**) arg1
;
2988 h2
= *(const struct elf_link_hash_entry
**) arg2
;
2989 vdiff
= h1
->root
.u
.def
.value
- h2
->root
.u
.def
.value
;
2991 return vdiff
> 0 ? 1 : -1;
2994 long sdiff
= h1
->root
.u
.def
.section
->id
- h2
->root
.u
.def
.section
->id
;
2996 return sdiff
> 0 ? 1 : -1;
3001 /* This function is used to adjust offsets into .dynstr for
3002 dynamic symbols. This is called via elf_link_hash_traverse. */
3005 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
3007 struct elf_strtab_hash
*dynstr
= data
;
3009 if (h
->root
.type
== bfd_link_hash_warning
)
3010 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3012 if (h
->dynindx
!= -1)
3013 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
3017 /* Assign string offsets in .dynstr, update all structures referencing
3021 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
3023 struct elf_link_hash_table
*hash_table
= elf_hash_table (info
);
3024 struct elf_link_local_dynamic_entry
*entry
;
3025 struct elf_strtab_hash
*dynstr
= hash_table
->dynstr
;
3026 bfd
*dynobj
= hash_table
->dynobj
;
3029 const struct elf_backend_data
*bed
;
3032 _bfd_elf_strtab_finalize (dynstr
);
3033 size
= _bfd_elf_strtab_size (dynstr
);
3035 bed
= get_elf_backend_data (dynobj
);
3036 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3037 BFD_ASSERT (sdyn
!= NULL
);
3039 /* Update all .dynamic entries referencing .dynstr strings. */
3040 for (extdyn
= sdyn
->contents
;
3041 extdyn
< sdyn
->contents
+ sdyn
->size
;
3042 extdyn
+= bed
->s
->sizeof_dyn
)
3044 Elf_Internal_Dyn dyn
;
3046 bed
->s
->swap_dyn_in (dynobj
, extdyn
, &dyn
);
3050 dyn
.d_un
.d_val
= size
;
3058 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
3063 bed
->s
->swap_dyn_out (dynobj
, &dyn
, extdyn
);
3066 /* Now update local dynamic symbols. */
3067 for (entry
= hash_table
->dynlocal
; entry
; entry
= entry
->next
)
3068 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
3069 entry
->isym
.st_name
);
3071 /* And the rest of dynamic symbols. */
3072 elf_link_hash_traverse (hash_table
, elf_adjust_dynstr_offsets
, dynstr
);
3074 /* Adjust version definitions. */
3075 if (elf_tdata (output_bfd
)->cverdefs
)
3080 Elf_Internal_Verdef def
;
3081 Elf_Internal_Verdaux defaux
;
3083 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
3087 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
3089 p
+= sizeof (Elf_External_Verdef
);
3090 if (def
.vd_aux
!= sizeof (Elf_External_Verdef
))
3092 for (i
= 0; i
< def
.vd_cnt
; ++i
)
3094 _bfd_elf_swap_verdaux_in (output_bfd
,
3095 (Elf_External_Verdaux
*) p
, &defaux
);
3096 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
3098 _bfd_elf_swap_verdaux_out (output_bfd
,
3099 &defaux
, (Elf_External_Verdaux
*) p
);
3100 p
+= sizeof (Elf_External_Verdaux
);
3103 while (def
.vd_next
);
3106 /* Adjust version references. */
3107 if (elf_tdata (output_bfd
)->verref
)
3112 Elf_Internal_Verneed need
;
3113 Elf_Internal_Vernaux needaux
;
3115 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
3119 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
3121 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
3122 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
3123 (Elf_External_Verneed
*) p
);
3124 p
+= sizeof (Elf_External_Verneed
);
3125 for (i
= 0; i
< need
.vn_cnt
; ++i
)
3127 _bfd_elf_swap_vernaux_in (output_bfd
,
3128 (Elf_External_Vernaux
*) p
, &needaux
);
3129 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
3131 _bfd_elf_swap_vernaux_out (output_bfd
,
3133 (Elf_External_Vernaux
*) p
);
3134 p
+= sizeof (Elf_External_Vernaux
);
3137 while (need
.vn_next
);
3143 /* Add symbols from an ELF object file to the linker hash table. */
3146 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
3148 Elf_Internal_Shdr
*hdr
;
3149 bfd_size_type symcount
;
3150 bfd_size_type extsymcount
;
3151 bfd_size_type extsymoff
;
3152 struct elf_link_hash_entry
**sym_hash
;
3153 bfd_boolean dynamic
;
3154 Elf_External_Versym
*extversym
= NULL
;
3155 Elf_External_Versym
*ever
;
3156 struct elf_link_hash_entry
*weaks
;
3157 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
3158 bfd_size_type nondeflt_vers_cnt
= 0;
3159 Elf_Internal_Sym
*isymbuf
= NULL
;
3160 Elf_Internal_Sym
*isym
;
3161 Elf_Internal_Sym
*isymend
;
3162 const struct elf_backend_data
*bed
;
3163 bfd_boolean add_needed
;
3164 struct elf_link_hash_table
*htab
;
3166 void *alloc_mark
= NULL
;
3167 struct bfd_hash_entry
**old_table
= NULL
;
3168 unsigned int old_size
= 0;
3169 unsigned int old_count
= 0;
3170 void *old_tab
= NULL
;
3173 struct bfd_link_hash_entry
*old_undefs
= NULL
;
3174 struct bfd_link_hash_entry
*old_undefs_tail
= NULL
;
3175 long old_dynsymcount
= 0;
3177 size_t hashsize
= 0;
3179 htab
= elf_hash_table (info
);
3180 bed
= get_elf_backend_data (abfd
);
3182 if ((abfd
->flags
& DYNAMIC
) == 0)
3188 /* You can't use -r against a dynamic object. Also, there's no
3189 hope of using a dynamic object which does not exactly match
3190 the format of the output file. */
3191 if (info
->relocatable
3192 || !is_elf_hash_table (htab
)
3193 || htab
->root
.creator
!= abfd
->xvec
)
3195 if (info
->relocatable
)
3196 bfd_set_error (bfd_error_invalid_operation
);
3198 bfd_set_error (bfd_error_wrong_format
);
3203 /* As a GNU extension, any input sections which are named
3204 .gnu.warning.SYMBOL are treated as warning symbols for the given
3205 symbol. This differs from .gnu.warning sections, which generate
3206 warnings when they are included in an output file. */
3207 if (info
->executable
)
3211 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3215 name
= bfd_get_section_name (abfd
, s
);
3216 if (CONST_STRNEQ (name
, ".gnu.warning."))
3221 name
+= sizeof ".gnu.warning." - 1;
3223 /* If this is a shared object, then look up the symbol
3224 in the hash table. If it is there, and it is already
3225 been defined, then we will not be using the entry
3226 from this shared object, so we don't need to warn.
3227 FIXME: If we see the definition in a regular object
3228 later on, we will warn, but we shouldn't. The only
3229 fix is to keep track of what warnings we are supposed
3230 to emit, and then handle them all at the end of the
3234 struct elf_link_hash_entry
*h
;
3236 h
= elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
3238 /* FIXME: What about bfd_link_hash_common? */
3240 && (h
->root
.type
== bfd_link_hash_defined
3241 || h
->root
.type
== bfd_link_hash_defweak
))
3243 /* We don't want to issue this warning. Clobber
3244 the section size so that the warning does not
3245 get copied into the output file. */
3252 msg
= bfd_alloc (abfd
, sz
+ 1);
3256 if (! bfd_get_section_contents (abfd
, s
, msg
, 0, sz
))
3261 if (! (_bfd_generic_link_add_one_symbol
3262 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
3263 FALSE
, bed
->collect
, NULL
)))
3266 if (! info
->relocatable
)
3268 /* Clobber the section size so that the warning does
3269 not get copied into the output file. */
3272 /* Also set SEC_EXCLUDE, so that symbols defined in
3273 the warning section don't get copied to the output. */
3274 s
->flags
|= SEC_EXCLUDE
;
3283 /* If we are creating a shared library, create all the dynamic
3284 sections immediately. We need to attach them to something,
3285 so we attach them to this BFD, provided it is the right
3286 format. FIXME: If there are no input BFD's of the same
3287 format as the output, we can't make a shared library. */
3289 && is_elf_hash_table (htab
)
3290 && htab
->root
.creator
== abfd
->xvec
3291 && !htab
->dynamic_sections_created
)
3293 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
3297 else if (!is_elf_hash_table (htab
))
3302 const char *soname
= NULL
;
3303 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
3306 /* ld --just-symbols and dynamic objects don't mix very well.
3307 ld shouldn't allow it. */
3308 if ((s
= abfd
->sections
) != NULL
3309 && s
->sec_info_type
== ELF_INFO_TYPE_JUST_SYMS
)
3312 /* If this dynamic lib was specified on the command line with
3313 --as-needed in effect, then we don't want to add a DT_NEEDED
3314 tag unless the lib is actually used. Similary for libs brought
3315 in by another lib's DT_NEEDED. When --no-add-needed is used
3316 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3317 any dynamic library in DT_NEEDED tags in the dynamic lib at
3319 add_needed
= (elf_dyn_lib_class (abfd
)
3320 & (DYN_AS_NEEDED
| DYN_DT_NEEDED
3321 | DYN_NO_NEEDED
)) == 0;
3323 s
= bfd_get_section_by_name (abfd
, ".dynamic");
3329 unsigned long shlink
;
3331 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
3332 goto error_free_dyn
;
3334 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
3336 goto error_free_dyn
;
3337 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
3339 for (extdyn
= dynbuf
;
3340 extdyn
< dynbuf
+ s
->size
;
3341 extdyn
+= bed
->s
->sizeof_dyn
)
3343 Elf_Internal_Dyn dyn
;
3345 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
3346 if (dyn
.d_tag
== DT_SONAME
)
3348 unsigned int tagv
= dyn
.d_un
.d_val
;
3349 soname
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3351 goto error_free_dyn
;
3353 if (dyn
.d_tag
== DT_NEEDED
)
3355 struct bfd_link_needed_list
*n
, **pn
;
3357 unsigned int tagv
= dyn
.d_un
.d_val
;
3359 amt
= sizeof (struct bfd_link_needed_list
);
3360 n
= bfd_alloc (abfd
, amt
);
3361 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3362 if (n
== NULL
|| fnm
== NULL
)
3363 goto error_free_dyn
;
3364 amt
= strlen (fnm
) + 1;
3365 anm
= bfd_alloc (abfd
, amt
);
3367 goto error_free_dyn
;
3368 memcpy (anm
, fnm
, amt
);
3372 for (pn
= &htab
->needed
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3376 if (dyn
.d_tag
== DT_RUNPATH
)
3378 struct bfd_link_needed_list
*n
, **pn
;
3380 unsigned int tagv
= dyn
.d_un
.d_val
;
3382 amt
= sizeof (struct bfd_link_needed_list
);
3383 n
= bfd_alloc (abfd
, amt
);
3384 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3385 if (n
== NULL
|| fnm
== NULL
)
3386 goto error_free_dyn
;
3387 amt
= strlen (fnm
) + 1;
3388 anm
= bfd_alloc (abfd
, amt
);
3390 goto error_free_dyn
;
3391 memcpy (anm
, fnm
, amt
);
3395 for (pn
= & runpath
;
3401 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3402 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
3404 struct bfd_link_needed_list
*n
, **pn
;
3406 unsigned int tagv
= dyn
.d_un
.d_val
;
3408 amt
= sizeof (struct bfd_link_needed_list
);
3409 n
= bfd_alloc (abfd
, amt
);
3410 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
3411 if (n
== NULL
|| fnm
== NULL
)
3412 goto error_free_dyn
;
3413 amt
= strlen (fnm
) + 1;
3414 anm
= bfd_alloc (abfd
, amt
);
3421 memcpy (anm
, fnm
, amt
);
3436 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3437 frees all more recently bfd_alloc'd blocks as well. */
3443 struct bfd_link_needed_list
**pn
;
3444 for (pn
= &htab
->runpath
; *pn
!= NULL
; pn
= &(*pn
)->next
)
3449 /* We do not want to include any of the sections in a dynamic
3450 object in the output file. We hack by simply clobbering the
3451 list of sections in the BFD. This could be handled more
3452 cleanly by, say, a new section flag; the existing
3453 SEC_NEVER_LOAD flag is not the one we want, because that one
3454 still implies that the section takes up space in the output
3456 bfd_section_list_clear (abfd
);
3458 /* Find the name to use in a DT_NEEDED entry that refers to this
3459 object. If the object has a DT_SONAME entry, we use it.
3460 Otherwise, if the generic linker stuck something in
3461 elf_dt_name, we use that. Otherwise, we just use the file
3463 if (soname
== NULL
|| *soname
== '\0')
3465 soname
= elf_dt_name (abfd
);
3466 if (soname
== NULL
|| *soname
== '\0')
3467 soname
= bfd_get_filename (abfd
);
3470 /* Save the SONAME because sometimes the linker emulation code
3471 will need to know it. */
3472 elf_dt_name (abfd
) = soname
;
3474 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
3478 /* If we have already included this dynamic object in the
3479 link, just ignore it. There is no reason to include a
3480 particular dynamic object more than once. */
3485 /* If this is a dynamic object, we always link against the .dynsym
3486 symbol table, not the .symtab symbol table. The dynamic linker
3487 will only see the .dynsym symbol table, so there is no reason to
3488 look at .symtab for a dynamic object. */
3490 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
3491 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3493 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3495 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
3497 /* The sh_info field of the symtab header tells us where the
3498 external symbols start. We don't care about the local symbols at
3500 if (elf_bad_symtab (abfd
))
3502 extsymcount
= symcount
;
3507 extsymcount
= symcount
- hdr
->sh_info
;
3508 extsymoff
= hdr
->sh_info
;
3512 if (extsymcount
!= 0)
3514 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
3516 if (isymbuf
== NULL
)
3519 /* We store a pointer to the hash table entry for each external
3521 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3522 sym_hash
= bfd_alloc (abfd
, amt
);
3523 if (sym_hash
== NULL
)
3524 goto error_free_sym
;
3525 elf_sym_hashes (abfd
) = sym_hash
;
3530 /* Read in any version definitions. */
3531 if (!_bfd_elf_slurp_version_tables (abfd
,
3532 info
->default_imported_symver
))
3533 goto error_free_sym
;
3535 /* Read in the symbol versions, but don't bother to convert them
3536 to internal format. */
3537 if (elf_dynversym (abfd
) != 0)
3539 Elf_Internal_Shdr
*versymhdr
;
3541 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
3542 extversym
= bfd_malloc (versymhdr
->sh_size
);
3543 if (extversym
== NULL
)
3544 goto error_free_sym
;
3545 amt
= versymhdr
->sh_size
;
3546 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
3547 || bfd_bread (extversym
, amt
, abfd
) != amt
)
3548 goto error_free_vers
;
3552 /* If we are loading an as-needed shared lib, save the symbol table
3553 state before we start adding symbols. If the lib turns out
3554 to be unneeded, restore the state. */
3555 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
3560 for (entsize
= 0, i
= 0; i
< htab
->root
.table
.size
; i
++)
3562 struct bfd_hash_entry
*p
;
3563 struct elf_link_hash_entry
*h
;
3565 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3567 h
= (struct elf_link_hash_entry
*) p
;
3568 entsize
+= htab
->root
.table
.entsize
;
3569 if (h
->root
.type
== bfd_link_hash_warning
)
3570 entsize
+= htab
->root
.table
.entsize
;
3574 tabsize
= htab
->root
.table
.size
* sizeof (struct bfd_hash_entry
*);
3575 hashsize
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
3576 old_tab
= bfd_malloc (tabsize
+ entsize
+ hashsize
);
3577 if (old_tab
== NULL
)
3578 goto error_free_vers
;
3580 /* Remember the current objalloc pointer, so that all mem for
3581 symbols added can later be reclaimed. */
3582 alloc_mark
= bfd_hash_allocate (&htab
->root
.table
, 1);
3583 if (alloc_mark
== NULL
)
3584 goto error_free_vers
;
3586 /* Make a special call to the linker "notice" function to
3587 tell it that we are about to handle an as-needed lib. */
3588 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
3593 /* Clone the symbol table and sym hashes. Remember some
3594 pointers into the symbol table, and dynamic symbol count. */
3595 old_hash
= (char *) old_tab
+ tabsize
;
3596 old_ent
= (char *) old_hash
+ hashsize
;
3597 memcpy (old_tab
, htab
->root
.table
.table
, tabsize
);
3598 memcpy (old_hash
, sym_hash
, hashsize
);
3599 old_undefs
= htab
->root
.undefs
;
3600 old_undefs_tail
= htab
->root
.undefs_tail
;
3601 old_table
= htab
->root
.table
.table
;
3602 old_size
= htab
->root
.table
.size
;
3603 old_count
= htab
->root
.table
.count
;
3604 old_dynsymcount
= htab
->dynsymcount
;
3606 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
3608 struct bfd_hash_entry
*p
;
3609 struct elf_link_hash_entry
*h
;
3611 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
3613 memcpy (old_ent
, p
, htab
->root
.table
.entsize
);
3614 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3615 h
= (struct elf_link_hash_entry
*) p
;
3616 if (h
->root
.type
== bfd_link_hash_warning
)
3618 memcpy (old_ent
, h
->root
.u
.i
.link
, htab
->root
.table
.entsize
);
3619 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
3626 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
3627 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
3629 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
3633 asection
*sec
, *new_sec
;
3636 struct elf_link_hash_entry
*h
;
3637 bfd_boolean definition
;
3638 bfd_boolean size_change_ok
;
3639 bfd_boolean type_change_ok
;
3640 bfd_boolean new_weakdef
;
3641 bfd_boolean override
;
3643 unsigned int old_alignment
;
3648 flags
= BSF_NO_FLAGS
;
3650 value
= isym
->st_value
;
3652 common
= bed
->common_definition (isym
);
3654 bind
= ELF_ST_BIND (isym
->st_info
);
3655 if (bind
== STB_LOCAL
)
3657 /* This should be impossible, since ELF requires that all
3658 global symbols follow all local symbols, and that sh_info
3659 point to the first global symbol. Unfortunately, Irix 5
3663 else if (bind
== STB_GLOBAL
)
3665 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
3668 else if (bind
== STB_WEAK
)
3672 /* Leave it up to the processor backend. */
3675 if (isym
->st_shndx
== SHN_UNDEF
)
3676 sec
= bfd_und_section_ptr
;
3677 else if (isym
->st_shndx
< SHN_LORESERVE
3678 || isym
->st_shndx
> SHN_HIRESERVE
)
3680 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3682 sec
= bfd_abs_section_ptr
;
3683 else if (sec
->kept_section
)
3685 /* Symbols from discarded section are undefined, and have
3686 default visibility. */
3687 sec
= bfd_und_section_ptr
;
3688 isym
->st_shndx
= SHN_UNDEF
;
3689 isym
->st_other
= (STV_DEFAULT
3690 | (isym
->st_other
& ~ ELF_ST_VISIBILITY (-1)));
3692 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
3695 else if (isym
->st_shndx
== SHN_ABS
)
3696 sec
= bfd_abs_section_ptr
;
3697 else if (isym
->st_shndx
== SHN_COMMON
)
3699 sec
= bfd_com_section_ptr
;
3700 /* What ELF calls the size we call the value. What ELF
3701 calls the value we call the alignment. */
3702 value
= isym
->st_size
;
3706 /* Leave it up to the processor backend. */
3709 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
3712 goto error_free_vers
;
3714 if (isym
->st_shndx
== SHN_COMMON
3715 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
3716 && !info
->relocatable
)
3718 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
3722 tcomm
= bfd_make_section_with_flags (abfd
, ".tcommon",
3725 | SEC_LINKER_CREATED
3726 | SEC_THREAD_LOCAL
));
3728 goto error_free_vers
;
3732 else if (bed
->elf_add_symbol_hook
)
3734 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
3736 goto error_free_vers
;
3738 /* The hook function sets the name to NULL if this symbol
3739 should be skipped for some reason. */
3744 /* Sanity check that all possibilities were handled. */
3747 bfd_set_error (bfd_error_bad_value
);
3748 goto error_free_vers
;
3751 if (bfd_is_und_section (sec
)
3752 || bfd_is_com_section (sec
))
3757 size_change_ok
= FALSE
;
3758 type_change_ok
= bed
->type_change_ok
;
3763 if (is_elf_hash_table (htab
))
3765 Elf_Internal_Versym iver
;
3766 unsigned int vernum
= 0;
3771 if (info
->default_imported_symver
)
3772 /* Use the default symbol version created earlier. */
3773 iver
.vs_vers
= elf_tdata (abfd
)->cverdefs
;
3778 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
3780 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
3782 /* If this is a hidden symbol, or if it is not version
3783 1, we append the version name to the symbol name.
3784 However, we do not modify a non-hidden absolute symbol
3785 if it is not a function, because it might be the version
3786 symbol itself. FIXME: What if it isn't? */
3787 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
3788 || (vernum
> 1 && (! bfd_is_abs_section (sec
)
3789 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
)))
3792 size_t namelen
, verlen
, newlen
;
3795 if (isym
->st_shndx
!= SHN_UNDEF
)
3797 if (vernum
> elf_tdata (abfd
)->cverdefs
)
3799 else if (vernum
> 1)
3801 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
3807 (*_bfd_error_handler
)
3808 (_("%B: %s: invalid version %u (max %d)"),
3810 elf_tdata (abfd
)->cverdefs
);
3811 bfd_set_error (bfd_error_bad_value
);
3812 goto error_free_vers
;
3817 /* We cannot simply test for the number of
3818 entries in the VERNEED section since the
3819 numbers for the needed versions do not start
3821 Elf_Internal_Verneed
*t
;
3824 for (t
= elf_tdata (abfd
)->verref
;
3828 Elf_Internal_Vernaux
*a
;
3830 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
3832 if (a
->vna_other
== vernum
)
3834 verstr
= a
->vna_nodename
;
3843 (*_bfd_error_handler
)
3844 (_("%B: %s: invalid needed version %d"),
3845 abfd
, name
, vernum
);
3846 bfd_set_error (bfd_error_bad_value
);
3847 goto error_free_vers
;
3851 namelen
= strlen (name
);
3852 verlen
= strlen (verstr
);
3853 newlen
= namelen
+ verlen
+ 2;
3854 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
3855 && isym
->st_shndx
!= SHN_UNDEF
)
3858 newname
= bfd_hash_allocate (&htab
->root
.table
, newlen
);
3859 if (newname
== NULL
)
3860 goto error_free_vers
;
3861 memcpy (newname
, name
, namelen
);
3862 p
= newname
+ namelen
;
3864 /* If this is a defined non-hidden version symbol,
3865 we add another @ to the name. This indicates the
3866 default version of the symbol. */
3867 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
3868 && isym
->st_shndx
!= SHN_UNDEF
)
3870 memcpy (p
, verstr
, verlen
+ 1);
3875 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
,
3876 &value
, &old_alignment
,
3877 sym_hash
, &skip
, &override
,
3878 &type_change_ok
, &size_change_ok
))
3879 goto error_free_vers
;
3888 while (h
->root
.type
== bfd_link_hash_indirect
3889 || h
->root
.type
== bfd_link_hash_warning
)
3890 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3892 /* Remember the old alignment if this is a common symbol, so
3893 that we don't reduce the alignment later on. We can't
3894 check later, because _bfd_generic_link_add_one_symbol
3895 will set a default for the alignment which we want to
3896 override. We also remember the old bfd where the existing
3897 definition comes from. */
3898 switch (h
->root
.type
)
3903 case bfd_link_hash_defined
:
3904 case bfd_link_hash_defweak
:
3905 old_bfd
= h
->root
.u
.def
.section
->owner
;
3908 case bfd_link_hash_common
:
3909 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
3910 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
3914 if (elf_tdata (abfd
)->verdef
!= NULL
3918 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
3921 if (! (_bfd_generic_link_add_one_symbol
3922 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
3923 (struct bfd_link_hash_entry
**) sym_hash
)))
3924 goto error_free_vers
;
3927 while (h
->root
.type
== bfd_link_hash_indirect
3928 || h
->root
.type
== bfd_link_hash_warning
)
3929 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3932 new_weakdef
= FALSE
;
3935 && (flags
& BSF_WEAK
) != 0
3936 && ELF_ST_TYPE (isym
->st_info
) != STT_FUNC
3937 && is_elf_hash_table (htab
)
3938 && h
->u
.weakdef
== NULL
)
3940 /* Keep a list of all weak defined non function symbols from
3941 a dynamic object, using the weakdef field. Later in this
3942 function we will set the weakdef field to the correct
3943 value. We only put non-function symbols from dynamic
3944 objects on this list, because that happens to be the only
3945 time we need to know the normal symbol corresponding to a
3946 weak symbol, and the information is time consuming to
3947 figure out. If the weakdef field is not already NULL,
3948 then this symbol was already defined by some previous
3949 dynamic object, and we will be using that previous
3950 definition anyhow. */
3952 h
->u
.weakdef
= weaks
;
3957 /* Set the alignment of a common symbol. */
3958 if ((common
|| bfd_is_com_section (sec
))
3959 && h
->root
.type
== bfd_link_hash_common
)
3964 align
= bfd_log2 (isym
->st_value
);
3967 /* The new symbol is a common symbol in a shared object.
3968 We need to get the alignment from the section. */
3969 align
= new_sec
->alignment_power
;
3971 if (align
> old_alignment
3972 /* Permit an alignment power of zero if an alignment of one
3973 is specified and no other alignments have been specified. */
3974 || (isym
->st_value
== 1 && old_alignment
== 0))
3975 h
->root
.u
.c
.p
->alignment_power
= align
;
3977 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
3980 if (is_elf_hash_table (htab
))
3984 /* Check the alignment when a common symbol is involved. This
3985 can change when a common symbol is overridden by a normal
3986 definition or a common symbol is ignored due to the old
3987 normal definition. We need to make sure the maximum
3988 alignment is maintained. */
3989 if ((old_alignment
|| common
)
3990 && h
->root
.type
!= bfd_link_hash_common
)
3992 unsigned int common_align
;
3993 unsigned int normal_align
;
3994 unsigned int symbol_align
;
3998 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
3999 if (h
->root
.u
.def
.section
->owner
!= NULL
4000 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
4002 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
4003 if (normal_align
> symbol_align
)
4004 normal_align
= symbol_align
;
4007 normal_align
= symbol_align
;
4011 common_align
= old_alignment
;
4012 common_bfd
= old_bfd
;
4017 common_align
= bfd_log2 (isym
->st_value
);
4019 normal_bfd
= old_bfd
;
4022 if (normal_align
< common_align
)
4024 /* PR binutils/2735 */
4025 if (normal_bfd
== NULL
)
4026 (*_bfd_error_handler
)
4027 (_("Warning: alignment %u of common symbol `%s' in %B"
4028 " is greater than the alignment (%u) of its section %A"),
4029 common_bfd
, h
->root
.u
.def
.section
,
4030 1 << common_align
, name
, 1 << normal_align
);
4032 (*_bfd_error_handler
)
4033 (_("Warning: alignment %u of symbol `%s' in %B"
4034 " is smaller than %u in %B"),
4035 normal_bfd
, common_bfd
,
4036 1 << normal_align
, name
, 1 << common_align
);
4040 /* Remember the symbol size and type. */
4041 if (isym
->st_size
!= 0
4042 && (definition
|| h
->size
== 0))
4044 if (h
->size
!= 0 && h
->size
!= isym
->st_size
&& ! size_change_ok
)
4045 (*_bfd_error_handler
)
4046 (_("Warning: size of symbol `%s' changed"
4047 " from %lu in %B to %lu in %B"),
4049 name
, (unsigned long) h
->size
,
4050 (unsigned long) isym
->st_size
);
4052 h
->size
= isym
->st_size
;
4055 /* If this is a common symbol, then we always want H->SIZE
4056 to be the size of the common symbol. The code just above
4057 won't fix the size if a common symbol becomes larger. We
4058 don't warn about a size change here, because that is
4059 covered by --warn-common. */
4060 if (h
->root
.type
== bfd_link_hash_common
)
4061 h
->size
= h
->root
.u
.c
.size
;
4063 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
4064 && (definition
|| h
->type
== STT_NOTYPE
))
4066 if (h
->type
!= STT_NOTYPE
4067 && h
->type
!= ELF_ST_TYPE (isym
->st_info
)
4068 && ! type_change_ok
)
4069 (*_bfd_error_handler
)
4070 (_("Warning: type of symbol `%s' changed"
4071 " from %d to %d in %B"),
4072 abfd
, name
, h
->type
, ELF_ST_TYPE (isym
->st_info
));
4074 h
->type
= ELF_ST_TYPE (isym
->st_info
);
4077 /* If st_other has a processor-specific meaning, specific
4078 code might be needed here. We never merge the visibility
4079 attribute with the one from a dynamic object. */
4080 if (bed
->elf_backend_merge_symbol_attribute
)
4081 (*bed
->elf_backend_merge_symbol_attribute
) (h
, isym
, definition
,
4084 /* If this symbol has default visibility and the user has requested
4085 we not re-export it, then mark it as hidden. */
4086 if (definition
&& !dynamic
4088 || (abfd
->my_archive
&& abfd
->my_archive
->no_export
))
4089 && ELF_ST_VISIBILITY (isym
->st_other
) != STV_INTERNAL
)
4090 isym
->st_other
= (STV_HIDDEN
4091 | (isym
->st_other
& ~ELF_ST_VISIBILITY (-1)));
4093 if (ELF_ST_VISIBILITY (isym
->st_other
) != 0 && !dynamic
)
4095 unsigned char hvis
, symvis
, other
, nvis
;
4097 /* Only merge the visibility. Leave the remainder of the
4098 st_other field to elf_backend_merge_symbol_attribute. */
4099 other
= h
->other
& ~ELF_ST_VISIBILITY (-1);
4101 /* Combine visibilities, using the most constraining one. */
4102 hvis
= ELF_ST_VISIBILITY (h
->other
);
4103 symvis
= ELF_ST_VISIBILITY (isym
->st_other
);
4109 nvis
= hvis
< symvis
? hvis
: symvis
;
4111 h
->other
= other
| nvis
;
4114 /* Set a flag in the hash table entry indicating the type of
4115 reference or definition we just found. Keep a count of
4116 the number of dynamic symbols we find. A dynamic symbol
4117 is one which is referenced or defined by both a regular
4118 object and a shared object. */
4125 if (bind
!= STB_WEAK
)
4126 h
->ref_regular_nonweak
= 1;
4130 if (! info
->executable
4143 || (h
->u
.weakdef
!= NULL
4145 && h
->u
.weakdef
->dynindx
!= -1))
4149 if (definition
&& (sec
->flags
& SEC_DEBUGGING
))
4151 /* We don't want to make debug symbol dynamic. */
4152 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
4156 /* Check to see if we need to add an indirect symbol for
4157 the default name. */
4158 if (definition
|| h
->root
.type
== bfd_link_hash_common
)
4159 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
4160 &sec
, &value
, &dynsym
,
4162 goto error_free_vers
;
4164 if (definition
&& !dynamic
)
4166 char *p
= strchr (name
, ELF_VER_CHR
);
4167 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
4169 /* Queue non-default versions so that .symver x, x@FOO
4170 aliases can be checked. */
4173 amt
= ((isymend
- isym
+ 1)
4174 * sizeof (struct elf_link_hash_entry
*));
4175 nondeflt_vers
= bfd_malloc (amt
);
4177 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
4181 if (dynsym
&& h
->dynindx
== -1)
4183 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4184 goto error_free_vers
;
4185 if (h
->u
.weakdef
!= NULL
4187 && h
->u
.weakdef
->dynindx
== -1)
4189 if (!bfd_elf_link_record_dynamic_symbol (info
, h
->u
.weakdef
))
4190 goto error_free_vers
;
4193 else if (dynsym
&& h
->dynindx
!= -1)
4194 /* If the symbol already has a dynamic index, but
4195 visibility says it should not be visible, turn it into
4197 switch (ELF_ST_VISIBILITY (h
->other
))
4201 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
4212 const char *soname
= elf_dt_name (abfd
);
4214 /* A symbol from a library loaded via DT_NEEDED of some
4215 other library is referenced by a regular object.
4216 Add a DT_NEEDED entry for it. Issue an error if
4217 --no-add-needed is used. */
4218 if ((elf_dyn_lib_class (abfd
) & DYN_NO_NEEDED
) != 0)
4220 (*_bfd_error_handler
)
4221 (_("%s: invalid DSO for symbol `%s' definition"),
4223 bfd_set_error (bfd_error_bad_value
);
4224 goto error_free_vers
;
4227 elf_dyn_lib_class (abfd
) &= ~DYN_AS_NEEDED
;
4230 ret
= elf_add_dt_needed_tag (abfd
, info
, soname
, add_needed
);
4232 goto error_free_vers
;
4234 BFD_ASSERT (ret
== 0);
4239 if (extversym
!= NULL
)
4245 if (isymbuf
!= NULL
)
4251 if ((elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)
4255 /* Restore the symbol table. */
4256 old_hash
= (char *) old_tab
+ tabsize
;
4257 old_ent
= (char *) old_hash
+ hashsize
;
4258 sym_hash
= elf_sym_hashes (abfd
);
4259 htab
->root
.table
.table
= old_table
;
4260 htab
->root
.table
.size
= old_size
;
4261 htab
->root
.table
.count
= old_count
;
4262 memcpy (htab
->root
.table
.table
, old_tab
, tabsize
);
4263 memcpy (sym_hash
, old_hash
, hashsize
);
4264 htab
->root
.undefs
= old_undefs
;
4265 htab
->root
.undefs_tail
= old_undefs_tail
;
4266 for (i
= 0; i
< htab
->root
.table
.size
; i
++)
4268 struct bfd_hash_entry
*p
;
4269 struct elf_link_hash_entry
*h
;
4271 for (p
= htab
->root
.table
.table
[i
]; p
!= NULL
; p
= p
->next
)
4273 h
= (struct elf_link_hash_entry
*) p
;
4274 if (h
->root
.type
== bfd_link_hash_warning
)
4275 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4276 if (h
->dynindx
>= old_dynsymcount
)
4277 _bfd_elf_strtab_delref (htab
->dynstr
, h
->dynstr_index
);
4279 memcpy (p
, old_ent
, htab
->root
.table
.entsize
);
4280 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4281 h
= (struct elf_link_hash_entry
*) p
;
4282 if (h
->root
.type
== bfd_link_hash_warning
)
4284 memcpy (h
->root
.u
.i
.link
, old_ent
, htab
->root
.table
.entsize
);
4285 old_ent
= (char *) old_ent
+ htab
->root
.table
.entsize
;
4290 /* Make a special call to the linker "notice" function to
4291 tell it that symbols added for crefs may need to be removed. */
4292 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4297 objalloc_free_block ((struct objalloc
*) htab
->root
.table
.memory
,
4299 if (nondeflt_vers
!= NULL
)
4300 free (nondeflt_vers
);
4304 if (old_tab
!= NULL
)
4306 if (!(*info
->callbacks
->notice
) (info
, NULL
, abfd
, NULL
,
4313 /* Now that all the symbols from this input file are created, handle
4314 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4315 if (nondeflt_vers
!= NULL
)
4317 bfd_size_type cnt
, symidx
;
4319 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
4321 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
4322 char *shortname
, *p
;
4324 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
4326 || (h
->root
.type
!= bfd_link_hash_defined
4327 && h
->root
.type
!= bfd_link_hash_defweak
))
4330 amt
= p
- h
->root
.root
.string
;
4331 shortname
= bfd_malloc (amt
+ 1);
4332 memcpy (shortname
, h
->root
.root
.string
, amt
);
4333 shortname
[amt
] = '\0';
4335 hi
= (struct elf_link_hash_entry
*)
4336 bfd_link_hash_lookup (&htab
->root
, shortname
,
4337 FALSE
, FALSE
, FALSE
);
4339 && hi
->root
.type
== h
->root
.type
4340 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
4341 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
4343 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
4344 hi
->root
.type
= bfd_link_hash_indirect
;
4345 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
4346 (*bed
->elf_backend_copy_indirect_symbol
) (info
, h
, hi
);
4347 sym_hash
= elf_sym_hashes (abfd
);
4349 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
4350 if (sym_hash
[symidx
] == hi
)
4352 sym_hash
[symidx
] = h
;
4358 free (nondeflt_vers
);
4359 nondeflt_vers
= NULL
;
4362 /* Now set the weakdefs field correctly for all the weak defined
4363 symbols we found. The only way to do this is to search all the
4364 symbols. Since we only need the information for non functions in
4365 dynamic objects, that's the only time we actually put anything on
4366 the list WEAKS. We need this information so that if a regular
4367 object refers to a symbol defined weakly in a dynamic object, the
4368 real symbol in the dynamic object is also put in the dynamic
4369 symbols; we also must arrange for both symbols to point to the
4370 same memory location. We could handle the general case of symbol
4371 aliasing, but a general symbol alias can only be generated in
4372 assembler code, handling it correctly would be very time
4373 consuming, and other ELF linkers don't handle general aliasing
4377 struct elf_link_hash_entry
**hpp
;
4378 struct elf_link_hash_entry
**hppend
;
4379 struct elf_link_hash_entry
**sorted_sym_hash
;
4380 struct elf_link_hash_entry
*h
;
4383 /* Since we have to search the whole symbol list for each weak
4384 defined symbol, search time for N weak defined symbols will be
4385 O(N^2). Binary search will cut it down to O(NlogN). */
4386 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4387 sorted_sym_hash
= bfd_malloc (amt
);
4388 if (sorted_sym_hash
== NULL
)
4390 sym_hash
= sorted_sym_hash
;
4391 hpp
= elf_sym_hashes (abfd
);
4392 hppend
= hpp
+ extsymcount
;
4394 for (; hpp
< hppend
; hpp
++)
4398 && h
->root
.type
== bfd_link_hash_defined
4399 && h
->type
!= STT_FUNC
)
4407 qsort (sorted_sym_hash
, sym_count
,
4408 sizeof (struct elf_link_hash_entry
*),
4411 while (weaks
!= NULL
)
4413 struct elf_link_hash_entry
*hlook
;
4420 weaks
= hlook
->u
.weakdef
;
4421 hlook
->u
.weakdef
= NULL
;
4423 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
4424 || hlook
->root
.type
== bfd_link_hash_defweak
4425 || hlook
->root
.type
== bfd_link_hash_common
4426 || hlook
->root
.type
== bfd_link_hash_indirect
);
4427 slook
= hlook
->root
.u
.def
.section
;
4428 vlook
= hlook
->root
.u
.def
.value
;
4435 bfd_signed_vma vdiff
;
4437 h
= sorted_sym_hash
[idx
];
4438 vdiff
= vlook
- h
->root
.u
.def
.value
;
4445 long sdiff
= slook
->id
- h
->root
.u
.def
.section
->id
;
4458 /* We didn't find a value/section match. */
4462 for (i
= ilook
; i
< sym_count
; i
++)
4464 h
= sorted_sym_hash
[i
];
4466 /* Stop if value or section doesn't match. */
4467 if (h
->root
.u
.def
.value
!= vlook
4468 || h
->root
.u
.def
.section
!= slook
)
4470 else if (h
!= hlook
)
4472 hlook
->u
.weakdef
= h
;
4474 /* If the weak definition is in the list of dynamic
4475 symbols, make sure the real definition is put
4477 if (hlook
->dynindx
!= -1 && h
->dynindx
== -1)
4479 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4483 /* If the real definition is in the list of dynamic
4484 symbols, make sure the weak definition is put
4485 there as well. If we don't do this, then the
4486 dynamic loader might not merge the entries for the
4487 real definition and the weak definition. */
4488 if (h
->dynindx
!= -1 && hlook
->dynindx
== -1)
4490 if (! bfd_elf_link_record_dynamic_symbol (info
, hlook
))
4498 free (sorted_sym_hash
);
4501 if (bed
->check_directives
)
4502 (*bed
->check_directives
) (abfd
, info
);
4504 /* If this object is the same format as the output object, and it is
4505 not a shared library, then let the backend look through the
4508 This is required to build global offset table entries and to
4509 arrange for dynamic relocs. It is not required for the
4510 particular common case of linking non PIC code, even when linking
4511 against shared libraries, but unfortunately there is no way of
4512 knowing whether an object file has been compiled PIC or not.
4513 Looking through the relocs is not particularly time consuming.
4514 The problem is that we must either (1) keep the relocs in memory,
4515 which causes the linker to require additional runtime memory or
4516 (2) read the relocs twice from the input file, which wastes time.
4517 This would be a good case for using mmap.
4519 I have no idea how to handle linking PIC code into a file of a
4520 different format. It probably can't be done. */
4522 && is_elf_hash_table (htab
)
4523 && htab
->root
.creator
== abfd
->xvec
4524 && bed
->check_relocs
!= NULL
)
4528 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4530 Elf_Internal_Rela
*internal_relocs
;
4533 if ((o
->flags
& SEC_RELOC
) == 0
4534 || o
->reloc_count
== 0
4535 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
4536 && (o
->flags
& SEC_DEBUGGING
) != 0)
4537 || bfd_is_abs_section (o
->output_section
))
4540 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
4542 if (internal_relocs
== NULL
)
4545 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
4547 if (elf_section_data (o
)->relocs
!= internal_relocs
)
4548 free (internal_relocs
);
4555 /* If this is a non-traditional link, try to optimize the handling
4556 of the .stab/.stabstr sections. */
4558 && ! info
->traditional_format
4559 && is_elf_hash_table (htab
)
4560 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
4564 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
4565 if (stabstr
!= NULL
)
4567 bfd_size_type string_offset
= 0;
4570 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
4571 if (CONST_STRNEQ (stab
->name
, ".stab")
4572 && (!stab
->name
[5] ||
4573 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
4574 && (stab
->flags
& SEC_MERGE
) == 0
4575 && !bfd_is_abs_section (stab
->output_section
))
4577 struct bfd_elf_section_data
*secdata
;
4579 secdata
= elf_section_data (stab
);
4580 if (! _bfd_link_section_stabs (abfd
, &htab
->stab_info
, stab
,
4581 stabstr
, &secdata
->sec_info
,
4584 if (secdata
->sec_info
)
4585 stab
->sec_info_type
= ELF_INFO_TYPE_STABS
;
4590 if (is_elf_hash_table (htab
) && add_needed
)
4592 /* Add this bfd to the loaded list. */
4593 struct elf_link_loaded_list
*n
;
4595 n
= bfd_alloc (abfd
, sizeof (struct elf_link_loaded_list
));
4599 n
->next
= htab
->loaded
;
4606 if (old_tab
!= NULL
)
4608 if (nondeflt_vers
!= NULL
)
4609 free (nondeflt_vers
);
4610 if (extversym
!= NULL
)
4613 if (isymbuf
!= NULL
)
4619 /* Return the linker hash table entry of a symbol that might be
4620 satisfied by an archive symbol. Return -1 on error. */
4622 struct elf_link_hash_entry
*
4623 _bfd_elf_archive_symbol_lookup (bfd
*abfd
,
4624 struct bfd_link_info
*info
,
4627 struct elf_link_hash_entry
*h
;
4631 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, FALSE
, FALSE
, FALSE
);
4635 /* If this is a default version (the name contains @@), look up the
4636 symbol again with only one `@' as well as without the version.
4637 The effect is that references to the symbol with and without the
4638 version will be matched by the default symbol in the archive. */
4640 p
= strchr (name
, ELF_VER_CHR
);
4641 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
4644 /* First check with only one `@'. */
4645 len
= strlen (name
);
4646 copy
= bfd_alloc (abfd
, len
);
4648 return (struct elf_link_hash_entry
*) 0 - 1;
4650 first
= p
- name
+ 1;
4651 memcpy (copy
, name
, first
);
4652 memcpy (copy
+ first
, name
+ first
+ 1, len
- first
);
4654 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
, FALSE
, FALSE
, FALSE
);
4657 /* We also need to check references to the symbol without the
4659 copy
[first
- 1] = '\0';
4660 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
4661 FALSE
, FALSE
, FALSE
);
4664 bfd_release (abfd
, copy
);
4668 /* Add symbols from an ELF archive file to the linker hash table. We
4669 don't use _bfd_generic_link_add_archive_symbols because of a
4670 problem which arises on UnixWare. The UnixWare libc.so is an
4671 archive which includes an entry libc.so.1 which defines a bunch of
4672 symbols. The libc.so archive also includes a number of other
4673 object files, which also define symbols, some of which are the same
4674 as those defined in libc.so.1. Correct linking requires that we
4675 consider each object file in turn, and include it if it defines any
4676 symbols we need. _bfd_generic_link_add_archive_symbols does not do
4677 this; it looks through the list of undefined symbols, and includes
4678 any object file which defines them. When this algorithm is used on
4679 UnixWare, it winds up pulling in libc.so.1 early and defining a
4680 bunch of symbols. This means that some of the other objects in the
4681 archive are not included in the link, which is incorrect since they
4682 precede libc.so.1 in the archive.
4684 Fortunately, ELF archive handling is simpler than that done by
4685 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4686 oddities. In ELF, if we find a symbol in the archive map, and the
4687 symbol is currently undefined, we know that we must pull in that
4690 Unfortunately, we do have to make multiple passes over the symbol
4691 table until nothing further is resolved. */
4694 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4697 bfd_boolean
*defined
= NULL
;
4698 bfd_boolean
*included
= NULL
;
4702 const struct elf_backend_data
*bed
;
4703 struct elf_link_hash_entry
* (*archive_symbol_lookup
)
4704 (bfd
*, struct bfd_link_info
*, const char *);
4706 if (! bfd_has_map (abfd
))
4708 /* An empty archive is a special case. */
4709 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
4711 bfd_set_error (bfd_error_no_armap
);
4715 /* Keep track of all symbols we know to be already defined, and all
4716 files we know to be already included. This is to speed up the
4717 second and subsequent passes. */
4718 c
= bfd_ardata (abfd
)->symdef_count
;
4722 amt
*= sizeof (bfd_boolean
);
4723 defined
= bfd_zmalloc (amt
);
4724 included
= bfd_zmalloc (amt
);
4725 if (defined
== NULL
|| included
== NULL
)
4728 symdefs
= bfd_ardata (abfd
)->symdefs
;
4729 bed
= get_elf_backend_data (abfd
);
4730 archive_symbol_lookup
= bed
->elf_backend_archive_symbol_lookup
;
4743 symdefend
= symdef
+ c
;
4744 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
4746 struct elf_link_hash_entry
*h
;
4748 struct bfd_link_hash_entry
*undefs_tail
;
4751 if (defined
[i
] || included
[i
])
4753 if (symdef
->file_offset
== last
)
4759 h
= archive_symbol_lookup (abfd
, info
, symdef
->name
);
4760 if (h
== (struct elf_link_hash_entry
*) 0 - 1)
4766 if (h
->root
.type
== bfd_link_hash_common
)
4768 /* We currently have a common symbol. The archive map contains
4769 a reference to this symbol, so we may want to include it. We
4770 only want to include it however, if this archive element
4771 contains a definition of the symbol, not just another common
4774 Unfortunately some archivers (including GNU ar) will put
4775 declarations of common symbols into their archive maps, as
4776 well as real definitions, so we cannot just go by the archive
4777 map alone. Instead we must read in the element's symbol
4778 table and check that to see what kind of symbol definition
4780 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
4783 else if (h
->root
.type
!= bfd_link_hash_undefined
)
4785 if (h
->root
.type
!= bfd_link_hash_undefweak
)
4790 /* We need to include this archive member. */
4791 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
4792 if (element
== NULL
)
4795 if (! bfd_check_format (element
, bfd_object
))
4798 /* Doublecheck that we have not included this object
4799 already--it should be impossible, but there may be
4800 something wrong with the archive. */
4801 if (element
->archive_pass
!= 0)
4803 bfd_set_error (bfd_error_bad_value
);
4806 element
->archive_pass
= 1;
4808 undefs_tail
= info
->hash
->undefs_tail
;
4810 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
4813 if (! bfd_link_add_symbols (element
, info
))
4816 /* If there are any new undefined symbols, we need to make
4817 another pass through the archive in order to see whether
4818 they can be defined. FIXME: This isn't perfect, because
4819 common symbols wind up on undefs_tail and because an
4820 undefined symbol which is defined later on in this pass
4821 does not require another pass. This isn't a bug, but it
4822 does make the code less efficient than it could be. */
4823 if (undefs_tail
!= info
->hash
->undefs_tail
)
4826 /* Look backward to mark all symbols from this object file
4827 which we have already seen in this pass. */
4831 included
[mark
] = TRUE
;
4836 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
4838 /* We mark subsequent symbols from this object file as we go
4839 on through the loop. */
4840 last
= symdef
->file_offset
;
4851 if (defined
!= NULL
)
4853 if (included
!= NULL
)
4858 /* Given an ELF BFD, add symbols to the global hash table as
4862 bfd_elf_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4864 switch (bfd_get_format (abfd
))
4867 return elf_link_add_object_symbols (abfd
, info
);
4869 return elf_link_add_archive_symbols (abfd
, info
);
4871 bfd_set_error (bfd_error_wrong_format
);
4876 /* This function will be called though elf_link_hash_traverse to store
4877 all hash value of the exported symbols in an array. */
4880 elf_collect_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
4882 unsigned long **valuep
= data
;
4888 if (h
->root
.type
== bfd_link_hash_warning
)
4889 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4891 /* Ignore indirect symbols. These are added by the versioning code. */
4892 if (h
->dynindx
== -1)
4895 name
= h
->root
.root
.string
;
4896 p
= strchr (name
, ELF_VER_CHR
);
4899 alc
= bfd_malloc (p
- name
+ 1);
4900 memcpy (alc
, name
, p
- name
);
4901 alc
[p
- name
] = '\0';
4905 /* Compute the hash value. */
4906 ha
= bfd_elf_hash (name
);
4908 /* Store the found hash value in the array given as the argument. */
4911 /* And store it in the struct so that we can put it in the hash table
4913 h
->u
.elf_hash_value
= ha
;
4921 struct collect_gnu_hash_codes
4924 const struct elf_backend_data
*bed
;
4925 unsigned long int nsyms
;
4926 unsigned long int maskbits
;
4927 unsigned long int *hashcodes
;
4928 unsigned long int *hashval
;
4929 unsigned long int *indx
;
4930 unsigned long int *counts
;
4933 long int min_dynindx
;
4934 unsigned long int bucketcount
;
4935 unsigned long int symindx
;
4936 long int local_indx
;
4937 long int shift1
, shift2
;
4938 unsigned long int mask
;
4941 /* This function will be called though elf_link_hash_traverse to store
4942 all hash value of the exported symbols in an array. */
4945 elf_collect_gnu_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
4947 struct collect_gnu_hash_codes
*s
= data
;
4953 if (h
->root
.type
== bfd_link_hash_warning
)
4954 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4956 /* Ignore indirect symbols. These are added by the versioning code. */
4957 if (h
->dynindx
== -1)
4960 /* Ignore also local symbols and undefined symbols. */
4961 if (! (*s
->bed
->elf_hash_symbol
) (h
))
4964 name
= h
->root
.root
.string
;
4965 p
= strchr (name
, ELF_VER_CHR
);
4968 alc
= bfd_malloc (p
- name
+ 1);
4969 memcpy (alc
, name
, p
- name
);
4970 alc
[p
- name
] = '\0';
4974 /* Compute the hash value. */
4975 ha
= bfd_elf_gnu_hash (name
);
4977 /* Store the found hash value in the array for compute_bucket_count,
4978 and also for .dynsym reordering purposes. */
4979 s
->hashcodes
[s
->nsyms
] = ha
;
4980 s
->hashval
[h
->dynindx
] = ha
;
4982 if (s
->min_dynindx
< 0 || s
->min_dynindx
> h
->dynindx
)
4983 s
->min_dynindx
= h
->dynindx
;
4991 /* This function will be called though elf_link_hash_traverse to do
4992 final dynaminc symbol renumbering. */
4995 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry
*h
, void *data
)
4997 struct collect_gnu_hash_codes
*s
= data
;
4998 unsigned long int bucket
;
4999 unsigned long int val
;
5001 if (h
->root
.type
== bfd_link_hash_warning
)
5002 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5004 /* Ignore indirect symbols. */
5005 if (h
->dynindx
== -1)
5008 /* Ignore also local symbols and undefined symbols. */
5009 if (! (*s
->bed
->elf_hash_symbol
) (h
))
5011 if (h
->dynindx
>= s
->min_dynindx
)
5012 h
->dynindx
= s
->local_indx
++;
5016 bucket
= s
->hashval
[h
->dynindx
] % s
->bucketcount
;
5017 val
= (s
->hashval
[h
->dynindx
] >> s
->shift1
)
5018 & ((s
->maskbits
>> s
->shift1
) - 1);
5019 s
->bitmask
[val
] |= ((bfd_vma
) 1) << (s
->hashval
[h
->dynindx
] & s
->mask
);
5021 |= ((bfd_vma
) 1) << ((s
->hashval
[h
->dynindx
] >> s
->shift2
) & s
->mask
);
5022 val
= s
->hashval
[h
->dynindx
] & ~(unsigned long int) 1;
5023 if (s
->counts
[bucket
] == 1)
5024 /* Last element terminates the chain. */
5026 bfd_put_32 (s
->output_bfd
, val
,
5027 s
->contents
+ (s
->indx
[bucket
] - s
->symindx
) * 4);
5028 --s
->counts
[bucket
];
5029 h
->dynindx
= s
->indx
[bucket
]++;
5033 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5036 _bfd_elf_hash_symbol (struct elf_link_hash_entry
*h
)
5038 return !(h
->forced_local
5039 || h
->root
.type
== bfd_link_hash_undefined
5040 || h
->root
.type
== bfd_link_hash_undefweak
5041 || ((h
->root
.type
== bfd_link_hash_defined
5042 || h
->root
.type
== bfd_link_hash_defweak
)
5043 && h
->root
.u
.def
.section
->output_section
== NULL
));
5046 /* Array used to determine the number of hash table buckets to use
5047 based on the number of symbols there are. If there are fewer than
5048 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5049 fewer than 37 we use 17 buckets, and so forth. We never use more
5050 than 32771 buckets. */
5052 static const size_t elf_buckets
[] =
5054 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5058 /* Compute bucket count for hashing table. We do not use a static set
5059 of possible tables sizes anymore. Instead we determine for all
5060 possible reasonable sizes of the table the outcome (i.e., the
5061 number of collisions etc) and choose the best solution. The
5062 weighting functions are not too simple to allow the table to grow
5063 without bounds. Instead one of the weighting factors is the size.
5064 Therefore the result is always a good payoff between few collisions
5065 (= short chain lengths) and table size. */
5067 compute_bucket_count (struct bfd_link_info
*info
, unsigned long int *hashcodes
,
5068 unsigned long int nsyms
, int gnu_hash
)
5070 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
5071 size_t best_size
= 0;
5072 unsigned long int i
;
5075 /* We have a problem here. The following code to optimize the table
5076 size requires an integer type with more the 32 bits. If
5077 BFD_HOST_U_64_BIT is set we know about such a type. */
5078 #ifdef BFD_HOST_U_64_BIT
5083 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
5084 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
5085 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
5086 unsigned long int *counts
;
5088 /* Possible optimization parameters: if we have NSYMS symbols we say
5089 that the hashing table must at least have NSYMS/4 and at most
5091 minsize
= nsyms
/ 4;
5094 best_size
= maxsize
= nsyms
* 2;
5099 if ((best_size
& 31) == 0)
5103 /* Create array where we count the collisions in. We must use bfd_malloc
5104 since the size could be large. */
5106 amt
*= sizeof (unsigned long int);
5107 counts
= bfd_malloc (amt
);
5111 /* Compute the "optimal" size for the hash table. The criteria is a
5112 minimal chain length. The minor criteria is (of course) the size
5114 for (i
= minsize
; i
< maxsize
; ++i
)
5116 /* Walk through the array of hashcodes and count the collisions. */
5117 BFD_HOST_U_64_BIT max
;
5118 unsigned long int j
;
5119 unsigned long int fact
;
5121 if (gnu_hash
&& (i
& 31) == 0)
5124 memset (counts
, '\0', i
* sizeof (unsigned long int));
5126 /* Determine how often each hash bucket is used. */
5127 for (j
= 0; j
< nsyms
; ++j
)
5128 ++counts
[hashcodes
[j
] % i
];
5130 /* For the weight function we need some information about the
5131 pagesize on the target. This is information need not be 100%
5132 accurate. Since this information is not available (so far) we
5133 define it here to a reasonable default value. If it is crucial
5134 to have a better value some day simply define this value. */
5135 # ifndef BFD_TARGET_PAGESIZE
5136 # define BFD_TARGET_PAGESIZE (4096)
5139 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5141 max
= (2 + dynsymcount
) * bed
->s
->sizeof_hash_entry
;
5144 /* Variant 1: optimize for short chains. We add the squares
5145 of all the chain lengths (which favors many small chain
5146 over a few long chains). */
5147 for (j
= 0; j
< i
; ++j
)
5148 max
+= counts
[j
] * counts
[j
];
5150 /* This adds penalties for the overall size of the table. */
5151 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5154 /* Variant 2: Optimize a lot more for small table. Here we
5155 also add squares of the size but we also add penalties for
5156 empty slots (the +1 term). */
5157 for (j
= 0; j
< i
; ++j
)
5158 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
5160 /* The overall size of the table is considered, but not as
5161 strong as in variant 1, where it is squared. */
5162 fact
= i
/ (BFD_TARGET_PAGESIZE
/ bed
->s
->sizeof_hash_entry
) + 1;
5166 /* Compare with current best results. */
5167 if (max
< best_chlen
)
5177 #endif /* defined (BFD_HOST_U_64_BIT) */
5179 /* This is the fallback solution if no 64bit type is available or if we
5180 are not supposed to spend much time on optimizations. We select the
5181 bucket count using a fixed set of numbers. */
5182 for (i
= 0; elf_buckets
[i
] != 0; i
++)
5184 best_size
= elf_buckets
[i
];
5185 if (nsyms
< elf_buckets
[i
+ 1])
5188 if (gnu_hash
&& best_size
< 2)
5195 /* Set up the sizes and contents of the ELF dynamic sections. This is
5196 called by the ELF linker emulation before_allocation routine. We
5197 must set the sizes of the sections before the linker sets the
5198 addresses of the various sections. */
5201 bfd_elf_size_dynamic_sections (bfd
*output_bfd
,
5204 const char *filter_shlib
,
5205 const char * const *auxiliary_filters
,
5206 struct bfd_link_info
*info
,
5207 asection
**sinterpptr
,
5208 struct bfd_elf_version_tree
*verdefs
)
5210 bfd_size_type soname_indx
;
5212 const struct elf_backend_data
*bed
;
5213 struct elf_assign_sym_version_info asvinfo
;
5217 soname_indx
= (bfd_size_type
) -1;
5219 if (!is_elf_hash_table (info
->hash
))
5222 elf_tdata (output_bfd
)->relro
= info
->relro
;
5223 if (info
->execstack
)
5224 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
5225 else if (info
->noexecstack
)
5226 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
;
5230 asection
*notesec
= NULL
;
5233 for (inputobj
= info
->input_bfds
;
5235 inputobj
= inputobj
->link_next
)
5239 if (inputobj
->flags
& (DYNAMIC
| BFD_LINKER_CREATED
))
5241 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
5244 if (s
->flags
& SEC_CODE
)
5253 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| exec
;
5254 if (exec
&& info
->relocatable
5255 && notesec
->output_section
!= bfd_abs_section_ptr
)
5256 notesec
->output_section
->flags
|= SEC_CODE
;
5260 /* Any syms created from now on start with -1 in
5261 got.refcount/offset and plt.refcount/offset. */
5262 elf_hash_table (info
)->init_got_refcount
5263 = elf_hash_table (info
)->init_got_offset
;
5264 elf_hash_table (info
)->init_plt_refcount
5265 = elf_hash_table (info
)->init_plt_offset
;
5267 /* The backend may have to create some sections regardless of whether
5268 we're dynamic or not. */
5269 bed
= get_elf_backend_data (output_bfd
);
5270 if (bed
->elf_backend_always_size_sections
5271 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
5274 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
5277 dynobj
= elf_hash_table (info
)->dynobj
;
5279 /* If there were no dynamic objects in the link, there is nothing to
5284 if (elf_hash_table (info
)->dynamic_sections_created
)
5286 struct elf_info_failed eif
;
5287 struct elf_link_hash_entry
*h
;
5289 struct bfd_elf_version_tree
*t
;
5290 struct bfd_elf_version_expr
*d
;
5292 bfd_boolean all_defined
;
5294 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
5295 BFD_ASSERT (*sinterpptr
!= NULL
|| !info
->executable
);
5299 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5301 if (soname_indx
== (bfd_size_type
) -1
5302 || !_bfd_elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
5308 if (!_bfd_elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
5310 info
->flags
|= DF_SYMBOLIC
;
5317 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
5319 if (indx
== (bfd_size_type
) -1
5320 || !_bfd_elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
5323 if (info
->new_dtags
)
5325 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
, indx
);
5326 if (!_bfd_elf_add_dynamic_entry (info
, DT_RUNPATH
, indx
))
5331 if (filter_shlib
!= NULL
)
5335 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5336 filter_shlib
, TRUE
);
5337 if (indx
== (bfd_size_type
) -1
5338 || !_bfd_elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
5342 if (auxiliary_filters
!= NULL
)
5344 const char * const *p
;
5346 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
5350 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5352 if (indx
== (bfd_size_type
) -1
5353 || !_bfd_elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
5359 eif
.verdefs
= verdefs
;
5362 /* If we are supposed to export all symbols into the dynamic symbol
5363 table (this is not the normal case), then do so. */
5364 if (info
->export_dynamic
5365 || (info
->executable
&& info
->dynamic
))
5367 elf_link_hash_traverse (elf_hash_table (info
),
5368 _bfd_elf_export_symbol
,
5374 /* Make all global versions with definition. */
5375 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5376 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5377 if (!d
->symver
&& d
->symbol
)
5379 const char *verstr
, *name
;
5380 size_t namelen
, verlen
, newlen
;
5382 struct elf_link_hash_entry
*newh
;
5385 namelen
= strlen (name
);
5387 verlen
= strlen (verstr
);
5388 newlen
= namelen
+ verlen
+ 3;
5390 newname
= bfd_malloc (newlen
);
5391 if (newname
== NULL
)
5393 memcpy (newname
, name
, namelen
);
5395 /* Check the hidden versioned definition. */
5396 p
= newname
+ namelen
;
5398 memcpy (p
, verstr
, verlen
+ 1);
5399 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5400 newname
, FALSE
, FALSE
,
5403 || (newh
->root
.type
!= bfd_link_hash_defined
5404 && newh
->root
.type
!= bfd_link_hash_defweak
))
5406 /* Check the default versioned definition. */
5408 memcpy (p
, verstr
, verlen
+ 1);
5409 newh
= elf_link_hash_lookup (elf_hash_table (info
),
5410 newname
, FALSE
, FALSE
,
5415 /* Mark this version if there is a definition and it is
5416 not defined in a shared object. */
5418 && !newh
->def_dynamic
5419 && (newh
->root
.type
== bfd_link_hash_defined
5420 || newh
->root
.type
== bfd_link_hash_defweak
))
5424 /* Attach all the symbols to their version information. */
5425 asvinfo
.output_bfd
= output_bfd
;
5426 asvinfo
.info
= info
;
5427 asvinfo
.verdefs
= verdefs
;
5428 asvinfo
.failed
= FALSE
;
5430 elf_link_hash_traverse (elf_hash_table (info
),
5431 _bfd_elf_link_assign_sym_version
,
5436 if (!info
->allow_undefined_version
)
5438 /* Check if all global versions have a definition. */
5440 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5441 for (d
= t
->globals
.list
; d
!= NULL
; d
= d
->next
)
5442 if (!d
->symver
&& !d
->script
)
5444 (*_bfd_error_handler
)
5445 (_("%s: undefined version: %s"),
5446 d
->pattern
, t
->name
);
5447 all_defined
= FALSE
;
5452 bfd_set_error (bfd_error_bad_value
);
5457 /* Find all symbols which were defined in a dynamic object and make
5458 the backend pick a reasonable value for them. */
5459 elf_link_hash_traverse (elf_hash_table (info
),
5460 _bfd_elf_adjust_dynamic_symbol
,
5465 /* Add some entries to the .dynamic section. We fill in some of the
5466 values later, in bfd_elf_final_link, but we must add the entries
5467 now so that we know the final size of the .dynamic section. */
5469 /* If there are initialization and/or finalization functions to
5470 call then add the corresponding DT_INIT/DT_FINI entries. */
5471 h
= (info
->init_function
5472 ? elf_link_hash_lookup (elf_hash_table (info
),
5473 info
->init_function
, FALSE
,
5480 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT
, 0))
5483 h
= (info
->fini_function
5484 ? elf_link_hash_lookup (elf_hash_table (info
),
5485 info
->fini_function
, FALSE
,
5492 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI
, 0))
5496 s
= bfd_get_section_by_name (output_bfd
, ".preinit_array");
5497 if (s
!= NULL
&& s
->linker_has_input
)
5499 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5500 if (! info
->executable
)
5505 for (sub
= info
->input_bfds
; sub
!= NULL
;
5506 sub
= sub
->link_next
)
5507 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5508 if (elf_section_data (o
)->this_hdr
.sh_type
5509 == SHT_PREINIT_ARRAY
)
5511 (*_bfd_error_handler
)
5512 (_("%B: .preinit_array section is not allowed in DSO"),
5517 bfd_set_error (bfd_error_nonrepresentable_section
);
5521 if (!_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
5522 || !_bfd_elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
5525 s
= bfd_get_section_by_name (output_bfd
, ".init_array");
5526 if (s
!= NULL
&& s
->linker_has_input
)
5528 if (!_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
5529 || !_bfd_elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
5532 s
= bfd_get_section_by_name (output_bfd
, ".fini_array");
5533 if (s
!= NULL
&& s
->linker_has_input
)
5535 if (!_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
5536 || !_bfd_elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
5540 dynstr
= bfd_get_section_by_name (dynobj
, ".dynstr");
5541 /* If .dynstr is excluded from the link, we don't want any of
5542 these tags. Strictly, we should be checking each section
5543 individually; This quick check covers for the case where
5544 someone does a /DISCARD/ : { *(*) }. */
5545 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
5547 bfd_size_type strsize
;
5549 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
5550 if ((info
->emit_hash
5551 && !_bfd_elf_add_dynamic_entry (info
, DT_HASH
, 0))
5552 || (info
->emit_gnu_hash
5553 && !_bfd_elf_add_dynamic_entry (info
, DT_GNU_HASH
, 0))
5554 || !_bfd_elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
5555 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
5556 || !_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
5557 || !_bfd_elf_add_dynamic_entry (info
, DT_SYMENT
,
5558 bed
->s
->sizeof_sym
))
5563 /* The backend must work out the sizes of all the other dynamic
5565 if (bed
->elf_backend_size_dynamic_sections
5566 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
5569 if (elf_hash_table (info
)->dynamic_sections_created
)
5571 unsigned long section_sym_count
;
5574 /* Set up the version definition section. */
5575 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
5576 BFD_ASSERT (s
!= NULL
);
5578 /* We may have created additional version definitions if we are
5579 just linking a regular application. */
5580 verdefs
= asvinfo
.verdefs
;
5582 /* Skip anonymous version tag. */
5583 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
5584 verdefs
= verdefs
->next
;
5586 if (verdefs
== NULL
&& !info
->create_default_symver
)
5587 s
->flags
|= SEC_EXCLUDE
;
5592 struct bfd_elf_version_tree
*t
;
5594 Elf_Internal_Verdef def
;
5595 Elf_Internal_Verdaux defaux
;
5596 struct bfd_link_hash_entry
*bh
;
5597 struct elf_link_hash_entry
*h
;
5603 /* Make space for the base version. */
5604 size
+= sizeof (Elf_External_Verdef
);
5605 size
+= sizeof (Elf_External_Verdaux
);
5608 /* Make space for the default version. */
5609 if (info
->create_default_symver
)
5611 size
+= sizeof (Elf_External_Verdef
);
5615 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5617 struct bfd_elf_version_deps
*n
;
5619 size
+= sizeof (Elf_External_Verdef
);
5620 size
+= sizeof (Elf_External_Verdaux
);
5623 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
5624 size
+= sizeof (Elf_External_Verdaux
);
5628 s
->contents
= bfd_alloc (output_bfd
, s
->size
);
5629 if (s
->contents
== NULL
&& s
->size
!= 0)
5632 /* Fill in the version definition section. */
5636 def
.vd_version
= VER_DEF_CURRENT
;
5637 def
.vd_flags
= VER_FLG_BASE
;
5640 if (info
->create_default_symver
)
5642 def
.vd_aux
= 2 * sizeof (Elf_External_Verdef
);
5643 def
.vd_next
= sizeof (Elf_External_Verdef
);
5647 def
.vd_aux
= sizeof (Elf_External_Verdef
);
5648 def
.vd_next
= (sizeof (Elf_External_Verdef
)
5649 + sizeof (Elf_External_Verdaux
));
5652 if (soname_indx
!= (bfd_size_type
) -1)
5654 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
5656 def
.vd_hash
= bfd_elf_hash (soname
);
5657 defaux
.vda_name
= soname_indx
;
5664 name
= lbasename (output_bfd
->filename
);
5665 def
.vd_hash
= bfd_elf_hash (name
);
5666 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5668 if (indx
== (bfd_size_type
) -1)
5670 defaux
.vda_name
= indx
;
5672 defaux
.vda_next
= 0;
5674 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
5675 (Elf_External_Verdef
*) p
);
5676 p
+= sizeof (Elf_External_Verdef
);
5677 if (info
->create_default_symver
)
5679 /* Add a symbol representing this version. */
5681 if (! (_bfd_generic_link_add_one_symbol
5682 (info
, dynobj
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
5684 get_elf_backend_data (dynobj
)->collect
, &bh
)))
5686 h
= (struct elf_link_hash_entry
*) bh
;
5689 h
->type
= STT_OBJECT
;
5690 h
->verinfo
.vertree
= NULL
;
5692 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5695 /* Create a duplicate of the base version with the same
5696 aux block, but different flags. */
5699 def
.vd_aux
= sizeof (Elf_External_Verdef
);
5701 def
.vd_next
= (sizeof (Elf_External_Verdef
)
5702 + sizeof (Elf_External_Verdaux
));
5705 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
5706 (Elf_External_Verdef
*) p
);
5707 p
+= sizeof (Elf_External_Verdef
);
5709 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
5710 (Elf_External_Verdaux
*) p
);
5711 p
+= sizeof (Elf_External_Verdaux
);
5713 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
5716 struct bfd_elf_version_deps
*n
;
5719 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
5722 /* Add a symbol representing this version. */
5724 if (! (_bfd_generic_link_add_one_symbol
5725 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
5727 get_elf_backend_data (dynobj
)->collect
, &bh
)))
5729 h
= (struct elf_link_hash_entry
*) bh
;
5732 h
->type
= STT_OBJECT
;
5733 h
->verinfo
.vertree
= t
;
5735 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5738 def
.vd_version
= VER_DEF_CURRENT
;
5740 if (t
->globals
.list
== NULL
5741 && t
->locals
.list
== NULL
5743 def
.vd_flags
|= VER_FLG_WEAK
;
5744 def
.vd_ndx
= t
->vernum
+ (info
->create_default_symver
? 2 : 1);
5745 def
.vd_cnt
= cdeps
+ 1;
5746 def
.vd_hash
= bfd_elf_hash (t
->name
);
5747 def
.vd_aux
= sizeof (Elf_External_Verdef
);
5749 if (t
->next
!= NULL
)
5750 def
.vd_next
= (sizeof (Elf_External_Verdef
)
5751 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
5753 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
5754 (Elf_External_Verdef
*) p
);
5755 p
+= sizeof (Elf_External_Verdef
);
5757 defaux
.vda_name
= h
->dynstr_index
;
5758 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
5760 defaux
.vda_next
= 0;
5761 if (t
->deps
!= NULL
)
5762 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
5763 t
->name_indx
= defaux
.vda_name
;
5765 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
5766 (Elf_External_Verdaux
*) p
);
5767 p
+= sizeof (Elf_External_Verdaux
);
5769 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
5771 if (n
->version_needed
== NULL
)
5773 /* This can happen if there was an error in the
5775 defaux
.vda_name
= 0;
5779 defaux
.vda_name
= n
->version_needed
->name_indx
;
5780 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
5783 if (n
->next
== NULL
)
5784 defaux
.vda_next
= 0;
5786 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
5788 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
5789 (Elf_External_Verdaux
*) p
);
5790 p
+= sizeof (Elf_External_Verdaux
);
5794 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
5795 || !_bfd_elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
5798 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
5801 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
5803 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
5806 else if (info
->flags
& DF_BIND_NOW
)
5808 if (!_bfd_elf_add_dynamic_entry (info
, DT_BIND_NOW
, 0))
5814 if (info
->executable
)
5815 info
->flags_1
&= ~ (DF_1_INITFIRST
5818 if (!_bfd_elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
5822 /* Work out the size of the version reference section. */
5824 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
5825 BFD_ASSERT (s
!= NULL
);
5827 struct elf_find_verdep_info sinfo
;
5829 sinfo
.output_bfd
= output_bfd
;
5831 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
5832 if (sinfo
.vers
== 0)
5834 sinfo
.failed
= FALSE
;
5836 elf_link_hash_traverse (elf_hash_table (info
),
5837 _bfd_elf_link_find_version_dependencies
,
5840 if (elf_tdata (output_bfd
)->verref
== NULL
)
5841 s
->flags
|= SEC_EXCLUDE
;
5844 Elf_Internal_Verneed
*t
;
5849 /* Build the version definition section. */
5852 for (t
= elf_tdata (output_bfd
)->verref
;
5856 Elf_Internal_Vernaux
*a
;
5858 size
+= sizeof (Elf_External_Verneed
);
5860 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
5861 size
+= sizeof (Elf_External_Vernaux
);
5865 s
->contents
= bfd_alloc (output_bfd
, s
->size
);
5866 if (s
->contents
== NULL
)
5870 for (t
= elf_tdata (output_bfd
)->verref
;
5875 Elf_Internal_Vernaux
*a
;
5879 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
5882 t
->vn_version
= VER_NEED_CURRENT
;
5884 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5885 elf_dt_name (t
->vn_bfd
) != NULL
5886 ? elf_dt_name (t
->vn_bfd
)
5887 : lbasename (t
->vn_bfd
->filename
),
5889 if (indx
== (bfd_size_type
) -1)
5892 t
->vn_aux
= sizeof (Elf_External_Verneed
);
5893 if (t
->vn_nextref
== NULL
)
5896 t
->vn_next
= (sizeof (Elf_External_Verneed
)
5897 + caux
* sizeof (Elf_External_Vernaux
));
5899 _bfd_elf_swap_verneed_out (output_bfd
, t
,
5900 (Elf_External_Verneed
*) p
);
5901 p
+= sizeof (Elf_External_Verneed
);
5903 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
5905 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
5906 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
5907 a
->vna_nodename
, FALSE
);
5908 if (indx
== (bfd_size_type
) -1)
5911 if (a
->vna_nextptr
== NULL
)
5914 a
->vna_next
= sizeof (Elf_External_Vernaux
);
5916 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
5917 (Elf_External_Vernaux
*) p
);
5918 p
+= sizeof (Elf_External_Vernaux
);
5922 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
5923 || !_bfd_elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
5926 elf_tdata (output_bfd
)->cverrefs
= crefs
;
5930 if ((elf_tdata (output_bfd
)->cverrefs
== 0
5931 && elf_tdata (output_bfd
)->cverdefs
== 0)
5932 || _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
5933 §ion_sym_count
) == 0)
5935 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
5936 s
->flags
|= SEC_EXCLUDE
;
5942 /* Find the first non-excluded output section. We'll use its
5943 section symbol for some emitted relocs. */
5945 _bfd_elf_init_1_index_section (bfd
*output_bfd
, struct bfd_link_info
*info
)
5949 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5950 if ((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
)) == SEC_ALLOC
5951 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
5953 elf_hash_table (info
)->text_index_section
= s
;
5958 /* Find two non-excluded output sections, one for code, one for data.
5959 We'll use their section symbols for some emitted relocs. */
5961 _bfd_elf_init_2_index_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
5965 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5966 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
))
5967 == (SEC_ALLOC
| SEC_READONLY
))
5968 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
5970 elf_hash_table (info
)->text_index_section
= s
;
5974 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5975 if (((s
->flags
& (SEC_EXCLUDE
| SEC_ALLOC
| SEC_READONLY
)) == SEC_ALLOC
)
5976 && !_bfd_elf_link_omit_section_dynsym (output_bfd
, info
, s
))
5978 elf_hash_table (info
)->data_index_section
= s
;
5982 if (elf_hash_table (info
)->text_index_section
== NULL
)
5983 elf_hash_table (info
)->text_index_section
5984 = elf_hash_table (info
)->data_index_section
;
5988 bfd_elf_size_dynsym_hash_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
5990 const struct elf_backend_data
*bed
;
5992 if (!is_elf_hash_table (info
->hash
))
5995 bed
= get_elf_backend_data (output_bfd
);
5996 (*bed
->elf_backend_init_index_section
) (output_bfd
, info
);
5998 if (elf_hash_table (info
)->dynamic_sections_created
)
6002 bfd_size_type dynsymcount
;
6003 unsigned long section_sym_count
;
6004 unsigned int dtagcount
;
6006 dynobj
= elf_hash_table (info
)->dynobj
;
6008 /* Assign dynsym indicies. In a shared library we generate a
6009 section symbol for each output section, which come first.
6010 Next come all of the back-end allocated local dynamic syms,
6011 followed by the rest of the global symbols. */
6013 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
,
6014 §ion_sym_count
);
6016 /* Work out the size of the symbol version section. */
6017 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
6018 BFD_ASSERT (s
!= NULL
);
6019 if (dynsymcount
!= 0
6020 && (s
->flags
& SEC_EXCLUDE
) == 0)
6022 s
->size
= dynsymcount
* sizeof (Elf_External_Versym
);
6023 s
->contents
= bfd_zalloc (output_bfd
, s
->size
);
6024 if (s
->contents
== NULL
)
6027 if (!_bfd_elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
6031 /* Set the size of the .dynsym and .hash sections. We counted
6032 the number of dynamic symbols in elf_link_add_object_symbols.
6033 We will build the contents of .dynsym and .hash when we build
6034 the final symbol table, because until then we do not know the
6035 correct value to give the symbols. We built the .dynstr
6036 section as we went along in elf_link_add_object_symbols. */
6037 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
6038 BFD_ASSERT (s
!= NULL
);
6039 s
->size
= dynsymcount
* bed
->s
->sizeof_sym
;
6041 if (dynsymcount
!= 0)
6043 s
->contents
= bfd_alloc (output_bfd
, s
->size
);
6044 if (s
->contents
== NULL
)
6047 /* The first entry in .dynsym is a dummy symbol.
6048 Clear all the section syms, in case we don't output them all. */
6049 ++section_sym_count
;
6050 memset (s
->contents
, 0, section_sym_count
* bed
->s
->sizeof_sym
);
6053 elf_hash_table (info
)->bucketcount
= 0;
6055 /* Compute the size of the hashing table. As a side effect this
6056 computes the hash values for all the names we export. */
6057 if (info
->emit_hash
)
6059 unsigned long int *hashcodes
;
6060 unsigned long int *hashcodesp
;
6062 unsigned long int nsyms
;
6064 size_t hash_entry_size
;
6066 /* Compute the hash values for all exported symbols. At the same
6067 time store the values in an array so that we could use them for
6069 amt
= dynsymcount
* sizeof (unsigned long int);
6070 hashcodes
= bfd_malloc (amt
);
6071 if (hashcodes
== NULL
)
6073 hashcodesp
= hashcodes
;
6075 /* Put all hash values in HASHCODES. */
6076 elf_link_hash_traverse (elf_hash_table (info
),
6077 elf_collect_hash_codes
, &hashcodesp
);
6079 nsyms
= hashcodesp
- hashcodes
;
6081 = compute_bucket_count (info
, hashcodes
, nsyms
, 0);
6084 if (bucketcount
== 0)
6087 elf_hash_table (info
)->bucketcount
= bucketcount
;
6089 s
= bfd_get_section_by_name (dynobj
, ".hash");
6090 BFD_ASSERT (s
!= NULL
);
6091 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
6092 s
->size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
6093 s
->contents
= bfd_zalloc (output_bfd
, s
->size
);
6094 if (s
->contents
== NULL
)
6097 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
6098 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
6099 s
->contents
+ hash_entry_size
);
6102 if (info
->emit_gnu_hash
)
6105 unsigned char *contents
;
6106 struct collect_gnu_hash_codes cinfo
;
6110 memset (&cinfo
, 0, sizeof (cinfo
));
6112 /* Compute the hash values for all exported symbols. At the same
6113 time store the values in an array so that we could use them for
6115 amt
= dynsymcount
* 2 * sizeof (unsigned long int);
6116 cinfo
.hashcodes
= bfd_malloc (amt
);
6117 if (cinfo
.hashcodes
== NULL
)
6120 cinfo
.hashval
= cinfo
.hashcodes
+ dynsymcount
;
6121 cinfo
.min_dynindx
= -1;
6122 cinfo
.output_bfd
= output_bfd
;
6125 /* Put all hash values in HASHCODES. */
6126 elf_link_hash_traverse (elf_hash_table (info
),
6127 elf_collect_gnu_hash_codes
, &cinfo
);
6130 = compute_bucket_count (info
, cinfo
.hashcodes
, cinfo
.nsyms
, 1);
6132 if (bucketcount
== 0)
6134 free (cinfo
.hashcodes
);
6138 s
= bfd_get_section_by_name (dynobj
, ".gnu.hash");
6139 BFD_ASSERT (s
!= NULL
);
6141 if (cinfo
.nsyms
== 0)
6143 /* Empty .gnu.hash section is special. */
6144 BFD_ASSERT (cinfo
.min_dynindx
== -1);
6145 free (cinfo
.hashcodes
);
6146 s
->size
= 5 * 4 + bed
->s
->arch_size
/ 8;
6147 contents
= bfd_zalloc (output_bfd
, s
->size
);
6148 if (contents
== NULL
)
6150 s
->contents
= contents
;
6151 /* 1 empty bucket. */
6152 bfd_put_32 (output_bfd
, 1, contents
);
6153 /* SYMIDX above the special symbol 0. */
6154 bfd_put_32 (output_bfd
, 1, contents
+ 4);
6155 /* Just one word for bitmask. */
6156 bfd_put_32 (output_bfd
, 1, contents
+ 8);
6157 /* Only hash fn bloom filter. */
6158 bfd_put_32 (output_bfd
, 0, contents
+ 12);
6159 /* No hashes are valid - empty bitmask. */
6160 bfd_put (bed
->s
->arch_size
, output_bfd
, 0, contents
+ 16);
6161 /* No hashes in the only bucket. */
6162 bfd_put_32 (output_bfd
, 0,
6163 contents
+ 16 + bed
->s
->arch_size
/ 8);
6167 unsigned long int maskwords
, maskbitslog2
;
6168 BFD_ASSERT (cinfo
.min_dynindx
!= -1);
6170 maskbitslog2
= bfd_log2 (cinfo
.nsyms
) + 1;
6171 if (maskbitslog2
< 3)
6173 else if ((1 << (maskbitslog2
- 2)) & cinfo
.nsyms
)
6174 maskbitslog2
= maskbitslog2
+ 3;
6176 maskbitslog2
= maskbitslog2
+ 2;
6177 if (bed
->s
->arch_size
== 64)
6179 if (maskbitslog2
== 5)
6185 cinfo
.mask
= (1 << cinfo
.shift1
) - 1;
6186 cinfo
.shift2
= maskbitslog2
;
6187 cinfo
.maskbits
= 1 << maskbitslog2
;
6188 maskwords
= 1 << (maskbitslog2
- cinfo
.shift1
);
6189 amt
= bucketcount
* sizeof (unsigned long int) * 2;
6190 amt
+= maskwords
* sizeof (bfd_vma
);
6191 cinfo
.bitmask
= bfd_malloc (amt
);
6192 if (cinfo
.bitmask
== NULL
)
6194 free (cinfo
.hashcodes
);
6198 cinfo
.counts
= (void *) (cinfo
.bitmask
+ maskwords
);
6199 cinfo
.indx
= cinfo
.counts
+ bucketcount
;
6200 cinfo
.symindx
= dynsymcount
- cinfo
.nsyms
;
6201 memset (cinfo
.bitmask
, 0, maskwords
* sizeof (bfd_vma
));
6203 /* Determine how often each hash bucket is used. */
6204 memset (cinfo
.counts
, 0, bucketcount
* sizeof (cinfo
.counts
[0]));
6205 for (i
= 0; i
< cinfo
.nsyms
; ++i
)
6206 ++cinfo
.counts
[cinfo
.hashcodes
[i
] % bucketcount
];
6208 for (i
= 0, cnt
= cinfo
.symindx
; i
< bucketcount
; ++i
)
6209 if (cinfo
.counts
[i
] != 0)
6211 cinfo
.indx
[i
] = cnt
;
6212 cnt
+= cinfo
.counts
[i
];
6214 BFD_ASSERT (cnt
== dynsymcount
);
6215 cinfo
.bucketcount
= bucketcount
;
6216 cinfo
.local_indx
= cinfo
.min_dynindx
;
6218 s
->size
= (4 + bucketcount
+ cinfo
.nsyms
) * 4;
6219 s
->size
+= cinfo
.maskbits
/ 8;
6220 contents
= bfd_zalloc (output_bfd
, s
->size
);
6221 if (contents
== NULL
)
6223 free (cinfo
.bitmask
);
6224 free (cinfo
.hashcodes
);
6228 s
->contents
= contents
;
6229 bfd_put_32 (output_bfd
, bucketcount
, contents
);
6230 bfd_put_32 (output_bfd
, cinfo
.symindx
, contents
+ 4);
6231 bfd_put_32 (output_bfd
, maskwords
, contents
+ 8);
6232 bfd_put_32 (output_bfd
, cinfo
.shift2
, contents
+ 12);
6233 contents
+= 16 + cinfo
.maskbits
/ 8;
6235 for (i
= 0; i
< bucketcount
; ++i
)
6237 if (cinfo
.counts
[i
] == 0)
6238 bfd_put_32 (output_bfd
, 0, contents
);
6240 bfd_put_32 (output_bfd
, cinfo
.indx
[i
], contents
);
6244 cinfo
.contents
= contents
;
6246 /* Renumber dynamic symbols, populate .gnu.hash section. */
6247 elf_link_hash_traverse (elf_hash_table (info
),
6248 elf_renumber_gnu_hash_syms
, &cinfo
);
6250 contents
= s
->contents
+ 16;
6251 for (i
= 0; i
< maskwords
; ++i
)
6253 bfd_put (bed
->s
->arch_size
, output_bfd
, cinfo
.bitmask
[i
],
6255 contents
+= bed
->s
->arch_size
/ 8;
6258 free (cinfo
.bitmask
);
6259 free (cinfo
.hashcodes
);
6263 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
6264 BFD_ASSERT (s
!= NULL
);
6266 elf_finalize_dynstr (output_bfd
, info
);
6268 s
->size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6270 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
6271 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0))
6278 /* Final phase of ELF linker. */
6280 /* A structure we use to avoid passing large numbers of arguments. */
6282 struct elf_final_link_info
6284 /* General link information. */
6285 struct bfd_link_info
*info
;
6288 /* Symbol string table. */
6289 struct bfd_strtab_hash
*symstrtab
;
6290 /* .dynsym section. */
6291 asection
*dynsym_sec
;
6292 /* .hash section. */
6294 /* symbol version section (.gnu.version). */
6295 asection
*symver_sec
;
6296 /* Buffer large enough to hold contents of any section. */
6298 /* Buffer large enough to hold external relocs of any section. */
6299 void *external_relocs
;
6300 /* Buffer large enough to hold internal relocs of any section. */
6301 Elf_Internal_Rela
*internal_relocs
;
6302 /* Buffer large enough to hold external local symbols of any input
6304 bfd_byte
*external_syms
;
6305 /* And a buffer for symbol section indices. */
6306 Elf_External_Sym_Shndx
*locsym_shndx
;
6307 /* Buffer large enough to hold internal local symbols of any input
6309 Elf_Internal_Sym
*internal_syms
;
6310 /* Array large enough to hold a symbol index for each local symbol
6311 of any input BFD. */
6313 /* Array large enough to hold a section pointer for each local
6314 symbol of any input BFD. */
6315 asection
**sections
;
6316 /* Buffer to hold swapped out symbols. */
6318 /* And one for symbol section indices. */
6319 Elf_External_Sym_Shndx
*symshndxbuf
;
6320 /* Number of swapped out symbols in buffer. */
6321 size_t symbuf_count
;
6322 /* Number of symbols which fit in symbuf. */
6324 /* And same for symshndxbuf. */
6325 size_t shndxbuf_size
;
6328 /* This struct is used to pass information to elf_link_output_extsym. */
6330 struct elf_outext_info
6333 bfd_boolean localsyms
;
6334 struct elf_final_link_info
*finfo
;
6337 /* When performing a relocatable link, the input relocations are
6338 preserved. But, if they reference global symbols, the indices
6339 referenced must be updated. Update all the relocations in
6340 REL_HDR (there are COUNT of them), using the data in REL_HASH. */
6343 elf_link_adjust_relocs (bfd
*abfd
,
6344 Elf_Internal_Shdr
*rel_hdr
,
6346 struct elf_link_hash_entry
**rel_hash
)
6349 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6351 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
6352 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
6353 bfd_vma r_type_mask
;
6356 if (rel_hdr
->sh_entsize
== bed
->s
->sizeof_rel
)
6358 swap_in
= bed
->s
->swap_reloc_in
;
6359 swap_out
= bed
->s
->swap_reloc_out
;
6361 else if (rel_hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
6363 swap_in
= bed
->s
->swap_reloca_in
;
6364 swap_out
= bed
->s
->swap_reloca_out
;
6369 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
6372 if (bed
->s
->arch_size
== 32)
6379 r_type_mask
= 0xffffffff;
6383 erela
= rel_hdr
->contents
;
6384 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= rel_hdr
->sh_entsize
)
6386 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
6389 if (*rel_hash
== NULL
)
6392 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
6394 (*swap_in
) (abfd
, erela
, irela
);
6395 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
6396 irela
[j
].r_info
= ((bfd_vma
) (*rel_hash
)->indx
<< r_sym_shift
6397 | (irela
[j
].r_info
& r_type_mask
));
6398 (*swap_out
) (abfd
, irela
, erela
);
6402 struct elf_link_sort_rela
6408 enum elf_reloc_type_class type
;
6409 /* We use this as an array of size int_rels_per_ext_rel. */
6410 Elf_Internal_Rela rela
[1];
6414 elf_link_sort_cmp1 (const void *A
, const void *B
)
6416 const struct elf_link_sort_rela
*a
= A
;
6417 const struct elf_link_sort_rela
*b
= B
;
6418 int relativea
, relativeb
;
6420 relativea
= a
->type
== reloc_class_relative
;
6421 relativeb
= b
->type
== reloc_class_relative
;
6423 if (relativea
< relativeb
)
6425 if (relativea
> relativeb
)
6427 if ((a
->rela
->r_info
& a
->u
.sym_mask
) < (b
->rela
->r_info
& b
->u
.sym_mask
))
6429 if ((a
->rela
->r_info
& a
->u
.sym_mask
) > (b
->rela
->r_info
& b
->u
.sym_mask
))
6431 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
6433 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
6439 elf_link_sort_cmp2 (const void *A
, const void *B
)
6441 const struct elf_link_sort_rela
*a
= A
;
6442 const struct elf_link_sort_rela
*b
= B
;
6445 if (a
->u
.offset
< b
->u
.offset
)
6447 if (a
->u
.offset
> b
->u
.offset
)
6449 copya
= (a
->type
== reloc_class_copy
) * 2 + (a
->type
== reloc_class_plt
);
6450 copyb
= (b
->type
== reloc_class_copy
) * 2 + (b
->type
== reloc_class_plt
);
6455 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
6457 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
6463 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
6466 bfd_size_type count
, size
;
6467 size_t i
, ret
, sort_elt
, ext_size
;
6468 bfd_byte
*sort
, *s_non_relative
, *p
;
6469 struct elf_link_sort_rela
*sq
;
6470 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6471 int i2e
= bed
->s
->int_rels_per_ext_rel
;
6472 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
6473 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
6474 struct bfd_link_order
*lo
;
6477 reldyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
6478 if (reldyn
== NULL
|| reldyn
->size
== 0)
6480 reldyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
6481 if (reldyn
== NULL
|| reldyn
->size
== 0)
6483 ext_size
= bed
->s
->sizeof_rel
;
6484 swap_in
= bed
->s
->swap_reloc_in
;
6485 swap_out
= bed
->s
->swap_reloc_out
;
6489 ext_size
= bed
->s
->sizeof_rela
;
6490 swap_in
= bed
->s
->swap_reloca_in
;
6491 swap_out
= bed
->s
->swap_reloca_out
;
6493 count
= reldyn
->size
/ ext_size
;
6496 for (lo
= reldyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
6497 if (lo
->type
== bfd_indirect_link_order
)
6499 asection
*o
= lo
->u
.indirect
.section
;
6503 if (size
!= reldyn
->size
)
6506 sort_elt
= (sizeof (struct elf_link_sort_rela
)
6507 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
6508 sort
= bfd_zmalloc (sort_elt
* count
);
6511 (*info
->callbacks
->warning
)
6512 (info
, _("Not enough memory to sort relocations"), 0, abfd
, 0, 0);
6516 if (bed
->s
->arch_size
== 32)
6517 r_sym_mask
= ~(bfd_vma
) 0xff;
6519 r_sym_mask
= ~(bfd_vma
) 0xffffffff;
6521 for (lo
= reldyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
6522 if (lo
->type
== bfd_indirect_link_order
)
6524 bfd_byte
*erel
, *erelend
;
6525 asection
*o
= lo
->u
.indirect
.section
;
6527 if (o
->contents
== NULL
&& o
->size
!= 0)
6529 /* This is a reloc section that is being handled as a normal
6530 section. See bfd_section_from_shdr. We can't combine
6531 relocs in this case. */
6536 erelend
= o
->contents
+ o
->size
;
6537 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
6538 while (erel
< erelend
)
6540 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
6541 (*swap_in
) (abfd
, erel
, s
->rela
);
6542 s
->type
= (*bed
->elf_backend_reloc_type_class
) (s
->rela
);
6543 s
->u
.sym_mask
= r_sym_mask
;
6549 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
6551 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
6553 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
6554 if (s
->type
!= reloc_class_relative
)
6560 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
6561 for (; i
< count
; i
++, p
+= sort_elt
)
6563 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
6564 if (((sp
->rela
->r_info
^ sq
->rela
->r_info
) & r_sym_mask
) != 0)
6566 sp
->u
.offset
= sq
->rela
->r_offset
;
6569 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
6571 for (lo
= reldyn
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
6572 if (lo
->type
== bfd_indirect_link_order
)
6574 bfd_byte
*erel
, *erelend
;
6575 asection
*o
= lo
->u
.indirect
.section
;
6578 erelend
= o
->contents
+ o
->size
;
6579 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
6580 while (erel
< erelend
)
6582 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
6583 (*swap_out
) (abfd
, s
->rela
, erel
);
6594 /* Flush the output symbols to the file. */
6597 elf_link_flush_output_syms (struct elf_final_link_info
*finfo
,
6598 const struct elf_backend_data
*bed
)
6600 if (finfo
->symbuf_count
> 0)
6602 Elf_Internal_Shdr
*hdr
;
6606 hdr
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
6607 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
6608 amt
= finfo
->symbuf_count
* bed
->s
->sizeof_sym
;
6609 if (bfd_seek (finfo
->output_bfd
, pos
, SEEK_SET
) != 0
6610 || bfd_bwrite (finfo
->symbuf
, amt
, finfo
->output_bfd
) != amt
)
6613 hdr
->sh_size
+= amt
;
6614 finfo
->symbuf_count
= 0;
6620 /* Add a symbol to the output symbol table. */
6623 elf_link_output_sym (struct elf_final_link_info
*finfo
,
6625 Elf_Internal_Sym
*elfsym
,
6626 asection
*input_sec
,
6627 struct elf_link_hash_entry
*h
)
6630 Elf_External_Sym_Shndx
*destshndx
;
6631 bfd_boolean (*output_symbol_hook
)
6632 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*, asection
*,
6633 struct elf_link_hash_entry
*);
6634 const struct elf_backend_data
*bed
;
6636 bed
= get_elf_backend_data (finfo
->output_bfd
);
6637 output_symbol_hook
= bed
->elf_backend_link_output_symbol_hook
;
6638 if (output_symbol_hook
!= NULL
)
6640 if (! (*output_symbol_hook
) (finfo
->info
, name
, elfsym
, input_sec
, h
))
6644 if (name
== NULL
|| *name
== '\0')
6645 elfsym
->st_name
= 0;
6646 else if (input_sec
->flags
& SEC_EXCLUDE
)
6647 elfsym
->st_name
= 0;
6650 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
6652 if (elfsym
->st_name
== (unsigned long) -1)
6656 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
6658 if (! elf_link_flush_output_syms (finfo
, bed
))
6662 dest
= finfo
->symbuf
+ finfo
->symbuf_count
* bed
->s
->sizeof_sym
;
6663 destshndx
= finfo
->symshndxbuf
;
6664 if (destshndx
!= NULL
)
6666 if (bfd_get_symcount (finfo
->output_bfd
) >= finfo
->shndxbuf_size
)
6670 amt
= finfo
->shndxbuf_size
* sizeof (Elf_External_Sym_Shndx
);
6671 finfo
->symshndxbuf
= destshndx
= bfd_realloc (destshndx
, amt
* 2);
6672 if (destshndx
== NULL
)
6674 memset ((char *) destshndx
+ amt
, 0, amt
);
6675 finfo
->shndxbuf_size
*= 2;
6677 destshndx
+= bfd_get_symcount (finfo
->output_bfd
);
6680 bed
->s
->swap_symbol_out (finfo
->output_bfd
, elfsym
, dest
, destshndx
);
6681 finfo
->symbuf_count
+= 1;
6682 bfd_get_symcount (finfo
->output_bfd
) += 1;
6687 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
6690 check_dynsym (bfd
*abfd
, Elf_Internal_Sym
*sym
)
6692 if (sym
->st_shndx
> SHN_HIRESERVE
)
6694 /* The gABI doesn't support dynamic symbols in output sections
6696 (*_bfd_error_handler
)
6697 (_("%B: Too many sections: %d (>= %d)"),
6698 abfd
, bfd_count_sections (abfd
), SHN_LORESERVE
);
6699 bfd_set_error (bfd_error_nonrepresentable_section
);
6705 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
6706 allowing an unsatisfied unversioned symbol in the DSO to match a
6707 versioned symbol that would normally require an explicit version.
6708 We also handle the case that a DSO references a hidden symbol
6709 which may be satisfied by a versioned symbol in another DSO. */
6712 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
6713 const struct elf_backend_data
*bed
,
6714 struct elf_link_hash_entry
*h
)
6717 struct elf_link_loaded_list
*loaded
;
6719 if (!is_elf_hash_table (info
->hash
))
6722 switch (h
->root
.type
)
6728 case bfd_link_hash_undefined
:
6729 case bfd_link_hash_undefweak
:
6730 abfd
= h
->root
.u
.undef
.abfd
;
6731 if ((abfd
->flags
& DYNAMIC
) == 0
6732 || (elf_dyn_lib_class (abfd
) & DYN_DT_NEEDED
) == 0)
6736 case bfd_link_hash_defined
:
6737 case bfd_link_hash_defweak
:
6738 abfd
= h
->root
.u
.def
.section
->owner
;
6741 case bfd_link_hash_common
:
6742 abfd
= h
->root
.u
.c
.p
->section
->owner
;
6745 BFD_ASSERT (abfd
!= NULL
);
6747 for (loaded
= elf_hash_table (info
)->loaded
;
6749 loaded
= loaded
->next
)
6752 Elf_Internal_Shdr
*hdr
;
6753 bfd_size_type symcount
;
6754 bfd_size_type extsymcount
;
6755 bfd_size_type extsymoff
;
6756 Elf_Internal_Shdr
*versymhdr
;
6757 Elf_Internal_Sym
*isym
;
6758 Elf_Internal_Sym
*isymend
;
6759 Elf_Internal_Sym
*isymbuf
;
6760 Elf_External_Versym
*ever
;
6761 Elf_External_Versym
*extversym
;
6763 input
= loaded
->abfd
;
6765 /* We check each DSO for a possible hidden versioned definition. */
6767 || (input
->flags
& DYNAMIC
) == 0
6768 || elf_dynversym (input
) == 0)
6771 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
6773 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
6774 if (elf_bad_symtab (input
))
6776 extsymcount
= symcount
;
6781 extsymcount
= symcount
- hdr
->sh_info
;
6782 extsymoff
= hdr
->sh_info
;
6785 if (extsymcount
== 0)
6788 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
6790 if (isymbuf
== NULL
)
6793 /* Read in any version definitions. */
6794 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
6795 extversym
= bfd_malloc (versymhdr
->sh_size
);
6796 if (extversym
== NULL
)
6799 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
6800 || (bfd_bread (extversym
, versymhdr
->sh_size
, input
)
6801 != versymhdr
->sh_size
))
6809 ever
= extversym
+ extsymoff
;
6810 isymend
= isymbuf
+ extsymcount
;
6811 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
6814 Elf_Internal_Versym iver
;
6815 unsigned short version_index
;
6817 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
6818 || isym
->st_shndx
== SHN_UNDEF
)
6821 name
= bfd_elf_string_from_elf_section (input
,
6824 if (strcmp (name
, h
->root
.root
.string
) != 0)
6827 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
6829 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
6831 /* If we have a non-hidden versioned sym, then it should
6832 have provided a definition for the undefined sym. */
6836 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
6837 if (version_index
== 1 || version_index
== 2)
6839 /* This is the base or first version. We can use it. */
6853 /* Add an external symbol to the symbol table. This is called from
6854 the hash table traversal routine. When generating a shared object,
6855 we go through the symbol table twice. The first time we output
6856 anything that might have been forced to local scope in a version
6857 script. The second time we output the symbols that are still
6861 elf_link_output_extsym (struct elf_link_hash_entry
*h
, void *data
)
6863 struct elf_outext_info
*eoinfo
= data
;
6864 struct elf_final_link_info
*finfo
= eoinfo
->finfo
;
6866 Elf_Internal_Sym sym
;
6867 asection
*input_sec
;
6868 const struct elf_backend_data
*bed
;
6870 if (h
->root
.type
== bfd_link_hash_warning
)
6872 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6873 if (h
->root
.type
== bfd_link_hash_new
)
6877 /* Decide whether to output this symbol in this pass. */
6878 if (eoinfo
->localsyms
)
6880 if (!h
->forced_local
)
6885 if (h
->forced_local
)
6889 bed
= get_elf_backend_data (finfo
->output_bfd
);
6891 if (h
->root
.type
== bfd_link_hash_undefined
)
6893 /* If we have an undefined symbol reference here then it must have
6894 come from a shared library that is being linked in. (Undefined
6895 references in regular files have already been handled). */
6896 bfd_boolean ignore_undef
= FALSE
;
6898 /* Some symbols may be special in that the fact that they're
6899 undefined can be safely ignored - let backend determine that. */
6900 if (bed
->elf_backend_ignore_undef_symbol
)
6901 ignore_undef
= bed
->elf_backend_ignore_undef_symbol (h
);
6903 /* If we are reporting errors for this situation then do so now. */
6904 if (ignore_undef
== FALSE
6907 && ! elf_link_check_versioned_symbol (finfo
->info
, bed
, h
)
6908 && finfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
6910 if (! (finfo
->info
->callbacks
->undefined_symbol
6911 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
6912 NULL
, 0, finfo
->info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
)))
6914 eoinfo
->failed
= TRUE
;
6920 /* We should also warn if a forced local symbol is referenced from
6921 shared libraries. */
6922 if (! finfo
->info
->relocatable
6923 && (! finfo
->info
->shared
)
6928 && ! elf_link_check_versioned_symbol (finfo
->info
, bed
, h
))
6930 (*_bfd_error_handler
)
6931 (_("%B: %s symbol `%s' in %B is referenced by DSO"),
6933 h
->root
.u
.def
.section
== bfd_abs_section_ptr
6934 ? finfo
->output_bfd
: h
->root
.u
.def
.section
->owner
,
6935 ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
6937 : ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
6938 ? "hidden" : "local",
6939 h
->root
.root
.string
);
6940 eoinfo
->failed
= TRUE
;
6944 /* We don't want to output symbols that have never been mentioned by
6945 a regular file, or that we have been told to strip. However, if
6946 h->indx is set to -2, the symbol is used by a reloc and we must
6950 else if ((h
->def_dynamic
6952 || h
->root
.type
== bfd_link_hash_new
)
6956 else if (finfo
->info
->strip
== strip_all
)
6958 else if (finfo
->info
->strip
== strip_some
6959 && bfd_hash_lookup (finfo
->info
->keep_hash
,
6960 h
->root
.root
.string
, FALSE
, FALSE
) == NULL
)
6962 else if (finfo
->info
->strip_discarded
6963 && (h
->root
.type
== bfd_link_hash_defined
6964 || h
->root
.type
== bfd_link_hash_defweak
)
6965 && elf_discarded_section (h
->root
.u
.def
.section
))
6970 /* If we're stripping it, and it's not a dynamic symbol, there's
6971 nothing else to do unless it is a forced local symbol. */
6974 && !h
->forced_local
)
6978 sym
.st_size
= h
->size
;
6979 sym
.st_other
= h
->other
;
6980 if (h
->forced_local
)
6981 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
6982 else if (h
->root
.type
== bfd_link_hash_undefweak
6983 || h
->root
.type
== bfd_link_hash_defweak
)
6984 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
6986 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
6988 switch (h
->root
.type
)
6991 case bfd_link_hash_new
:
6992 case bfd_link_hash_warning
:
6996 case bfd_link_hash_undefined
:
6997 case bfd_link_hash_undefweak
:
6998 input_sec
= bfd_und_section_ptr
;
6999 sym
.st_shndx
= SHN_UNDEF
;
7002 case bfd_link_hash_defined
:
7003 case bfd_link_hash_defweak
:
7005 input_sec
= h
->root
.u
.def
.section
;
7006 if (input_sec
->output_section
!= NULL
)
7009 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
7010 input_sec
->output_section
);
7011 if (sym
.st_shndx
== SHN_BAD
)
7013 (*_bfd_error_handler
)
7014 (_("%B: could not find output section %A for input section %A"),
7015 finfo
->output_bfd
, input_sec
->output_section
, input_sec
);
7016 eoinfo
->failed
= TRUE
;
7020 /* ELF symbols in relocatable files are section relative,
7021 but in nonrelocatable files they are virtual
7023 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
7024 if (! finfo
->info
->relocatable
)
7026 sym
.st_value
+= input_sec
->output_section
->vma
;
7027 if (h
->type
== STT_TLS
)
7029 /* STT_TLS symbols are relative to PT_TLS segment
7031 BFD_ASSERT (elf_hash_table (finfo
->info
)->tls_sec
!= NULL
);
7032 sym
.st_value
-= elf_hash_table (finfo
->info
)->tls_sec
->vma
;
7038 BFD_ASSERT (input_sec
->owner
== NULL
7039 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
7040 sym
.st_shndx
= SHN_UNDEF
;
7041 input_sec
= bfd_und_section_ptr
;
7046 case bfd_link_hash_common
:
7047 input_sec
= h
->root
.u
.c
.p
->section
;
7048 sym
.st_shndx
= bed
->common_section_index (input_sec
);
7049 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
7052 case bfd_link_hash_indirect
:
7053 /* These symbols are created by symbol versioning. They point
7054 to the decorated version of the name. For example, if the
7055 symbol foo@@GNU_1.2 is the default, which should be used when
7056 foo is used with no version, then we add an indirect symbol
7057 foo which points to foo@@GNU_1.2. We ignore these symbols,
7058 since the indirected symbol is already in the hash table. */
7062 /* Give the processor backend a chance to tweak the symbol value,
7063 and also to finish up anything that needs to be done for this
7064 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
7065 forced local syms when non-shared is due to a historical quirk. */
7066 if ((h
->dynindx
!= -1
7068 && ((finfo
->info
->shared
7069 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
7070 || h
->root
.type
!= bfd_link_hash_undefweak
))
7071 || !h
->forced_local
)
7072 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
7074 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
7075 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
7077 eoinfo
->failed
= TRUE
;
7082 /* If we are marking the symbol as undefined, and there are no
7083 non-weak references to this symbol from a regular object, then
7084 mark the symbol as weak undefined; if there are non-weak
7085 references, mark the symbol as strong. We can't do this earlier,
7086 because it might not be marked as undefined until the
7087 finish_dynamic_symbol routine gets through with it. */
7088 if (sym
.st_shndx
== SHN_UNDEF
7090 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
7091 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
7095 if (h
->ref_regular_nonweak
)
7096 bindtype
= STB_GLOBAL
;
7098 bindtype
= STB_WEAK
;
7099 sym
.st_info
= ELF_ST_INFO (bindtype
, ELF_ST_TYPE (sym
.st_info
));
7102 /* If a non-weak symbol with non-default visibility is not defined
7103 locally, it is a fatal error. */
7104 if (! finfo
->info
->relocatable
7105 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
7106 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
7107 && h
->root
.type
== bfd_link_hash_undefined
7110 (*_bfd_error_handler
)
7111 (_("%B: %s symbol `%s' isn't defined"),
7113 ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
7115 : ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
7116 ? "internal" : "hidden",
7117 h
->root
.root
.string
);
7118 eoinfo
->failed
= TRUE
;
7122 /* If this symbol should be put in the .dynsym section, then put it
7123 there now. We already know the symbol index. We also fill in
7124 the entry in the .hash section. */
7125 if (h
->dynindx
!= -1
7126 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
7130 sym
.st_name
= h
->dynstr_index
;
7131 esym
= finfo
->dynsym_sec
->contents
+ h
->dynindx
* bed
->s
->sizeof_sym
;
7132 if (! check_dynsym (finfo
->output_bfd
, &sym
))
7134 eoinfo
->failed
= TRUE
;
7137 bed
->s
->swap_symbol_out (finfo
->output_bfd
, &sym
, esym
, 0);
7139 if (finfo
->hash_sec
!= NULL
)
7141 size_t hash_entry_size
;
7142 bfd_byte
*bucketpos
;
7147 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
7148 bucket
= h
->u
.elf_hash_value
% bucketcount
;
7151 = elf_section_data (finfo
->hash_sec
)->this_hdr
.sh_entsize
;
7152 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
7153 + (bucket
+ 2) * hash_entry_size
);
7154 chain
= bfd_get (8 * hash_entry_size
, finfo
->output_bfd
, bucketpos
);
7155 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, h
->dynindx
, bucketpos
);
7156 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, chain
,
7157 ((bfd_byte
*) finfo
->hash_sec
->contents
7158 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
7161 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
7163 Elf_Internal_Versym iversym
;
7164 Elf_External_Versym
*eversym
;
7166 if (!h
->def_regular
)
7168 if (h
->verinfo
.verdef
== NULL
)
7169 iversym
.vs_vers
= 0;
7171 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
7175 if (h
->verinfo
.vertree
== NULL
)
7176 iversym
.vs_vers
= 1;
7178 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
7179 if (finfo
->info
->create_default_symver
)
7184 iversym
.vs_vers
|= VERSYM_HIDDEN
;
7186 eversym
= (Elf_External_Versym
*) finfo
->symver_sec
->contents
;
7187 eversym
+= h
->dynindx
;
7188 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
, eversym
);
7192 /* If we're stripping it, then it was just a dynamic symbol, and
7193 there's nothing else to do. */
7194 if (strip
|| (input_sec
->flags
& SEC_EXCLUDE
) != 0)
7197 h
->indx
= bfd_get_symcount (finfo
->output_bfd
);
7199 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
, h
))
7201 eoinfo
->failed
= TRUE
;
7208 /* Return TRUE if special handling is done for relocs in SEC against
7209 symbols defined in discarded sections. */
7212 elf_section_ignore_discarded_relocs (asection
*sec
)
7214 const struct elf_backend_data
*bed
;
7216 switch (sec
->sec_info_type
)
7218 case ELF_INFO_TYPE_STABS
:
7219 case ELF_INFO_TYPE_EH_FRAME
:
7225 bed
= get_elf_backend_data (sec
->owner
);
7226 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
7227 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))
7233 /* Return a mask saying how ld should treat relocations in SEC against
7234 symbols defined in discarded sections. If this function returns
7235 COMPLAIN set, ld will issue a warning message. If this function
7236 returns PRETEND set, and the discarded section was link-once and the
7237 same size as the kept link-once section, ld will pretend that the
7238 symbol was actually defined in the kept section. Otherwise ld will
7239 zero the reloc (at least that is the intent, but some cooperation by
7240 the target dependent code is needed, particularly for REL targets). */
7243 _bfd_elf_default_action_discarded (asection
*sec
)
7245 if (sec
->flags
& SEC_DEBUGGING
)
7248 if (strcmp (".eh_frame", sec
->name
) == 0)
7251 if (strcmp (".gcc_except_table", sec
->name
) == 0)
7254 return COMPLAIN
| PRETEND
;
7257 /* Find a match between a section and a member of a section group. */
7260 match_group_member (asection
*sec
, asection
*group
,
7261 struct bfd_link_info
*info
)
7263 asection
*first
= elf_next_in_group (group
);
7264 asection
*s
= first
;
7268 if (bfd_elf_match_symbols_in_sections (s
, sec
, info
))
7271 s
= elf_next_in_group (s
);
7279 /* Check if the kept section of a discarded section SEC can be used
7280 to replace it. Return the replacement if it is OK. Otherwise return
7284 _bfd_elf_check_kept_section (asection
*sec
, struct bfd_link_info
*info
)
7288 kept
= sec
->kept_section
;
7291 if ((kept
->flags
& SEC_GROUP
) != 0)
7292 kept
= match_group_member (sec
, kept
, info
);
7293 if (kept
!= NULL
&& sec
->size
!= kept
->size
)
7295 sec
->kept_section
= kept
;
7300 /* Link an input file into the linker output file. This function
7301 handles all the sections and relocations of the input file at once.
7302 This is so that we only have to read the local symbols once, and
7303 don't have to keep them in memory. */
7306 elf_link_input_bfd (struct elf_final_link_info
*finfo
, bfd
*input_bfd
)
7308 bfd_boolean (*relocate_section
)
7309 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
7310 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
7312 Elf_Internal_Shdr
*symtab_hdr
;
7315 Elf_Internal_Sym
*isymbuf
;
7316 Elf_Internal_Sym
*isym
;
7317 Elf_Internal_Sym
*isymend
;
7319 asection
**ppsection
;
7321 const struct elf_backend_data
*bed
;
7322 bfd_boolean emit_relocs
;
7323 struct elf_link_hash_entry
**sym_hashes
;
7325 output_bfd
= finfo
->output_bfd
;
7326 bed
= get_elf_backend_data (output_bfd
);
7327 relocate_section
= bed
->elf_backend_relocate_section
;
7329 /* If this is a dynamic object, we don't want to do anything here:
7330 we don't want the local symbols, and we don't want the section
7332 if ((input_bfd
->flags
& DYNAMIC
) != 0)
7335 emit_relocs
= (finfo
->info
->relocatable
7336 || finfo
->info
->emitrelocations
);
7338 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
7339 if (elf_bad_symtab (input_bfd
))
7341 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
7346 locsymcount
= symtab_hdr
->sh_info
;
7347 extsymoff
= symtab_hdr
->sh_info
;
7350 /* Read the local symbols. */
7351 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
7352 if (isymbuf
== NULL
&& locsymcount
!= 0)
7354 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
7355 finfo
->internal_syms
,
7356 finfo
->external_syms
,
7357 finfo
->locsym_shndx
);
7358 if (isymbuf
== NULL
)
7362 /* Find local symbol sections and adjust values of symbols in
7363 SEC_MERGE sections. Write out those local symbols we know are
7364 going into the output file. */
7365 isymend
= isymbuf
+ locsymcount
;
7366 for (isym
= isymbuf
, pindex
= finfo
->indices
, ppsection
= finfo
->sections
;
7368 isym
++, pindex
++, ppsection
++)
7372 Elf_Internal_Sym osym
;
7376 if (elf_bad_symtab (input_bfd
))
7378 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
7385 if (isym
->st_shndx
== SHN_UNDEF
)
7386 isec
= bfd_und_section_ptr
;
7387 else if (isym
->st_shndx
< SHN_LORESERVE
7388 || isym
->st_shndx
> SHN_HIRESERVE
)
7390 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
7392 && isec
->sec_info_type
== ELF_INFO_TYPE_MERGE
7393 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
7395 _bfd_merged_section_offset (output_bfd
, &isec
,
7396 elf_section_data (isec
)->sec_info
,
7399 else if (isym
->st_shndx
== SHN_ABS
)
7400 isec
= bfd_abs_section_ptr
;
7401 else if (isym
->st_shndx
== SHN_COMMON
)
7402 isec
= bfd_com_section_ptr
;
7405 /* Don't attempt to output symbols with st_shnx in the
7406 reserved range other than SHN_ABS and SHN_COMMON. */
7413 /* Don't output the first, undefined, symbol. */
7414 if (ppsection
== finfo
->sections
)
7417 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
7419 /* We never output section symbols. Instead, we use the
7420 section symbol of the corresponding section in the output
7425 /* If we are stripping all symbols, we don't want to output this
7427 if (finfo
->info
->strip
== strip_all
)
7430 /* If we are discarding all local symbols, we don't want to
7431 output this one. If we are generating a relocatable output
7432 file, then some of the local symbols may be required by
7433 relocs; we output them below as we discover that they are
7435 if (finfo
->info
->discard
== discard_all
)
7438 /* If this symbol is defined in a section which we are
7439 discarding, we don't need to keep it. */
7440 if (isym
->st_shndx
!= SHN_UNDEF
7441 && (isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
7443 || bfd_section_removed_from_list (output_bfd
,
7444 isec
->output_section
)))
7447 /* Get the name of the symbol. */
7448 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
7453 /* See if we are discarding symbols with this name. */
7454 if ((finfo
->info
->strip
== strip_some
7455 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
7457 || (((finfo
->info
->discard
== discard_sec_merge
7458 && (isec
->flags
& SEC_MERGE
) && ! finfo
->info
->relocatable
)
7459 || finfo
->info
->discard
== discard_l
)
7460 && bfd_is_local_label_name (input_bfd
, name
)))
7463 /* If we get here, we are going to output this symbol. */
7467 /* Adjust the section index for the output file. */
7468 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
7469 isec
->output_section
);
7470 if (osym
.st_shndx
== SHN_BAD
)
7473 *pindex
= bfd_get_symcount (output_bfd
);
7475 /* ELF symbols in relocatable files are section relative, but
7476 in executable files they are virtual addresses. Note that
7477 this code assumes that all ELF sections have an associated
7478 BFD section with a reasonable value for output_offset; below
7479 we assume that they also have a reasonable value for
7480 output_section. Any special sections must be set up to meet
7481 these requirements. */
7482 osym
.st_value
+= isec
->output_offset
;
7483 if (! finfo
->info
->relocatable
)
7485 osym
.st_value
+= isec
->output_section
->vma
;
7486 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
7488 /* STT_TLS symbols are relative to PT_TLS segment base. */
7489 BFD_ASSERT (elf_hash_table (finfo
->info
)->tls_sec
!= NULL
);
7490 osym
.st_value
-= elf_hash_table (finfo
->info
)->tls_sec
->vma
;
7494 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
, NULL
))
7498 /* Relocate the contents of each section. */
7499 sym_hashes
= elf_sym_hashes (input_bfd
);
7500 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7504 if (! o
->linker_mark
)
7506 /* This section was omitted from the link. */
7510 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
7511 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
7514 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
7516 /* Section was created by _bfd_elf_link_create_dynamic_sections
7521 /* Get the contents of the section. They have been cached by a
7522 relaxation routine. Note that o is a section in an input
7523 file, so the contents field will not have been set by any of
7524 the routines which work on output files. */
7525 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
7526 contents
= elf_section_data (o
)->this_hdr
.contents
;
7529 bfd_size_type amt
= o
->rawsize
? o
->rawsize
: o
->size
;
7531 contents
= finfo
->contents
;
7532 if (! bfd_get_section_contents (input_bfd
, o
, contents
, 0, amt
))
7536 if ((o
->flags
& SEC_RELOC
) != 0)
7538 Elf_Internal_Rela
*internal_relocs
;
7539 bfd_vma r_type_mask
;
7542 /* Get the swapped relocs. */
7544 = _bfd_elf_link_read_relocs (input_bfd
, o
, finfo
->external_relocs
,
7545 finfo
->internal_relocs
, FALSE
);
7546 if (internal_relocs
== NULL
7547 && o
->reloc_count
> 0)
7550 if (bed
->s
->arch_size
== 32)
7557 r_type_mask
= 0xffffffff;
7561 /* Run through the relocs looking for any against symbols
7562 from discarded sections and section symbols from
7563 removed link-once sections. Complain about relocs
7564 against discarded sections. Zero relocs against removed
7565 link-once sections. */
7566 if (!elf_section_ignore_discarded_relocs (o
))
7568 Elf_Internal_Rela
*rel
, *relend
;
7569 unsigned int action
= (*bed
->action_discarded
) (o
);
7571 rel
= internal_relocs
;
7572 relend
= rel
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7573 for ( ; rel
< relend
; rel
++)
7575 unsigned long r_symndx
= rel
->r_info
>> r_sym_shift
;
7576 asection
**ps
, *sec
;
7577 struct elf_link_hash_entry
*h
= NULL
;
7578 const char *sym_name
;
7580 if (r_symndx
== STN_UNDEF
)
7583 if (r_symndx
>= locsymcount
7584 || (elf_bad_symtab (input_bfd
)
7585 && finfo
->sections
[r_symndx
] == NULL
))
7587 h
= sym_hashes
[r_symndx
- extsymoff
];
7589 /* Badly formatted input files can contain relocs that
7590 reference non-existant symbols. Check here so that
7591 we do not seg fault. */
7596 sprintf_vma (buffer
, rel
->r_info
);
7597 (*_bfd_error_handler
)
7598 (_("error: %B contains a reloc (0x%s) for section %A "
7599 "that references a non-existent global symbol"),
7600 input_bfd
, o
, buffer
);
7601 bfd_set_error (bfd_error_bad_value
);
7605 while (h
->root
.type
== bfd_link_hash_indirect
7606 || h
->root
.type
== bfd_link_hash_warning
)
7607 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7609 if (h
->root
.type
!= bfd_link_hash_defined
7610 && h
->root
.type
!= bfd_link_hash_defweak
)
7613 ps
= &h
->root
.u
.def
.section
;
7614 sym_name
= h
->root
.root
.string
;
7618 Elf_Internal_Sym
*sym
= isymbuf
+ r_symndx
;
7619 ps
= &finfo
->sections
[r_symndx
];
7620 sym_name
= bfd_elf_sym_name (input_bfd
,
7625 /* Complain if the definition comes from a
7626 discarded section. */
7627 if ((sec
= *ps
) != NULL
&& elf_discarded_section (sec
))
7629 BFD_ASSERT (r_symndx
!= 0);
7630 if (action
& COMPLAIN
)
7631 (*finfo
->info
->callbacks
->einfo
)
7632 (_("%X`%s' referenced in section `%A' of %B: "
7633 "defined in discarded section `%A' of %B\n"),
7634 sym_name
, o
, input_bfd
, sec
, sec
->owner
);
7636 /* Try to do the best we can to support buggy old
7637 versions of gcc. Pretend that the symbol is
7638 really defined in the kept linkonce section.
7639 FIXME: This is quite broken. Modifying the
7640 symbol here means we will be changing all later
7641 uses of the symbol, not just in this section. */
7642 if (action
& PRETEND
)
7646 kept
= _bfd_elf_check_kept_section (sec
,
7655 /* Remove the symbol reference from the reloc, but
7656 don't kill the reloc completely. This is so that
7657 a zero value will be written into the section,
7658 which may have non-zero contents put there by the
7659 assembler. Zero in things like an eh_frame fde
7660 pc_begin allows stack unwinders to recognize the
7662 rel
->r_info
&= r_type_mask
;
7668 /* Relocate the section by invoking a back end routine.
7670 The back end routine is responsible for adjusting the
7671 section contents as necessary, and (if using Rela relocs
7672 and generating a relocatable output file) adjusting the
7673 reloc addend as necessary.
7675 The back end routine does not have to worry about setting
7676 the reloc address or the reloc symbol index.
7678 The back end routine is given a pointer to the swapped in
7679 internal symbols, and can access the hash table entries
7680 for the external symbols via elf_sym_hashes (input_bfd).
7682 When generating relocatable output, the back end routine
7683 must handle STB_LOCAL/STT_SECTION symbols specially. The
7684 output symbol is going to be a section symbol
7685 corresponding to the output section, which will require
7686 the addend to be adjusted. */
7688 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
7689 input_bfd
, o
, contents
,
7697 Elf_Internal_Rela
*irela
;
7698 Elf_Internal_Rela
*irelaend
;
7699 bfd_vma last_offset
;
7700 struct elf_link_hash_entry
**rel_hash
;
7701 struct elf_link_hash_entry
**rel_hash_list
;
7702 Elf_Internal_Shdr
*input_rel_hdr
, *input_rel_hdr2
;
7703 unsigned int next_erel
;
7704 bfd_boolean rela_normal
;
7706 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
7707 rela_normal
= (bed
->rela_normal
7708 && (input_rel_hdr
->sh_entsize
7709 == bed
->s
->sizeof_rela
));
7711 /* Adjust the reloc addresses and symbol indices. */
7713 irela
= internal_relocs
;
7714 irelaend
= irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7715 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
7716 + elf_section_data (o
->output_section
)->rel_count
7717 + elf_section_data (o
->output_section
)->rel_count2
);
7718 rel_hash_list
= rel_hash
;
7719 last_offset
= o
->output_offset
;
7720 if (!finfo
->info
->relocatable
)
7721 last_offset
+= o
->output_section
->vma
;
7722 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
7724 unsigned long r_symndx
;
7726 Elf_Internal_Sym sym
;
7728 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
7734 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
7737 if (irela
->r_offset
>= (bfd_vma
) -2)
7739 /* This is a reloc for a deleted entry or somesuch.
7740 Turn it into an R_*_NONE reloc, at the same
7741 offset as the last reloc. elf_eh_frame.c and
7742 bfd_elf_discard_info rely on reloc offsets
7744 irela
->r_offset
= last_offset
;
7746 irela
->r_addend
= 0;
7750 irela
->r_offset
+= o
->output_offset
;
7752 /* Relocs in an executable have to be virtual addresses. */
7753 if (!finfo
->info
->relocatable
)
7754 irela
->r_offset
+= o
->output_section
->vma
;
7756 last_offset
= irela
->r_offset
;
7758 r_symndx
= irela
->r_info
>> r_sym_shift
;
7759 if (r_symndx
== STN_UNDEF
)
7762 if (r_symndx
>= locsymcount
7763 || (elf_bad_symtab (input_bfd
)
7764 && finfo
->sections
[r_symndx
] == NULL
))
7766 struct elf_link_hash_entry
*rh
;
7769 /* This is a reloc against a global symbol. We
7770 have not yet output all the local symbols, so
7771 we do not know the symbol index of any global
7772 symbol. We set the rel_hash entry for this
7773 reloc to point to the global hash table entry
7774 for this symbol. The symbol index is then
7775 set at the end of bfd_elf_final_link. */
7776 indx
= r_symndx
- extsymoff
;
7777 rh
= elf_sym_hashes (input_bfd
)[indx
];
7778 while (rh
->root
.type
== bfd_link_hash_indirect
7779 || rh
->root
.type
== bfd_link_hash_warning
)
7780 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
7782 /* Setting the index to -2 tells
7783 elf_link_output_extsym that this symbol is
7785 BFD_ASSERT (rh
->indx
< 0);
7793 /* This is a reloc against a local symbol. */
7796 sym
= isymbuf
[r_symndx
];
7797 sec
= finfo
->sections
[r_symndx
];
7798 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
7800 /* I suppose the backend ought to fill in the
7801 section of any STT_SECTION symbol against a
7802 processor specific section. */
7804 if (bfd_is_abs_section (sec
))
7806 else if (sec
== NULL
|| sec
->owner
== NULL
)
7808 bfd_set_error (bfd_error_bad_value
);
7813 asection
*osec
= sec
->output_section
;
7815 /* If we have discarded a section, the output
7816 section will be the absolute section. In
7817 case of discarded link-once and discarded
7818 SEC_MERGE sections, use the kept section. */
7819 if (bfd_is_abs_section (osec
)
7820 && sec
->kept_section
!= NULL
7821 && sec
->kept_section
->output_section
!= NULL
)
7823 osec
= sec
->kept_section
->output_section
;
7824 irela
->r_addend
-= osec
->vma
;
7827 if (!bfd_is_abs_section (osec
))
7829 r_symndx
= osec
->target_index
;
7832 struct elf_link_hash_table
*htab
;
7835 htab
= elf_hash_table (finfo
->info
);
7836 oi
= htab
->text_index_section
;
7837 if ((osec
->flags
& SEC_READONLY
) == 0
7838 && htab
->data_index_section
!= NULL
)
7839 oi
= htab
->data_index_section
;
7843 irela
->r_addend
+= osec
->vma
- oi
->vma
;
7844 r_symndx
= oi
->target_index
;
7848 BFD_ASSERT (r_symndx
!= 0);
7852 /* Adjust the addend according to where the
7853 section winds up in the output section. */
7855 irela
->r_addend
+= sec
->output_offset
;
7859 if (finfo
->indices
[r_symndx
] == -1)
7861 unsigned long shlink
;
7865 if (finfo
->info
->strip
== strip_all
)
7867 /* You can't do ld -r -s. */
7868 bfd_set_error (bfd_error_invalid_operation
);
7872 /* This symbol was skipped earlier, but
7873 since it is needed by a reloc, we
7874 must output it now. */
7875 shlink
= symtab_hdr
->sh_link
;
7876 name
= (bfd_elf_string_from_elf_section
7877 (input_bfd
, shlink
, sym
.st_name
));
7881 osec
= sec
->output_section
;
7883 _bfd_elf_section_from_bfd_section (output_bfd
,
7885 if (sym
.st_shndx
== SHN_BAD
)
7888 sym
.st_value
+= sec
->output_offset
;
7889 if (! finfo
->info
->relocatable
)
7891 sym
.st_value
+= osec
->vma
;
7892 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
7894 /* STT_TLS symbols are relative to PT_TLS
7896 BFD_ASSERT (elf_hash_table (finfo
->info
)
7898 sym
.st_value
-= (elf_hash_table (finfo
->info
)
7903 finfo
->indices
[r_symndx
]
7904 = bfd_get_symcount (output_bfd
);
7906 if (! elf_link_output_sym (finfo
, name
, &sym
, sec
,
7911 r_symndx
= finfo
->indices
[r_symndx
];
7914 irela
->r_info
= ((bfd_vma
) r_symndx
<< r_sym_shift
7915 | (irela
->r_info
& r_type_mask
));
7918 /* Swap out the relocs. */
7919 if (input_rel_hdr
->sh_size
!= 0
7920 && !bed
->elf_backend_emit_relocs (output_bfd
, o
,
7926 input_rel_hdr2
= elf_section_data (o
)->rel_hdr2
;
7927 if (input_rel_hdr2
&& input_rel_hdr2
->sh_size
!= 0)
7929 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
7930 * bed
->s
->int_rels_per_ext_rel
);
7931 rel_hash_list
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
7932 if (!bed
->elf_backend_emit_relocs (output_bfd
, o
,
7941 /* Write out the modified section contents. */
7942 if (bed
->elf_backend_write_section
7943 && (*bed
->elf_backend_write_section
) (output_bfd
, o
, contents
))
7945 /* Section written out. */
7947 else switch (o
->sec_info_type
)
7949 case ELF_INFO_TYPE_STABS
:
7950 if (! (_bfd_write_section_stabs
7952 &elf_hash_table (finfo
->info
)->stab_info
,
7953 o
, &elf_section_data (o
)->sec_info
, contents
)))
7956 case ELF_INFO_TYPE_MERGE
:
7957 if (! _bfd_write_merged_section (output_bfd
, o
,
7958 elf_section_data (o
)->sec_info
))
7961 case ELF_INFO_TYPE_EH_FRAME
:
7963 if (! _bfd_elf_write_section_eh_frame (output_bfd
, finfo
->info
,
7970 if (! (o
->flags
& SEC_EXCLUDE
)
7971 && ! bfd_set_section_contents (output_bfd
, o
->output_section
,
7973 (file_ptr
) o
->output_offset
,
7984 /* Generate a reloc when linking an ELF file. This is a reloc
7985 requested by the linker, and does not come from any input file. This
7986 is used to build constructor and destructor tables when linking
7990 elf_reloc_link_order (bfd
*output_bfd
,
7991 struct bfd_link_info
*info
,
7992 asection
*output_section
,
7993 struct bfd_link_order
*link_order
)
7995 reloc_howto_type
*howto
;
7999 struct elf_link_hash_entry
**rel_hash_ptr
;
8000 Elf_Internal_Shdr
*rel_hdr
;
8001 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
8002 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
8006 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
8009 bfd_set_error (bfd_error_bad_value
);
8013 addend
= link_order
->u
.reloc
.p
->addend
;
8015 /* Figure out the symbol index. */
8016 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
8017 + elf_section_data (output_section
)->rel_count
8018 + elf_section_data (output_section
)->rel_count2
);
8019 if (link_order
->type
== bfd_section_reloc_link_order
)
8021 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
8022 BFD_ASSERT (indx
!= 0);
8023 *rel_hash_ptr
= NULL
;
8027 struct elf_link_hash_entry
*h
;
8029 /* Treat a reloc against a defined symbol as though it were
8030 actually against the section. */
8031 h
= ((struct elf_link_hash_entry
*)
8032 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
8033 link_order
->u
.reloc
.p
->u
.name
,
8034 FALSE
, FALSE
, TRUE
));
8036 && (h
->root
.type
== bfd_link_hash_defined
8037 || h
->root
.type
== bfd_link_hash_defweak
))
8041 section
= h
->root
.u
.def
.section
;
8042 indx
= section
->output_section
->target_index
;
8043 *rel_hash_ptr
= NULL
;
8044 /* It seems that we ought to add the symbol value to the
8045 addend here, but in practice it has already been added
8046 because it was passed to constructor_callback. */
8047 addend
+= section
->output_section
->vma
+ section
->output_offset
;
8051 /* Setting the index to -2 tells elf_link_output_extsym that
8052 this symbol is used by a reloc. */
8059 if (! ((*info
->callbacks
->unattached_reloc
)
8060 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0)))
8066 /* If this is an inplace reloc, we must write the addend into the
8068 if (howto
->partial_inplace
&& addend
!= 0)
8071 bfd_reloc_status_type rstat
;
8074 const char *sym_name
;
8076 size
= bfd_get_reloc_size (howto
);
8077 buf
= bfd_zmalloc (size
);
8080 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
8087 case bfd_reloc_outofrange
:
8090 case bfd_reloc_overflow
:
8091 if (link_order
->type
== bfd_section_reloc_link_order
)
8092 sym_name
= bfd_section_name (output_bfd
,
8093 link_order
->u
.reloc
.p
->u
.section
);
8095 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
8096 if (! ((*info
->callbacks
->reloc_overflow
)
8097 (info
, NULL
, sym_name
, howto
->name
, addend
, NULL
,
8098 NULL
, (bfd_vma
) 0)))
8105 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
8106 link_order
->offset
, size
);
8112 /* The address of a reloc is relative to the section in a
8113 relocatable file, and is a virtual address in an executable
8115 offset
= link_order
->offset
;
8116 if (! info
->relocatable
)
8117 offset
+= output_section
->vma
;
8119 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
8121 irel
[i
].r_offset
= offset
;
8123 irel
[i
].r_addend
= 0;
8125 if (bed
->s
->arch_size
== 32)
8126 irel
[0].r_info
= ELF32_R_INFO (indx
, howto
->type
);
8128 irel
[0].r_info
= ELF64_R_INFO (indx
, howto
->type
);
8130 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
8131 erel
= rel_hdr
->contents
;
8132 if (rel_hdr
->sh_type
== SHT_REL
)
8134 erel
+= (elf_section_data (output_section
)->rel_count
8135 * bed
->s
->sizeof_rel
);
8136 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
8140 irel
[0].r_addend
= addend
;
8141 erel
+= (elf_section_data (output_section
)->rel_count
8142 * bed
->s
->sizeof_rela
);
8143 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
8146 ++elf_section_data (output_section
)->rel_count
;
8152 /* Get the output vma of the section pointed to by the sh_link field. */
8155 elf_get_linked_section_vma (struct bfd_link_order
*p
)
8157 Elf_Internal_Shdr
**elf_shdrp
;
8161 s
= p
->u
.indirect
.section
;
8162 elf_shdrp
= elf_elfsections (s
->owner
);
8163 elfsec
= _bfd_elf_section_from_bfd_section (s
->owner
, s
);
8164 elfsec
= elf_shdrp
[elfsec
]->sh_link
;
8166 The Intel C compiler generates SHT_IA_64_UNWIND with
8167 SHF_LINK_ORDER. But it doesn't set the sh_link or
8168 sh_info fields. Hence we could get the situation
8169 where elfsec is 0. */
8172 const struct elf_backend_data
*bed
8173 = get_elf_backend_data (s
->owner
);
8174 if (bed
->link_order_error_handler
)
8175 bed
->link_order_error_handler
8176 (_("%B: warning: sh_link not set for section `%A'"), s
->owner
, s
);
8181 s
= elf_shdrp
[elfsec
]->bfd_section
;
8182 return s
->output_section
->vma
+ s
->output_offset
;
8187 /* Compare two sections based on the locations of the sections they are
8188 linked to. Used by elf_fixup_link_order. */
8191 compare_link_order (const void * a
, const void * b
)
8196 apos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)a
);
8197 bpos
= elf_get_linked_section_vma (*(struct bfd_link_order
**)b
);
8204 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
8205 order as their linked sections. Returns false if this could not be done
8206 because an output section includes both ordered and unordered
8207 sections. Ideally we'd do this in the linker proper. */
8210 elf_fixup_link_order (bfd
*abfd
, asection
*o
)
8215 struct bfd_link_order
*p
;
8217 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8219 struct bfd_link_order
**sections
;
8220 asection
*s
, *other_sec
, *linkorder_sec
;
8224 linkorder_sec
= NULL
;
8227 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
8229 if (p
->type
== bfd_indirect_link_order
)
8231 s
= p
->u
.indirect
.section
;
8233 if (bfd_get_flavour (sub
) == bfd_target_elf_flavour
8234 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
8235 && (elfsec
= _bfd_elf_section_from_bfd_section (sub
, s
))
8236 && elfsec
< elf_numsections (sub
)
8237 && elf_elfsections (sub
)[elfsec
]->sh_flags
& SHF_LINK_ORDER
)
8251 if (seen_other
&& seen_linkorder
)
8253 if (other_sec
&& linkorder_sec
)
8254 (*_bfd_error_handler
) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
8256 linkorder_sec
->owner
, other_sec
,
8259 (*_bfd_error_handler
) (_("%A has both ordered and unordered sections"),
8261 bfd_set_error (bfd_error_bad_value
);
8266 if (!seen_linkorder
)
8269 sections
= (struct bfd_link_order
**)
8270 xmalloc (seen_linkorder
* sizeof (struct bfd_link_order
*));
8273 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
8275 sections
[seen_linkorder
++] = p
;
8277 /* Sort the input sections in the order of their linked section. */
8278 qsort (sections
, seen_linkorder
, sizeof (struct bfd_link_order
*),
8279 compare_link_order
);
8281 /* Change the offsets of the sections. */
8283 for (n
= 0; n
< seen_linkorder
; n
++)
8285 s
= sections
[n
]->u
.indirect
.section
;
8286 offset
&= ~(bfd_vma
)((1 << s
->alignment_power
) - 1);
8287 s
->output_offset
= offset
;
8288 sections
[n
]->offset
= offset
;
8289 offset
+= sections
[n
]->size
;
8296 /* Do the final step of an ELF link. */
8299 bfd_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8301 bfd_boolean dynamic
;
8302 bfd_boolean emit_relocs
;
8304 struct elf_final_link_info finfo
;
8305 register asection
*o
;
8306 register struct bfd_link_order
*p
;
8308 bfd_size_type max_contents_size
;
8309 bfd_size_type max_external_reloc_size
;
8310 bfd_size_type max_internal_reloc_count
;
8311 bfd_size_type max_sym_count
;
8312 bfd_size_type max_sym_shndx_count
;
8314 Elf_Internal_Sym elfsym
;
8316 Elf_Internal_Shdr
*symtab_hdr
;
8317 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8318 Elf_Internal_Shdr
*symstrtab_hdr
;
8319 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8320 struct elf_outext_info eoinfo
;
8322 size_t relativecount
= 0;
8323 asection
*reldyn
= 0;
8326 if (! is_elf_hash_table (info
->hash
))
8330 abfd
->flags
|= DYNAMIC
;
8332 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
8333 dynobj
= elf_hash_table (info
)->dynobj
;
8335 emit_relocs
= (info
->relocatable
8336 || info
->emitrelocations
);
8339 finfo
.output_bfd
= abfd
;
8340 finfo
.symstrtab
= _bfd_elf_stringtab_init ();
8341 if (finfo
.symstrtab
== NULL
)
8346 finfo
.dynsym_sec
= NULL
;
8347 finfo
.hash_sec
= NULL
;
8348 finfo
.symver_sec
= NULL
;
8352 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
8353 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
8354 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
);
8355 finfo
.symver_sec
= bfd_get_section_by_name (dynobj
, ".gnu.version");
8356 /* Note that it is OK if symver_sec is NULL. */
8359 finfo
.contents
= NULL
;
8360 finfo
.external_relocs
= NULL
;
8361 finfo
.internal_relocs
= NULL
;
8362 finfo
.external_syms
= NULL
;
8363 finfo
.locsym_shndx
= NULL
;
8364 finfo
.internal_syms
= NULL
;
8365 finfo
.indices
= NULL
;
8366 finfo
.sections
= NULL
;
8367 finfo
.symbuf
= NULL
;
8368 finfo
.symshndxbuf
= NULL
;
8369 finfo
.symbuf_count
= 0;
8370 finfo
.shndxbuf_size
= 0;
8372 /* Count up the number of relocations we will output for each output
8373 section, so that we know the sizes of the reloc sections. We
8374 also figure out some maximum sizes. */
8375 max_contents_size
= 0;
8376 max_external_reloc_size
= 0;
8377 max_internal_reloc_count
= 0;
8379 max_sym_shndx_count
= 0;
8381 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8383 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
8386 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
8388 unsigned int reloc_count
= 0;
8389 struct bfd_elf_section_data
*esdi
= NULL
;
8390 unsigned int *rel_count1
;
8392 if (p
->type
== bfd_section_reloc_link_order
8393 || p
->type
== bfd_symbol_reloc_link_order
)
8395 else if (p
->type
== bfd_indirect_link_order
)
8399 sec
= p
->u
.indirect
.section
;
8400 esdi
= elf_section_data (sec
);
8402 /* Mark all sections which are to be included in the
8403 link. This will normally be every section. We need
8404 to do this so that we can identify any sections which
8405 the linker has decided to not include. */
8406 sec
->linker_mark
= TRUE
;
8408 if (sec
->flags
& SEC_MERGE
)
8411 if (info
->relocatable
|| info
->emitrelocations
)
8412 reloc_count
= sec
->reloc_count
;
8413 else if (bed
->elf_backend_count_relocs
)
8415 Elf_Internal_Rela
* relocs
;
8417 relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
8420 reloc_count
= (*bed
->elf_backend_count_relocs
) (sec
, relocs
);
8422 if (elf_section_data (o
)->relocs
!= relocs
)
8426 if (sec
->rawsize
> max_contents_size
)
8427 max_contents_size
= sec
->rawsize
;
8428 if (sec
->size
> max_contents_size
)
8429 max_contents_size
= sec
->size
;
8431 /* We are interested in just local symbols, not all
8433 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
8434 && (sec
->owner
->flags
& DYNAMIC
) == 0)
8438 if (elf_bad_symtab (sec
->owner
))
8439 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
8440 / bed
->s
->sizeof_sym
);
8442 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
8444 if (sym_count
> max_sym_count
)
8445 max_sym_count
= sym_count
;
8447 if (sym_count
> max_sym_shndx_count
8448 && elf_symtab_shndx (sec
->owner
) != 0)
8449 max_sym_shndx_count
= sym_count
;
8451 if ((sec
->flags
& SEC_RELOC
) != 0)
8455 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
8456 if (ext_size
> max_external_reloc_size
)
8457 max_external_reloc_size
= ext_size
;
8458 if (sec
->reloc_count
> max_internal_reloc_count
)
8459 max_internal_reloc_count
= sec
->reloc_count
;
8464 if (reloc_count
== 0)
8467 o
->reloc_count
+= reloc_count
;
8469 /* MIPS may have a mix of REL and RELA relocs on sections.
8470 To support this curious ABI we keep reloc counts in
8471 elf_section_data too. We must be careful to add the
8472 relocations from the input section to the right output
8473 count. FIXME: Get rid of one count. We have
8474 o->reloc_count == esdo->rel_count + esdo->rel_count2. */
8475 rel_count1
= &esdo
->rel_count
;
8478 bfd_boolean same_size
;
8479 bfd_size_type entsize1
;
8481 entsize1
= esdi
->rel_hdr
.sh_entsize
;
8482 BFD_ASSERT (entsize1
== bed
->s
->sizeof_rel
8483 || entsize1
== bed
->s
->sizeof_rela
);
8484 same_size
= !o
->use_rela_p
== (entsize1
== bed
->s
->sizeof_rel
);
8487 rel_count1
= &esdo
->rel_count2
;
8489 if (esdi
->rel_hdr2
!= NULL
)
8491 bfd_size_type entsize2
= esdi
->rel_hdr2
->sh_entsize
;
8492 unsigned int alt_count
;
8493 unsigned int *rel_count2
;
8495 BFD_ASSERT (entsize2
!= entsize1
8496 && (entsize2
== bed
->s
->sizeof_rel
8497 || entsize2
== bed
->s
->sizeof_rela
));
8499 rel_count2
= &esdo
->rel_count2
;
8501 rel_count2
= &esdo
->rel_count
;
8503 /* The following is probably too simplistic if the
8504 backend counts output relocs unusually. */
8505 BFD_ASSERT (bed
->elf_backend_count_relocs
== NULL
);
8506 alt_count
= NUM_SHDR_ENTRIES (esdi
->rel_hdr2
);
8507 *rel_count2
+= alt_count
;
8508 reloc_count
-= alt_count
;
8511 *rel_count1
+= reloc_count
;
8514 if (o
->reloc_count
> 0)
8515 o
->flags
|= SEC_RELOC
;
8518 /* Explicitly clear the SEC_RELOC flag. The linker tends to
8519 set it (this is probably a bug) and if it is set
8520 assign_section_numbers will create a reloc section. */
8521 o
->flags
&=~ SEC_RELOC
;
8524 /* If the SEC_ALLOC flag is not set, force the section VMA to
8525 zero. This is done in elf_fake_sections as well, but forcing
8526 the VMA to 0 here will ensure that relocs against these
8527 sections are handled correctly. */
8528 if ((o
->flags
& SEC_ALLOC
) == 0
8529 && ! o
->user_set_vma
)
8533 if (! info
->relocatable
&& merged
)
8534 elf_link_hash_traverse (elf_hash_table (info
),
8535 _bfd_elf_link_sec_merge_syms
, abfd
);
8537 /* Figure out the file positions for everything but the symbol table
8538 and the relocs. We set symcount to force assign_section_numbers
8539 to create a symbol table. */
8540 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
8541 BFD_ASSERT (! abfd
->output_has_begun
);
8542 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
8545 /* Set sizes, and assign file positions for reloc sections. */
8546 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8548 if ((o
->flags
& SEC_RELOC
) != 0)
8550 if (!(_bfd_elf_link_size_reloc_section
8551 (abfd
, &elf_section_data (o
)->rel_hdr
, o
)))
8554 if (elf_section_data (o
)->rel_hdr2
8555 && !(_bfd_elf_link_size_reloc_section
8556 (abfd
, elf_section_data (o
)->rel_hdr2
, o
)))
8560 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
8561 to count upwards while actually outputting the relocations. */
8562 elf_section_data (o
)->rel_count
= 0;
8563 elf_section_data (o
)->rel_count2
= 0;
8566 _bfd_elf_assign_file_positions_for_relocs (abfd
);
8568 /* We have now assigned file positions for all the sections except
8569 .symtab and .strtab. We start the .symtab section at the current
8570 file position, and write directly to it. We build the .strtab
8571 section in memory. */
8572 bfd_get_symcount (abfd
) = 0;
8573 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8574 /* sh_name is set in prep_headers. */
8575 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8576 /* sh_flags, sh_addr and sh_size all start off zero. */
8577 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8578 /* sh_link is set in assign_section_numbers. */
8579 /* sh_info is set below. */
8580 /* sh_offset is set just below. */
8581 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
8583 off
= elf_tdata (abfd
)->next_file_pos
;
8584 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, TRUE
);
8586 /* Note that at this point elf_tdata (abfd)->next_file_pos is
8587 incorrect. We do not yet know the size of the .symtab section.
8588 We correct next_file_pos below, after we do know the size. */
8590 /* Allocate a buffer to hold swapped out symbols. This is to avoid
8591 continuously seeking to the right position in the file. */
8592 if (! info
->keep_memory
|| max_sym_count
< 20)
8593 finfo
.symbuf_size
= 20;
8595 finfo
.symbuf_size
= max_sym_count
;
8596 amt
= finfo
.symbuf_size
;
8597 amt
*= bed
->s
->sizeof_sym
;
8598 finfo
.symbuf
= bfd_malloc (amt
);
8599 if (finfo
.symbuf
== NULL
)
8601 if (elf_numsections (abfd
) > SHN_LORESERVE
)
8603 /* Wild guess at number of output symbols. realloc'd as needed. */
8604 amt
= 2 * max_sym_count
+ elf_numsections (abfd
) + 1000;
8605 finfo
.shndxbuf_size
= amt
;
8606 amt
*= sizeof (Elf_External_Sym_Shndx
);
8607 finfo
.symshndxbuf
= bfd_zmalloc (amt
);
8608 if (finfo
.symshndxbuf
== NULL
)
8612 /* Start writing out the symbol table. The first symbol is always a
8614 if (info
->strip
!= strip_all
8617 elfsym
.st_value
= 0;
8620 elfsym
.st_other
= 0;
8621 elfsym
.st_shndx
= SHN_UNDEF
;
8622 if (! elf_link_output_sym (&finfo
, NULL
, &elfsym
, bfd_und_section_ptr
,
8627 /* Output a symbol for each section. We output these even if we are
8628 discarding local symbols, since they are used for relocs. These
8629 symbols have no names. We store the index of each one in the
8630 index field of the section, so that we can find it again when
8631 outputting relocs. */
8632 if (info
->strip
!= strip_all
8636 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8637 elfsym
.st_other
= 0;
8638 elfsym
.st_value
= 0;
8639 for (i
= 1; i
< elf_numsections (abfd
); i
++)
8641 o
= bfd_section_from_elf_index (abfd
, i
);
8644 o
->target_index
= bfd_get_symcount (abfd
);
8645 elfsym
.st_shndx
= i
;
8646 if (!info
->relocatable
)
8647 elfsym
.st_value
= o
->vma
;
8648 if (!elf_link_output_sym (&finfo
, NULL
, &elfsym
, o
, NULL
))
8651 if (i
== SHN_LORESERVE
- 1)
8652 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
8656 /* Allocate some memory to hold information read in from the input
8658 if (max_contents_size
!= 0)
8660 finfo
.contents
= bfd_malloc (max_contents_size
);
8661 if (finfo
.contents
== NULL
)
8665 if (max_external_reloc_size
!= 0)
8667 finfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
8668 if (finfo
.external_relocs
== NULL
)
8672 if (max_internal_reloc_count
!= 0)
8674 amt
= max_internal_reloc_count
* bed
->s
->int_rels_per_ext_rel
;
8675 amt
*= sizeof (Elf_Internal_Rela
);
8676 finfo
.internal_relocs
= bfd_malloc (amt
);
8677 if (finfo
.internal_relocs
== NULL
)
8681 if (max_sym_count
!= 0)
8683 amt
= max_sym_count
* bed
->s
->sizeof_sym
;
8684 finfo
.external_syms
= bfd_malloc (amt
);
8685 if (finfo
.external_syms
== NULL
)
8688 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
8689 finfo
.internal_syms
= bfd_malloc (amt
);
8690 if (finfo
.internal_syms
== NULL
)
8693 amt
= max_sym_count
* sizeof (long);
8694 finfo
.indices
= bfd_malloc (amt
);
8695 if (finfo
.indices
== NULL
)
8698 amt
= max_sym_count
* sizeof (asection
*);
8699 finfo
.sections
= bfd_malloc (amt
);
8700 if (finfo
.sections
== NULL
)
8704 if (max_sym_shndx_count
!= 0)
8706 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
8707 finfo
.locsym_shndx
= bfd_malloc (amt
);
8708 if (finfo
.locsym_shndx
== NULL
)
8712 if (elf_hash_table (info
)->tls_sec
)
8714 bfd_vma base
, end
= 0;
8717 for (sec
= elf_hash_table (info
)->tls_sec
;
8718 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
8721 bfd_size_type size
= sec
->size
;
8724 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
8726 struct bfd_link_order
*o
= sec
->map_tail
.link_order
;
8728 size
= o
->offset
+ o
->size
;
8730 end
= sec
->vma
+ size
;
8732 base
= elf_hash_table (info
)->tls_sec
->vma
;
8733 end
= align_power (end
, elf_hash_table (info
)->tls_sec
->alignment_power
);
8734 elf_hash_table (info
)->tls_size
= end
- base
;
8737 /* Reorder SHF_LINK_ORDER sections. */
8738 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8740 if (!elf_fixup_link_order (abfd
, o
))
8744 /* Since ELF permits relocations to be against local symbols, we
8745 must have the local symbols available when we do the relocations.
8746 Since we would rather only read the local symbols once, and we
8747 would rather not keep them in memory, we handle all the
8748 relocations for a single input file at the same time.
8750 Unfortunately, there is no way to know the total number of local
8751 symbols until we have seen all of them, and the local symbol
8752 indices precede the global symbol indices. This means that when
8753 we are generating relocatable output, and we see a reloc against
8754 a global symbol, we can not know the symbol index until we have
8755 finished examining all the local symbols to see which ones we are
8756 going to output. To deal with this, we keep the relocations in
8757 memory, and don't output them until the end of the link. This is
8758 an unfortunate waste of memory, but I don't see a good way around
8759 it. Fortunately, it only happens when performing a relocatable
8760 link, which is not the common case. FIXME: If keep_memory is set
8761 we could write the relocs out and then read them again; I don't
8762 know how bad the memory loss will be. */
8764 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
8765 sub
->output_has_begun
= FALSE
;
8766 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8768 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
8770 if (p
->type
== bfd_indirect_link_order
8771 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
8772 == bfd_target_elf_flavour
)
8773 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
8775 if (! sub
->output_has_begun
)
8777 if (! elf_link_input_bfd (&finfo
, sub
))
8779 sub
->output_has_begun
= TRUE
;
8782 else if (p
->type
== bfd_section_reloc_link_order
8783 || p
->type
== bfd_symbol_reloc_link_order
)
8785 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
8790 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
8796 /* Free symbol buffer if needed. */
8797 if (!info
->reduce_memory_overheads
)
8799 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
8800 if (elf_tdata (sub
)->symbuf
)
8802 free (elf_tdata (sub
)->symbuf
);
8803 elf_tdata (sub
)->symbuf
= NULL
;
8807 /* Output any global symbols that got converted to local in a
8808 version script or due to symbol visibility. We do this in a
8809 separate step since ELF requires all local symbols to appear
8810 prior to any global symbols. FIXME: We should only do this if
8811 some global symbols were, in fact, converted to become local.
8812 FIXME: Will this work correctly with the Irix 5 linker? */
8813 eoinfo
.failed
= FALSE
;
8814 eoinfo
.finfo
= &finfo
;
8815 eoinfo
.localsyms
= TRUE
;
8816 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
8821 /* If backend needs to output some local symbols not present in the hash
8822 table, do it now. */
8823 if (bed
->elf_backend_output_arch_local_syms
)
8825 typedef bfd_boolean (*out_sym_func
)
8826 (void *, const char *, Elf_Internal_Sym
*, asection
*,
8827 struct elf_link_hash_entry
*);
8829 if (! ((*bed
->elf_backend_output_arch_local_syms
)
8830 (abfd
, info
, &finfo
, (out_sym_func
) elf_link_output_sym
)))
8834 /* That wrote out all the local symbols. Finish up the symbol table
8835 with the global symbols. Even if we want to strip everything we
8836 can, we still need to deal with those global symbols that got
8837 converted to local in a version script. */
8839 /* The sh_info field records the index of the first non local symbol. */
8840 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
8843 && finfo
.dynsym_sec
->output_section
!= bfd_abs_section_ptr
)
8845 Elf_Internal_Sym sym
;
8846 bfd_byte
*dynsym
= finfo
.dynsym_sec
->contents
;
8847 long last_local
= 0;
8849 /* Write out the section symbols for the output sections. */
8850 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
8856 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8859 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8865 dynindx
= elf_section_data (s
)->dynindx
;
8868 indx
= elf_section_data (s
)->this_idx
;
8869 BFD_ASSERT (indx
> 0);
8870 sym
.st_shndx
= indx
;
8871 if (! check_dynsym (abfd
, &sym
))
8873 sym
.st_value
= s
->vma
;
8874 dest
= dynsym
+ dynindx
* bed
->s
->sizeof_sym
;
8875 if (last_local
< dynindx
)
8876 last_local
= dynindx
;
8877 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
8881 /* Write out the local dynsyms. */
8882 if (elf_hash_table (info
)->dynlocal
)
8884 struct elf_link_local_dynamic_entry
*e
;
8885 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
8890 sym
.st_size
= e
->isym
.st_size
;
8891 sym
.st_other
= e
->isym
.st_other
;
8893 /* Copy the internal symbol as is.
8894 Note that we saved a word of storage and overwrote
8895 the original st_name with the dynstr_index. */
8898 if (e
->isym
.st_shndx
!= SHN_UNDEF
8899 && (e
->isym
.st_shndx
< SHN_LORESERVE
8900 || e
->isym
.st_shndx
> SHN_HIRESERVE
))
8902 s
= bfd_section_from_elf_index (e
->input_bfd
,
8906 elf_section_data (s
->output_section
)->this_idx
;
8907 if (! check_dynsym (abfd
, &sym
))
8909 sym
.st_value
= (s
->output_section
->vma
8911 + e
->isym
.st_value
);
8914 if (last_local
< e
->dynindx
)
8915 last_local
= e
->dynindx
;
8917 dest
= dynsym
+ e
->dynindx
* bed
->s
->sizeof_sym
;
8918 bed
->s
->swap_symbol_out (abfd
, &sym
, dest
, 0);
8922 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
=
8926 /* We get the global symbols from the hash table. */
8927 eoinfo
.failed
= FALSE
;
8928 eoinfo
.localsyms
= FALSE
;
8929 eoinfo
.finfo
= &finfo
;
8930 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
8935 /* If backend needs to output some symbols not present in the hash
8936 table, do it now. */
8937 if (bed
->elf_backend_output_arch_syms
)
8939 typedef bfd_boolean (*out_sym_func
)
8940 (void *, const char *, Elf_Internal_Sym
*, asection
*,
8941 struct elf_link_hash_entry
*);
8943 if (! ((*bed
->elf_backend_output_arch_syms
)
8944 (abfd
, info
, &finfo
, (out_sym_func
) elf_link_output_sym
)))
8948 /* Flush all symbols to the file. */
8949 if (! elf_link_flush_output_syms (&finfo
, bed
))
8952 /* Now we know the size of the symtab section. */
8953 off
+= symtab_hdr
->sh_size
;
8955 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
8956 if (symtab_shndx_hdr
->sh_name
!= 0)
8958 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8959 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8960 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8961 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
8962 symtab_shndx_hdr
->sh_size
= amt
;
8964 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
8967 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
8968 || (bfd_bwrite (finfo
.symshndxbuf
, amt
, abfd
) != amt
))
8973 /* Finish up and write out the symbol string table (.strtab)
8975 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8976 /* sh_name was set in prep_headers. */
8977 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8978 symstrtab_hdr
->sh_flags
= 0;
8979 symstrtab_hdr
->sh_addr
= 0;
8980 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
8981 symstrtab_hdr
->sh_entsize
= 0;
8982 symstrtab_hdr
->sh_link
= 0;
8983 symstrtab_hdr
->sh_info
= 0;
8984 /* sh_offset is set just below. */
8985 symstrtab_hdr
->sh_addralign
= 1;
8987 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, TRUE
);
8988 elf_tdata (abfd
)->next_file_pos
= off
;
8990 if (bfd_get_symcount (abfd
) > 0)
8992 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
8993 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
8997 /* Adjust the relocs to have the correct symbol indices. */
8998 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
9000 if ((o
->flags
& SEC_RELOC
) == 0)
9003 elf_link_adjust_relocs (abfd
, &elf_section_data (o
)->rel_hdr
,
9004 elf_section_data (o
)->rel_count
,
9005 elf_section_data (o
)->rel_hashes
);
9006 if (elf_section_data (o
)->rel_hdr2
!= NULL
)
9007 elf_link_adjust_relocs (abfd
, elf_section_data (o
)->rel_hdr2
,
9008 elf_section_data (o
)->rel_count2
,
9009 (elf_section_data (o
)->rel_hashes
9010 + elf_section_data (o
)->rel_count
));
9012 /* Set the reloc_count field to 0 to prevent write_relocs from
9013 trying to swap the relocs out itself. */
9017 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
9018 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
9020 /* If we are linking against a dynamic object, or generating a
9021 shared library, finish up the dynamic linking information. */
9024 bfd_byte
*dyncon
, *dynconend
;
9026 /* Fix up .dynamic entries. */
9027 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
9028 BFD_ASSERT (o
!= NULL
);
9030 dyncon
= o
->contents
;
9031 dynconend
= o
->contents
+ o
->size
;
9032 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
9034 Elf_Internal_Dyn dyn
;
9038 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
9045 if (relativecount
> 0 && dyncon
+ bed
->s
->sizeof_dyn
< dynconend
)
9047 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
9049 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
9050 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
9053 dyn
.d_un
.d_val
= relativecount
;
9060 name
= info
->init_function
;
9063 name
= info
->fini_function
;
9066 struct elf_link_hash_entry
*h
;
9068 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
9069 FALSE
, FALSE
, TRUE
);
9071 && (h
->root
.type
== bfd_link_hash_defined
9072 || h
->root
.type
== bfd_link_hash_defweak
))
9074 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
9075 o
= h
->root
.u
.def
.section
;
9076 if (o
->output_section
!= NULL
)
9077 dyn
.d_un
.d_val
+= (o
->output_section
->vma
9078 + o
->output_offset
);
9081 /* The symbol is imported from another shared
9082 library and does not apply to this one. */
9090 case DT_PREINIT_ARRAYSZ
:
9091 name
= ".preinit_array";
9093 case DT_INIT_ARRAYSZ
:
9094 name
= ".init_array";
9096 case DT_FINI_ARRAYSZ
:
9097 name
= ".fini_array";
9099 o
= bfd_get_section_by_name (abfd
, name
);
9102 (*_bfd_error_handler
)
9103 (_("%B: could not find output section %s"), abfd
, name
);
9107 (*_bfd_error_handler
)
9108 (_("warning: %s section has zero size"), name
);
9109 dyn
.d_un
.d_val
= o
->size
;
9112 case DT_PREINIT_ARRAY
:
9113 name
= ".preinit_array";
9116 name
= ".init_array";
9119 name
= ".fini_array";
9135 name
= ".gnu.version_d";
9138 name
= ".gnu.version_r";
9141 name
= ".gnu.version";
9143 o
= bfd_get_section_by_name (abfd
, name
);
9146 (*_bfd_error_handler
)
9147 (_("%B: could not find output section %s"), abfd
, name
);
9150 dyn
.d_un
.d_ptr
= o
->vma
;
9157 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
9162 for (i
= 1; i
< elf_numsections (abfd
); i
++)
9164 Elf_Internal_Shdr
*hdr
;
9166 hdr
= elf_elfsections (abfd
)[i
];
9167 if (hdr
->sh_type
== type
9168 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
9170 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
9171 dyn
.d_un
.d_val
+= hdr
->sh_size
;
9174 if (dyn
.d_un
.d_val
== 0
9175 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
9176 dyn
.d_un
.d_val
= hdr
->sh_addr
;
9182 bed
->s
->swap_dyn_out (dynobj
, &dyn
, dyncon
);
9186 /* If we have created any dynamic sections, then output them. */
9189 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
9192 /* Check for DT_TEXTREL (late, in case the backend removes it). */
9193 if (info
->warn_shared_textrel
&& info
->shared
)
9195 bfd_byte
*dyncon
, *dynconend
;
9197 /* Fix up .dynamic entries. */
9198 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
9199 BFD_ASSERT (o
!= NULL
);
9201 dyncon
= o
->contents
;
9202 dynconend
= o
->contents
+ o
->size
;
9203 for (; dyncon
< dynconend
; dyncon
+= bed
->s
->sizeof_dyn
)
9205 Elf_Internal_Dyn dyn
;
9207 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
9209 if (dyn
.d_tag
== DT_TEXTREL
)
9212 (_("warning: creating a DT_TEXTREL in a shared object."));
9218 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
9220 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
9222 || o
->output_section
== bfd_abs_section_ptr
)
9224 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
9226 /* At this point, we are only interested in sections
9227 created by _bfd_elf_link_create_dynamic_sections. */
9230 if (elf_hash_table (info
)->stab_info
.stabstr
== o
)
9232 if (elf_hash_table (info
)->eh_info
.hdr_sec
== o
)
9234 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
9236 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
9238 if (! bfd_set_section_contents (abfd
, o
->output_section
,
9240 (file_ptr
) o
->output_offset
,
9246 /* The contents of the .dynstr section are actually in a
9248 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
9249 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
9250 || ! _bfd_elf_strtab_emit (abfd
,
9251 elf_hash_table (info
)->dynstr
))
9257 if (info
->relocatable
)
9259 bfd_boolean failed
= FALSE
;
9261 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
9266 /* If we have optimized stabs strings, output them. */
9267 if (elf_hash_table (info
)->stab_info
.stabstr
!= NULL
)
9269 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
9273 if (info
->eh_frame_hdr
)
9275 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
9279 if (finfo
.symstrtab
!= NULL
)
9280 _bfd_stringtab_free (finfo
.symstrtab
);
9281 if (finfo
.contents
!= NULL
)
9282 free (finfo
.contents
);
9283 if (finfo
.external_relocs
!= NULL
)
9284 free (finfo
.external_relocs
);
9285 if (finfo
.internal_relocs
!= NULL
)
9286 free (finfo
.internal_relocs
);
9287 if (finfo
.external_syms
!= NULL
)
9288 free (finfo
.external_syms
);
9289 if (finfo
.locsym_shndx
!= NULL
)
9290 free (finfo
.locsym_shndx
);
9291 if (finfo
.internal_syms
!= NULL
)
9292 free (finfo
.internal_syms
);
9293 if (finfo
.indices
!= NULL
)
9294 free (finfo
.indices
);
9295 if (finfo
.sections
!= NULL
)
9296 free (finfo
.sections
);
9297 if (finfo
.symbuf
!= NULL
)
9298 free (finfo
.symbuf
);
9299 if (finfo
.symshndxbuf
!= NULL
)
9300 free (finfo
.symshndxbuf
);
9301 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
9303 if ((o
->flags
& SEC_RELOC
) != 0
9304 && elf_section_data (o
)->rel_hashes
!= NULL
)
9305 free (elf_section_data (o
)->rel_hashes
);
9308 elf_tdata (abfd
)->linker
= TRUE
;
9313 if (finfo
.symstrtab
!= NULL
)
9314 _bfd_stringtab_free (finfo
.symstrtab
);
9315 if (finfo
.contents
!= NULL
)
9316 free (finfo
.contents
);
9317 if (finfo
.external_relocs
!= NULL
)
9318 free (finfo
.external_relocs
);
9319 if (finfo
.internal_relocs
!= NULL
)
9320 free (finfo
.internal_relocs
);
9321 if (finfo
.external_syms
!= NULL
)
9322 free (finfo
.external_syms
);
9323 if (finfo
.locsym_shndx
!= NULL
)
9324 free (finfo
.locsym_shndx
);
9325 if (finfo
.internal_syms
!= NULL
)
9326 free (finfo
.internal_syms
);
9327 if (finfo
.indices
!= NULL
)
9328 free (finfo
.indices
);
9329 if (finfo
.sections
!= NULL
)
9330 free (finfo
.sections
);
9331 if (finfo
.symbuf
!= NULL
)
9332 free (finfo
.symbuf
);
9333 if (finfo
.symshndxbuf
!= NULL
)
9334 free (finfo
.symshndxbuf
);
9335 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
9337 if ((o
->flags
& SEC_RELOC
) != 0
9338 && elf_section_data (o
)->rel_hashes
!= NULL
)
9339 free (elf_section_data (o
)->rel_hashes
);
9345 /* Garbage collect unused sections. */
9347 typedef asection
* (*gc_mark_hook_fn
)
9348 (asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
9349 struct elf_link_hash_entry
*, Elf_Internal_Sym
*);
9351 /* Default gc_mark_hook. */
9354 _bfd_elf_gc_mark_hook (asection
*sec
,
9355 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
9356 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
,
9357 struct elf_link_hash_entry
*h
,
9358 Elf_Internal_Sym
*sym
)
9362 switch (h
->root
.type
)
9364 case bfd_link_hash_defined
:
9365 case bfd_link_hash_defweak
:
9366 return h
->root
.u
.def
.section
;
9368 case bfd_link_hash_common
:
9369 return h
->root
.u
.c
.p
->section
;
9376 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
9381 /* The mark phase of garbage collection. For a given section, mark
9382 it and any sections in this section's group, and all the sections
9383 which define symbols to which it refers. */
9386 _bfd_elf_gc_mark (struct bfd_link_info
*info
,
9388 gc_mark_hook_fn gc_mark_hook
)
9392 asection
*group_sec
;
9396 /* Mark all the sections in the group. */
9397 group_sec
= elf_section_data (sec
)->next_in_group
;
9398 if (group_sec
&& !group_sec
->gc_mark
)
9399 if (!_bfd_elf_gc_mark (info
, group_sec
, gc_mark_hook
))
9402 /* Look through the section relocs. */
9404 is_eh
= strcmp (sec
->name
, ".eh_frame") == 0;
9405 if ((sec
->flags
& SEC_RELOC
) != 0 && sec
->reloc_count
> 0)
9407 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
9408 Elf_Internal_Shdr
*symtab_hdr
;
9409 struct elf_link_hash_entry
**sym_hashes
;
9412 bfd
*input_bfd
= sec
->owner
;
9413 const struct elf_backend_data
*bed
= get_elf_backend_data (input_bfd
);
9414 Elf_Internal_Sym
*isym
= NULL
;
9417 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
9418 sym_hashes
= elf_sym_hashes (input_bfd
);
9420 /* Read the local symbols. */
9421 if (elf_bad_symtab (input_bfd
))
9423 nlocsyms
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
9427 extsymoff
= nlocsyms
= symtab_hdr
->sh_info
;
9429 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
9430 if (isym
== NULL
&& nlocsyms
!= 0)
9432 isym
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, nlocsyms
, 0,
9438 /* Read the relocations. */
9439 relstart
= _bfd_elf_link_read_relocs (input_bfd
, sec
, NULL
, NULL
,
9441 if (relstart
== NULL
)
9446 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9448 if (bed
->s
->arch_size
== 32)
9453 for (rel
= relstart
; rel
< relend
; rel
++)
9455 unsigned long r_symndx
;
9457 struct elf_link_hash_entry
*h
;
9459 r_symndx
= rel
->r_info
>> r_sym_shift
;
9463 if (r_symndx
>= nlocsyms
9464 || ELF_ST_BIND (isym
[r_symndx
].st_info
) != STB_LOCAL
)
9466 h
= sym_hashes
[r_symndx
- extsymoff
];
9467 while (h
->root
.type
== bfd_link_hash_indirect
9468 || h
->root
.type
== bfd_link_hash_warning
)
9469 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9470 rsec
= (*gc_mark_hook
) (sec
, info
, rel
, h
, NULL
);
9474 rsec
= (*gc_mark_hook
) (sec
, info
, rel
, NULL
, &isym
[r_symndx
]);
9477 if (rsec
&& !rsec
->gc_mark
)
9479 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
)
9482 rsec
->gc_mark_from_eh
= 1;
9483 else if (!_bfd_elf_gc_mark (info
, rsec
, gc_mark_hook
))
9492 if (elf_section_data (sec
)->relocs
!= relstart
)
9495 if (isym
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isym
)
9497 if (! info
->keep_memory
)
9500 symtab_hdr
->contents
= (unsigned char *) isym
;
9507 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
9509 struct elf_gc_sweep_symbol_info
9511 struct bfd_link_info
*info
;
9512 void (*hide_symbol
) (struct bfd_link_info
*, struct elf_link_hash_entry
*,
9517 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *data
)
9519 if (h
->root
.type
== bfd_link_hash_warning
)
9520 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9522 if ((h
->root
.type
== bfd_link_hash_defined
9523 || h
->root
.type
== bfd_link_hash_defweak
)
9524 && !h
->root
.u
.def
.section
->gc_mark
9525 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
9527 struct elf_gc_sweep_symbol_info
*inf
= data
;
9528 (*inf
->hide_symbol
) (inf
->info
, h
, TRUE
);
9534 /* The sweep phase of garbage collection. Remove all garbage sections. */
9536 typedef bfd_boolean (*gc_sweep_hook_fn
)
9537 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
9540 elf_gc_sweep (bfd
*abfd
, struct bfd_link_info
*info
)
9543 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9544 gc_sweep_hook_fn gc_sweep_hook
= bed
->gc_sweep_hook
;
9545 unsigned long section_sym_count
;
9546 struct elf_gc_sweep_symbol_info sweep_info
;
9548 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
9552 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
9555 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
9557 /* Keep debug and special sections. */
9558 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
9559 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
9565 /* Skip sweeping sections already excluded. */
9566 if (o
->flags
& SEC_EXCLUDE
)
9569 /* Since this is early in the link process, it is simple
9570 to remove a section from the output. */
9571 o
->flags
|= SEC_EXCLUDE
;
9573 if (info
->print_gc_sections
== TRUE
)
9574 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub
, o
->name
);
9576 /* But we also have to update some of the relocation
9577 info we collected before. */
9579 && (o
->flags
& SEC_RELOC
) != 0
9580 && o
->reloc_count
> 0
9581 && !bfd_is_abs_section (o
->output_section
))
9583 Elf_Internal_Rela
*internal_relocs
;
9587 = _bfd_elf_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
9589 if (internal_relocs
== NULL
)
9592 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
9594 if (elf_section_data (o
)->relocs
!= internal_relocs
)
9595 free (internal_relocs
);
9603 /* Remove the symbols that were in the swept sections from the dynamic
9604 symbol table. GCFIXME: Anyone know how to get them out of the
9605 static symbol table as well? */
9606 sweep_info
.info
= info
;
9607 sweep_info
.hide_symbol
= bed
->elf_backend_hide_symbol
;
9608 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
,
9611 _bfd_elf_link_renumber_dynsyms (abfd
, info
, §ion_sym_count
);
9615 /* Propagate collected vtable information. This is called through
9616 elf_link_hash_traverse. */
9619 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
9621 if (h
->root
.type
== bfd_link_hash_warning
)
9622 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9624 /* Those that are not vtables. */
9625 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
9628 /* Those vtables that do not have parents, we cannot merge. */
9629 if (h
->vtable
->parent
== (struct elf_link_hash_entry
*) -1)
9632 /* If we've already been done, exit. */
9633 if (h
->vtable
->used
&& h
->vtable
->used
[-1])
9636 /* Make sure the parent's table is up to date. */
9637 elf_gc_propagate_vtable_entries_used (h
->vtable
->parent
, okp
);
9639 if (h
->vtable
->used
== NULL
)
9641 /* None of this table's entries were referenced. Re-use the
9643 h
->vtable
->used
= h
->vtable
->parent
->vtable
->used
;
9644 h
->vtable
->size
= h
->vtable
->parent
->vtable
->size
;
9649 bfd_boolean
*cu
, *pu
;
9651 /* Or the parent's entries into ours. */
9652 cu
= h
->vtable
->used
;
9654 pu
= h
->vtable
->parent
->vtable
->used
;
9657 const struct elf_backend_data
*bed
;
9658 unsigned int log_file_align
;
9660 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
9661 log_file_align
= bed
->s
->log_file_align
;
9662 n
= h
->vtable
->parent
->vtable
->size
>> log_file_align
;
9677 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
, void *okp
)
9680 bfd_vma hstart
, hend
;
9681 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
9682 const struct elf_backend_data
*bed
;
9683 unsigned int log_file_align
;
9685 if (h
->root
.type
== bfd_link_hash_warning
)
9686 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9688 /* Take care of both those symbols that do not describe vtables as
9689 well as those that are not loaded. */
9690 if (h
->vtable
== NULL
|| h
->vtable
->parent
== NULL
)
9693 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
9694 || h
->root
.type
== bfd_link_hash_defweak
);
9696 sec
= h
->root
.u
.def
.section
;
9697 hstart
= h
->root
.u
.def
.value
;
9698 hend
= hstart
+ h
->size
;
9700 relstart
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, TRUE
);
9702 return *(bfd_boolean
*) okp
= FALSE
;
9703 bed
= get_elf_backend_data (sec
->owner
);
9704 log_file_align
= bed
->s
->log_file_align
;
9706 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9708 for (rel
= relstart
; rel
< relend
; ++rel
)
9709 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
9711 /* If the entry is in use, do nothing. */
9713 && (rel
->r_offset
- hstart
) < h
->vtable
->size
)
9715 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
9716 if (h
->vtable
->used
[entry
])
9719 /* Otherwise, kill it. */
9720 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
9726 /* Mark sections containing dynamically referenced symbols. When
9727 building shared libraries, we must assume that any visible symbol is
9731 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry
*h
, void *inf
)
9733 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
9735 if (h
->root
.type
== bfd_link_hash_warning
)
9736 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9738 if ((h
->root
.type
== bfd_link_hash_defined
9739 || h
->root
.type
== bfd_link_hash_defweak
)
9741 || (!info
->executable
9743 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
9744 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
)))
9745 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
9750 /* Do mark and sweep of unused sections. */
9753 bfd_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
9755 bfd_boolean ok
= TRUE
;
9757 asection
* (*gc_mark_hook
)
9758 (asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
9759 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*);
9760 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9762 if (!bed
->can_gc_sections
9763 || info
->relocatable
9764 || info
->emitrelocations
9765 || !is_elf_hash_table (info
->hash
))
9767 (*_bfd_error_handler
)(_("Warning: gc-sections option ignored"));
9771 /* Apply transitive closure to the vtable entry usage info. */
9772 elf_link_hash_traverse (elf_hash_table (info
),
9773 elf_gc_propagate_vtable_entries_used
,
9778 /* Kill the vtable relocations that were not used. */
9779 elf_link_hash_traverse (elf_hash_table (info
),
9780 elf_gc_smash_unused_vtentry_relocs
,
9785 /* Mark dynamically referenced symbols. */
9786 if (elf_hash_table (info
)->dynamic_sections_created
)
9787 elf_link_hash_traverse (elf_hash_table (info
),
9788 bed
->gc_mark_dynamic_ref
,
9791 /* Grovel through relocs to find out who stays ... */
9792 gc_mark_hook
= bed
->gc_mark_hook
;
9793 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
9797 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
9800 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
9801 if ((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
&& !o
->gc_mark
)
9802 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
9806 /* ... again for sections marked from eh_frame. */
9807 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
9811 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
9814 /* Keep .gcc_except_table.* if the associated .text.* is
9815 marked. This isn't very nice, but the proper solution,
9816 splitting .eh_frame up and using comdat doesn't pan out
9817 easily due to needing special relocs to handle the
9818 difference of two symbols in separate sections.
9819 Don't keep code sections referenced by .eh_frame. */
9820 #define TEXT_PREFIX ".text."
9821 #define GCC_EXCEPT_TABLE_PREFIX ".gcc_except_table."
9822 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
9823 if (!o
->gc_mark
&& o
->gc_mark_from_eh
&& (o
->flags
& SEC_CODE
) == 0)
9825 if (CONST_STRNEQ (o
->name
, GCC_EXCEPT_TABLE_PREFIX
))
9828 const char *sec_name
;
9830 unsigned o_name_prefix_len
= strlen (GCC_EXCEPT_TABLE_PREFIX
);
9831 unsigned fn_name_prefix_len
= strlen (TEXT_PREFIX
);
9833 sec_name
= o
->name
+ o_name_prefix_len
;
9834 fn_name
= bfd_malloc (strlen (sec_name
) + fn_name_prefix_len
+ 1);
9835 if (fn_name
== NULL
)
9837 sprintf (fn_name
, "%s%s", TEXT_PREFIX
, sec_name
);
9838 fn_text
= bfd_get_section_by_name (sub
, fn_name
);
9840 if (fn_text
== NULL
|| !fn_text
->gc_mark
)
9844 /* If not using specially named exception table section,
9845 then keep whatever we are using. */
9846 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
9851 /* ... and mark SEC_EXCLUDE for those that go. */
9852 return elf_gc_sweep (abfd
, info
);
9855 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
9858 bfd_elf_gc_record_vtinherit (bfd
*abfd
,
9860 struct elf_link_hash_entry
*h
,
9863 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
9864 struct elf_link_hash_entry
**search
, *child
;
9865 bfd_size_type extsymcount
;
9866 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9868 /* The sh_info field of the symtab header tells us where the
9869 external symbols start. We don't care about the local symbols at
9871 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/ bed
->s
->sizeof_sym
;
9872 if (!elf_bad_symtab (abfd
))
9873 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
9875 sym_hashes
= elf_sym_hashes (abfd
);
9876 sym_hashes_end
= sym_hashes
+ extsymcount
;
9878 /* Hunt down the child symbol, which is in this section at the same
9879 offset as the relocation. */
9880 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
9882 if ((child
= *search
) != NULL
9883 && (child
->root
.type
== bfd_link_hash_defined
9884 || child
->root
.type
== bfd_link_hash_defweak
)
9885 && child
->root
.u
.def
.section
== sec
9886 && child
->root
.u
.def
.value
== offset
)
9890 (*_bfd_error_handler
) ("%B: %A+%lu: No symbol found for INHERIT",
9891 abfd
, sec
, (unsigned long) offset
);
9892 bfd_set_error (bfd_error_invalid_operation
);
9898 child
->vtable
= bfd_zalloc (abfd
, sizeof (*child
->vtable
));
9904 /* This *should* only be the absolute section. It could potentially
9905 be that someone has defined a non-global vtable though, which
9906 would be bad. It isn't worth paging in the local symbols to be
9907 sure though; that case should simply be handled by the assembler. */
9909 child
->vtable
->parent
= (struct elf_link_hash_entry
*) -1;
9912 child
->vtable
->parent
= h
;
9917 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
9920 bfd_elf_gc_record_vtentry (bfd
*abfd ATTRIBUTE_UNUSED
,
9921 asection
*sec ATTRIBUTE_UNUSED
,
9922 struct elf_link_hash_entry
*h
,
9925 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9926 unsigned int log_file_align
= bed
->s
->log_file_align
;
9930 h
->vtable
= bfd_zalloc (abfd
, sizeof (*h
->vtable
));
9935 if (addend
>= h
->vtable
->size
)
9937 size_t size
, bytes
, file_align
;
9938 bfd_boolean
*ptr
= h
->vtable
->used
;
9940 /* While the symbol is undefined, we have to be prepared to handle
9942 file_align
= 1 << log_file_align
;
9943 if (h
->root
.type
== bfd_link_hash_undefined
)
9944 size
= addend
+ file_align
;
9950 /* Oops! We've got a reference past the defined end of
9951 the table. This is probably a bug -- shall we warn? */
9952 size
= addend
+ file_align
;
9955 size
= (size
+ file_align
- 1) & -file_align
;
9957 /* Allocate one extra entry for use as a "done" flag for the
9958 consolidation pass. */
9959 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bfd_boolean
);
9963 ptr
= bfd_realloc (ptr
- 1, bytes
);
9969 oldbytes
= (((h
->vtable
->size
>> log_file_align
) + 1)
9970 * sizeof (bfd_boolean
));
9971 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
9975 ptr
= bfd_zmalloc (bytes
);
9980 /* And arrange for that done flag to be at index -1. */
9981 h
->vtable
->used
= ptr
+ 1;
9982 h
->vtable
->size
= size
;
9985 h
->vtable
->used
[addend
>> log_file_align
] = TRUE
;
9990 struct alloc_got_off_arg
{
9992 unsigned int got_elt_size
;
9995 /* We need a special top-level link routine to convert got reference counts
9996 to real got offsets. */
9999 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *arg
)
10001 struct alloc_got_off_arg
*gofarg
= arg
;
10003 if (h
->root
.type
== bfd_link_hash_warning
)
10004 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10006 if (h
->got
.refcount
> 0)
10008 h
->got
.offset
= gofarg
->gotoff
;
10009 gofarg
->gotoff
+= gofarg
->got_elt_size
;
10012 h
->got
.offset
= (bfd_vma
) -1;
10017 /* And an accompanying bit to work out final got entry offsets once
10018 we're done. Should be called from final_link. */
10021 bfd_elf_gc_common_finalize_got_offsets (bfd
*abfd
,
10022 struct bfd_link_info
*info
)
10025 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10027 unsigned int got_elt_size
= bed
->s
->arch_size
/ 8;
10028 struct alloc_got_off_arg gofarg
;
10030 if (! is_elf_hash_table (info
->hash
))
10033 /* The GOT offset is relative to the .got section, but the GOT header is
10034 put into the .got.plt section, if the backend uses it. */
10035 if (bed
->want_got_plt
)
10038 gotoff
= bed
->got_header_size
;
10040 /* Do the local .got entries first. */
10041 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
10043 bfd_signed_vma
*local_got
;
10044 bfd_size_type j
, locsymcount
;
10045 Elf_Internal_Shdr
*symtab_hdr
;
10047 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
10050 local_got
= elf_local_got_refcounts (i
);
10054 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
10055 if (elf_bad_symtab (i
))
10056 locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
10058 locsymcount
= symtab_hdr
->sh_info
;
10060 for (j
= 0; j
< locsymcount
; ++j
)
10062 if (local_got
[j
] > 0)
10064 local_got
[j
] = gotoff
;
10065 gotoff
+= got_elt_size
;
10068 local_got
[j
] = (bfd_vma
) -1;
10072 /* Then the global .got entries. .plt refcounts are handled by
10073 adjust_dynamic_symbol */
10074 gofarg
.gotoff
= gotoff
;
10075 gofarg
.got_elt_size
= got_elt_size
;
10076 elf_link_hash_traverse (elf_hash_table (info
),
10077 elf_gc_allocate_got_offsets
,
10082 /* Many folk need no more in the way of final link than this, once
10083 got entry reference counting is enabled. */
10086 bfd_elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10088 if (!bfd_elf_gc_common_finalize_got_offsets (abfd
, info
))
10091 /* Invoke the regular ELF backend linker to do all the work. */
10092 return bfd_elf_final_link (abfd
, info
);
10096 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
10098 struct elf_reloc_cookie
*rcookie
= cookie
;
10100 if (rcookie
->bad_symtab
)
10101 rcookie
->rel
= rcookie
->rels
;
10103 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
10105 unsigned long r_symndx
;
10107 if (! rcookie
->bad_symtab
)
10108 if (rcookie
->rel
->r_offset
> offset
)
10110 if (rcookie
->rel
->r_offset
!= offset
)
10113 r_symndx
= rcookie
->rel
->r_info
>> rcookie
->r_sym_shift
;
10114 if (r_symndx
== SHN_UNDEF
)
10117 if (r_symndx
>= rcookie
->locsymcount
10118 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
10120 struct elf_link_hash_entry
*h
;
10122 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
10124 while (h
->root
.type
== bfd_link_hash_indirect
10125 || h
->root
.type
== bfd_link_hash_warning
)
10126 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10128 if ((h
->root
.type
== bfd_link_hash_defined
10129 || h
->root
.type
== bfd_link_hash_defweak
)
10130 && elf_discarded_section (h
->root
.u
.def
.section
))
10137 /* It's not a relocation against a global symbol,
10138 but it could be a relocation against a local
10139 symbol for a discarded section. */
10141 Elf_Internal_Sym
*isym
;
10143 /* Need to: get the symbol; get the section. */
10144 isym
= &rcookie
->locsyms
[r_symndx
];
10145 if (isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
10147 isec
= bfd_section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
10148 if (isec
!= NULL
&& elf_discarded_section (isec
))
10157 /* Discard unneeded references to discarded sections.
10158 Returns TRUE if any section's size was changed. */
10159 /* This function assumes that the relocations are in sorted order,
10160 which is true for all known assemblers. */
10163 bfd_elf_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
10165 struct elf_reloc_cookie cookie
;
10166 asection
*stab
, *eh
;
10167 Elf_Internal_Shdr
*symtab_hdr
;
10168 const struct elf_backend_data
*bed
;
10170 unsigned int count
;
10171 bfd_boolean ret
= FALSE
;
10173 if (info
->traditional_format
10174 || !is_elf_hash_table (info
->hash
))
10177 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
10179 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
10182 bed
= get_elf_backend_data (abfd
);
10184 if ((abfd
->flags
& DYNAMIC
) != 0)
10187 eh
= bfd_get_section_by_name (abfd
, ".eh_frame");
10188 if (info
->relocatable
10191 || bfd_is_abs_section (eh
->output_section
))))
10194 stab
= bfd_get_section_by_name (abfd
, ".stab");
10196 && (stab
->size
== 0
10197 || bfd_is_abs_section (stab
->output_section
)
10198 || stab
->sec_info_type
!= ELF_INFO_TYPE_STABS
))
10203 && bed
->elf_backend_discard_info
== NULL
)
10206 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10207 cookie
.abfd
= abfd
;
10208 cookie
.sym_hashes
= elf_sym_hashes (abfd
);
10209 cookie
.bad_symtab
= elf_bad_symtab (abfd
);
10210 if (cookie
.bad_symtab
)
10212 cookie
.locsymcount
= symtab_hdr
->sh_size
/ bed
->s
->sizeof_sym
;
10213 cookie
.extsymoff
= 0;
10217 cookie
.locsymcount
= symtab_hdr
->sh_info
;
10218 cookie
.extsymoff
= symtab_hdr
->sh_info
;
10221 if (bed
->s
->arch_size
== 32)
10222 cookie
.r_sym_shift
= 8;
10224 cookie
.r_sym_shift
= 32;
10226 cookie
.locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
10227 if (cookie
.locsyms
== NULL
&& cookie
.locsymcount
!= 0)
10229 cookie
.locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
10230 cookie
.locsymcount
, 0,
10232 if (cookie
.locsyms
== NULL
)
10238 cookie
.rels
= NULL
;
10239 count
= stab
->reloc_count
;
10241 cookie
.rels
= _bfd_elf_link_read_relocs (abfd
, stab
, NULL
, NULL
,
10242 info
->keep_memory
);
10243 if (cookie
.rels
!= NULL
)
10245 cookie
.rel
= cookie
.rels
;
10246 cookie
.relend
= cookie
.rels
;
10247 cookie
.relend
+= count
* bed
->s
->int_rels_per_ext_rel
;
10248 if (_bfd_discard_section_stabs (abfd
, stab
,
10249 elf_section_data (stab
)->sec_info
,
10250 bfd_elf_reloc_symbol_deleted_p
,
10253 if (elf_section_data (stab
)->relocs
!= cookie
.rels
)
10254 free (cookie
.rels
);
10260 cookie
.rels
= NULL
;
10261 count
= eh
->reloc_count
;
10263 cookie
.rels
= _bfd_elf_link_read_relocs (abfd
, eh
, NULL
, NULL
,
10264 info
->keep_memory
);
10265 cookie
.rel
= cookie
.rels
;
10266 cookie
.relend
= cookie
.rels
;
10267 if (cookie
.rels
!= NULL
)
10268 cookie
.relend
+= count
* bed
->s
->int_rels_per_ext_rel
;
10270 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, eh
,
10271 bfd_elf_reloc_symbol_deleted_p
,
10275 if (cookie
.rels
!= NULL
10276 && elf_section_data (eh
)->relocs
!= cookie
.rels
)
10277 free (cookie
.rels
);
10280 if (bed
->elf_backend_discard_info
!= NULL
10281 && (*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
10284 if (cookie
.locsyms
!= NULL
10285 && symtab_hdr
->contents
!= (unsigned char *) cookie
.locsyms
)
10287 if (! info
->keep_memory
)
10288 free (cookie
.locsyms
);
10290 symtab_hdr
->contents
= (unsigned char *) cookie
.locsyms
;
10294 if (info
->eh_frame_hdr
10295 && !info
->relocatable
10296 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
10303 _bfd_elf_section_already_linked (bfd
*abfd
, struct bfd_section
*sec
,
10304 struct bfd_link_info
*info
)
10307 const char *name
, *p
;
10308 struct bfd_section_already_linked
*l
;
10309 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
10311 if (sec
->output_section
== bfd_abs_section_ptr
)
10314 flags
= sec
->flags
;
10316 /* Return if it isn't a linkonce section. A comdat group section
10317 also has SEC_LINK_ONCE set. */
10318 if ((flags
& SEC_LINK_ONCE
) == 0)
10321 /* Don't put group member sections on our list of already linked
10322 sections. They are handled as a group via their group section. */
10323 if (elf_sec_group (sec
) != NULL
)
10326 /* FIXME: When doing a relocatable link, we may have trouble
10327 copying relocations in other sections that refer to local symbols
10328 in the section being discarded. Those relocations will have to
10329 be converted somehow; as of this writing I'm not sure that any of
10330 the backends handle that correctly.
10332 It is tempting to instead not discard link once sections when
10333 doing a relocatable link (technically, they should be discarded
10334 whenever we are building constructors). However, that fails,
10335 because the linker winds up combining all the link once sections
10336 into a single large link once section, which defeats the purpose
10337 of having link once sections in the first place.
10339 Also, not merging link once sections in a relocatable link
10340 causes trouble for MIPS ELF, which relies on link once semantics
10341 to handle the .reginfo section correctly. */
10343 name
= bfd_get_section_name (abfd
, sec
);
10345 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
10346 && (p
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
10351 already_linked_list
= bfd_section_already_linked_table_lookup (p
);
10353 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
10355 /* We may have 2 different types of sections on the list: group
10356 sections and linkonce sections. Match like sections. */
10357 if ((flags
& SEC_GROUP
) == (l
->sec
->flags
& SEC_GROUP
)
10358 && strcmp (name
, l
->sec
->name
) == 0
10359 && bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
) == NULL
)
10361 /* The section has already been linked. See if we should
10362 issue a warning. */
10363 switch (flags
& SEC_LINK_DUPLICATES
)
10368 case SEC_LINK_DUPLICATES_DISCARD
:
10371 case SEC_LINK_DUPLICATES_ONE_ONLY
:
10372 (*_bfd_error_handler
)
10373 (_("%B: ignoring duplicate section `%A'"),
10377 case SEC_LINK_DUPLICATES_SAME_SIZE
:
10378 if (sec
->size
!= l
->sec
->size
)
10379 (*_bfd_error_handler
)
10380 (_("%B: duplicate section `%A' has different size"),
10384 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
10385 if (sec
->size
!= l
->sec
->size
)
10386 (*_bfd_error_handler
)
10387 (_("%B: duplicate section `%A' has different size"),
10389 else if (sec
->size
!= 0)
10391 bfd_byte
*sec_contents
, *l_sec_contents
;
10393 if (!bfd_malloc_and_get_section (abfd
, sec
, &sec_contents
))
10394 (*_bfd_error_handler
)
10395 (_("%B: warning: could not read contents of section `%A'"),
10397 else if (!bfd_malloc_and_get_section (l
->sec
->owner
, l
->sec
,
10399 (*_bfd_error_handler
)
10400 (_("%B: warning: could not read contents of section `%A'"),
10401 l
->sec
->owner
, l
->sec
);
10402 else if (memcmp (sec_contents
, l_sec_contents
, sec
->size
) != 0)
10403 (*_bfd_error_handler
)
10404 (_("%B: warning: duplicate section `%A' has different contents"),
10408 free (sec_contents
);
10409 if (l_sec_contents
)
10410 free (l_sec_contents
);
10415 /* Set the output_section field so that lang_add_section
10416 does not create a lang_input_section structure for this
10417 section. Since there might be a symbol in the section
10418 being discarded, we must retain a pointer to the section
10419 which we are really going to use. */
10420 sec
->output_section
= bfd_abs_section_ptr
;
10421 sec
->kept_section
= l
->sec
;
10423 if (flags
& SEC_GROUP
)
10425 asection
*first
= elf_next_in_group (sec
);
10426 asection
*s
= first
;
10430 s
->output_section
= bfd_abs_section_ptr
;
10431 /* Record which group discards it. */
10432 s
->kept_section
= l
->sec
;
10433 s
= elf_next_in_group (s
);
10434 /* These lists are circular. */
10444 /* A single member comdat group section may be discarded by a
10445 linkonce section and vice versa. */
10447 if ((flags
& SEC_GROUP
) != 0)
10449 asection
*first
= elf_next_in_group (sec
);
10451 if (first
!= NULL
&& elf_next_in_group (first
) == first
)
10452 /* Check this single member group against linkonce sections. */
10453 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
10454 if ((l
->sec
->flags
& SEC_GROUP
) == 0
10455 && bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
) == NULL
10456 && bfd_elf_match_symbols_in_sections (l
->sec
, first
, info
))
10458 first
->output_section
= bfd_abs_section_ptr
;
10459 first
->kept_section
= l
->sec
;
10460 sec
->output_section
= bfd_abs_section_ptr
;
10465 /* Check this linkonce section against single member groups. */
10466 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
10467 if (l
->sec
->flags
& SEC_GROUP
)
10469 asection
*first
= elf_next_in_group (l
->sec
);
10472 && elf_next_in_group (first
) == first
10473 && bfd_elf_match_symbols_in_sections (first
, sec
, info
))
10475 sec
->output_section
= bfd_abs_section_ptr
;
10476 sec
->kept_section
= first
;
10481 /* This is the first section with this name. Record it. */
10482 bfd_section_already_linked_table_insert (already_linked_list
, sec
);
10486 _bfd_elf_common_definition (Elf_Internal_Sym
*sym
)
10488 return sym
->st_shndx
== SHN_COMMON
;
10492 _bfd_elf_common_section_index (asection
*sec ATTRIBUTE_UNUSED
)
10498 _bfd_elf_common_section (asection
*sec ATTRIBUTE_UNUSED
)
10500 return bfd_com_section_ptr
;