1 /* ELF linking support for BFD.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
29 #include "safe-ctype.h"
30 #include "libiberty.h"
33 /* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
36 struct elf_info_failed
38 struct bfd_link_info *info;
39 struct bfd_elf_version_tree *verdefs;
43 /* This structure is used to pass information to
44 _bfd_elf_link_find_version_dependencies. */
46 struct elf_find_verdep_info
48 /* General link information. */
49 struct bfd_link_info *info;
50 /* The number of dependencies. */
52 /* Whether we had a failure. */
56 static bfd_boolean _bfd_elf_fix_symbol_flags
57 (struct elf_link_hash_entry *, struct elf_info_failed *);
59 /* Define a symbol in a dynamic linkage section. */
61 struct elf_link_hash_entry *
62 _bfd_elf_define_linkage_sym (bfd *abfd,
63 struct bfd_link_info *info,
67 struct elf_link_hash_entry *h;
68 struct bfd_link_hash_entry *bh;
69 const struct elf_backend_data *bed;
71 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
74 /* Zap symbol defined in an as-needed lib that wasn't linked.
75 This is a symptom of a larger problem: Absolute symbols
76 defined in shared libraries can't be overridden, because we
77 lose the link to the bfd which is via the symbol section. */
78 h->root.type = bfd_link_hash_new;
82 if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
84 get_elf_backend_data (abfd)->collect,
87 h = (struct elf_link_hash_entry *) bh;
90 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
92 bed = get_elf_backend_data (abfd);
93 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
98 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
102 struct elf_link_hash_entry *h;
103 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
104 struct elf_link_hash_table *htab = elf_hash_table (info);
106 /* This function may be called more than once. */
107 s = bfd_get_section_by_name (abfd, ".got");
108 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
111 flags = bed->dynamic_sec_flags;
113 s = bfd_make_section_with_flags (abfd,
114 (bed->rela_plts_and_copies_p
115 ? ".rela.got" : ".rel.got"),
116 (bed->dynamic_sec_flags
119 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
123 s = bfd_make_section_with_flags (abfd, ".got", flags);
125 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
129 if (bed->want_got_plt)
131 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
133 || !bfd_set_section_alignment (abfd, s,
134 bed->s->log_file_align))
139 /* The first bit of the global offset table is the header. */
140 s->size += bed->got_header_size;
142 if (bed->want_got_sym)
144 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
145 (or .got.plt) section. We don't do this in the linker script
146 because we don't want to define the symbol if we are not creating
147 a global offset table. */
148 h = _bfd_elf_define_linkage_sym (abfd, info, s,
149 "_GLOBAL_OFFSET_TABLE_");
150 elf_hash_table (info)->hgot = h;
158 /* Create a strtab to hold the dynamic symbol names. */
160 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
162 struct elf_link_hash_table *hash_table;
164 hash_table = elf_hash_table (info);
165 if (hash_table->dynobj == NULL)
166 hash_table->dynobj = abfd;
168 if (hash_table->dynstr == NULL)
170 hash_table->dynstr = _bfd_elf_strtab_init ();
171 if (hash_table->dynstr == NULL)
177 /* Create some sections which will be filled in with dynamic linking
178 information. ABFD is an input file which requires dynamic sections
179 to be created. The dynamic sections take up virtual memory space
180 when the final executable is run, so we need to create them before
181 addresses are assigned to the output sections. We work out the
182 actual contents and size of these sections later. */
185 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
188 register asection *s;
189 const struct elf_backend_data *bed;
191 if (! is_elf_hash_table (info->hash))
194 if (elf_hash_table (info)->dynamic_sections_created)
197 if (!_bfd_elf_link_create_dynstrtab (abfd, info))
200 abfd = elf_hash_table (info)->dynobj;
201 bed = get_elf_backend_data (abfd);
203 flags = bed->dynamic_sec_flags;
205 /* A dynamically linked executable has a .interp section, but a
206 shared library does not. */
207 if (info->executable)
209 s = bfd_make_section_with_flags (abfd, ".interp",
210 flags | SEC_READONLY);
215 /* Create sections to hold version informations. These are removed
216 if they are not needed. */
217 s = bfd_make_section_with_flags (abfd, ".gnu.version_d",
218 flags | SEC_READONLY);
220 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
223 s = bfd_make_section_with_flags (abfd, ".gnu.version",
224 flags | SEC_READONLY);
226 || ! bfd_set_section_alignment (abfd, s, 1))
229 s = bfd_make_section_with_flags (abfd, ".gnu.version_r",
230 flags | SEC_READONLY);
232 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
235 s = bfd_make_section_with_flags (abfd, ".dynsym",
236 flags | SEC_READONLY);
238 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
241 s = bfd_make_section_with_flags (abfd, ".dynstr",
242 flags | SEC_READONLY);
246 s = bfd_make_section_with_flags (abfd, ".dynamic", flags);
248 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
251 /* The special symbol _DYNAMIC is always set to the start of the
252 .dynamic section. We could set _DYNAMIC in a linker script, but we
253 only want to define it if we are, in fact, creating a .dynamic
254 section. We don't want to define it if there is no .dynamic
255 section, since on some ELF platforms the start up code examines it
256 to decide how to initialize the process. */
257 if (!_bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC"))
262 s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY);
264 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
266 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
269 if (info->emit_gnu_hash)
271 s = bfd_make_section_with_flags (abfd, ".gnu.hash",
272 flags | SEC_READONLY);
274 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
276 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
277 4 32-bit words followed by variable count of 64-bit words, then
278 variable count of 32-bit words. */
279 if (bed->s->arch_size == 64)
280 elf_section_data (s)->this_hdr.sh_entsize = 0;
282 elf_section_data (s)->this_hdr.sh_entsize = 4;
285 /* Let the backend create the rest of the sections. This lets the
286 backend set the right flags. The backend will normally create
287 the .got and .plt sections. */
288 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
291 elf_hash_table (info)->dynamic_sections_created = TRUE;
296 /* Create dynamic sections when linking against a dynamic object. */
299 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
301 flagword flags, pltflags;
302 struct elf_link_hash_entry *h;
304 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
305 struct elf_link_hash_table *htab = elf_hash_table (info);
307 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
308 .rel[a].bss sections. */
309 flags = bed->dynamic_sec_flags;
312 if (bed->plt_not_loaded)
313 /* We do not clear SEC_ALLOC here because we still want the OS to
314 allocate space for the section; it's just that there's nothing
315 to read in from the object file. */
316 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
318 pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
319 if (bed->plt_readonly)
320 pltflags |= SEC_READONLY;
322 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
324 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
328 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
330 if (bed->want_plt_sym)
332 h = _bfd_elf_define_linkage_sym (abfd, info, s,
333 "_PROCEDURE_LINKAGE_TABLE_");
334 elf_hash_table (info)->hplt = h;
339 s = bfd_make_section_with_flags (abfd,
340 (bed->rela_plts_and_copies_p
341 ? ".rela.plt" : ".rel.plt"),
342 flags | SEC_READONLY);
344 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
348 if (! _bfd_elf_create_got_section (abfd, info))
351 if (bed->want_dynbss)
353 /* The .dynbss section is a place to put symbols which are defined
354 by dynamic objects, are referenced by regular objects, and are
355 not functions. We must allocate space for them in the process
356 image and use a R_*_COPY reloc to tell the dynamic linker to
357 initialize them at run time. The linker script puts the .dynbss
358 section into the .bss section of the final image. */
359 s = bfd_make_section_with_flags (abfd, ".dynbss",
361 | SEC_LINKER_CREATED));
365 /* The .rel[a].bss section holds copy relocs. This section is not
366 normally needed. We need to create it here, though, so that the
367 linker will map it to an output section. We can't just create it
368 only if we need it, because we will not know whether we need it
369 until we have seen all the input files, and the first time the
370 main linker code calls BFD after examining all the input files
371 (size_dynamic_sections) the input sections have already been
372 mapped to the output sections. If the section turns out not to
373 be needed, we can discard it later. We will never need this
374 section when generating a shared object, since they do not use
378 s = bfd_make_section_with_flags (abfd,
379 (bed->rela_plts_and_copies_p
380 ? ".rela.bss" : ".rel.bss"),
381 flags | SEC_READONLY);
383 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
391 /* Record a new dynamic symbol. We record the dynamic symbols as we
392 read the input files, since we need to have a list of all of them
393 before we can determine the final sizes of the output sections.
394 Note that we may actually call this function even though we are not
395 going to output any dynamic symbols; in some cases we know that a
396 symbol should be in the dynamic symbol table, but only if there is
400 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
401 struct elf_link_hash_entry *h)
403 if (h->dynindx == -1)
405 struct elf_strtab_hash *dynstr;
410 /* XXX: The ABI draft says the linker must turn hidden and
411 internal symbols into STB_LOCAL symbols when producing the
412 DSO. However, if ld.so honors st_other in the dynamic table,
413 this would not be necessary. */
414 switch (ELF_ST_VISIBILITY (h->other))
418 if (h->root.type != bfd_link_hash_undefined
419 && h->root.type != bfd_link_hash_undefweak)
422 if (!elf_hash_table (info)->is_relocatable_executable)
430 h->dynindx = elf_hash_table (info)->dynsymcount;
431 ++elf_hash_table (info)->dynsymcount;
433 dynstr = elf_hash_table (info)->dynstr;
436 /* Create a strtab to hold the dynamic symbol names. */
437 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
442 /* We don't put any version information in the dynamic string
444 name = h->root.root.string;
445 p = strchr (name, ELF_VER_CHR);
447 /* We know that the p points into writable memory. In fact,
448 there are only a few symbols that have read-only names, being
449 those like _GLOBAL_OFFSET_TABLE_ that are created specially
450 by the backends. Most symbols will have names pointing into
451 an ELF string table read from a file, or to objalloc memory. */
454 indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
459 if (indx == (bfd_size_type) -1)
461 h->dynstr_index = indx;
467 /* Mark a symbol dynamic. */
470 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
471 struct elf_link_hash_entry *h,
472 Elf_Internal_Sym *sym)
474 struct bfd_elf_dynamic_list *d = info->dynamic_list;
476 /* It may be called more than once on the same H. */
477 if(h->dynamic || info->relocatable)
480 if ((info->dynamic_data
481 && (h->type == STT_OBJECT
483 && ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
485 && h->root.type == bfd_link_hash_new
486 && (*d->match) (&d->head, NULL, h->root.root.string)))
490 /* Record an assignment to a symbol made by a linker script. We need
491 this in case some dynamic object refers to this symbol. */
494 bfd_elf_record_link_assignment (bfd *output_bfd,
495 struct bfd_link_info *info,
500 struct elf_link_hash_entry *h, *hv;
501 struct elf_link_hash_table *htab;
502 const struct elf_backend_data *bed;
504 if (!is_elf_hash_table (info->hash))
507 htab = elf_hash_table (info);
508 h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
512 switch (h->root.type)
514 case bfd_link_hash_defined:
515 case bfd_link_hash_defweak:
516 case bfd_link_hash_common:
518 case bfd_link_hash_undefweak:
519 case bfd_link_hash_undefined:
520 /* Since we're defining the symbol, don't let it seem to have not
521 been defined. record_dynamic_symbol and size_dynamic_sections
522 may depend on this. */
523 h->root.type = bfd_link_hash_new;
524 if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
525 bfd_link_repair_undef_list (&htab->root);
527 case bfd_link_hash_new:
528 bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
531 case bfd_link_hash_indirect:
532 /* We had a versioned symbol in a dynamic library. We make the
533 the versioned symbol point to this one. */
534 bed = get_elf_backend_data (output_bfd);
536 while (hv->root.type == bfd_link_hash_indirect
537 || hv->root.type == bfd_link_hash_warning)
538 hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
539 /* We don't need to update h->root.u since linker will set them
541 h->root.type = bfd_link_hash_undefined;
542 hv->root.type = bfd_link_hash_indirect;
543 hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
544 (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
546 case bfd_link_hash_warning:
551 /* If this symbol is being provided by the linker script, and it is
552 currently defined by a dynamic object, but not by a regular
553 object, then mark it as undefined so that the generic linker will
554 force the correct value. */
558 h->root.type = bfd_link_hash_undefined;
560 /* If this symbol is not being provided by the linker script, and it is
561 currently defined by a dynamic object, but not by a regular object,
562 then clear out any version information because the symbol will not be
563 associated with the dynamic object any more. */
567 h->verinfo.verdef = NULL;
571 if (provide && hidden)
573 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
575 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
576 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
579 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
581 if (!info->relocatable
583 && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
584 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
590 || (info->executable && elf_hash_table (info)->is_relocatable_executable))
593 if (! bfd_elf_link_record_dynamic_symbol (info, h))
596 /* If this is a weak defined symbol, and we know a corresponding
597 real symbol from the same dynamic object, make sure the real
598 symbol is also made into a dynamic symbol. */
599 if (h->u.weakdef != NULL
600 && h->u.weakdef->dynindx == -1)
602 if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
610 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
611 success, and 2 on a failure caused by attempting to record a symbol
612 in a discarded section, eg. a discarded link-once section symbol. */
615 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
620 struct elf_link_local_dynamic_entry *entry;
621 struct elf_link_hash_table *eht;
622 struct elf_strtab_hash *dynstr;
623 unsigned long dynstr_index;
625 Elf_External_Sym_Shndx eshndx;
626 char esym[sizeof (Elf64_External_Sym)];
628 if (! is_elf_hash_table (info->hash))
631 /* See if the entry exists already. */
632 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
633 if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
636 amt = sizeof (*entry);
637 entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
641 /* Go find the symbol, so that we can find it's name. */
642 if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
643 1, input_indx, &entry->isym, esym, &eshndx))
645 bfd_release (input_bfd, entry);
649 if (entry->isym.st_shndx != SHN_UNDEF
650 && entry->isym.st_shndx < SHN_LORESERVE)
654 s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
655 if (s == NULL || bfd_is_abs_section (s->output_section))
657 /* We can still bfd_release here as nothing has done another
658 bfd_alloc. We can't do this later in this function. */
659 bfd_release (input_bfd, entry);
664 name = (bfd_elf_string_from_elf_section
665 (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
666 entry->isym.st_name));
668 dynstr = elf_hash_table (info)->dynstr;
671 /* Create a strtab to hold the dynamic symbol names. */
672 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
677 dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
678 if (dynstr_index == (unsigned long) -1)
680 entry->isym.st_name = dynstr_index;
682 eht = elf_hash_table (info);
684 entry->next = eht->dynlocal;
685 eht->dynlocal = entry;
686 entry->input_bfd = input_bfd;
687 entry->input_indx = input_indx;
690 /* Whatever binding the symbol had before, it's now local. */
692 = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
694 /* The dynindx will be set at the end of size_dynamic_sections. */
699 /* Return the dynindex of a local dynamic symbol. */
702 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
706 struct elf_link_local_dynamic_entry *e;
708 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
709 if (e->input_bfd == input_bfd && e->input_indx == input_indx)
714 /* This function is used to renumber the dynamic symbols, if some of
715 them are removed because they are marked as local. This is called
716 via elf_link_hash_traverse. */
719 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
722 size_t *count = (size_t *) data;
724 if (h->root.type == bfd_link_hash_warning)
725 h = (struct elf_link_hash_entry *) h->root.u.i.link;
730 if (h->dynindx != -1)
731 h->dynindx = ++(*count);
737 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
738 STB_LOCAL binding. */
741 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
744 size_t *count = (size_t *) data;
746 if (h->root.type == bfd_link_hash_warning)
747 h = (struct elf_link_hash_entry *) h->root.u.i.link;
749 if (!h->forced_local)
752 if (h->dynindx != -1)
753 h->dynindx = ++(*count);
758 /* Return true if the dynamic symbol for a given section should be
759 omitted when creating a shared library. */
761 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
762 struct bfd_link_info *info,
765 struct elf_link_hash_table *htab;
767 switch (elf_section_data (p)->this_hdr.sh_type)
771 /* If sh_type is yet undecided, assume it could be
772 SHT_PROGBITS/SHT_NOBITS. */
774 htab = elf_hash_table (info);
775 if (p == htab->tls_sec)
778 if (htab->text_index_section != NULL)
779 return p != htab->text_index_section && p != htab->data_index_section;
781 if (strcmp (p->name, ".got") == 0
782 || strcmp (p->name, ".got.plt") == 0
783 || strcmp (p->name, ".plt") == 0)
787 if (htab->dynobj != NULL
788 && (ip = bfd_get_section_by_name (htab->dynobj, p->name)) != NULL
789 && (ip->flags & SEC_LINKER_CREATED)
790 && ip->output_section == p)
795 /* There shouldn't be section relative relocations
796 against any other section. */
802 /* Assign dynsym indices. In a shared library we generate a section
803 symbol for each output section, which come first. Next come symbols
804 which have been forced to local binding. Then all of the back-end
805 allocated local dynamic syms, followed by the rest of the global
809 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
810 struct bfd_link_info *info,
811 unsigned long *section_sym_count)
813 unsigned long dynsymcount = 0;
815 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
817 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
819 for (p = output_bfd->sections; p ; p = p->next)
820 if ((p->flags & SEC_EXCLUDE) == 0
821 && (p->flags & SEC_ALLOC) != 0
822 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
823 elf_section_data (p)->dynindx = ++dynsymcount;
825 elf_section_data (p)->dynindx = 0;
827 *section_sym_count = dynsymcount;
829 elf_link_hash_traverse (elf_hash_table (info),
830 elf_link_renumber_local_hash_table_dynsyms,
833 if (elf_hash_table (info)->dynlocal)
835 struct elf_link_local_dynamic_entry *p;
836 for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
837 p->dynindx = ++dynsymcount;
840 elf_link_hash_traverse (elf_hash_table (info),
841 elf_link_renumber_hash_table_dynsyms,
844 /* There is an unused NULL entry at the head of the table which
845 we must account for in our count. Unless there weren't any
846 symbols, which means we'll have no table at all. */
847 if (dynsymcount != 0)
850 elf_hash_table (info)->dynsymcount = dynsymcount;
854 /* Merge st_other field. */
857 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
858 Elf_Internal_Sym *isym, bfd_boolean definition,
861 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
863 /* If st_other has a processor-specific meaning, specific
864 code might be needed here. We never merge the visibility
865 attribute with the one from a dynamic object. */
866 if (bed->elf_backend_merge_symbol_attribute)
867 (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
870 /* If this symbol has default visibility and the user has requested
871 we not re-export it, then mark it as hidden. */
875 || (abfd->my_archive && abfd->my_archive->no_export))
876 && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
877 isym->st_other = (STV_HIDDEN
878 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
880 if (!dynamic && ELF_ST_VISIBILITY (isym->st_other) != 0)
882 unsigned char hvis, symvis, other, nvis;
884 /* Only merge the visibility. Leave the remainder of the
885 st_other field to elf_backend_merge_symbol_attribute. */
886 other = h->other & ~ELF_ST_VISIBILITY (-1);
888 /* Combine visibilities, using the most constraining one. */
889 hvis = ELF_ST_VISIBILITY (h->other);
890 symvis = ELF_ST_VISIBILITY (isym->st_other);
896 nvis = hvis < symvis ? hvis : symvis;
898 h->other = other | nvis;
902 /* This function is called when we want to define a new symbol. It
903 handles the various cases which arise when we find a definition in
904 a dynamic object, or when there is already a definition in a
905 dynamic object. The new symbol is described by NAME, SYM, PSEC,
906 and PVALUE. We set SYM_HASH to the hash table entry. We set
907 OVERRIDE if the old symbol is overriding a new definition. We set
908 TYPE_CHANGE_OK if it is OK for the type to change. We set
909 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
910 change, we mean that we shouldn't warn if the type or size does
911 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic
912 object is overridden by a regular object. */
915 _bfd_elf_merge_symbol (bfd *abfd,
916 struct bfd_link_info *info,
918 Elf_Internal_Sym *sym,
921 unsigned int *pold_alignment,
922 struct elf_link_hash_entry **sym_hash,
924 bfd_boolean *override,
925 bfd_boolean *type_change_ok,
926 bfd_boolean *size_change_ok)
928 asection *sec, *oldsec;
929 struct elf_link_hash_entry *h;
930 struct elf_link_hash_entry *flip;
933 bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
934 bfd_boolean newweak, oldweak, newfunc, oldfunc;
935 const struct elf_backend_data *bed;
941 bind = ELF_ST_BIND (sym->st_info);
943 /* Silently discard TLS symbols from --just-syms. There's no way to
944 combine a static TLS block with a new TLS block for this executable. */
945 if (ELF_ST_TYPE (sym->st_info) == STT_TLS
946 && sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
952 if (! bfd_is_und_section (sec))
953 h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
955 h = ((struct elf_link_hash_entry *)
956 bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
961 bed = get_elf_backend_data (abfd);
963 /* This code is for coping with dynamic objects, and is only useful
964 if we are doing an ELF link. */
965 if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
968 /* For merging, we only care about real symbols. */
970 while (h->root.type == bfd_link_hash_indirect
971 || h->root.type == bfd_link_hash_warning)
972 h = (struct elf_link_hash_entry *) h->root.u.i.link;
974 /* We have to check it for every instance since the first few may be
975 refereences and not all compilers emit symbol type for undefined
977 bfd_elf_link_mark_dynamic_symbol (info, h, sym);
979 /* If we just created the symbol, mark it as being an ELF symbol.
980 Other than that, there is nothing to do--there is no merge issue
981 with a newly defined symbol--so we just return. */
983 if (h->root.type == bfd_link_hash_new)
989 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
992 switch (h->root.type)
999 case bfd_link_hash_undefined:
1000 case bfd_link_hash_undefweak:
1001 oldbfd = h->root.u.undef.abfd;
1005 case bfd_link_hash_defined:
1006 case bfd_link_hash_defweak:
1007 oldbfd = h->root.u.def.section->owner;
1008 oldsec = h->root.u.def.section;
1011 case bfd_link_hash_common:
1012 oldbfd = h->root.u.c.p->section->owner;
1013 oldsec = h->root.u.c.p->section;
1017 /* In cases involving weak versioned symbols, we may wind up trying
1018 to merge a symbol with itself. Catch that here, to avoid the
1019 confusion that results if we try to override a symbol with
1020 itself. The additional tests catch cases like
1021 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1022 dynamic object, which we do want to handle here. */
1024 && ((abfd->flags & DYNAMIC) == 0
1025 || !h->def_regular))
1028 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1029 respectively, is from a dynamic object. */
1031 newdyn = (abfd->flags & DYNAMIC) != 0;
1035 olddyn = (oldbfd->flags & DYNAMIC) != 0;
1036 else if (oldsec != NULL)
1038 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1039 indices used by MIPS ELF. */
1040 olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1043 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1044 respectively, appear to be a definition rather than reference. */
1046 newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1048 olddef = (h->root.type != bfd_link_hash_undefined
1049 && h->root.type != bfd_link_hash_undefweak
1050 && h->root.type != bfd_link_hash_common);
1052 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1053 respectively, appear to be a function. */
1055 newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1056 && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1058 oldfunc = (h->type != STT_NOTYPE
1059 && bed->is_function_type (h->type));
1061 /* When we try to create a default indirect symbol from the dynamic
1062 definition with the default version, we skip it if its type and
1063 the type of existing regular definition mismatch. We only do it
1064 if the existing regular definition won't be dynamic. */
1065 if (pold_alignment == NULL
1067 && !info->export_dynamic
1072 && (olddef || h->root.type == bfd_link_hash_common)
1073 && ELF_ST_TYPE (sym->st_info) != h->type
1074 && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1075 && h->type != STT_NOTYPE
1076 && !(newfunc && oldfunc))
1082 /* Check TLS symbol. We don't check undefined symbol introduced by
1084 if ((ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS)
1085 && ELF_ST_TYPE (sym->st_info) != h->type
1089 bfd_boolean ntdef, tdef;
1090 asection *ntsec, *tsec;
1092 if (h->type == STT_TLS)
1112 (*_bfd_error_handler)
1113 (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1114 tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1115 else if (!tdef && !ntdef)
1116 (*_bfd_error_handler)
1117 (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1118 tbfd, ntbfd, h->root.root.string);
1120 (*_bfd_error_handler)
1121 (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1122 tbfd, tsec, ntbfd, h->root.root.string);
1124 (*_bfd_error_handler)
1125 (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1126 tbfd, ntbfd, ntsec, h->root.root.string);
1128 bfd_set_error (bfd_error_bad_value);
1132 /* We need to remember if a symbol has a definition in a dynamic
1133 object or is weak in all dynamic objects. Internal and hidden
1134 visibility will make it unavailable to dynamic objects. */
1135 if (newdyn && !h->dynamic_def)
1137 if (!bfd_is_und_section (sec))
1141 /* Check if this symbol is weak in all dynamic objects. If it
1142 is the first time we see it in a dynamic object, we mark
1143 if it is weak. Otherwise, we clear it. */
1144 if (!h->ref_dynamic)
1146 if (bind == STB_WEAK)
1147 h->dynamic_weak = 1;
1149 else if (bind != STB_WEAK)
1150 h->dynamic_weak = 0;
1154 /* If the old symbol has non-default visibility, we ignore the new
1155 definition from a dynamic object. */
1157 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1158 && !bfd_is_und_section (sec))
1161 /* Make sure this symbol is dynamic. */
1163 /* A protected symbol has external availability. Make sure it is
1164 recorded as dynamic.
1166 FIXME: Should we check type and size for protected symbol? */
1167 if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1168 return bfd_elf_link_record_dynamic_symbol (info, h);
1173 && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1176 /* If the new symbol with non-default visibility comes from a
1177 relocatable file and the old definition comes from a dynamic
1178 object, we remove the old definition. */
1179 if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1181 /* Handle the case where the old dynamic definition is
1182 default versioned. We need to copy the symbol info from
1183 the symbol with default version to the normal one if it
1184 was referenced before. */
1187 const struct elf_backend_data *bed
1188 = get_elf_backend_data (abfd);
1189 struct elf_link_hash_entry *vh = *sym_hash;
1190 vh->root.type = h->root.type;
1191 h->root.type = bfd_link_hash_indirect;
1192 (*bed->elf_backend_copy_indirect_symbol) (info, vh, h);
1193 /* Protected symbols will override the dynamic definition
1194 with default version. */
1195 if (ELF_ST_VISIBILITY (sym->st_other) == STV_PROTECTED)
1197 h->root.u.i.link = (struct bfd_link_hash_entry *) vh;
1198 vh->dynamic_def = 1;
1199 vh->ref_dynamic = 1;
1203 h->root.type = vh->root.type;
1204 vh->ref_dynamic = 0;
1205 /* We have to hide it here since it was made dynamic
1206 global with extra bits when the symbol info was
1207 copied from the old dynamic definition. */
1208 (*bed->elf_backend_hide_symbol) (info, vh, TRUE);
1216 if ((h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1217 && bfd_is_und_section (sec))
1219 /* If the new symbol is undefined and the old symbol was
1220 also undefined before, we need to make sure
1221 _bfd_generic_link_add_one_symbol doesn't mess
1222 up the linker hash table undefs list. Since the old
1223 definition came from a dynamic object, it is still on the
1225 h->root.type = bfd_link_hash_undefined;
1226 h->root.u.undef.abfd = abfd;
1230 h->root.type = bfd_link_hash_new;
1231 h->root.u.undef.abfd = NULL;
1240 /* FIXME: Should we check type and size for protected symbol? */
1246 /* Differentiate strong and weak symbols. */
1247 newweak = bind == STB_WEAK;
1248 oldweak = (h->root.type == bfd_link_hash_defweak
1249 || h->root.type == bfd_link_hash_undefweak);
1251 if (bind == STB_GNU_UNIQUE)
1252 h->unique_global = 1;
1254 /* If a new weak symbol definition comes from a regular file and the
1255 old symbol comes from a dynamic library, we treat the new one as
1256 strong. Similarly, an old weak symbol definition from a regular
1257 file is treated as strong when the new symbol comes from a dynamic
1258 library. Further, an old weak symbol from a dynamic library is
1259 treated as strong if the new symbol is from a dynamic library.
1260 This reflects the way glibc's ld.so works.
1262 Do this before setting *type_change_ok or *size_change_ok so that
1263 we warn properly when dynamic library symbols are overridden. */
1265 if (newdef && !newdyn && olddyn)
1267 if (olddef && newdyn)
1270 /* Allow changes between different types of function symbol. */
1271 if (newfunc && oldfunc)
1272 *type_change_ok = TRUE;
1274 /* It's OK to change the type if either the existing symbol or the
1275 new symbol is weak. A type change is also OK if the old symbol
1276 is undefined and the new symbol is defined. */
1281 && h->root.type == bfd_link_hash_undefined))
1282 *type_change_ok = TRUE;
1284 /* It's OK to change the size if either the existing symbol or the
1285 new symbol is weak, or if the old symbol is undefined. */
1288 || h->root.type == bfd_link_hash_undefined)
1289 *size_change_ok = TRUE;
1291 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1292 symbol, respectively, appears to be a common symbol in a dynamic
1293 object. If a symbol appears in an uninitialized section, and is
1294 not weak, and is not a function, then it may be a common symbol
1295 which was resolved when the dynamic object was created. We want
1296 to treat such symbols specially, because they raise special
1297 considerations when setting the symbol size: if the symbol
1298 appears as a common symbol in a regular object, and the size in
1299 the regular object is larger, we must make sure that we use the
1300 larger size. This problematic case can always be avoided in C,
1301 but it must be handled correctly when using Fortran shared
1304 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1305 likewise for OLDDYNCOMMON and OLDDEF.
1307 Note that this test is just a heuristic, and that it is quite
1308 possible to have an uninitialized symbol in a shared object which
1309 is really a definition, rather than a common symbol. This could
1310 lead to some minor confusion when the symbol really is a common
1311 symbol in some regular object. However, I think it will be
1317 && (sec->flags & SEC_ALLOC) != 0
1318 && (sec->flags & SEC_LOAD) == 0
1321 newdyncommon = TRUE;
1323 newdyncommon = FALSE;
1327 && h->root.type == bfd_link_hash_defined
1329 && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1330 && (h->root.u.def.section->flags & SEC_LOAD) == 0
1333 olddyncommon = TRUE;
1335 olddyncommon = FALSE;
1337 /* We now know everything about the old and new symbols. We ask the
1338 backend to check if we can merge them. */
1339 if (bed->merge_symbol
1340 && !bed->merge_symbol (info, sym_hash, h, sym, psec, pvalue,
1341 pold_alignment, skip, override,
1342 type_change_ok, size_change_ok,
1343 &newdyn, &newdef, &newdyncommon, &newweak,
1345 &olddyn, &olddef, &olddyncommon, &oldweak,
1349 /* If both the old and the new symbols look like common symbols in a
1350 dynamic object, set the size of the symbol to the larger of the
1355 && sym->st_size != h->size)
1357 /* Since we think we have two common symbols, issue a multiple
1358 common warning if desired. Note that we only warn if the
1359 size is different. If the size is the same, we simply let
1360 the old symbol override the new one as normally happens with
1361 symbols defined in dynamic objects. */
1363 if (! ((*info->callbacks->multiple_common)
1364 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
1365 h->size, abfd, bfd_link_hash_common, sym->st_size)))
1368 if (sym->st_size > h->size)
1369 h->size = sym->st_size;
1371 *size_change_ok = TRUE;
1374 /* If we are looking at a dynamic object, and we have found a
1375 definition, we need to see if the symbol was already defined by
1376 some other object. If so, we want to use the existing
1377 definition, and we do not want to report a multiple symbol
1378 definition error; we do this by clobbering *PSEC to be
1379 bfd_und_section_ptr.
1381 We treat a common symbol as a definition if the symbol in the
1382 shared library is a function, since common symbols always
1383 represent variables; this can cause confusion in principle, but
1384 any such confusion would seem to indicate an erroneous program or
1385 shared library. We also permit a common symbol in a regular
1386 object to override a weak symbol in a shared object. */
1391 || (h->root.type == bfd_link_hash_common
1392 && (newweak || newfunc))))
1396 newdyncommon = FALSE;
1398 *psec = sec = bfd_und_section_ptr;
1399 *size_change_ok = TRUE;
1401 /* If we get here when the old symbol is a common symbol, then
1402 we are explicitly letting it override a weak symbol or
1403 function in a dynamic object, and we don't want to warn about
1404 a type change. If the old symbol is a defined symbol, a type
1405 change warning may still be appropriate. */
1407 if (h->root.type == bfd_link_hash_common)
1408 *type_change_ok = TRUE;
1411 /* Handle the special case of an old common symbol merging with a
1412 new symbol which looks like a common symbol in a shared object.
1413 We change *PSEC and *PVALUE to make the new symbol look like a
1414 common symbol, and let _bfd_generic_link_add_one_symbol do the
1418 && h->root.type == bfd_link_hash_common)
1422 newdyncommon = FALSE;
1423 *pvalue = sym->st_size;
1424 *psec = sec = bed->common_section (oldsec);
1425 *size_change_ok = TRUE;
1428 /* Skip weak definitions of symbols that are already defined. */
1429 if (newdef && olddef && newweak)
1433 /* Merge st_other. If the symbol already has a dynamic index,
1434 but visibility says it should not be visible, turn it into a
1436 elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1437 if (h->dynindx != -1)
1438 switch (ELF_ST_VISIBILITY (h->other))
1442 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1447 /* If the old symbol is from a dynamic object, and the new symbol is
1448 a definition which is not from a dynamic object, then the new
1449 symbol overrides the old symbol. Symbols from regular files
1450 always take precedence over symbols from dynamic objects, even if
1451 they are defined after the dynamic object in the link.
1453 As above, we again permit a common symbol in a regular object to
1454 override a definition in a shared object if the shared object
1455 symbol is a function or is weak. */
1460 || (bfd_is_com_section (sec)
1461 && (oldweak || oldfunc)))
1466 /* Change the hash table entry to undefined, and let
1467 _bfd_generic_link_add_one_symbol do the right thing with the
1470 h->root.type = bfd_link_hash_undefined;
1471 h->root.u.undef.abfd = h->root.u.def.section->owner;
1472 *size_change_ok = TRUE;
1475 olddyncommon = FALSE;
1477 /* We again permit a type change when a common symbol may be
1478 overriding a function. */
1480 if (bfd_is_com_section (sec))
1484 /* If a common symbol overrides a function, make sure
1485 that it isn't defined dynamically nor has type
1488 h->type = STT_NOTYPE;
1490 *type_change_ok = TRUE;
1493 if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1496 /* This union may have been set to be non-NULL when this symbol
1497 was seen in a dynamic object. We must force the union to be
1498 NULL, so that it is correct for a regular symbol. */
1499 h->verinfo.vertree = NULL;
1502 /* Handle the special case of a new common symbol merging with an
1503 old symbol that looks like it might be a common symbol defined in
1504 a shared object. Note that we have already handled the case in
1505 which a new common symbol should simply override the definition
1506 in the shared library. */
1509 && bfd_is_com_section (sec)
1512 /* It would be best if we could set the hash table entry to a
1513 common symbol, but we don't know what to use for the section
1514 or the alignment. */
1515 if (! ((*info->callbacks->multiple_common)
1516 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
1517 h->size, abfd, bfd_link_hash_common, sym->st_size)))
1520 /* If the presumed common symbol in the dynamic object is
1521 larger, pretend that the new symbol has its size. */
1523 if (h->size > *pvalue)
1526 /* We need to remember the alignment required by the symbol
1527 in the dynamic object. */
1528 BFD_ASSERT (pold_alignment);
1529 *pold_alignment = h->root.u.def.section->alignment_power;
1532 olddyncommon = FALSE;
1534 h->root.type = bfd_link_hash_undefined;
1535 h->root.u.undef.abfd = h->root.u.def.section->owner;
1537 *size_change_ok = TRUE;
1538 *type_change_ok = TRUE;
1540 if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1543 h->verinfo.vertree = NULL;
1548 /* Handle the case where we had a versioned symbol in a dynamic
1549 library and now find a definition in a normal object. In this
1550 case, we make the versioned symbol point to the normal one. */
1551 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1552 flip->root.type = h->root.type;
1553 flip->root.u.undef.abfd = h->root.u.undef.abfd;
1554 h->root.type = bfd_link_hash_indirect;
1555 h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1556 (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1560 flip->ref_dynamic = 1;
1567 /* This function is called to create an indirect symbol from the
1568 default for the symbol with the default version if needed. The
1569 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
1570 set DYNSYM if the new indirect symbol is dynamic. */
1573 _bfd_elf_add_default_symbol (bfd *abfd,
1574 struct bfd_link_info *info,
1575 struct elf_link_hash_entry *h,
1577 Elf_Internal_Sym *sym,
1580 bfd_boolean *dynsym,
1581 bfd_boolean override)
1583 bfd_boolean type_change_ok;
1584 bfd_boolean size_change_ok;
1587 struct elf_link_hash_entry *hi;
1588 struct bfd_link_hash_entry *bh;
1589 const struct elf_backend_data *bed;
1590 bfd_boolean collect;
1591 bfd_boolean dynamic;
1593 size_t len, shortlen;
1596 /* If this symbol has a version, and it is the default version, we
1597 create an indirect symbol from the default name to the fully
1598 decorated name. This will cause external references which do not
1599 specify a version to be bound to this version of the symbol. */
1600 p = strchr (name, ELF_VER_CHR);
1601 if (p == NULL || p[1] != ELF_VER_CHR)
1606 /* We are overridden by an old definition. We need to check if we
1607 need to create the indirect symbol from the default name. */
1608 hi = elf_link_hash_lookup (elf_hash_table (info), name, TRUE,
1610 BFD_ASSERT (hi != NULL);
1613 while (hi->root.type == bfd_link_hash_indirect
1614 || hi->root.type == bfd_link_hash_warning)
1616 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1622 bed = get_elf_backend_data (abfd);
1623 collect = bed->collect;
1624 dynamic = (abfd->flags & DYNAMIC) != 0;
1626 shortlen = p - name;
1627 shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1628 if (shortname == NULL)
1630 memcpy (shortname, name, shortlen);
1631 shortname[shortlen] = '\0';
1633 /* We are going to create a new symbol. Merge it with any existing
1634 symbol with this name. For the purposes of the merge, act as
1635 though we were defining the symbol we just defined, although we
1636 actually going to define an indirect symbol. */
1637 type_change_ok = FALSE;
1638 size_change_ok = FALSE;
1640 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1641 NULL, &hi, &skip, &override,
1642 &type_change_ok, &size_change_ok))
1651 if (! (_bfd_generic_link_add_one_symbol
1652 (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1653 0, name, FALSE, collect, &bh)))
1655 hi = (struct elf_link_hash_entry *) bh;
1659 /* In this case the symbol named SHORTNAME is overriding the
1660 indirect symbol we want to add. We were planning on making
1661 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1662 is the name without a version. NAME is the fully versioned
1663 name, and it is the default version.
1665 Overriding means that we already saw a definition for the
1666 symbol SHORTNAME in a regular object, and it is overriding
1667 the symbol defined in the dynamic object.
1669 When this happens, we actually want to change NAME, the
1670 symbol we just added, to refer to SHORTNAME. This will cause
1671 references to NAME in the shared object to become references
1672 to SHORTNAME in the regular object. This is what we expect
1673 when we override a function in a shared object: that the
1674 references in the shared object will be mapped to the
1675 definition in the regular object. */
1677 while (hi->root.type == bfd_link_hash_indirect
1678 || hi->root.type == bfd_link_hash_warning)
1679 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1681 h->root.type = bfd_link_hash_indirect;
1682 h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1686 hi->ref_dynamic = 1;
1690 if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1695 /* Now set HI to H, so that the following code will set the
1696 other fields correctly. */
1700 /* Check if HI is a warning symbol. */
1701 if (hi->root.type == bfd_link_hash_warning)
1702 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1704 /* If there is a duplicate definition somewhere, then HI may not
1705 point to an indirect symbol. We will have reported an error to
1706 the user in that case. */
1708 if (hi->root.type == bfd_link_hash_indirect)
1710 struct elf_link_hash_entry *ht;
1712 ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1713 (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1715 /* See if the new flags lead us to realize that the symbol must
1727 if (hi->ref_regular)
1733 /* We also need to define an indirection from the nondefault version
1737 len = strlen (name);
1738 shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1739 if (shortname == NULL)
1741 memcpy (shortname, name, shortlen);
1742 memcpy (shortname + shortlen, p + 1, len - shortlen);
1744 /* Once again, merge with any existing symbol. */
1745 type_change_ok = FALSE;
1746 size_change_ok = FALSE;
1748 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1749 NULL, &hi, &skip, &override,
1750 &type_change_ok, &size_change_ok))
1758 /* Here SHORTNAME is a versioned name, so we don't expect to see
1759 the type of override we do in the case above unless it is
1760 overridden by a versioned definition. */
1761 if (hi->root.type != bfd_link_hash_defined
1762 && hi->root.type != bfd_link_hash_defweak)
1763 (*_bfd_error_handler)
1764 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1770 if (! (_bfd_generic_link_add_one_symbol
1771 (info, abfd, shortname, BSF_INDIRECT,
1772 bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1774 hi = (struct elf_link_hash_entry *) bh;
1776 /* If there is a duplicate definition somewhere, then HI may not
1777 point to an indirect symbol. We will have reported an error
1778 to the user in that case. */
1780 if (hi->root.type == bfd_link_hash_indirect)
1782 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1784 /* See if the new flags lead us to realize that the symbol
1796 if (hi->ref_regular)
1806 /* This routine is used to export all defined symbols into the dynamic
1807 symbol table. It is called via elf_link_hash_traverse. */
1810 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1812 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1814 /* Ignore this if we won't export it. */
1815 if (!eif->info->export_dynamic && !h->dynamic)
1818 /* Ignore indirect symbols. These are added by the versioning code. */
1819 if (h->root.type == bfd_link_hash_indirect)
1822 if (h->root.type == bfd_link_hash_warning)
1823 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1825 if (h->dynindx == -1
1831 if (eif->verdefs == NULL
1832 || (bfd_find_version_for_sym (eif->verdefs, h->root.root.string, &hide)
1835 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1846 /* Look through the symbols which are defined in other shared
1847 libraries and referenced here. Update the list of version
1848 dependencies. This will be put into the .gnu.version_r section.
1849 This function is called via elf_link_hash_traverse. */
1852 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1855 struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1856 Elf_Internal_Verneed *t;
1857 Elf_Internal_Vernaux *a;
1860 if (h->root.type == bfd_link_hash_warning)
1861 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1863 /* We only care about symbols defined in shared objects with version
1868 || h->verinfo.verdef == NULL)
1871 /* See if we already know about this version. */
1872 for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1876 if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1879 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1880 if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1886 /* This is a new version. Add it to tree we are building. */
1891 t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1894 rinfo->failed = TRUE;
1898 t->vn_bfd = h->verinfo.verdef->vd_bfd;
1899 t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1900 elf_tdata (rinfo->info->output_bfd)->verref = t;
1904 a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1907 rinfo->failed = TRUE;
1911 /* Note that we are copying a string pointer here, and testing it
1912 above. If bfd_elf_string_from_elf_section is ever changed to
1913 discard the string data when low in memory, this will have to be
1915 a->vna_nodename = h->verinfo.verdef->vd_nodename;
1917 a->vna_flags = h->verinfo.verdef->vd_flags;
1918 a->vna_nextptr = t->vn_auxptr;
1920 h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1923 a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1930 /* Figure out appropriate versions for all the symbols. We may not
1931 have the version number script until we have read all of the input
1932 files, so until that point we don't know which symbols should be
1933 local. This function is called via elf_link_hash_traverse. */
1936 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1938 struct elf_info_failed *sinfo;
1939 struct bfd_link_info *info;
1940 const struct elf_backend_data *bed;
1941 struct elf_info_failed eif;
1945 sinfo = (struct elf_info_failed *) data;
1948 if (h->root.type == bfd_link_hash_warning)
1949 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1951 /* Fix the symbol flags. */
1954 if (! _bfd_elf_fix_symbol_flags (h, &eif))
1957 sinfo->failed = TRUE;
1961 /* We only need version numbers for symbols defined in regular
1963 if (!h->def_regular)
1966 bed = get_elf_backend_data (info->output_bfd);
1967 p = strchr (h->root.root.string, ELF_VER_CHR);
1968 if (p != NULL && h->verinfo.vertree == NULL)
1970 struct bfd_elf_version_tree *t;
1975 /* There are two consecutive ELF_VER_CHR characters if this is
1976 not a hidden symbol. */
1978 if (*p == ELF_VER_CHR)
1984 /* If there is no version string, we can just return out. */
1992 /* Look for the version. If we find it, it is no longer weak. */
1993 for (t = sinfo->verdefs; t != NULL; t = t->next)
1995 if (strcmp (t->name, p) == 0)
1999 struct bfd_elf_version_expr *d;
2001 len = p - h->root.root.string;
2002 alc = (char *) bfd_malloc (len);
2005 sinfo->failed = TRUE;
2008 memcpy (alc, h->root.root.string, len - 1);
2009 alc[len - 1] = '\0';
2010 if (alc[len - 2] == ELF_VER_CHR)
2011 alc[len - 2] = '\0';
2013 h->verinfo.vertree = t;
2017 if (t->globals.list != NULL)
2018 d = (*t->match) (&t->globals, NULL, alc);
2020 /* See if there is anything to force this symbol to
2022 if (d == NULL && t->locals.list != NULL)
2024 d = (*t->match) (&t->locals, NULL, alc);
2027 && ! info->export_dynamic)
2028 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2036 /* If we are building an application, we need to create a
2037 version node for this version. */
2038 if (t == NULL && info->executable)
2040 struct bfd_elf_version_tree **pp;
2043 /* If we aren't going to export this symbol, we don't need
2044 to worry about it. */
2045 if (h->dynindx == -1)
2049 t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2052 sinfo->failed = TRUE;
2057 t->name_indx = (unsigned int) -1;
2061 /* Don't count anonymous version tag. */
2062 if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0)
2064 for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
2066 t->vernum = version_index;
2070 h->verinfo.vertree = t;
2074 /* We could not find the version for a symbol when
2075 generating a shared archive. Return an error. */
2076 (*_bfd_error_handler)
2077 (_("%B: version node not found for symbol %s"),
2078 info->output_bfd, h->root.root.string);
2079 bfd_set_error (bfd_error_bad_value);
2080 sinfo->failed = TRUE;
2088 /* If we don't have a version for this symbol, see if we can find
2090 if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
2094 h->verinfo.vertree = bfd_find_version_for_sym (sinfo->verdefs,
2095 h->root.root.string, &hide);
2096 if (h->verinfo.vertree != NULL && hide)
2097 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2103 /* Read and swap the relocs from the section indicated by SHDR. This
2104 may be either a REL or a RELA section. The relocations are
2105 translated into RELA relocations and stored in INTERNAL_RELOCS,
2106 which should have already been allocated to contain enough space.
2107 The EXTERNAL_RELOCS are a buffer where the external form of the
2108 relocations should be stored.
2110 Returns FALSE if something goes wrong. */
2113 elf_link_read_relocs_from_section (bfd *abfd,
2115 Elf_Internal_Shdr *shdr,
2116 void *external_relocs,
2117 Elf_Internal_Rela *internal_relocs)
2119 const struct elf_backend_data *bed;
2120 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2121 const bfd_byte *erela;
2122 const bfd_byte *erelaend;
2123 Elf_Internal_Rela *irela;
2124 Elf_Internal_Shdr *symtab_hdr;
2127 /* Position ourselves at the start of the section. */
2128 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2131 /* Read the relocations. */
2132 if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2135 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2136 nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2138 bed = get_elf_backend_data (abfd);
2140 /* Convert the external relocations to the internal format. */
2141 if (shdr->sh_entsize == bed->s->sizeof_rel)
2142 swap_in = bed->s->swap_reloc_in;
2143 else if (shdr->sh_entsize == bed->s->sizeof_rela)
2144 swap_in = bed->s->swap_reloca_in;
2147 bfd_set_error (bfd_error_wrong_format);
2151 erela = (const bfd_byte *) external_relocs;
2152 erelaend = erela + shdr->sh_size;
2153 irela = internal_relocs;
2154 while (erela < erelaend)
2158 (*swap_in) (abfd, erela, irela);
2159 r_symndx = ELF32_R_SYM (irela->r_info);
2160 if (bed->s->arch_size == 64)
2164 if ((size_t) r_symndx >= nsyms)
2166 (*_bfd_error_handler)
2167 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2168 " for offset 0x%lx in section `%A'"),
2170 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2171 bfd_set_error (bfd_error_bad_value);
2175 else if (r_symndx != 0)
2177 (*_bfd_error_handler)
2178 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2179 " when the object file has no symbol table"),
2181 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2182 bfd_set_error (bfd_error_bad_value);
2185 irela += bed->s->int_rels_per_ext_rel;
2186 erela += shdr->sh_entsize;
2192 /* Read and swap the relocs for a section O. They may have been
2193 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2194 not NULL, they are used as buffers to read into. They are known to
2195 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2196 the return value is allocated using either malloc or bfd_alloc,
2197 according to the KEEP_MEMORY argument. If O has two relocation
2198 sections (both REL and RELA relocations), then the REL_HDR
2199 relocations will appear first in INTERNAL_RELOCS, followed by the
2200 REL_HDR2 relocations. */
2203 _bfd_elf_link_read_relocs (bfd *abfd,
2205 void *external_relocs,
2206 Elf_Internal_Rela *internal_relocs,
2207 bfd_boolean keep_memory)
2209 Elf_Internal_Shdr *rel_hdr;
2210 void *alloc1 = NULL;
2211 Elf_Internal_Rela *alloc2 = NULL;
2212 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2214 if (elf_section_data (o)->relocs != NULL)
2215 return elf_section_data (o)->relocs;
2217 if (o->reloc_count == 0)
2220 rel_hdr = &elf_section_data (o)->rel_hdr;
2222 if (internal_relocs == NULL)
2226 size = o->reloc_count;
2227 size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2229 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2231 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2232 if (internal_relocs == NULL)
2236 if (external_relocs == NULL)
2238 bfd_size_type size = rel_hdr->sh_size;
2240 if (elf_section_data (o)->rel_hdr2)
2241 size += elf_section_data (o)->rel_hdr2->sh_size;
2242 alloc1 = bfd_malloc (size);
2245 external_relocs = alloc1;
2248 if (!elf_link_read_relocs_from_section (abfd, o, rel_hdr,
2252 if (elf_section_data (o)->rel_hdr2
2253 && (!elf_link_read_relocs_from_section
2255 elf_section_data (o)->rel_hdr2,
2256 ((bfd_byte *) external_relocs) + rel_hdr->sh_size,
2257 internal_relocs + (NUM_SHDR_ENTRIES (rel_hdr)
2258 * bed->s->int_rels_per_ext_rel))))
2261 /* Cache the results for next time, if we can. */
2263 elf_section_data (o)->relocs = internal_relocs;
2268 /* Don't free alloc2, since if it was allocated we are passing it
2269 back (under the name of internal_relocs). */
2271 return internal_relocs;
2279 bfd_release (abfd, alloc2);
2286 /* Compute the size of, and allocate space for, REL_HDR which is the
2287 section header for a section containing relocations for O. */
2290 _bfd_elf_link_size_reloc_section (bfd *abfd,
2291 Elf_Internal_Shdr *rel_hdr,
2294 bfd_size_type reloc_count;
2295 bfd_size_type num_rel_hashes;
2297 /* Figure out how many relocations there will be. */
2298 if (rel_hdr == &elf_section_data (o)->rel_hdr)
2299 reloc_count = elf_section_data (o)->rel_count;
2301 reloc_count = elf_section_data (o)->rel_count2;
2303 num_rel_hashes = o->reloc_count;
2304 if (num_rel_hashes < reloc_count)
2305 num_rel_hashes = reloc_count;
2307 /* That allows us to calculate the size of the section. */
2308 rel_hdr->sh_size = rel_hdr->sh_entsize * reloc_count;
2310 /* The contents field must last into write_object_contents, so we
2311 allocate it with bfd_alloc rather than malloc. Also since we
2312 cannot be sure that the contents will actually be filled in,
2313 we zero the allocated space. */
2314 rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2315 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2318 /* We only allocate one set of hash entries, so we only do it the
2319 first time we are called. */
2320 if (elf_section_data (o)->rel_hashes == NULL
2323 struct elf_link_hash_entry **p;
2325 p = (struct elf_link_hash_entry **)
2326 bfd_zmalloc (num_rel_hashes * sizeof (struct elf_link_hash_entry *));
2330 elf_section_data (o)->rel_hashes = p;
2336 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2337 originated from the section given by INPUT_REL_HDR) to the
2341 _bfd_elf_link_output_relocs (bfd *output_bfd,
2342 asection *input_section,
2343 Elf_Internal_Shdr *input_rel_hdr,
2344 Elf_Internal_Rela *internal_relocs,
2345 struct elf_link_hash_entry **rel_hash
2348 Elf_Internal_Rela *irela;
2349 Elf_Internal_Rela *irelaend;
2351 Elf_Internal_Shdr *output_rel_hdr;
2352 asection *output_section;
2353 unsigned int *rel_countp = NULL;
2354 const struct elf_backend_data *bed;
2355 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2357 output_section = input_section->output_section;
2358 output_rel_hdr = NULL;
2360 if (elf_section_data (output_section)->rel_hdr.sh_entsize
2361 == input_rel_hdr->sh_entsize)
2363 output_rel_hdr = &elf_section_data (output_section)->rel_hdr;
2364 rel_countp = &elf_section_data (output_section)->rel_count;
2366 else if (elf_section_data (output_section)->rel_hdr2
2367 && (elf_section_data (output_section)->rel_hdr2->sh_entsize
2368 == input_rel_hdr->sh_entsize))
2370 output_rel_hdr = elf_section_data (output_section)->rel_hdr2;
2371 rel_countp = &elf_section_data (output_section)->rel_count2;
2375 (*_bfd_error_handler)
2376 (_("%B: relocation size mismatch in %B section %A"),
2377 output_bfd, input_section->owner, input_section);
2378 bfd_set_error (bfd_error_wrong_format);
2382 bed = get_elf_backend_data (output_bfd);
2383 if (input_rel_hdr->sh_entsize == bed->s->sizeof_rel)
2384 swap_out = bed->s->swap_reloc_out;
2385 else if (input_rel_hdr->sh_entsize == bed->s->sizeof_rela)
2386 swap_out = bed->s->swap_reloca_out;
2390 erel = output_rel_hdr->contents;
2391 erel += *rel_countp * input_rel_hdr->sh_entsize;
2392 irela = internal_relocs;
2393 irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2394 * bed->s->int_rels_per_ext_rel);
2395 while (irela < irelaend)
2397 (*swap_out) (output_bfd, irela, erel);
2398 irela += bed->s->int_rels_per_ext_rel;
2399 erel += input_rel_hdr->sh_entsize;
2402 /* Bump the counter, so that we know where to add the next set of
2404 *rel_countp += NUM_SHDR_ENTRIES (input_rel_hdr);
2409 /* Make weak undefined symbols in PIE dynamic. */
2412 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2413 struct elf_link_hash_entry *h)
2417 && h->root.type == bfd_link_hash_undefweak)
2418 return bfd_elf_link_record_dynamic_symbol (info, h);
2423 /* Fix up the flags for a symbol. This handles various cases which
2424 can only be fixed after all the input files are seen. This is
2425 currently called by both adjust_dynamic_symbol and
2426 assign_sym_version, which is unnecessary but perhaps more robust in
2427 the face of future changes. */
2430 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2431 struct elf_info_failed *eif)
2433 const struct elf_backend_data *bed;
2435 /* If this symbol was mentioned in a non-ELF file, try to set
2436 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2437 permit a non-ELF file to correctly refer to a symbol defined in
2438 an ELF dynamic object. */
2441 while (h->root.type == bfd_link_hash_indirect)
2442 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2444 if (h->root.type != bfd_link_hash_defined
2445 && h->root.type != bfd_link_hash_defweak)
2448 h->ref_regular_nonweak = 1;
2452 if (h->root.u.def.section->owner != NULL
2453 && (bfd_get_flavour (h->root.u.def.section->owner)
2454 == bfd_target_elf_flavour))
2457 h->ref_regular_nonweak = 1;
2463 if (h->dynindx == -1
2467 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2476 /* Unfortunately, NON_ELF is only correct if the symbol
2477 was first seen in a non-ELF file. Fortunately, if the symbol
2478 was first seen in an ELF file, we're probably OK unless the
2479 symbol was defined in a non-ELF file. Catch that case here.
2480 FIXME: We're still in trouble if the symbol was first seen in
2481 a dynamic object, and then later in a non-ELF regular object. */
2482 if ((h->root.type == bfd_link_hash_defined
2483 || h->root.type == bfd_link_hash_defweak)
2485 && (h->root.u.def.section->owner != NULL
2486 ? (bfd_get_flavour (h->root.u.def.section->owner)
2487 != bfd_target_elf_flavour)
2488 : (bfd_is_abs_section (h->root.u.def.section)
2489 && !h->def_dynamic)))
2493 /* Backend specific symbol fixup. */
2494 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2495 if (bed->elf_backend_fixup_symbol
2496 && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2499 /* If this is a final link, and the symbol was defined as a common
2500 symbol in a regular object file, and there was no definition in
2501 any dynamic object, then the linker will have allocated space for
2502 the symbol in a common section but the DEF_REGULAR
2503 flag will not have been set. */
2504 if (h->root.type == bfd_link_hash_defined
2508 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
2511 /* If -Bsymbolic was used (which means to bind references to global
2512 symbols to the definition within the shared object), and this
2513 symbol was defined in a regular object, then it actually doesn't
2514 need a PLT entry. Likewise, if the symbol has non-default
2515 visibility. If the symbol has hidden or internal visibility, we
2516 will force it local. */
2518 && eif->info->shared
2519 && is_elf_hash_table (eif->info->hash)
2520 && (SYMBOLIC_BIND (eif->info, h)
2521 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2524 bfd_boolean force_local;
2526 force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2527 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2528 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2531 /* If a weak undefined symbol has non-default visibility, we also
2532 hide it from the dynamic linker. */
2533 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2534 && h->root.type == bfd_link_hash_undefweak)
2535 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2537 /* If this is a weak defined symbol in a dynamic object, and we know
2538 the real definition in the dynamic object, copy interesting flags
2539 over to the real definition. */
2540 if (h->u.weakdef != NULL)
2542 struct elf_link_hash_entry *weakdef;
2544 weakdef = h->u.weakdef;
2545 if (h->root.type == bfd_link_hash_indirect)
2546 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2548 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2549 || h->root.type == bfd_link_hash_defweak);
2550 BFD_ASSERT (weakdef->def_dynamic);
2552 /* If the real definition is defined by a regular object file,
2553 don't do anything special. See the longer description in
2554 _bfd_elf_adjust_dynamic_symbol, below. */
2555 if (weakdef->def_regular)
2556 h->u.weakdef = NULL;
2559 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2560 || weakdef->root.type == bfd_link_hash_defweak);
2561 (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2568 /* Make the backend pick a good value for a dynamic symbol. This is
2569 called via elf_link_hash_traverse, and also calls itself
2573 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2575 struct elf_info_failed *eif = (struct elf_info_failed *) data;
2577 const struct elf_backend_data *bed;
2579 if (! is_elf_hash_table (eif->info->hash))
2582 if (h->root.type == bfd_link_hash_warning)
2584 h->got = elf_hash_table (eif->info)->init_got_offset;
2585 h->plt = elf_hash_table (eif->info)->init_plt_offset;
2587 /* When warning symbols are created, they **replace** the "real"
2588 entry in the hash table, thus we never get to see the real
2589 symbol in a hash traversal. So look at it now. */
2590 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2593 /* Ignore indirect symbols. These are added by the versioning code. */
2594 if (h->root.type == bfd_link_hash_indirect)
2597 /* Fix the symbol flags. */
2598 if (! _bfd_elf_fix_symbol_flags (h, eif))
2601 /* If this symbol does not require a PLT entry, and it is not
2602 defined by a dynamic object, or is not referenced by a regular
2603 object, ignore it. We do have to handle a weak defined symbol,
2604 even if no regular object refers to it, if we decided to add it
2605 to the dynamic symbol table. FIXME: Do we normally need to worry
2606 about symbols which are defined by one dynamic object and
2607 referenced by another one? */
2609 && h->type != STT_GNU_IFUNC
2613 && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2615 h->plt = elf_hash_table (eif->info)->init_plt_offset;
2619 /* If we've already adjusted this symbol, don't do it again. This
2620 can happen via a recursive call. */
2621 if (h->dynamic_adjusted)
2624 /* Don't look at this symbol again. Note that we must set this
2625 after checking the above conditions, because we may look at a
2626 symbol once, decide not to do anything, and then get called
2627 recursively later after REF_REGULAR is set below. */
2628 h->dynamic_adjusted = 1;
2630 /* If this is a weak definition, and we know a real definition, and
2631 the real symbol is not itself defined by a regular object file,
2632 then get a good value for the real definition. We handle the
2633 real symbol first, for the convenience of the backend routine.
2635 Note that there is a confusing case here. If the real definition
2636 is defined by a regular object file, we don't get the real symbol
2637 from the dynamic object, but we do get the weak symbol. If the
2638 processor backend uses a COPY reloc, then if some routine in the
2639 dynamic object changes the real symbol, we will not see that
2640 change in the corresponding weak symbol. This is the way other
2641 ELF linkers work as well, and seems to be a result of the shared
2644 I will clarify this issue. Most SVR4 shared libraries define the
2645 variable _timezone and define timezone as a weak synonym. The
2646 tzset call changes _timezone. If you write
2647 extern int timezone;
2649 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2650 you might expect that, since timezone is a synonym for _timezone,
2651 the same number will print both times. However, if the processor
2652 backend uses a COPY reloc, then actually timezone will be copied
2653 into your process image, and, since you define _timezone
2654 yourself, _timezone will not. Thus timezone and _timezone will
2655 wind up at different memory locations. The tzset call will set
2656 _timezone, leaving timezone unchanged. */
2658 if (h->u.weakdef != NULL)
2660 /* If we get to this point, we know there is an implicit
2661 reference by a regular object file via the weak symbol H.
2662 FIXME: Is this really true? What if the traversal finds
2663 H->U.WEAKDEF before it finds H? */
2664 h->u.weakdef->ref_regular = 1;
2666 if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2670 /* If a symbol has no type and no size and does not require a PLT
2671 entry, then we are probably about to do the wrong thing here: we
2672 are probably going to create a COPY reloc for an empty object.
2673 This case can arise when a shared object is built with assembly
2674 code, and the assembly code fails to set the symbol type. */
2676 && h->type == STT_NOTYPE
2678 (*_bfd_error_handler)
2679 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2680 h->root.root.string);
2682 dynobj = elf_hash_table (eif->info)->dynobj;
2683 bed = get_elf_backend_data (dynobj);
2685 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2694 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2698 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
2701 unsigned int power_of_two;
2703 asection *sec = h->root.u.def.section;
2705 /* The section aligment of definition is the maximum alignment
2706 requirement of symbols defined in the section. Since we don't
2707 know the symbol alignment requirement, we start with the
2708 maximum alignment and check low bits of the symbol address
2709 for the minimum alignment. */
2710 power_of_two = bfd_get_section_alignment (sec->owner, sec);
2711 mask = ((bfd_vma) 1 << power_of_two) - 1;
2712 while ((h->root.u.def.value & mask) != 0)
2718 if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2721 /* Adjust the section alignment if needed. */
2722 if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2727 /* We make sure that the symbol will be aligned properly. */
2728 dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2730 /* Define the symbol as being at this point in DYNBSS. */
2731 h->root.u.def.section = dynbss;
2732 h->root.u.def.value = dynbss->size;
2734 /* Increment the size of DYNBSS to make room for the symbol. */
2735 dynbss->size += h->size;
2740 /* Adjust all external symbols pointing into SEC_MERGE sections
2741 to reflect the object merging within the sections. */
2744 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2748 if (h->root.type == bfd_link_hash_warning)
2749 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2751 if ((h->root.type == bfd_link_hash_defined
2752 || h->root.type == bfd_link_hash_defweak)
2753 && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2754 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2756 bfd *output_bfd = (bfd *) data;
2758 h->root.u.def.value =
2759 _bfd_merged_section_offset (output_bfd,
2760 &h->root.u.def.section,
2761 elf_section_data (sec)->sec_info,
2762 h->root.u.def.value);
2768 /* Returns false if the symbol referred to by H should be considered
2769 to resolve local to the current module, and true if it should be
2770 considered to bind dynamically. */
2773 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2774 struct bfd_link_info *info,
2775 bfd_boolean ignore_protected)
2777 bfd_boolean binding_stays_local_p;
2778 const struct elf_backend_data *bed;
2779 struct elf_link_hash_table *hash_table;
2784 while (h->root.type == bfd_link_hash_indirect
2785 || h->root.type == bfd_link_hash_warning)
2786 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2788 /* If it was forced local, then clearly it's not dynamic. */
2789 if (h->dynindx == -1)
2791 if (h->forced_local)
2794 /* Identify the cases where name binding rules say that a
2795 visible symbol resolves locally. */
2796 binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2798 switch (ELF_ST_VISIBILITY (h->other))
2805 hash_table = elf_hash_table (info);
2806 if (!is_elf_hash_table (hash_table))
2809 bed = get_elf_backend_data (hash_table->dynobj);
2811 /* Proper resolution for function pointer equality may require
2812 that these symbols perhaps be resolved dynamically, even though
2813 we should be resolving them to the current module. */
2814 if (!ignore_protected || !bed->is_function_type (h->type))
2815 binding_stays_local_p = TRUE;
2822 /* If it isn't defined locally, then clearly it's dynamic. */
2823 if (!h->def_regular)
2826 /* Otherwise, the symbol is dynamic if binding rules don't tell
2827 us that it remains local. */
2828 return !binding_stays_local_p;
2831 /* Return true if the symbol referred to by H should be considered
2832 to resolve local to the current module, and false otherwise. Differs
2833 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2834 undefined symbols and weak symbols. */
2837 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2838 struct bfd_link_info *info,
2839 bfd_boolean local_protected)
2841 const struct elf_backend_data *bed;
2842 struct elf_link_hash_table *hash_table;
2844 /* If it's a local sym, of course we resolve locally. */
2848 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
2849 if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2850 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2853 /* Common symbols that become definitions don't get the DEF_REGULAR
2854 flag set, so test it first, and don't bail out. */
2855 if (ELF_COMMON_DEF_P (h))
2857 /* If we don't have a definition in a regular file, then we can't
2858 resolve locally. The sym is either undefined or dynamic. */
2859 else if (!h->def_regular)
2862 /* Forced local symbols resolve locally. */
2863 if (h->forced_local)
2866 /* As do non-dynamic symbols. */
2867 if (h->dynindx == -1)
2870 /* At this point, we know the symbol is defined and dynamic. In an
2871 executable it must resolve locally, likewise when building symbolic
2872 shared libraries. */
2873 if (info->executable || SYMBOLIC_BIND (info, h))
2876 /* Now deal with defined dynamic symbols in shared libraries. Ones
2877 with default visibility might not resolve locally. */
2878 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2881 hash_table = elf_hash_table (info);
2882 if (!is_elf_hash_table (hash_table))
2885 bed = get_elf_backend_data (hash_table->dynobj);
2887 /* STV_PROTECTED non-function symbols are local. */
2888 if (!bed->is_function_type (h->type))
2891 /* Function pointer equality tests may require that STV_PROTECTED
2892 symbols be treated as dynamic symbols, even when we know that the
2893 dynamic linker will resolve them locally. */
2894 return local_protected;
2897 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2898 aligned. Returns the first TLS output section. */
2900 struct bfd_section *
2901 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2903 struct bfd_section *sec, *tls;
2904 unsigned int align = 0;
2906 for (sec = obfd->sections; sec != NULL; sec = sec->next)
2907 if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2911 for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2912 if (sec->alignment_power > align)
2913 align = sec->alignment_power;
2915 elf_hash_table (info)->tls_sec = tls;
2917 /* Ensure the alignment of the first section is the largest alignment,
2918 so that the tls segment starts aligned. */
2920 tls->alignment_power = align;
2925 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2927 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2928 Elf_Internal_Sym *sym)
2930 const struct elf_backend_data *bed;
2932 /* Local symbols do not count, but target specific ones might. */
2933 if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2934 && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2937 bed = get_elf_backend_data (abfd);
2938 /* Function symbols do not count. */
2939 if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2942 /* If the section is undefined, then so is the symbol. */
2943 if (sym->st_shndx == SHN_UNDEF)
2946 /* If the symbol is defined in the common section, then
2947 it is a common definition and so does not count. */
2948 if (bed->common_definition (sym))
2951 /* If the symbol is in a target specific section then we
2952 must rely upon the backend to tell us what it is. */
2953 if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2954 /* FIXME - this function is not coded yet:
2956 return _bfd_is_global_symbol_definition (abfd, sym);
2958 Instead for now assume that the definition is not global,
2959 Even if this is wrong, at least the linker will behave
2960 in the same way that it used to do. */
2966 /* Search the symbol table of the archive element of the archive ABFD
2967 whose archive map contains a mention of SYMDEF, and determine if
2968 the symbol is defined in this element. */
2970 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2972 Elf_Internal_Shdr * hdr;
2973 bfd_size_type symcount;
2974 bfd_size_type extsymcount;
2975 bfd_size_type extsymoff;
2976 Elf_Internal_Sym *isymbuf;
2977 Elf_Internal_Sym *isym;
2978 Elf_Internal_Sym *isymend;
2981 abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2985 if (! bfd_check_format (abfd, bfd_object))
2988 /* If we have already included the element containing this symbol in the
2989 link then we do not need to include it again. Just claim that any symbol
2990 it contains is not a definition, so that our caller will not decide to
2991 (re)include this element. */
2992 if (abfd->archive_pass)
2995 /* Select the appropriate symbol table. */
2996 if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2997 hdr = &elf_tdata (abfd)->symtab_hdr;
2999 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3001 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3003 /* The sh_info field of the symtab header tells us where the
3004 external symbols start. We don't care about the local symbols. */
3005 if (elf_bad_symtab (abfd))
3007 extsymcount = symcount;
3012 extsymcount = symcount - hdr->sh_info;
3013 extsymoff = hdr->sh_info;
3016 if (extsymcount == 0)
3019 /* Read in the symbol table. */
3020 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3022 if (isymbuf == NULL)
3025 /* Scan the symbol table looking for SYMDEF. */
3027 for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
3031 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3036 if (strcmp (name, symdef->name) == 0)
3038 result = is_global_data_symbol_definition (abfd, isym);
3048 /* Add an entry to the .dynamic table. */
3051 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3055 struct elf_link_hash_table *hash_table;
3056 const struct elf_backend_data *bed;
3058 bfd_size_type newsize;
3059 bfd_byte *newcontents;
3060 Elf_Internal_Dyn dyn;
3062 hash_table = elf_hash_table (info);
3063 if (! is_elf_hash_table (hash_table))
3066 bed = get_elf_backend_data (hash_table->dynobj);
3067 s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3068 BFD_ASSERT (s != NULL);
3070 newsize = s->size + bed->s->sizeof_dyn;
3071 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3072 if (newcontents == NULL)
3076 dyn.d_un.d_val = val;
3077 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3080 s->contents = newcontents;
3085 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3086 otherwise just check whether one already exists. Returns -1 on error,
3087 1 if a DT_NEEDED tag already exists, and 0 on success. */
3090 elf_add_dt_needed_tag (bfd *abfd,
3091 struct bfd_link_info *info,
3095 struct elf_link_hash_table *hash_table;
3096 bfd_size_type oldsize;
3097 bfd_size_type strindex;
3099 if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3102 hash_table = elf_hash_table (info);
3103 oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
3104 strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3105 if (strindex == (bfd_size_type) -1)
3108 if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
3111 const struct elf_backend_data *bed;
3114 bed = get_elf_backend_data (hash_table->dynobj);
3115 sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3117 for (extdyn = sdyn->contents;
3118 extdyn < sdyn->contents + sdyn->size;
3119 extdyn += bed->s->sizeof_dyn)
3121 Elf_Internal_Dyn dyn;
3123 bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3124 if (dyn.d_tag == DT_NEEDED
3125 && dyn.d_un.d_val == strindex)
3127 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3135 if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3138 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3142 /* We were just checking for existence of the tag. */
3143 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3149 on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3151 for (; needed != NULL; needed = needed->next)
3152 if (strcmp (soname, needed->name) == 0)
3158 /* Sort symbol by value and section. */
3160 elf_sort_symbol (const void *arg1, const void *arg2)
3162 const struct elf_link_hash_entry *h1;
3163 const struct elf_link_hash_entry *h2;
3164 bfd_signed_vma vdiff;
3166 h1 = *(const struct elf_link_hash_entry **) arg1;
3167 h2 = *(const struct elf_link_hash_entry **) arg2;
3168 vdiff = h1->root.u.def.value - h2->root.u.def.value;
3170 return vdiff > 0 ? 1 : -1;
3173 long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3175 return sdiff > 0 ? 1 : -1;
3180 /* This function is used to adjust offsets into .dynstr for
3181 dynamic symbols. This is called via elf_link_hash_traverse. */
3184 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3186 struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3188 if (h->root.type == bfd_link_hash_warning)
3189 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3191 if (h->dynindx != -1)
3192 h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3196 /* Assign string offsets in .dynstr, update all structures referencing
3200 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3202 struct elf_link_hash_table *hash_table = elf_hash_table (info);
3203 struct elf_link_local_dynamic_entry *entry;
3204 struct elf_strtab_hash *dynstr = hash_table->dynstr;
3205 bfd *dynobj = hash_table->dynobj;
3208 const struct elf_backend_data *bed;
3211 _bfd_elf_strtab_finalize (dynstr);
3212 size = _bfd_elf_strtab_size (dynstr);
3214 bed = get_elf_backend_data (dynobj);
3215 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3216 BFD_ASSERT (sdyn != NULL);
3218 /* Update all .dynamic entries referencing .dynstr strings. */
3219 for (extdyn = sdyn->contents;
3220 extdyn < sdyn->contents + sdyn->size;
3221 extdyn += bed->s->sizeof_dyn)
3223 Elf_Internal_Dyn dyn;
3225 bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3229 dyn.d_un.d_val = size;
3239 dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3244 bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3247 /* Now update local dynamic symbols. */
3248 for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3249 entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3250 entry->isym.st_name);
3252 /* And the rest of dynamic symbols. */
3253 elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3255 /* Adjust version definitions. */
3256 if (elf_tdata (output_bfd)->cverdefs)
3261 Elf_Internal_Verdef def;
3262 Elf_Internal_Verdaux defaux;
3264 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3268 _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3270 p += sizeof (Elf_External_Verdef);
3271 if (def.vd_aux != sizeof (Elf_External_Verdef))
3273 for (i = 0; i < def.vd_cnt; ++i)
3275 _bfd_elf_swap_verdaux_in (output_bfd,
3276 (Elf_External_Verdaux *) p, &defaux);
3277 defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3279 _bfd_elf_swap_verdaux_out (output_bfd,
3280 &defaux, (Elf_External_Verdaux *) p);
3281 p += sizeof (Elf_External_Verdaux);
3284 while (def.vd_next);
3287 /* Adjust version references. */
3288 if (elf_tdata (output_bfd)->verref)
3293 Elf_Internal_Verneed need;
3294 Elf_Internal_Vernaux needaux;
3296 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3300 _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3302 need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3303 _bfd_elf_swap_verneed_out (output_bfd, &need,
3304 (Elf_External_Verneed *) p);
3305 p += sizeof (Elf_External_Verneed);
3306 for (i = 0; i < need.vn_cnt; ++i)
3308 _bfd_elf_swap_vernaux_in (output_bfd,
3309 (Elf_External_Vernaux *) p, &needaux);
3310 needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3312 _bfd_elf_swap_vernaux_out (output_bfd,
3314 (Elf_External_Vernaux *) p);
3315 p += sizeof (Elf_External_Vernaux);
3318 while (need.vn_next);
3324 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3325 The default is to only match when the INPUT and OUTPUT are exactly
3329 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3330 const bfd_target *output)
3332 return input == output;
3335 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3336 This version is used when different targets for the same architecture
3337 are virtually identical. */
3340 _bfd_elf_relocs_compatible (const bfd_target *input,
3341 const bfd_target *output)
3343 const struct elf_backend_data *obed, *ibed;
3345 if (input == output)
3348 ibed = xvec_get_elf_backend_data (input);
3349 obed = xvec_get_elf_backend_data (output);
3351 if (ibed->arch != obed->arch)
3354 /* If both backends are using this function, deem them compatible. */
3355 return ibed->relocs_compatible == obed->relocs_compatible;
3358 /* Add symbols from an ELF object file to the linker hash table. */
3361 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3363 Elf_Internal_Ehdr *ehdr;
3364 Elf_Internal_Shdr *hdr;
3365 bfd_size_type symcount;
3366 bfd_size_type extsymcount;
3367 bfd_size_type extsymoff;
3368 struct elf_link_hash_entry **sym_hash;
3369 bfd_boolean dynamic;
3370 Elf_External_Versym *extversym = NULL;
3371 Elf_External_Versym *ever;
3372 struct elf_link_hash_entry *weaks;
3373 struct elf_link_hash_entry **nondeflt_vers = NULL;
3374 bfd_size_type nondeflt_vers_cnt = 0;
3375 Elf_Internal_Sym *isymbuf = NULL;
3376 Elf_Internal_Sym *isym;
3377 Elf_Internal_Sym *isymend;
3378 const struct elf_backend_data *bed;
3379 bfd_boolean add_needed;
3380 struct elf_link_hash_table *htab;
3382 void *alloc_mark = NULL;
3383 struct bfd_hash_entry **old_table = NULL;
3384 unsigned int old_size = 0;
3385 unsigned int old_count = 0;
3386 void *old_tab = NULL;
3389 struct bfd_link_hash_entry *old_undefs = NULL;
3390 struct bfd_link_hash_entry *old_undefs_tail = NULL;
3391 long old_dynsymcount = 0;
3393 size_t hashsize = 0;
3395 htab = elf_hash_table (info);
3396 bed = get_elf_backend_data (abfd);
3398 if ((abfd->flags & DYNAMIC) == 0)
3404 /* You can't use -r against a dynamic object. Also, there's no
3405 hope of using a dynamic object which does not exactly match
3406 the format of the output file. */
3407 if (info->relocatable
3408 || !is_elf_hash_table (htab)
3409 || info->output_bfd->xvec != abfd->xvec)
3411 if (info->relocatable)
3412 bfd_set_error (bfd_error_invalid_operation);
3414 bfd_set_error (bfd_error_wrong_format);
3419 ehdr = elf_elfheader (abfd);
3420 if (info->warn_alternate_em
3421 && bed->elf_machine_code != ehdr->e_machine
3422 && ((bed->elf_machine_alt1 != 0
3423 && ehdr->e_machine == bed->elf_machine_alt1)
3424 || (bed->elf_machine_alt2 != 0
3425 && ehdr->e_machine == bed->elf_machine_alt2)))
3426 info->callbacks->einfo
3427 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3428 ehdr->e_machine, abfd, bed->elf_machine_code);
3430 /* As a GNU extension, any input sections which are named
3431 .gnu.warning.SYMBOL are treated as warning symbols for the given
3432 symbol. This differs from .gnu.warning sections, which generate
3433 warnings when they are included in an output file. */
3434 if (info->executable)
3438 for (s = abfd->sections; s != NULL; s = s->next)
3442 name = bfd_get_section_name (abfd, s);
3443 if (CONST_STRNEQ (name, ".gnu.warning."))
3448 name += sizeof ".gnu.warning." - 1;
3450 /* If this is a shared object, then look up the symbol
3451 in the hash table. If it is there, and it is already
3452 been defined, then we will not be using the entry
3453 from this shared object, so we don't need to warn.
3454 FIXME: If we see the definition in a regular object
3455 later on, we will warn, but we shouldn't. The only
3456 fix is to keep track of what warnings we are supposed
3457 to emit, and then handle them all at the end of the
3461 struct elf_link_hash_entry *h;
3463 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3465 /* FIXME: What about bfd_link_hash_common? */
3467 && (h->root.type == bfd_link_hash_defined
3468 || h->root.type == bfd_link_hash_defweak))
3470 /* We don't want to issue this warning. Clobber
3471 the section size so that the warning does not
3472 get copied into the output file. */
3479 msg = (char *) bfd_alloc (abfd, sz + 1);
3483 if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3488 if (! (_bfd_generic_link_add_one_symbol
3489 (info, abfd, name, BSF_WARNING, s, 0, msg,
3490 FALSE, bed->collect, NULL)))
3493 if (! info->relocatable)
3495 /* Clobber the section size so that the warning does
3496 not get copied into the output file. */
3499 /* Also set SEC_EXCLUDE, so that symbols defined in
3500 the warning section don't get copied to the output. */
3501 s->flags |= SEC_EXCLUDE;
3510 /* If we are creating a shared library, create all the dynamic
3511 sections immediately. We need to attach them to something,
3512 so we attach them to this BFD, provided it is the right
3513 format. FIXME: If there are no input BFD's of the same
3514 format as the output, we can't make a shared library. */
3516 && is_elf_hash_table (htab)
3517 && info->output_bfd->xvec == abfd->xvec
3518 && !htab->dynamic_sections_created)
3520 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3524 else if (!is_elf_hash_table (htab))
3529 const char *soname = NULL;
3531 struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3534 /* ld --just-symbols and dynamic objects don't mix very well.
3535 ld shouldn't allow it. */
3536 if ((s = abfd->sections) != NULL
3537 && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3540 /* If this dynamic lib was specified on the command line with
3541 --as-needed in effect, then we don't want to add a DT_NEEDED
3542 tag unless the lib is actually used. Similary for libs brought
3543 in by another lib's DT_NEEDED. When --no-add-needed is used
3544 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3545 any dynamic library in DT_NEEDED tags in the dynamic lib at
3547 add_needed = (elf_dyn_lib_class (abfd)
3548 & (DYN_AS_NEEDED | DYN_DT_NEEDED
3549 | DYN_NO_NEEDED)) == 0;
3551 s = bfd_get_section_by_name (abfd, ".dynamic");
3556 unsigned int elfsec;
3557 unsigned long shlink;
3559 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3566 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3567 if (elfsec == SHN_BAD)
3568 goto error_free_dyn;
3569 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3571 for (extdyn = dynbuf;
3572 extdyn < dynbuf + s->size;
3573 extdyn += bed->s->sizeof_dyn)
3575 Elf_Internal_Dyn dyn;
3577 bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3578 if (dyn.d_tag == DT_SONAME)
3580 unsigned int tagv = dyn.d_un.d_val;
3581 soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3583 goto error_free_dyn;
3585 if (dyn.d_tag == DT_NEEDED)
3587 struct bfd_link_needed_list *n, **pn;
3589 unsigned int tagv = dyn.d_un.d_val;
3591 amt = sizeof (struct bfd_link_needed_list);
3592 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3593 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3594 if (n == NULL || fnm == NULL)
3595 goto error_free_dyn;
3596 amt = strlen (fnm) + 1;
3597 anm = (char *) bfd_alloc (abfd, amt);
3599 goto error_free_dyn;
3600 memcpy (anm, fnm, amt);
3604 for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3608 if (dyn.d_tag == DT_RUNPATH)
3610 struct bfd_link_needed_list *n, **pn;
3612 unsigned int tagv = dyn.d_un.d_val;
3614 amt = sizeof (struct bfd_link_needed_list);
3615 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3616 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3617 if (n == NULL || fnm == NULL)
3618 goto error_free_dyn;
3619 amt = strlen (fnm) + 1;
3620 anm = (char *) bfd_alloc (abfd, amt);
3622 goto error_free_dyn;
3623 memcpy (anm, fnm, amt);
3627 for (pn = & runpath;
3633 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3634 if (!runpath && dyn.d_tag == DT_RPATH)
3636 struct bfd_link_needed_list *n, **pn;
3638 unsigned int tagv = dyn.d_un.d_val;
3640 amt = sizeof (struct bfd_link_needed_list);
3641 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3642 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3643 if (n == NULL || fnm == NULL)
3644 goto error_free_dyn;
3645 amt = strlen (fnm) + 1;
3646 anm = (char *) bfd_alloc (abfd, amt);
3648 goto error_free_dyn;
3649 memcpy (anm, fnm, amt);
3659 if (dyn.d_tag == DT_AUDIT)
3661 unsigned int tagv = dyn.d_un.d_val;
3662 audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3669 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3670 frees all more recently bfd_alloc'd blocks as well. */
3676 struct bfd_link_needed_list **pn;
3677 for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3682 /* We do not want to include any of the sections in a dynamic
3683 object in the output file. We hack by simply clobbering the
3684 list of sections in the BFD. This could be handled more
3685 cleanly by, say, a new section flag; the existing
3686 SEC_NEVER_LOAD flag is not the one we want, because that one
3687 still implies that the section takes up space in the output
3689 bfd_section_list_clear (abfd);
3691 /* Find the name to use in a DT_NEEDED entry that refers to this
3692 object. If the object has a DT_SONAME entry, we use it.
3693 Otherwise, if the generic linker stuck something in
3694 elf_dt_name, we use that. Otherwise, we just use the file
3696 if (soname == NULL || *soname == '\0')
3698 soname = elf_dt_name (abfd);
3699 if (soname == NULL || *soname == '\0')
3700 soname = bfd_get_filename (abfd);
3703 /* Save the SONAME because sometimes the linker emulation code
3704 will need to know it. */
3705 elf_dt_name (abfd) = soname;
3707 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3711 /* If we have already included this dynamic object in the
3712 link, just ignore it. There is no reason to include a
3713 particular dynamic object more than once. */
3717 /* Save the DT_AUDIT entry for the linker emulation code. */
3718 elf_dt_audit (abfd) = audit;
3721 /* If this is a dynamic object, we always link against the .dynsym
3722 symbol table, not the .symtab symbol table. The dynamic linker
3723 will only see the .dynsym symbol table, so there is no reason to
3724 look at .symtab for a dynamic object. */
3726 if (! dynamic || elf_dynsymtab (abfd) == 0)
3727 hdr = &elf_tdata (abfd)->symtab_hdr;
3729 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3731 symcount = hdr->sh_size / bed->s->sizeof_sym;
3733 /* The sh_info field of the symtab header tells us where the
3734 external symbols start. We don't care about the local symbols at
3736 if (elf_bad_symtab (abfd))
3738 extsymcount = symcount;
3743 extsymcount = symcount - hdr->sh_info;
3744 extsymoff = hdr->sh_info;
3748 if (extsymcount != 0)
3750 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3752 if (isymbuf == NULL)
3755 /* We store a pointer to the hash table entry for each external
3757 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3758 sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
3759 if (sym_hash == NULL)
3760 goto error_free_sym;
3761 elf_sym_hashes (abfd) = sym_hash;
3766 /* Read in any version definitions. */
3767 if (!_bfd_elf_slurp_version_tables (abfd,
3768 info->default_imported_symver))
3769 goto error_free_sym;
3771 /* Read in the symbol versions, but don't bother to convert them
3772 to internal format. */
3773 if (elf_dynversym (abfd) != 0)
3775 Elf_Internal_Shdr *versymhdr;
3777 versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3778 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3779 if (extversym == NULL)
3780 goto error_free_sym;
3781 amt = versymhdr->sh_size;
3782 if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3783 || bfd_bread (extversym, amt, abfd) != amt)
3784 goto error_free_vers;
3788 /* If we are loading an as-needed shared lib, save the symbol table
3789 state before we start adding symbols. If the lib turns out
3790 to be unneeded, restore the state. */
3791 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3796 for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3798 struct bfd_hash_entry *p;
3799 struct elf_link_hash_entry *h;
3801 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3803 h = (struct elf_link_hash_entry *) p;
3804 entsize += htab->root.table.entsize;
3805 if (h->root.type == bfd_link_hash_warning)
3806 entsize += htab->root.table.entsize;
3810 tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3811 hashsize = extsymcount * sizeof (struct elf_link_hash_entry *);
3812 old_tab = bfd_malloc (tabsize + entsize + hashsize);
3813 if (old_tab == NULL)
3814 goto error_free_vers;
3816 /* Remember the current objalloc pointer, so that all mem for
3817 symbols added can later be reclaimed. */
3818 alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3819 if (alloc_mark == NULL)
3820 goto error_free_vers;
3822 /* Make a special call to the linker "notice" function to
3823 tell it that we are about to handle an as-needed lib. */
3824 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
3826 goto error_free_vers;
3828 /* Clone the symbol table and sym hashes. Remember some
3829 pointers into the symbol table, and dynamic symbol count. */
3830 old_hash = (char *) old_tab + tabsize;
3831 old_ent = (char *) old_hash + hashsize;
3832 memcpy (old_tab, htab->root.table.table, tabsize);
3833 memcpy (old_hash, sym_hash, hashsize);
3834 old_undefs = htab->root.undefs;
3835 old_undefs_tail = htab->root.undefs_tail;
3836 old_table = htab->root.table.table;
3837 old_size = htab->root.table.size;
3838 old_count = htab->root.table.count;
3839 old_dynsymcount = htab->dynsymcount;
3841 for (i = 0; i < htab->root.table.size; i++)
3843 struct bfd_hash_entry *p;
3844 struct elf_link_hash_entry *h;
3846 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3848 memcpy (old_ent, p, htab->root.table.entsize);
3849 old_ent = (char *) old_ent + htab->root.table.entsize;
3850 h = (struct elf_link_hash_entry *) p;
3851 if (h->root.type == bfd_link_hash_warning)
3853 memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3854 old_ent = (char *) old_ent + htab->root.table.entsize;
3861 ever = extversym != NULL ? extversym + extsymoff : NULL;
3862 for (isym = isymbuf, isymend = isymbuf + extsymcount;
3864 isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3868 asection *sec, *new_sec;
3871 struct elf_link_hash_entry *h;
3872 bfd_boolean definition;
3873 bfd_boolean size_change_ok;
3874 bfd_boolean type_change_ok;
3875 bfd_boolean new_weakdef;
3876 bfd_boolean override;
3878 unsigned int old_alignment;
3883 flags = BSF_NO_FLAGS;
3885 value = isym->st_value;
3887 common = bed->common_definition (isym);
3889 bind = ELF_ST_BIND (isym->st_info);
3893 /* This should be impossible, since ELF requires that all
3894 global symbols follow all local symbols, and that sh_info
3895 point to the first global symbol. Unfortunately, Irix 5
3900 if (isym->st_shndx != SHN_UNDEF && !common)
3908 case STB_GNU_UNIQUE:
3909 flags = BSF_GNU_UNIQUE;
3913 /* Leave it up to the processor backend. */
3917 if (isym->st_shndx == SHN_UNDEF)
3918 sec = bfd_und_section_ptr;
3919 else if (isym->st_shndx == SHN_ABS)
3920 sec = bfd_abs_section_ptr;
3921 else if (isym->st_shndx == SHN_COMMON)
3923 sec = bfd_com_section_ptr;
3924 /* What ELF calls the size we call the value. What ELF
3925 calls the value we call the alignment. */
3926 value = isym->st_size;
3930 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3932 sec = bfd_abs_section_ptr;
3933 else if (sec->kept_section)
3935 /* Symbols from discarded section are undefined. We keep
3937 sec = bfd_und_section_ptr;
3938 isym->st_shndx = SHN_UNDEF;
3940 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3944 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3947 goto error_free_vers;
3949 if (isym->st_shndx == SHN_COMMON
3950 && ELF_ST_TYPE (isym->st_info) == STT_TLS
3951 && !info->relocatable)
3953 asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3957 tcomm = bfd_make_section_with_flags (abfd, ".tcommon",
3960 | SEC_LINKER_CREATED
3961 | SEC_THREAD_LOCAL));
3963 goto error_free_vers;
3967 else if (bed->elf_add_symbol_hook)
3969 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3971 goto error_free_vers;
3973 /* The hook function sets the name to NULL if this symbol
3974 should be skipped for some reason. */
3979 /* Sanity check that all possibilities were handled. */
3982 bfd_set_error (bfd_error_bad_value);
3983 goto error_free_vers;
3986 if (bfd_is_und_section (sec)
3987 || bfd_is_com_section (sec))
3992 size_change_ok = FALSE;
3993 type_change_ok = bed->type_change_ok;
3998 if (is_elf_hash_table (htab))
4000 Elf_Internal_Versym iver;
4001 unsigned int vernum = 0;
4006 if (info->default_imported_symver)
4007 /* Use the default symbol version created earlier. */
4008 iver.vs_vers = elf_tdata (abfd)->cverdefs;
4013 _bfd_elf_swap_versym_in (abfd, ever, &iver);
4015 vernum = iver.vs_vers & VERSYM_VERSION;
4017 /* If this is a hidden symbol, or if it is not version
4018 1, we append the version name to the symbol name.
4019 However, we do not modify a non-hidden absolute symbol
4020 if it is not a function, because it might be the version
4021 symbol itself. FIXME: What if it isn't? */
4022 if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4024 && (!bfd_is_abs_section (sec)
4025 || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4028 size_t namelen, verlen, newlen;
4031 if (isym->st_shndx != SHN_UNDEF)
4033 if (vernum > elf_tdata (abfd)->cverdefs)
4035 else if (vernum > 1)
4037 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4043 (*_bfd_error_handler)
4044 (_("%B: %s: invalid version %u (max %d)"),
4046 elf_tdata (abfd)->cverdefs);
4047 bfd_set_error (bfd_error_bad_value);
4048 goto error_free_vers;
4053 /* We cannot simply test for the number of
4054 entries in the VERNEED section since the
4055 numbers for the needed versions do not start
4057 Elf_Internal_Verneed *t;
4060 for (t = elf_tdata (abfd)->verref;
4064 Elf_Internal_Vernaux *a;
4066 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4068 if (a->vna_other == vernum)
4070 verstr = a->vna_nodename;
4079 (*_bfd_error_handler)
4080 (_("%B: %s: invalid needed version %d"),
4081 abfd, name, vernum);
4082 bfd_set_error (bfd_error_bad_value);
4083 goto error_free_vers;
4087 namelen = strlen (name);
4088 verlen = strlen (verstr);
4089 newlen = namelen + verlen + 2;
4090 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4091 && isym->st_shndx != SHN_UNDEF)
4094 newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4095 if (newname == NULL)
4096 goto error_free_vers;
4097 memcpy (newname, name, namelen);
4098 p = newname + namelen;
4100 /* If this is a defined non-hidden version symbol,
4101 we add another @ to the name. This indicates the
4102 default version of the symbol. */
4103 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4104 && isym->st_shndx != SHN_UNDEF)
4106 memcpy (p, verstr, verlen + 1);
4111 if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec,
4112 &value, &old_alignment,
4113 sym_hash, &skip, &override,
4114 &type_change_ok, &size_change_ok))
4115 goto error_free_vers;
4124 while (h->root.type == bfd_link_hash_indirect
4125 || h->root.type == bfd_link_hash_warning)
4126 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4128 /* Remember the old alignment if this is a common symbol, so
4129 that we don't reduce the alignment later on. We can't
4130 check later, because _bfd_generic_link_add_one_symbol
4131 will set a default for the alignment which we want to
4132 override. We also remember the old bfd where the existing
4133 definition comes from. */
4134 switch (h->root.type)
4139 case bfd_link_hash_defined:
4140 case bfd_link_hash_defweak:
4141 old_bfd = h->root.u.def.section->owner;
4144 case bfd_link_hash_common:
4145 old_bfd = h->root.u.c.p->section->owner;
4146 old_alignment = h->root.u.c.p->alignment_power;
4150 if (elf_tdata (abfd)->verdef != NULL
4154 h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4157 if (! (_bfd_generic_link_add_one_symbol
4158 (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4159 (struct bfd_link_hash_entry **) sym_hash)))
4160 goto error_free_vers;
4163 while (h->root.type == bfd_link_hash_indirect
4164 || h->root.type == bfd_link_hash_warning)
4165 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4168 h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4170 new_weakdef = FALSE;
4173 && (flags & BSF_WEAK) != 0
4174 && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4175 && is_elf_hash_table (htab)
4176 && h->u.weakdef == NULL)
4178 /* Keep a list of all weak defined non function symbols from
4179 a dynamic object, using the weakdef field. Later in this
4180 function we will set the weakdef field to the correct
4181 value. We only put non-function symbols from dynamic
4182 objects on this list, because that happens to be the only
4183 time we need to know the normal symbol corresponding to a
4184 weak symbol, and the information is time consuming to
4185 figure out. If the weakdef field is not already NULL,
4186 then this symbol was already defined by some previous
4187 dynamic object, and we will be using that previous
4188 definition anyhow. */
4190 h->u.weakdef = weaks;
4195 /* Set the alignment of a common symbol. */
4196 if ((common || bfd_is_com_section (sec))
4197 && h->root.type == bfd_link_hash_common)
4202 align = bfd_log2 (isym->st_value);
4205 /* The new symbol is a common symbol in a shared object.
4206 We need to get the alignment from the section. */
4207 align = new_sec->alignment_power;
4209 if (align > old_alignment
4210 /* Permit an alignment power of zero if an alignment of one
4211 is specified and no other alignments have been specified. */
4212 || (isym->st_value == 1 && old_alignment == 0))
4213 h->root.u.c.p->alignment_power = align;
4215 h->root.u.c.p->alignment_power = old_alignment;
4218 if (is_elf_hash_table (htab))
4222 /* Check the alignment when a common symbol is involved. This
4223 can change when a common symbol is overridden by a normal
4224 definition or a common symbol is ignored due to the old
4225 normal definition. We need to make sure the maximum
4226 alignment is maintained. */
4227 if ((old_alignment || common)
4228 && h->root.type != bfd_link_hash_common)
4230 unsigned int common_align;
4231 unsigned int normal_align;
4232 unsigned int symbol_align;
4236 symbol_align = ffs (h->root.u.def.value) - 1;
4237 if (h->root.u.def.section->owner != NULL
4238 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4240 normal_align = h->root.u.def.section->alignment_power;
4241 if (normal_align > symbol_align)
4242 normal_align = symbol_align;
4245 normal_align = symbol_align;
4249 common_align = old_alignment;
4250 common_bfd = old_bfd;
4255 common_align = bfd_log2 (isym->st_value);
4257 normal_bfd = old_bfd;
4260 if (normal_align < common_align)
4262 /* PR binutils/2735 */
4263 if (normal_bfd == NULL)
4264 (*_bfd_error_handler)
4265 (_("Warning: alignment %u of common symbol `%s' in %B"
4266 " is greater than the alignment (%u) of its section %A"),
4267 common_bfd, h->root.u.def.section,
4268 1 << common_align, name, 1 << normal_align);
4270 (*_bfd_error_handler)
4271 (_("Warning: alignment %u of symbol `%s' in %B"
4272 " is smaller than %u in %B"),
4273 normal_bfd, common_bfd,
4274 1 << normal_align, name, 1 << common_align);
4278 /* Remember the symbol size if it isn't undefined. */
4279 if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF)
4280 && (definition || h->size == 0))
4283 && h->size != isym->st_size
4284 && ! size_change_ok)
4285 (*_bfd_error_handler)
4286 (_("Warning: size of symbol `%s' changed"
4287 " from %lu in %B to %lu in %B"),
4289 name, (unsigned long) h->size,
4290 (unsigned long) isym->st_size);
4292 h->size = isym->st_size;
4295 /* If this is a common symbol, then we always want H->SIZE
4296 to be the size of the common symbol. The code just above
4297 won't fix the size if a common symbol becomes larger. We
4298 don't warn about a size change here, because that is
4299 covered by --warn-common. Allow changed between different
4301 if (h->root.type == bfd_link_hash_common)
4302 h->size = h->root.u.c.size;
4304 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4305 && (definition || h->type == STT_NOTYPE))
4307 unsigned int type = ELF_ST_TYPE (isym->st_info);
4309 /* Turn an IFUNC symbol from a DSO into a normal FUNC
4311 if (type == STT_GNU_IFUNC
4312 && (abfd->flags & DYNAMIC) != 0)
4315 if (h->type != type)
4317 if (h->type != STT_NOTYPE && ! type_change_ok)
4318 (*_bfd_error_handler)
4319 (_("Warning: type of symbol `%s' changed"
4320 " from %d to %d in %B"),
4321 abfd, name, h->type, type);
4327 /* Merge st_other field. */
4328 elf_merge_st_other (abfd, h, isym, definition, dynamic);
4330 /* Set a flag in the hash table entry indicating the type of
4331 reference or definition we just found. Keep a count of
4332 the number of dynamic symbols we find. A dynamic symbol
4333 is one which is referenced or defined by both a regular
4334 object and a shared object. */
4341 if (bind != STB_WEAK)
4342 h->ref_regular_nonweak = 1;
4354 if (! info->executable
4367 || (h->u.weakdef != NULL
4369 && h->u.weakdef->dynindx != -1))
4373 if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
4375 /* We don't want to make debug symbol dynamic. */
4376 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4380 /* Check to see if we need to add an indirect symbol for
4381 the default name. */
4382 if (definition || h->root.type == bfd_link_hash_common)
4383 if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4384 &sec, &value, &dynsym,
4386 goto error_free_vers;
4388 if (definition && !dynamic)
4390 char *p = strchr (name, ELF_VER_CHR);
4391 if (p != NULL && p[1] != ELF_VER_CHR)
4393 /* Queue non-default versions so that .symver x, x@FOO
4394 aliases can be checked. */
4397 amt = ((isymend - isym + 1)
4398 * sizeof (struct elf_link_hash_entry *));
4400 (struct elf_link_hash_entry **) bfd_malloc (amt);
4402 goto error_free_vers;
4404 nondeflt_vers[nondeflt_vers_cnt++] = h;
4408 if (dynsym && h->dynindx == -1)
4410 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4411 goto error_free_vers;
4412 if (h->u.weakdef != NULL
4414 && h->u.weakdef->dynindx == -1)
4416 if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4417 goto error_free_vers;
4420 else if (dynsym && h->dynindx != -1)
4421 /* If the symbol already has a dynamic index, but
4422 visibility says it should not be visible, turn it into
4424 switch (ELF_ST_VISIBILITY (h->other))
4428 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4438 && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4439 && !on_needed_list (elf_dt_name (abfd), htab->needed))))
4442 const char *soname = elf_dt_name (abfd);
4444 /* A symbol from a library loaded via DT_NEEDED of some
4445 other library is referenced by a regular object.
4446 Add a DT_NEEDED entry for it. Issue an error if
4447 --no-add-needed is used. */
4448 if ((elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4450 (*_bfd_error_handler)
4451 (_("%s: invalid DSO for symbol `%s' definition"),
4453 bfd_set_error (bfd_error_bad_value);
4454 goto error_free_vers;
4457 elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4458 (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4461 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4463 goto error_free_vers;
4465 BFD_ASSERT (ret == 0);
4470 if (extversym != NULL)
4476 if (isymbuf != NULL)
4482 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4486 /* Restore the symbol table. */
4487 if (bed->as_needed_cleanup)
4488 (*bed->as_needed_cleanup) (abfd, info);
4489 old_hash = (char *) old_tab + tabsize;
4490 old_ent = (char *) old_hash + hashsize;
4491 sym_hash = elf_sym_hashes (abfd);
4492 htab->root.table.table = old_table;
4493 htab->root.table.size = old_size;
4494 htab->root.table.count = old_count;
4495 memcpy (htab->root.table.table, old_tab, tabsize);
4496 memcpy (sym_hash, old_hash, hashsize);
4497 htab->root.undefs = old_undefs;
4498 htab->root.undefs_tail = old_undefs_tail;
4499 for (i = 0; i < htab->root.table.size; i++)
4501 struct bfd_hash_entry *p;
4502 struct elf_link_hash_entry *h;
4504 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4506 h = (struct elf_link_hash_entry *) p;
4507 if (h->root.type == bfd_link_hash_warning)
4508 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4509 if (h->dynindx >= old_dynsymcount)
4510 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4512 memcpy (p, old_ent, htab->root.table.entsize);
4513 old_ent = (char *) old_ent + htab->root.table.entsize;
4514 h = (struct elf_link_hash_entry *) p;
4515 if (h->root.type == bfd_link_hash_warning)
4517 memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4518 old_ent = (char *) old_ent + htab->root.table.entsize;
4523 /* Make a special call to the linker "notice" function to
4524 tell it that symbols added for crefs may need to be removed. */
4525 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4527 goto error_free_vers;
4530 objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4532 if (nondeflt_vers != NULL)
4533 free (nondeflt_vers);
4537 if (old_tab != NULL)
4539 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4541 goto error_free_vers;
4546 /* Now that all the symbols from this input file are created, handle
4547 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4548 if (nondeflt_vers != NULL)
4550 bfd_size_type cnt, symidx;
4552 for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4554 struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4555 char *shortname, *p;
4557 p = strchr (h->root.root.string, ELF_VER_CHR);
4559 || (h->root.type != bfd_link_hash_defined
4560 && h->root.type != bfd_link_hash_defweak))
4563 amt = p - h->root.root.string;
4564 shortname = (char *) bfd_malloc (amt + 1);
4566 goto error_free_vers;
4567 memcpy (shortname, h->root.root.string, amt);
4568 shortname[amt] = '\0';
4570 hi = (struct elf_link_hash_entry *)
4571 bfd_link_hash_lookup (&htab->root, shortname,
4572 FALSE, FALSE, FALSE);
4574 && hi->root.type == h->root.type
4575 && hi->root.u.def.value == h->root.u.def.value
4576 && hi->root.u.def.section == h->root.u.def.section)
4578 (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4579 hi->root.type = bfd_link_hash_indirect;
4580 hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4581 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4582 sym_hash = elf_sym_hashes (abfd);
4584 for (symidx = 0; symidx < extsymcount; ++symidx)
4585 if (sym_hash[symidx] == hi)
4587 sym_hash[symidx] = h;
4593 free (nondeflt_vers);
4594 nondeflt_vers = NULL;
4597 /* Now set the weakdefs field correctly for all the weak defined
4598 symbols we found. The only way to do this is to search all the
4599 symbols. Since we only need the information for non functions in
4600 dynamic objects, that's the only time we actually put anything on
4601 the list WEAKS. We need this information so that if a regular
4602 object refers to a symbol defined weakly in a dynamic object, the
4603 real symbol in the dynamic object is also put in the dynamic
4604 symbols; we also must arrange for both symbols to point to the
4605 same memory location. We could handle the general case of symbol
4606 aliasing, but a general symbol alias can only be generated in
4607 assembler code, handling it correctly would be very time
4608 consuming, and other ELF linkers don't handle general aliasing
4612 struct elf_link_hash_entry **hpp;
4613 struct elf_link_hash_entry **hppend;
4614 struct elf_link_hash_entry **sorted_sym_hash;
4615 struct elf_link_hash_entry *h;
4618 /* Since we have to search the whole symbol list for each weak
4619 defined symbol, search time for N weak defined symbols will be
4620 O(N^2). Binary search will cut it down to O(NlogN). */
4621 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4622 sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4623 if (sorted_sym_hash == NULL)
4625 sym_hash = sorted_sym_hash;
4626 hpp = elf_sym_hashes (abfd);
4627 hppend = hpp + extsymcount;
4629 for (; hpp < hppend; hpp++)
4633 && h->root.type == bfd_link_hash_defined
4634 && !bed->is_function_type (h->type))
4642 qsort (sorted_sym_hash, sym_count,
4643 sizeof (struct elf_link_hash_entry *),
4646 while (weaks != NULL)
4648 struct elf_link_hash_entry *hlook;
4655 weaks = hlook->u.weakdef;
4656 hlook->u.weakdef = NULL;
4658 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4659 || hlook->root.type == bfd_link_hash_defweak
4660 || hlook->root.type == bfd_link_hash_common
4661 || hlook->root.type == bfd_link_hash_indirect);
4662 slook = hlook->root.u.def.section;
4663 vlook = hlook->root.u.def.value;
4670 bfd_signed_vma vdiff;
4672 h = sorted_sym_hash [idx];
4673 vdiff = vlook - h->root.u.def.value;
4680 long sdiff = slook->id - h->root.u.def.section->id;
4693 /* We didn't find a value/section match. */
4697 for (i = ilook; i < sym_count; i++)
4699 h = sorted_sym_hash [i];
4701 /* Stop if value or section doesn't match. */
4702 if (h->root.u.def.value != vlook
4703 || h->root.u.def.section != slook)
4705 else if (h != hlook)
4707 hlook->u.weakdef = h;
4709 /* If the weak definition is in the list of dynamic
4710 symbols, make sure the real definition is put
4712 if (hlook->dynindx != -1 && h->dynindx == -1)
4714 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4717 free (sorted_sym_hash);
4722 /* If the real definition is in the list of dynamic
4723 symbols, make sure the weak definition is put
4724 there as well. If we don't do this, then the
4725 dynamic loader might not merge the entries for the
4726 real definition and the weak definition. */
4727 if (h->dynindx != -1 && hlook->dynindx == -1)
4729 if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4730 goto err_free_sym_hash;
4737 free (sorted_sym_hash);
4740 if (bed->check_directives
4741 && !(*bed->check_directives) (abfd, info))
4744 /* If this object is the same format as the output object, and it is
4745 not a shared library, then let the backend look through the
4748 This is required to build global offset table entries and to
4749 arrange for dynamic relocs. It is not required for the
4750 particular common case of linking non PIC code, even when linking
4751 against shared libraries, but unfortunately there is no way of
4752 knowing whether an object file has been compiled PIC or not.
4753 Looking through the relocs is not particularly time consuming.
4754 The problem is that we must either (1) keep the relocs in memory,
4755 which causes the linker to require additional runtime memory or
4756 (2) read the relocs twice from the input file, which wastes time.
4757 This would be a good case for using mmap.
4759 I have no idea how to handle linking PIC code into a file of a
4760 different format. It probably can't be done. */
4762 && is_elf_hash_table (htab)
4763 && bed->check_relocs != NULL
4764 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4768 for (o = abfd->sections; o != NULL; o = o->next)
4770 Elf_Internal_Rela *internal_relocs;
4773 if ((o->flags & SEC_RELOC) == 0
4774 || o->reloc_count == 0
4775 || ((info->strip == strip_all || info->strip == strip_debugger)
4776 && (o->flags & SEC_DEBUGGING) != 0)
4777 || bfd_is_abs_section (o->output_section))
4780 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4782 if (internal_relocs == NULL)
4785 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4787 if (elf_section_data (o)->relocs != internal_relocs)
4788 free (internal_relocs);
4795 /* If this is a non-traditional link, try to optimize the handling
4796 of the .stab/.stabstr sections. */
4798 && ! info->traditional_format
4799 && is_elf_hash_table (htab)
4800 && (info->strip != strip_all && info->strip != strip_debugger))
4804 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4805 if (stabstr != NULL)
4807 bfd_size_type string_offset = 0;
4810 for (stab = abfd->sections; stab; stab = stab->next)
4811 if (CONST_STRNEQ (stab->name, ".stab")
4812 && (!stab->name[5] ||
4813 (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4814 && (stab->flags & SEC_MERGE) == 0
4815 && !bfd_is_abs_section (stab->output_section))
4817 struct bfd_elf_section_data *secdata;
4819 secdata = elf_section_data (stab);
4820 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4821 stabstr, &secdata->sec_info,
4824 if (secdata->sec_info)
4825 stab->sec_info_type = ELF_INFO_TYPE_STABS;
4830 if (is_elf_hash_table (htab) && add_needed)
4832 /* Add this bfd to the loaded list. */
4833 struct elf_link_loaded_list *n;
4835 n = (struct elf_link_loaded_list *)
4836 bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
4840 n->next = htab->loaded;
4847 if (old_tab != NULL)
4849 if (nondeflt_vers != NULL)
4850 free (nondeflt_vers);
4851 if (extversym != NULL)
4854 if (isymbuf != NULL)
4860 /* Return the linker hash table entry of a symbol that might be
4861 satisfied by an archive symbol. Return -1 on error. */
4863 struct elf_link_hash_entry *
4864 _bfd_elf_archive_symbol_lookup (bfd *abfd,
4865 struct bfd_link_info *info,
4868 struct elf_link_hash_entry *h;
4872 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
4876 /* If this is a default version (the name contains @@), look up the
4877 symbol again with only one `@' as well as without the version.
4878 The effect is that references to the symbol with and without the
4879 version will be matched by the default symbol in the archive. */
4881 p = strchr (name, ELF_VER_CHR);
4882 if (p == NULL || p[1] != ELF_VER_CHR)
4885 /* First check with only one `@'. */
4886 len = strlen (name);
4887 copy = (char *) bfd_alloc (abfd, len);
4889 return (struct elf_link_hash_entry *) 0 - 1;
4891 first = p - name + 1;
4892 memcpy (copy, name, first);
4893 memcpy (copy + first, name + first + 1, len - first);
4895 h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, FALSE);
4898 /* We also need to check references to the symbol without the
4900 copy[first - 1] = '\0';
4901 h = elf_link_hash_lookup (elf_hash_table (info), copy,
4902 FALSE, FALSE, FALSE);
4905 bfd_release (abfd, copy);
4909 /* Add symbols from an ELF archive file to the linker hash table. We
4910 don't use _bfd_generic_link_add_archive_symbols because of a
4911 problem which arises on UnixWare. The UnixWare libc.so is an
4912 archive which includes an entry libc.so.1 which defines a bunch of
4913 symbols. The libc.so archive also includes a number of other
4914 object files, which also define symbols, some of which are the same
4915 as those defined in libc.so.1. Correct linking requires that we
4916 consider each object file in turn, and include it if it defines any
4917 symbols we need. _bfd_generic_link_add_archive_symbols does not do
4918 this; it looks through the list of undefined symbols, and includes
4919 any object file which defines them. When this algorithm is used on
4920 UnixWare, it winds up pulling in libc.so.1 early and defining a
4921 bunch of symbols. This means that some of the other objects in the
4922 archive are not included in the link, which is incorrect since they
4923 precede libc.so.1 in the archive.
4925 Fortunately, ELF archive handling is simpler than that done by
4926 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4927 oddities. In ELF, if we find a symbol in the archive map, and the
4928 symbol is currently undefined, we know that we must pull in that
4931 Unfortunately, we do have to make multiple passes over the symbol
4932 table until nothing further is resolved. */
4935 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
4938 bfd_boolean *defined = NULL;
4939 bfd_boolean *included = NULL;
4943 const struct elf_backend_data *bed;
4944 struct elf_link_hash_entry * (*archive_symbol_lookup)
4945 (bfd *, struct bfd_link_info *, const char *);
4947 if (! bfd_has_map (abfd))
4949 /* An empty archive is a special case. */
4950 if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4952 bfd_set_error (bfd_error_no_armap);
4956 /* Keep track of all symbols we know to be already defined, and all
4957 files we know to be already included. This is to speed up the
4958 second and subsequent passes. */
4959 c = bfd_ardata (abfd)->symdef_count;
4963 amt *= sizeof (bfd_boolean);
4964 defined = (bfd_boolean *) bfd_zmalloc (amt);
4965 included = (bfd_boolean *) bfd_zmalloc (amt);
4966 if (defined == NULL || included == NULL)
4969 symdefs = bfd_ardata (abfd)->symdefs;
4970 bed = get_elf_backend_data (abfd);
4971 archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
4984 symdefend = symdef + c;
4985 for (i = 0; symdef < symdefend; symdef++, i++)
4987 struct elf_link_hash_entry *h;
4989 struct bfd_link_hash_entry *undefs_tail;
4992 if (defined[i] || included[i])
4994 if (symdef->file_offset == last)
5000 h = archive_symbol_lookup (abfd, info, symdef->name);
5001 if (h == (struct elf_link_hash_entry *) 0 - 1)
5007 if (h->root.type == bfd_link_hash_common)
5009 /* We currently have a common symbol. The archive map contains
5010 a reference to this symbol, so we may want to include it. We
5011 only want to include it however, if this archive element
5012 contains a definition of the symbol, not just another common
5015 Unfortunately some archivers (including GNU ar) will put
5016 declarations of common symbols into their archive maps, as
5017 well as real definitions, so we cannot just go by the archive
5018 map alone. Instead we must read in the element's symbol
5019 table and check that to see what kind of symbol definition
5021 if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5024 else if (h->root.type != bfd_link_hash_undefined)
5026 if (h->root.type != bfd_link_hash_undefweak)
5031 /* We need to include this archive member. */
5032 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5033 if (element == NULL)
5036 if (! bfd_check_format (element, bfd_object))
5039 /* Doublecheck that we have not included this object
5040 already--it should be impossible, but there may be
5041 something wrong with the archive. */
5042 if (element->archive_pass != 0)
5044 bfd_set_error (bfd_error_bad_value);
5047 element->archive_pass = 1;
5049 undefs_tail = info->hash->undefs_tail;
5051 if (! (*info->callbacks->add_archive_element) (info, element,
5054 if (! bfd_link_add_symbols (element, info))
5057 /* If there are any new undefined symbols, we need to make
5058 another pass through the archive in order to see whether
5059 they can be defined. FIXME: This isn't perfect, because
5060 common symbols wind up on undefs_tail and because an
5061 undefined symbol which is defined later on in this pass
5062 does not require another pass. This isn't a bug, but it
5063 does make the code less efficient than it could be. */
5064 if (undefs_tail != info->hash->undefs_tail)
5067 /* Look backward to mark all symbols from this object file
5068 which we have already seen in this pass. */
5072 included[mark] = TRUE;
5077 while (symdefs[mark].file_offset == symdef->file_offset);
5079 /* We mark subsequent symbols from this object file as we go
5080 on through the loop. */
5081 last = symdef->file_offset;
5092 if (defined != NULL)
5094 if (included != NULL)
5099 /* Given an ELF BFD, add symbols to the global hash table as
5103 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5105 switch (bfd_get_format (abfd))
5108 return elf_link_add_object_symbols (abfd, info);
5110 return elf_link_add_archive_symbols (abfd, info);
5112 bfd_set_error (bfd_error_wrong_format);
5117 struct hash_codes_info
5119 unsigned long *hashcodes;
5123 /* This function will be called though elf_link_hash_traverse to store
5124 all hash value of the exported symbols in an array. */
5127 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5129 struct hash_codes_info *inf = (struct hash_codes_info *) data;
5135 if (h->root.type == bfd_link_hash_warning)
5136 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5138 /* Ignore indirect symbols. These are added by the versioning code. */
5139 if (h->dynindx == -1)
5142 name = h->root.root.string;
5143 p = strchr (name, ELF_VER_CHR);
5146 alc = (char *) bfd_malloc (p - name + 1);
5152 memcpy (alc, name, p - name);
5153 alc[p - name] = '\0';
5157 /* Compute the hash value. */
5158 ha = bfd_elf_hash (name);
5160 /* Store the found hash value in the array given as the argument. */
5161 *(inf->hashcodes)++ = ha;
5163 /* And store it in the struct so that we can put it in the hash table
5165 h->u.elf_hash_value = ha;
5173 struct collect_gnu_hash_codes
5176 const struct elf_backend_data *bed;
5177 unsigned long int nsyms;
5178 unsigned long int maskbits;
5179 unsigned long int *hashcodes;
5180 unsigned long int *hashval;
5181 unsigned long int *indx;
5182 unsigned long int *counts;
5185 long int min_dynindx;
5186 unsigned long int bucketcount;
5187 unsigned long int symindx;
5188 long int local_indx;
5189 long int shift1, shift2;
5190 unsigned long int mask;
5194 /* This function will be called though elf_link_hash_traverse to store
5195 all hash value of the exported symbols in an array. */
5198 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5200 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5206 if (h->root.type == bfd_link_hash_warning)
5207 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5209 /* Ignore indirect symbols. These are added by the versioning code. */
5210 if (h->dynindx == -1)
5213 /* Ignore also local symbols and undefined symbols. */
5214 if (! (*s->bed->elf_hash_symbol) (h))
5217 name = h->root.root.string;
5218 p = strchr (name, ELF_VER_CHR);
5221 alc = (char *) bfd_malloc (p - name + 1);
5227 memcpy (alc, name, p - name);
5228 alc[p - name] = '\0';
5232 /* Compute the hash value. */
5233 ha = bfd_elf_gnu_hash (name);
5235 /* Store the found hash value in the array for compute_bucket_count,
5236 and also for .dynsym reordering purposes. */
5237 s->hashcodes[s->nsyms] = ha;
5238 s->hashval[h->dynindx] = ha;
5240 if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5241 s->min_dynindx = h->dynindx;
5249 /* This function will be called though elf_link_hash_traverse to do
5250 final dynaminc symbol renumbering. */
5253 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5255 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5256 unsigned long int bucket;
5257 unsigned long int val;
5259 if (h->root.type == bfd_link_hash_warning)
5260 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5262 /* Ignore indirect symbols. */
5263 if (h->dynindx == -1)
5266 /* Ignore also local symbols and undefined symbols. */
5267 if (! (*s->bed->elf_hash_symbol) (h))
5269 if (h->dynindx >= s->min_dynindx)
5270 h->dynindx = s->local_indx++;
5274 bucket = s->hashval[h->dynindx] % s->bucketcount;
5275 val = (s->hashval[h->dynindx] >> s->shift1)
5276 & ((s->maskbits >> s->shift1) - 1);
5277 s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5279 |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5280 val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5281 if (s->counts[bucket] == 1)
5282 /* Last element terminates the chain. */
5284 bfd_put_32 (s->output_bfd, val,
5285 s->contents + (s->indx[bucket] - s->symindx) * 4);
5286 --s->counts[bucket];
5287 h->dynindx = s->indx[bucket]++;
5291 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5294 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5296 return !(h->forced_local
5297 || h->root.type == bfd_link_hash_undefined
5298 || h->root.type == bfd_link_hash_undefweak
5299 || ((h->root.type == bfd_link_hash_defined
5300 || h->root.type == bfd_link_hash_defweak)
5301 && h->root.u.def.section->output_section == NULL));
5304 /* Array used to determine the number of hash table buckets to use
5305 based on the number of symbols there are. If there are fewer than
5306 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5307 fewer than 37 we use 17 buckets, and so forth. We never use more
5308 than 32771 buckets. */
5310 static const size_t elf_buckets[] =
5312 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5316 /* Compute bucket count for hashing table. We do not use a static set
5317 of possible tables sizes anymore. Instead we determine for all
5318 possible reasonable sizes of the table the outcome (i.e., the
5319 number of collisions etc) and choose the best solution. The
5320 weighting functions are not too simple to allow the table to grow
5321 without bounds. Instead one of the weighting factors is the size.
5322 Therefore the result is always a good payoff between few collisions
5323 (= short chain lengths) and table size. */
5325 compute_bucket_count (struct bfd_link_info *info,
5326 unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5327 unsigned long int nsyms,
5330 size_t best_size = 0;
5331 unsigned long int i;
5333 /* We have a problem here. The following code to optimize the table
5334 size requires an integer type with more the 32 bits. If
5335 BFD_HOST_U_64_BIT is set we know about such a type. */
5336 #ifdef BFD_HOST_U_64_BIT
5341 BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5342 bfd *dynobj = elf_hash_table (info)->dynobj;
5343 size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5344 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5345 unsigned long int *counts;
5348 /* Possible optimization parameters: if we have NSYMS symbols we say
5349 that the hashing table must at least have NSYMS/4 and at most
5351 minsize = nsyms / 4;
5354 best_size = maxsize = nsyms * 2;
5359 if ((best_size & 31) == 0)
5363 /* Create array where we count the collisions in. We must use bfd_malloc
5364 since the size could be large. */
5366 amt *= sizeof (unsigned long int);
5367 counts = (unsigned long int *) bfd_malloc (amt);
5371 /* Compute the "optimal" size for the hash table. The criteria is a
5372 minimal chain length. The minor criteria is (of course) the size
5374 for (i = minsize; i < maxsize; ++i)
5376 /* Walk through the array of hashcodes and count the collisions. */
5377 BFD_HOST_U_64_BIT max;
5378 unsigned long int j;
5379 unsigned long int fact;
5381 if (gnu_hash && (i & 31) == 0)
5384 memset (counts, '\0', i * sizeof (unsigned long int));
5386 /* Determine how often each hash bucket is used. */
5387 for (j = 0; j < nsyms; ++j)
5388 ++counts[hashcodes[j] % i];
5390 /* For the weight function we need some information about the
5391 pagesize on the target. This is information need not be 100%
5392 accurate. Since this information is not available (so far) we
5393 define it here to a reasonable default value. If it is crucial
5394 to have a better value some day simply define this value. */
5395 # ifndef BFD_TARGET_PAGESIZE
5396 # define BFD_TARGET_PAGESIZE (4096)
5399 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5401 max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5404 /* Variant 1: optimize for short chains. We add the squares
5405 of all the chain lengths (which favors many small chain
5406 over a few long chains). */
5407 for (j = 0; j < i; ++j)
5408 max += counts[j] * counts[j];
5410 /* This adds penalties for the overall size of the table. */
5411 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5414 /* Variant 2: Optimize a lot more for small table. Here we
5415 also add squares of the size but we also add penalties for
5416 empty slots (the +1 term). */
5417 for (j = 0; j < i; ++j)
5418 max += (1 + counts[j]) * (1 + counts[j]);
5420 /* The overall size of the table is considered, but not as
5421 strong as in variant 1, where it is squared. */
5422 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5426 /* Compare with current best results. */
5427 if (max < best_chlen)
5437 #endif /* defined (BFD_HOST_U_64_BIT) */
5439 /* This is the fallback solution if no 64bit type is available or if we
5440 are not supposed to spend much time on optimizations. We select the
5441 bucket count using a fixed set of numbers. */
5442 for (i = 0; elf_buckets[i] != 0; i++)
5444 best_size = elf_buckets[i];
5445 if (nsyms < elf_buckets[i + 1])
5448 if (gnu_hash && best_size < 2)
5455 /* Set up the sizes and contents of the ELF dynamic sections. This is
5456 called by the ELF linker emulation before_allocation routine. We
5457 must set the sizes of the sections before the linker sets the
5458 addresses of the various sections. */
5461 bfd_elf_size_dynamic_sections (bfd *output_bfd,
5464 const char *filter_shlib,
5466 const char *depaudit,
5467 const char * const *auxiliary_filters,
5468 struct bfd_link_info *info,
5469 asection **sinterpptr,
5470 struct bfd_elf_version_tree *verdefs)
5472 bfd_size_type soname_indx;
5474 const struct elf_backend_data *bed;
5475 struct elf_info_failed asvinfo;
5479 soname_indx = (bfd_size_type) -1;
5481 if (!is_elf_hash_table (info->hash))
5484 bed = get_elf_backend_data (output_bfd);
5485 if (info->execstack)
5486 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5487 else if (info->noexecstack)
5488 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W;
5492 asection *notesec = NULL;
5495 for (inputobj = info->input_bfds;
5497 inputobj = inputobj->link_next)
5501 if (inputobj->flags & (DYNAMIC | EXEC_P | BFD_LINKER_CREATED))
5503 s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5506 if (s->flags & SEC_CODE)
5510 else if (bed->default_execstack)
5515 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | exec;
5516 if (exec && info->relocatable
5517 && notesec->output_section != bfd_abs_section_ptr)
5518 notesec->output_section->flags |= SEC_CODE;
5522 /* Any syms created from now on start with -1 in
5523 got.refcount/offset and plt.refcount/offset. */
5524 elf_hash_table (info)->init_got_refcount
5525 = elf_hash_table (info)->init_got_offset;
5526 elf_hash_table (info)->init_plt_refcount
5527 = elf_hash_table (info)->init_plt_offset;
5529 /* The backend may have to create some sections regardless of whether
5530 we're dynamic or not. */
5531 if (bed->elf_backend_always_size_sections
5532 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5535 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5538 dynobj = elf_hash_table (info)->dynobj;
5540 /* If there were no dynamic objects in the link, there is nothing to
5545 if (elf_hash_table (info)->dynamic_sections_created)
5547 struct elf_info_failed eif;
5548 struct elf_link_hash_entry *h;
5550 struct bfd_elf_version_tree *t;
5551 struct bfd_elf_version_expr *d;
5553 bfd_boolean all_defined;
5555 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
5556 BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5560 soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5562 if (soname_indx == (bfd_size_type) -1
5563 || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5569 if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5571 info->flags |= DF_SYMBOLIC;
5578 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5580 if (indx == (bfd_size_type) -1
5581 || !_bfd_elf_add_dynamic_entry (info, DT_RPATH, indx))
5584 if (info->new_dtags)
5586 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
5587 if (!_bfd_elf_add_dynamic_entry (info, DT_RUNPATH, indx))
5592 if (filter_shlib != NULL)
5596 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5597 filter_shlib, TRUE);
5598 if (indx == (bfd_size_type) -1
5599 || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5603 if (auxiliary_filters != NULL)
5605 const char * const *p;
5607 for (p = auxiliary_filters; *p != NULL; p++)
5611 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5613 if (indx == (bfd_size_type) -1
5614 || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5623 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5625 if (indx == (bfd_size_type) -1
5626 || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5630 if (depaudit != NULL)
5634 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5636 if (indx == (bfd_size_type) -1
5637 || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5642 eif.verdefs = verdefs;
5645 /* If we are supposed to export all symbols into the dynamic symbol
5646 table (this is not the normal case), then do so. */
5647 if (info->export_dynamic
5648 || (info->executable && info->dynamic))
5650 elf_link_hash_traverse (elf_hash_table (info),
5651 _bfd_elf_export_symbol,
5657 /* Make all global versions with definition. */
5658 for (t = verdefs; t != NULL; t = t->next)
5659 for (d = t->globals.list; d != NULL; d = d->next)
5660 if (!d->symver && d->literal)
5662 const char *verstr, *name;
5663 size_t namelen, verlen, newlen;
5665 struct elf_link_hash_entry *newh;
5668 namelen = strlen (name);
5670 verlen = strlen (verstr);
5671 newlen = namelen + verlen + 3;
5673 newname = (char *) bfd_malloc (newlen);
5674 if (newname == NULL)
5676 memcpy (newname, name, namelen);
5678 /* Check the hidden versioned definition. */
5679 p = newname + namelen;
5681 memcpy (p, verstr, verlen + 1);
5682 newh = elf_link_hash_lookup (elf_hash_table (info),
5683 newname, FALSE, FALSE,
5686 || (newh->root.type != bfd_link_hash_defined
5687 && newh->root.type != bfd_link_hash_defweak))
5689 /* Check the default versioned definition. */
5691 memcpy (p, verstr, verlen + 1);
5692 newh = elf_link_hash_lookup (elf_hash_table (info),
5693 newname, FALSE, FALSE,
5698 /* Mark this version if there is a definition and it is
5699 not defined in a shared object. */
5701 && !newh->def_dynamic
5702 && (newh->root.type == bfd_link_hash_defined
5703 || newh->root.type == bfd_link_hash_defweak))
5707 /* Attach all the symbols to their version information. */
5708 asvinfo.info = info;
5709 asvinfo.verdefs = verdefs;
5710 asvinfo.failed = FALSE;
5712 elf_link_hash_traverse (elf_hash_table (info),
5713 _bfd_elf_link_assign_sym_version,
5718 if (!info->allow_undefined_version)
5720 /* Check if all global versions have a definition. */
5722 for (t = verdefs; t != NULL; t = t->next)
5723 for (d = t->globals.list; d != NULL; d = d->next)
5724 if (d->literal && !d->symver && !d->script)
5726 (*_bfd_error_handler)
5727 (_("%s: undefined version: %s"),
5728 d->pattern, t->name);
5729 all_defined = FALSE;
5734 bfd_set_error (bfd_error_bad_value);
5739 /* Find all symbols which were defined in a dynamic object and make
5740 the backend pick a reasonable value for them. */
5741 elf_link_hash_traverse (elf_hash_table (info),
5742 _bfd_elf_adjust_dynamic_symbol,
5747 /* Add some entries to the .dynamic section. We fill in some of the
5748 values later, in bfd_elf_final_link, but we must add the entries
5749 now so that we know the final size of the .dynamic section. */
5751 /* If there are initialization and/or finalization functions to
5752 call then add the corresponding DT_INIT/DT_FINI entries. */
5753 h = (info->init_function
5754 ? elf_link_hash_lookup (elf_hash_table (info),
5755 info->init_function, FALSE,
5762 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5765 h = (info->fini_function
5766 ? elf_link_hash_lookup (elf_hash_table (info),
5767 info->fini_function, FALSE,
5774 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5778 s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5779 if (s != NULL && s->linker_has_input)
5781 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5782 if (! info->executable)
5787 for (sub = info->input_bfds; sub != NULL;
5788 sub = sub->link_next)
5789 if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5790 for (o = sub->sections; o != NULL; o = o->next)
5791 if (elf_section_data (o)->this_hdr.sh_type
5792 == SHT_PREINIT_ARRAY)
5794 (*_bfd_error_handler)
5795 (_("%B: .preinit_array section is not allowed in DSO"),
5800 bfd_set_error (bfd_error_nonrepresentable_section);
5804 if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5805 || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5808 s = bfd_get_section_by_name (output_bfd, ".init_array");
5809 if (s != NULL && s->linker_has_input)
5811 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5812 || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5815 s = bfd_get_section_by_name (output_bfd, ".fini_array");
5816 if (s != NULL && s->linker_has_input)
5818 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5819 || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5823 dynstr = bfd_get_section_by_name (dynobj, ".dynstr");
5824 /* If .dynstr is excluded from the link, we don't want any of
5825 these tags. Strictly, we should be checking each section
5826 individually; This quick check covers for the case where
5827 someone does a /DISCARD/ : { *(*) }. */
5828 if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5830 bfd_size_type strsize;
5832 strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5833 if ((info->emit_hash
5834 && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5835 || (info->emit_gnu_hash
5836 && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5837 || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5838 || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5839 || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5840 || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5841 bed->s->sizeof_sym))
5846 /* The backend must work out the sizes of all the other dynamic
5848 if (bed->elf_backend_size_dynamic_sections
5849 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5852 if (elf_hash_table (info)->dynamic_sections_created)
5854 unsigned long section_sym_count;
5857 /* Set up the version definition section. */
5858 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
5859 BFD_ASSERT (s != NULL);
5861 /* We may have created additional version definitions if we are
5862 just linking a regular application. */
5863 verdefs = asvinfo.verdefs;
5865 /* Skip anonymous version tag. */
5866 if (verdefs != NULL && verdefs->vernum == 0)
5867 verdefs = verdefs->next;
5869 if (verdefs == NULL && !info->create_default_symver)
5870 s->flags |= SEC_EXCLUDE;
5875 struct bfd_elf_version_tree *t;
5877 Elf_Internal_Verdef def;
5878 Elf_Internal_Verdaux defaux;
5879 struct bfd_link_hash_entry *bh;
5880 struct elf_link_hash_entry *h;
5886 /* Make space for the base version. */
5887 size += sizeof (Elf_External_Verdef);
5888 size += sizeof (Elf_External_Verdaux);
5891 /* Make space for the default version. */
5892 if (info->create_default_symver)
5894 size += sizeof (Elf_External_Verdef);
5898 for (t = verdefs; t != NULL; t = t->next)
5900 struct bfd_elf_version_deps *n;
5902 size += sizeof (Elf_External_Verdef);
5903 size += sizeof (Elf_External_Verdaux);
5906 for (n = t->deps; n != NULL; n = n->next)
5907 size += sizeof (Elf_External_Verdaux);
5911 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
5912 if (s->contents == NULL && s->size != 0)
5915 /* Fill in the version definition section. */
5919 def.vd_version = VER_DEF_CURRENT;
5920 def.vd_flags = VER_FLG_BASE;
5923 if (info->create_default_symver)
5925 def.vd_aux = 2 * sizeof (Elf_External_Verdef);
5926 def.vd_next = sizeof (Elf_External_Verdef);
5930 def.vd_aux = sizeof (Elf_External_Verdef);
5931 def.vd_next = (sizeof (Elf_External_Verdef)
5932 + sizeof (Elf_External_Verdaux));
5935 if (soname_indx != (bfd_size_type) -1)
5937 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
5939 def.vd_hash = bfd_elf_hash (soname);
5940 defaux.vda_name = soname_indx;
5947 name = lbasename (output_bfd->filename);
5948 def.vd_hash = bfd_elf_hash (name);
5949 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5951 if (indx == (bfd_size_type) -1)
5953 defaux.vda_name = indx;
5955 defaux.vda_next = 0;
5957 _bfd_elf_swap_verdef_out (output_bfd, &def,
5958 (Elf_External_Verdef *) p);
5959 p += sizeof (Elf_External_Verdef);
5960 if (info->create_default_symver)
5962 /* Add a symbol representing this version. */
5964 if (! (_bfd_generic_link_add_one_symbol
5965 (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
5967 get_elf_backend_data (dynobj)->collect, &bh)))
5969 h = (struct elf_link_hash_entry *) bh;
5972 h->type = STT_OBJECT;
5973 h->verinfo.vertree = NULL;
5975 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5978 /* Create a duplicate of the base version with the same
5979 aux block, but different flags. */
5982 def.vd_aux = sizeof (Elf_External_Verdef);
5984 def.vd_next = (sizeof (Elf_External_Verdef)
5985 + sizeof (Elf_External_Verdaux));
5988 _bfd_elf_swap_verdef_out (output_bfd, &def,
5989 (Elf_External_Verdef *) p);
5990 p += sizeof (Elf_External_Verdef);
5992 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
5993 (Elf_External_Verdaux *) p);
5994 p += sizeof (Elf_External_Verdaux);
5996 for (t = verdefs; t != NULL; t = t->next)
5999 struct bfd_elf_version_deps *n;
6002 for (n = t->deps; n != NULL; n = n->next)
6005 /* Add a symbol representing this version. */
6007 if (! (_bfd_generic_link_add_one_symbol
6008 (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6010 get_elf_backend_data (dynobj)->collect, &bh)))
6012 h = (struct elf_link_hash_entry *) bh;
6015 h->type = STT_OBJECT;
6016 h->verinfo.vertree = t;
6018 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6021 def.vd_version = VER_DEF_CURRENT;
6023 if (t->globals.list == NULL
6024 && t->locals.list == NULL
6026 def.vd_flags |= VER_FLG_WEAK;
6027 def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6028 def.vd_cnt = cdeps + 1;
6029 def.vd_hash = bfd_elf_hash (t->name);
6030 def.vd_aux = sizeof (Elf_External_Verdef);
6032 if (t->next != NULL)
6033 def.vd_next = (sizeof (Elf_External_Verdef)
6034 + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6036 _bfd_elf_swap_verdef_out (output_bfd, &def,
6037 (Elf_External_Verdef *) p);
6038 p += sizeof (Elf_External_Verdef);
6040 defaux.vda_name = h->dynstr_index;
6041 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6043 defaux.vda_next = 0;
6044 if (t->deps != NULL)
6045 defaux.vda_next = sizeof (Elf_External_Verdaux);
6046 t->name_indx = defaux.vda_name;
6048 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6049 (Elf_External_Verdaux *) p);
6050 p += sizeof (Elf_External_Verdaux);
6052 for (n = t->deps; n != NULL; n = n->next)
6054 if (n->version_needed == NULL)
6056 /* This can happen if there was an error in the
6058 defaux.vda_name = 0;
6062 defaux.vda_name = n->version_needed->name_indx;
6063 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6066 if (n->next == NULL)
6067 defaux.vda_next = 0;
6069 defaux.vda_next = sizeof (Elf_External_Verdaux);
6071 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6072 (Elf_External_Verdaux *) p);
6073 p += sizeof (Elf_External_Verdaux);
6077 if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6078 || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6081 elf_tdata (output_bfd)->cverdefs = cdefs;
6084 if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6086 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6089 else if (info->flags & DF_BIND_NOW)
6091 if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6097 if (info->executable)
6098 info->flags_1 &= ~ (DF_1_INITFIRST
6101 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6105 /* Work out the size of the version reference section. */
6107 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
6108 BFD_ASSERT (s != NULL);
6110 struct elf_find_verdep_info sinfo;
6113 sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6114 if (sinfo.vers == 0)
6116 sinfo.failed = FALSE;
6118 elf_link_hash_traverse (elf_hash_table (info),
6119 _bfd_elf_link_find_version_dependencies,
6124 if (elf_tdata (output_bfd)->verref == NULL)
6125 s->flags |= SEC_EXCLUDE;
6128 Elf_Internal_Verneed *t;
6133 /* Build the version definition section. */
6136 for (t = elf_tdata (output_bfd)->verref;
6140 Elf_Internal_Vernaux *a;
6142 size += sizeof (Elf_External_Verneed);
6144 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6145 size += sizeof (Elf_External_Vernaux);
6149 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6150 if (s->contents == NULL)
6154 for (t = elf_tdata (output_bfd)->verref;
6159 Elf_Internal_Vernaux *a;
6163 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6166 t->vn_version = VER_NEED_CURRENT;
6168 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6169 elf_dt_name (t->vn_bfd) != NULL
6170 ? elf_dt_name (t->vn_bfd)
6171 : lbasename (t->vn_bfd->filename),
6173 if (indx == (bfd_size_type) -1)
6176 t->vn_aux = sizeof (Elf_External_Verneed);
6177 if (t->vn_nextref == NULL)
6180 t->vn_next = (sizeof (Elf_External_Verneed)
6181 + caux * sizeof (Elf_External_Vernaux));
6183 _bfd_elf_swap_verneed_out (output_bfd, t,
6184 (Elf_External_Verneed *) p);
6185 p += sizeof (Elf_External_Verneed);
6187 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6189 a->vna_hash = bfd_elf_hash (a->vna_nodename);
6190 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6191 a->vna_nodename, FALSE);
6192 if (indx == (bfd_size_type) -1)
6195 if (a->vna_nextptr == NULL)
6198 a->vna_next = sizeof (Elf_External_Vernaux);
6200 _bfd_elf_swap_vernaux_out (output_bfd, a,
6201 (Elf_External_Vernaux *) p);
6202 p += sizeof (Elf_External_Vernaux);
6206 if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6207 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6210 elf_tdata (output_bfd)->cverrefs = crefs;
6214 if ((elf_tdata (output_bfd)->cverrefs == 0
6215 && elf_tdata (output_bfd)->cverdefs == 0)
6216 || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6217 §ion_sym_count) == 0)
6219 s = bfd_get_section_by_name (dynobj, ".gnu.version");
6220 s->flags |= SEC_EXCLUDE;
6226 /* Find the first non-excluded output section. We'll use its
6227 section symbol for some emitted relocs. */
6229 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6233 for (s = output_bfd->sections; s != NULL; s = s->next)
6234 if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6235 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6237 elf_hash_table (info)->text_index_section = s;
6242 /* Find two non-excluded output sections, one for code, one for data.
6243 We'll use their section symbols for some emitted relocs. */
6245 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6249 /* Data first, since setting text_index_section changes
6250 _bfd_elf_link_omit_section_dynsym. */
6251 for (s = output_bfd->sections; s != NULL; s = s->next)
6252 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6253 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6255 elf_hash_table (info)->data_index_section = s;
6259 for (s = output_bfd->sections; s != NULL; s = s->next)
6260 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6261 == (SEC_ALLOC | SEC_READONLY))
6262 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6264 elf_hash_table (info)->text_index_section = s;
6268 if (elf_hash_table (info)->text_index_section == NULL)
6269 elf_hash_table (info)->text_index_section
6270 = elf_hash_table (info)->data_index_section;
6274 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6276 const struct elf_backend_data *bed;
6278 if (!is_elf_hash_table (info->hash))
6281 bed = get_elf_backend_data (output_bfd);
6282 (*bed->elf_backend_init_index_section) (output_bfd, info);
6284 if (elf_hash_table (info)->dynamic_sections_created)
6288 bfd_size_type dynsymcount;
6289 unsigned long section_sym_count;
6290 unsigned int dtagcount;
6292 dynobj = elf_hash_table (info)->dynobj;
6294 /* Assign dynsym indicies. In a shared library we generate a
6295 section symbol for each output section, which come first.
6296 Next come all of the back-end allocated local dynamic syms,
6297 followed by the rest of the global symbols. */
6299 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6300 §ion_sym_count);
6302 /* Work out the size of the symbol version section. */
6303 s = bfd_get_section_by_name (dynobj, ".gnu.version");
6304 BFD_ASSERT (s != NULL);
6305 if (dynsymcount != 0
6306 && (s->flags & SEC_EXCLUDE) == 0)
6308 s->size = dynsymcount * sizeof (Elf_External_Versym);
6309 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6310 if (s->contents == NULL)
6313 if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6317 /* Set the size of the .dynsym and .hash sections. We counted
6318 the number of dynamic symbols in elf_link_add_object_symbols.
6319 We will build the contents of .dynsym and .hash when we build
6320 the final symbol table, because until then we do not know the
6321 correct value to give the symbols. We built the .dynstr
6322 section as we went along in elf_link_add_object_symbols. */
6323 s = bfd_get_section_by_name (dynobj, ".dynsym");
6324 BFD_ASSERT (s != NULL);
6325 s->size = dynsymcount * bed->s->sizeof_sym;
6327 if (dynsymcount != 0)
6329 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6330 if (s->contents == NULL)
6333 /* The first entry in .dynsym is a dummy symbol.
6334 Clear all the section syms, in case we don't output them all. */
6335 ++section_sym_count;
6336 memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6339 elf_hash_table (info)->bucketcount = 0;
6341 /* Compute the size of the hashing table. As a side effect this
6342 computes the hash values for all the names we export. */
6343 if (info->emit_hash)
6345 unsigned long int *hashcodes;
6346 struct hash_codes_info hashinf;
6348 unsigned long int nsyms;
6350 size_t hash_entry_size;
6352 /* Compute the hash values for all exported symbols. At the same
6353 time store the values in an array so that we could use them for
6355 amt = dynsymcount * sizeof (unsigned long int);
6356 hashcodes = (unsigned long int *) bfd_malloc (amt);
6357 if (hashcodes == NULL)
6359 hashinf.hashcodes = hashcodes;
6360 hashinf.error = FALSE;
6362 /* Put all hash values in HASHCODES. */
6363 elf_link_hash_traverse (elf_hash_table (info),
6364 elf_collect_hash_codes, &hashinf);
6371 nsyms = hashinf.hashcodes - hashcodes;
6373 = compute_bucket_count (info, hashcodes, nsyms, 0);
6376 if (bucketcount == 0)
6379 elf_hash_table (info)->bucketcount = bucketcount;
6381 s = bfd_get_section_by_name (dynobj, ".hash");
6382 BFD_ASSERT (s != NULL);
6383 hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6384 s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6385 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6386 if (s->contents == NULL)
6389 bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6390 bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6391 s->contents + hash_entry_size);
6394 if (info->emit_gnu_hash)
6397 unsigned char *contents;
6398 struct collect_gnu_hash_codes cinfo;
6402 memset (&cinfo, 0, sizeof (cinfo));
6404 /* Compute the hash values for all exported symbols. At the same
6405 time store the values in an array so that we could use them for
6407 amt = dynsymcount * 2 * sizeof (unsigned long int);
6408 cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6409 if (cinfo.hashcodes == NULL)
6412 cinfo.hashval = cinfo.hashcodes + dynsymcount;
6413 cinfo.min_dynindx = -1;
6414 cinfo.output_bfd = output_bfd;
6417 /* Put all hash values in HASHCODES. */
6418 elf_link_hash_traverse (elf_hash_table (info),
6419 elf_collect_gnu_hash_codes, &cinfo);
6422 free (cinfo.hashcodes);
6427 = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6429 if (bucketcount == 0)
6431 free (cinfo.hashcodes);
6435 s = bfd_get_section_by_name (dynobj, ".gnu.hash");
6436 BFD_ASSERT (s != NULL);
6438 if (cinfo.nsyms == 0)
6440 /* Empty .gnu.hash section is special. */
6441 BFD_ASSERT (cinfo.min_dynindx == -1);
6442 free (cinfo.hashcodes);
6443 s->size = 5 * 4 + bed->s->arch_size / 8;
6444 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6445 if (contents == NULL)
6447 s->contents = contents;
6448 /* 1 empty bucket. */
6449 bfd_put_32 (output_bfd, 1, contents);
6450 /* SYMIDX above the special symbol 0. */
6451 bfd_put_32 (output_bfd, 1, contents + 4);
6452 /* Just one word for bitmask. */
6453 bfd_put_32 (output_bfd, 1, contents + 8);
6454 /* Only hash fn bloom filter. */
6455 bfd_put_32 (output_bfd, 0, contents + 12);
6456 /* No hashes are valid - empty bitmask. */
6457 bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6458 /* No hashes in the only bucket. */
6459 bfd_put_32 (output_bfd, 0,
6460 contents + 16 + bed->s->arch_size / 8);
6464 unsigned long int maskwords, maskbitslog2;
6465 BFD_ASSERT (cinfo.min_dynindx != -1);
6467 maskbitslog2 = bfd_log2 (cinfo.nsyms) + 1;
6468 if (maskbitslog2 < 3)
6470 else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6471 maskbitslog2 = maskbitslog2 + 3;
6473 maskbitslog2 = maskbitslog2 + 2;
6474 if (bed->s->arch_size == 64)
6476 if (maskbitslog2 == 5)
6482 cinfo.mask = (1 << cinfo.shift1) - 1;
6483 cinfo.shift2 = maskbitslog2;
6484 cinfo.maskbits = 1 << maskbitslog2;
6485 maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6486 amt = bucketcount * sizeof (unsigned long int) * 2;
6487 amt += maskwords * sizeof (bfd_vma);
6488 cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6489 if (cinfo.bitmask == NULL)
6491 free (cinfo.hashcodes);
6495 cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6496 cinfo.indx = cinfo.counts + bucketcount;
6497 cinfo.symindx = dynsymcount - cinfo.nsyms;
6498 memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6500 /* Determine how often each hash bucket is used. */
6501 memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6502 for (i = 0; i < cinfo.nsyms; ++i)
6503 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6505 for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6506 if (cinfo.counts[i] != 0)
6508 cinfo.indx[i] = cnt;
6509 cnt += cinfo.counts[i];
6511 BFD_ASSERT (cnt == dynsymcount);
6512 cinfo.bucketcount = bucketcount;
6513 cinfo.local_indx = cinfo.min_dynindx;
6515 s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6516 s->size += cinfo.maskbits / 8;
6517 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6518 if (contents == NULL)
6520 free (cinfo.bitmask);
6521 free (cinfo.hashcodes);
6525 s->contents = contents;
6526 bfd_put_32 (output_bfd, bucketcount, contents);
6527 bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6528 bfd_put_32 (output_bfd, maskwords, contents + 8);
6529 bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6530 contents += 16 + cinfo.maskbits / 8;
6532 for (i = 0; i < bucketcount; ++i)
6534 if (cinfo.counts[i] == 0)
6535 bfd_put_32 (output_bfd, 0, contents);
6537 bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6541 cinfo.contents = contents;
6543 /* Renumber dynamic symbols, populate .gnu.hash section. */
6544 elf_link_hash_traverse (elf_hash_table (info),
6545 elf_renumber_gnu_hash_syms, &cinfo);
6547 contents = s->contents + 16;
6548 for (i = 0; i < maskwords; ++i)
6550 bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6552 contents += bed->s->arch_size / 8;
6555 free (cinfo.bitmask);
6556 free (cinfo.hashcodes);
6560 s = bfd_get_section_by_name (dynobj, ".dynstr");
6561 BFD_ASSERT (s != NULL);
6563 elf_finalize_dynstr (output_bfd, info);
6565 s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6567 for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6568 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6575 /* Indicate that we are only retrieving symbol values from this
6579 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
6581 if (is_elf_hash_table (info->hash))
6582 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
6583 _bfd_generic_link_just_syms (sec, info);
6586 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
6589 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6592 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
6593 sec->sec_info_type = ELF_INFO_TYPE_NONE;
6596 /* Finish SHF_MERGE section merging. */
6599 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6604 if (!is_elf_hash_table (info->hash))
6607 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6608 if ((ibfd->flags & DYNAMIC) == 0)
6609 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6610 if ((sec->flags & SEC_MERGE) != 0
6611 && !bfd_is_abs_section (sec->output_section))
6613 struct bfd_elf_section_data *secdata;
6615 secdata = elf_section_data (sec);
6616 if (! _bfd_add_merge_section (abfd,
6617 &elf_hash_table (info)->merge_info,
6618 sec, &secdata->sec_info))
6620 else if (secdata->sec_info)
6621 sec->sec_info_type = ELF_INFO_TYPE_MERGE;
6624 if (elf_hash_table (info)->merge_info != NULL)
6625 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6626 merge_sections_remove_hook);
6630 /* Create an entry in an ELF linker hash table. */
6632 struct bfd_hash_entry *
6633 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6634 struct bfd_hash_table *table,
6637 /* Allocate the structure if it has not already been allocated by a
6641 entry = (struct bfd_hash_entry *)
6642 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6647 /* Call the allocation method of the superclass. */
6648 entry = _bfd_link_hash_newfunc (entry, table, string);
6651 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6652 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6654 /* Set local fields. */
6657 ret->got = htab->init_got_refcount;
6658 ret->plt = htab->init_plt_refcount;
6659 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6660 - offsetof (struct elf_link_hash_entry, size)));
6661 /* Assume that we have been called by a non-ELF symbol reader.
6662 This flag is then reset by the code which reads an ELF input
6663 file. This ensures that a symbol created by a non-ELF symbol
6664 reader will have the flag set correctly. */
6671 /* Copy data from an indirect symbol to its direct symbol, hiding the
6672 old indirect symbol. Also used for copying flags to a weakdef. */
6675 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6676 struct elf_link_hash_entry *dir,
6677 struct elf_link_hash_entry *ind)
6679 struct elf_link_hash_table *htab;
6681 /* Copy down any references that we may have already seen to the
6682 symbol which just became indirect. */
6684 dir->ref_dynamic |= ind->ref_dynamic;
6685 dir->ref_regular |= ind->ref_regular;
6686 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6687 dir->non_got_ref |= ind->non_got_ref;
6688 dir->needs_plt |= ind->needs_plt;
6689 dir->pointer_equality_needed |= ind->pointer_equality_needed;
6691 if (ind->root.type != bfd_link_hash_indirect)
6694 /* Copy over the global and procedure linkage table refcount entries.
6695 These may have been already set up by a check_relocs routine. */
6696 htab = elf_hash_table (info);
6697 if (ind->got.refcount > htab->init_got_refcount.refcount)
6699 if (dir->got.refcount < 0)
6700 dir->got.refcount = 0;
6701 dir->got.refcount += ind->got.refcount;
6702 ind->got.refcount = htab->init_got_refcount.refcount;
6705 if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6707 if (dir->plt.refcount < 0)
6708 dir->plt.refcount = 0;
6709 dir->plt.refcount += ind->plt.refcount;
6710 ind->plt.refcount = htab->init_plt_refcount.refcount;
6713 if (ind->dynindx != -1)
6715 if (dir->dynindx != -1)
6716 _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6717 dir->dynindx = ind->dynindx;
6718 dir->dynstr_index = ind->dynstr_index;
6720 ind->dynstr_index = 0;
6725 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6726 struct elf_link_hash_entry *h,
6727 bfd_boolean force_local)
6729 /* STT_GNU_IFUNC symbol must go through PLT. */
6730 if (h->type != STT_GNU_IFUNC)
6732 h->plt = elf_hash_table (info)->init_plt_offset;
6737 h->forced_local = 1;
6738 if (h->dynindx != -1)
6741 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6747 /* Initialize an ELF linker hash table. */
6750 _bfd_elf_link_hash_table_init
6751 (struct elf_link_hash_table *table,
6753 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6754 struct bfd_hash_table *,
6756 unsigned int entsize)
6759 int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6761 memset (table, 0, sizeof * table);
6762 table->init_got_refcount.refcount = can_refcount - 1;
6763 table->init_plt_refcount.refcount = can_refcount - 1;
6764 table->init_got_offset.offset = -(bfd_vma) 1;
6765 table->init_plt_offset.offset = -(bfd_vma) 1;
6766 /* The first dynamic symbol is a dummy. */
6767 table->dynsymcount = 1;
6769 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6770 table->root.type = bfd_link_elf_hash_table;
6775 /* Create an ELF linker hash table. */
6777 struct bfd_link_hash_table *
6778 _bfd_elf_link_hash_table_create (bfd *abfd)
6780 struct elf_link_hash_table *ret;
6781 bfd_size_type amt = sizeof (struct elf_link_hash_table);
6783 ret = (struct elf_link_hash_table *) bfd_malloc (amt);
6787 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6788 sizeof (struct elf_link_hash_entry)))
6797 /* This is a hook for the ELF emulation code in the generic linker to
6798 tell the backend linker what file name to use for the DT_NEEDED
6799 entry for a dynamic object. */
6802 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6804 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6805 && bfd_get_format (abfd) == bfd_object)
6806 elf_dt_name (abfd) = name;
6810 bfd_elf_get_dyn_lib_class (bfd *abfd)
6813 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6814 && bfd_get_format (abfd) == bfd_object)
6815 lib_class = elf_dyn_lib_class (abfd);
6822 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6824 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6825 && bfd_get_format (abfd) == bfd_object)
6826 elf_dyn_lib_class (abfd) = lib_class;
6829 /* Get the list of DT_NEEDED entries for a link. This is a hook for
6830 the linker ELF emulation code. */
6832 struct bfd_link_needed_list *
6833 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6834 struct bfd_link_info *info)
6836 if (! is_elf_hash_table (info->hash))
6838 return elf_hash_table (info)->needed;
6841 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
6842 hook for the linker ELF emulation code. */
6844 struct bfd_link_needed_list *
6845 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6846 struct bfd_link_info *info)
6848 if (! is_elf_hash_table (info->hash))
6850 return elf_hash_table (info)->runpath;
6853 /* Get the name actually used for a dynamic object for a link. This
6854 is the SONAME entry if there is one. Otherwise, it is the string
6855 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
6858 bfd_elf_get_dt_soname (bfd *abfd)
6860 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6861 && bfd_get_format (abfd) == bfd_object)
6862 return elf_dt_name (abfd);
6866 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
6867 the ELF linker emulation code. */
6870 bfd_elf_get_bfd_needed_list (bfd *abfd,
6871 struct bfd_link_needed_list **pneeded)
6874 bfd_byte *dynbuf = NULL;
6875 unsigned int elfsec;
6876 unsigned long shlink;
6877 bfd_byte *extdyn, *extdynend;
6879 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6883 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6884 || bfd_get_format (abfd) != bfd_object)
6887 s = bfd_get_section_by_name (abfd, ".dynamic");
6888 if (s == NULL || s->size == 0)
6891 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
6894 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
6895 if (elfsec == SHN_BAD)
6898 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
6900 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
6901 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
6904 extdynend = extdyn + s->size;
6905 for (; extdyn < extdynend; extdyn += extdynsize)
6907 Elf_Internal_Dyn dyn;
6909 (*swap_dyn_in) (abfd, extdyn, &dyn);
6911 if (dyn.d_tag == DT_NULL)
6914 if (dyn.d_tag == DT_NEEDED)
6917 struct bfd_link_needed_list *l;
6918 unsigned int tagv = dyn.d_un.d_val;
6921 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
6926 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
6947 struct elf_symbuf_symbol
6949 unsigned long st_name; /* Symbol name, index in string tbl */
6950 unsigned char st_info; /* Type and binding attributes */
6951 unsigned char st_other; /* Visibilty, and target specific */
6954 struct elf_symbuf_head
6956 struct elf_symbuf_symbol *ssym;
6957 bfd_size_type count;
6958 unsigned int st_shndx;
6965 Elf_Internal_Sym *isym;
6966 struct elf_symbuf_symbol *ssym;
6971 /* Sort references to symbols by ascending section number. */
6974 elf_sort_elf_symbol (const void *arg1, const void *arg2)
6976 const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
6977 const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
6979 return s1->st_shndx - s2->st_shndx;
6983 elf_sym_name_compare (const void *arg1, const void *arg2)
6985 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
6986 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
6987 return strcmp (s1->name, s2->name);
6990 static struct elf_symbuf_head *
6991 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
6993 Elf_Internal_Sym **ind, **indbufend, **indbuf;
6994 struct elf_symbuf_symbol *ssym;
6995 struct elf_symbuf_head *ssymbuf, *ssymhead;
6996 bfd_size_type i, shndx_count, total_size;
6998 indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7002 for (ind = indbuf, i = 0; i < symcount; i++)
7003 if (isymbuf[i].st_shndx != SHN_UNDEF)
7004 *ind++ = &isymbuf[i];
7007 qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7008 elf_sort_elf_symbol);
7011 if (indbufend > indbuf)
7012 for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7013 if (ind[0]->st_shndx != ind[1]->st_shndx)
7016 total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7017 + (indbufend - indbuf) * sizeof (*ssym));
7018 ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7019 if (ssymbuf == NULL)
7025 ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7026 ssymbuf->ssym = NULL;
7027 ssymbuf->count = shndx_count;
7028 ssymbuf->st_shndx = 0;
7029 for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7031 if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7034 ssymhead->ssym = ssym;
7035 ssymhead->count = 0;
7036 ssymhead->st_shndx = (*ind)->st_shndx;
7038 ssym->st_name = (*ind)->st_name;
7039 ssym->st_info = (*ind)->st_info;
7040 ssym->st_other = (*ind)->st_other;
7043 BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7044 && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7051 /* Check if 2 sections define the same set of local and global
7055 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7056 struct bfd_link_info *info)
7059 const struct elf_backend_data *bed1, *bed2;
7060 Elf_Internal_Shdr *hdr1, *hdr2;
7061 bfd_size_type symcount1, symcount2;
7062 Elf_Internal_Sym *isymbuf1, *isymbuf2;
7063 struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7064 Elf_Internal_Sym *isym, *isymend;
7065 struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7066 bfd_size_type count1, count2, i;
7067 unsigned int shndx1, shndx2;
7073 /* Both sections have to be in ELF. */
7074 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7075 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7078 if (elf_section_type (sec1) != elf_section_type (sec2))
7081 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7082 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7083 if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7086 bed1 = get_elf_backend_data (bfd1);
7087 bed2 = get_elf_backend_data (bfd2);
7088 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7089 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7090 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7091 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7093 if (symcount1 == 0 || symcount2 == 0)
7099 ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7100 ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7102 if (ssymbuf1 == NULL)
7104 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7106 if (isymbuf1 == NULL)
7109 if (!info->reduce_memory_overheads)
7110 elf_tdata (bfd1)->symbuf = ssymbuf1
7111 = elf_create_symbuf (symcount1, isymbuf1);
7114 if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7116 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7118 if (isymbuf2 == NULL)
7121 if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7122 elf_tdata (bfd2)->symbuf = ssymbuf2
7123 = elf_create_symbuf (symcount2, isymbuf2);
7126 if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7128 /* Optimized faster version. */
7129 bfd_size_type lo, hi, mid;
7130 struct elf_symbol *symp;
7131 struct elf_symbuf_symbol *ssym, *ssymend;
7134 hi = ssymbuf1->count;
7139 mid = (lo + hi) / 2;
7140 if (shndx1 < ssymbuf1[mid].st_shndx)
7142 else if (shndx1 > ssymbuf1[mid].st_shndx)
7146 count1 = ssymbuf1[mid].count;
7153 hi = ssymbuf2->count;
7158 mid = (lo + hi) / 2;
7159 if (shndx2 < ssymbuf2[mid].st_shndx)
7161 else if (shndx2 > ssymbuf2[mid].st_shndx)
7165 count2 = ssymbuf2[mid].count;
7171 if (count1 == 0 || count2 == 0 || count1 != count2)
7174 symtable1 = (struct elf_symbol *)
7175 bfd_malloc (count1 * sizeof (struct elf_symbol));
7176 symtable2 = (struct elf_symbol *)
7177 bfd_malloc (count2 * sizeof (struct elf_symbol));
7178 if (symtable1 == NULL || symtable2 == NULL)
7182 for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7183 ssym < ssymend; ssym++, symp++)
7185 symp->u.ssym = ssym;
7186 symp->name = bfd_elf_string_from_elf_section (bfd1,
7192 for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7193 ssym < ssymend; ssym++, symp++)
7195 symp->u.ssym = ssym;
7196 symp->name = bfd_elf_string_from_elf_section (bfd2,
7201 /* Sort symbol by name. */
7202 qsort (symtable1, count1, sizeof (struct elf_symbol),
7203 elf_sym_name_compare);
7204 qsort (symtable2, count1, sizeof (struct elf_symbol),
7205 elf_sym_name_compare);
7207 for (i = 0; i < count1; i++)
7208 /* Two symbols must have the same binding, type and name. */
7209 if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7210 || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7211 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7218 symtable1 = (struct elf_symbol *)
7219 bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7220 symtable2 = (struct elf_symbol *)
7221 bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7222 if (symtable1 == NULL || symtable2 == NULL)
7225 /* Count definitions in the section. */
7227 for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7228 if (isym->st_shndx == shndx1)
7229 symtable1[count1++].u.isym = isym;
7232 for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7233 if (isym->st_shndx == shndx2)
7234 symtable2[count2++].u.isym = isym;
7236 if (count1 == 0 || count2 == 0 || count1 != count2)
7239 for (i = 0; i < count1; i++)
7241 = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7242 symtable1[i].u.isym->st_name);
7244 for (i = 0; i < count2; i++)
7246 = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7247 symtable2[i].u.isym->st_name);
7249 /* Sort symbol by name. */
7250 qsort (symtable1, count1, sizeof (struct elf_symbol),
7251 elf_sym_name_compare);
7252 qsort (symtable2, count1, sizeof (struct elf_symbol),
7253 elf_sym_name_compare);
7255 for (i = 0; i < count1; i++)
7256 /* Two symbols must have the same binding, type and name. */
7257 if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7258 || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7259 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7277 /* Return TRUE if 2 section types are compatible. */
7280 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7281 bfd *bbfd, const asection *bsec)
7285 || abfd->xvec->flavour != bfd_target_elf_flavour
7286 || bbfd->xvec->flavour != bfd_target_elf_flavour)
7289 return elf_section_type (asec) == elf_section_type (bsec);
7292 /* Final phase of ELF linker. */
7294 /* A structure we use to avoid passing large numbers of arguments. */
7296 struct elf_final_link_info
7298 /* General link information. */
7299 struct bfd_link_info *info;
7302 /* Symbol string table. */
7303 struct bfd_strtab_hash *symstrtab;
7304 /* .dynsym section. */
7305 asection *dynsym_sec;
7306 /* .hash section. */
7308 /* symbol version section (.gnu.version). */
7309 asection *symver_sec;
7310 /* Buffer large enough to hold contents of any section. */
7312 /* Buffer large enough to hold external relocs of any section. */
7313 void *external_relocs;
7314 /* Buffer large enough to hold internal relocs of any section. */
7315 Elf_Internal_Rela *internal_relocs;
7316 /* Buffer large enough to hold external local symbols of any input
7318 bfd_byte *external_syms;
7319 /* And a buffer for symbol section indices. */
7320 Elf_External_Sym_Shndx *locsym_shndx;
7321 /* Buffer large enough to hold internal local symbols of any input
7323 Elf_Internal_Sym *internal_syms;
7324 /* Array large enough to hold a symbol index for each local symbol
7325 of any input BFD. */
7327 /* Array large enough to hold a section pointer for each local
7328 symbol of any input BFD. */
7329 asection **sections;
7330 /* Buffer to hold swapped out symbols. */
7332 /* And one for symbol section indices. */
7333 Elf_External_Sym_Shndx *symshndxbuf;
7334 /* Number of swapped out symbols in buffer. */
7335 size_t symbuf_count;
7336 /* Number of symbols which fit in symbuf. */
7338 /* And same for symshndxbuf. */
7339 size_t shndxbuf_size;
7342 /* This struct is used to pass information to elf_link_output_extsym. */
7344 struct elf_outext_info
7347 bfd_boolean localsyms;
7348 struct elf_final_link_info *finfo;
7352 /* Support for evaluating a complex relocation.
7354 Complex relocations are generalized, self-describing relocations. The
7355 implementation of them consists of two parts: complex symbols, and the
7356 relocations themselves.
7358 The relocations are use a reserved elf-wide relocation type code (R_RELC
7359 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7360 information (start bit, end bit, word width, etc) into the addend. This
7361 information is extracted from CGEN-generated operand tables within gas.
7363 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7364 internal) representing prefix-notation expressions, including but not
7365 limited to those sorts of expressions normally encoded as addends in the
7366 addend field. The symbol mangling format is:
7369 | <unary-operator> ':' <node>
7370 | <binary-operator> ':' <node> ':' <node>
7373 <literal> := 's' <digits=N> ':' <N character symbol name>
7374 | 'S' <digits=N> ':' <N character section name>
7378 <binary-operator> := as in C
7379 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7382 set_symbol_value (bfd *bfd_with_globals,
7383 Elf_Internal_Sym *isymbuf,
7388 struct elf_link_hash_entry **sym_hashes;
7389 struct elf_link_hash_entry *h;
7390 size_t extsymoff = locsymcount;
7392 if (symidx < locsymcount)
7394 Elf_Internal_Sym *sym;
7396 sym = isymbuf + symidx;
7397 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7399 /* It is a local symbol: move it to the
7400 "absolute" section and give it a value. */
7401 sym->st_shndx = SHN_ABS;
7402 sym->st_value = val;
7405 BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7409 /* It is a global symbol: set its link type
7410 to "defined" and give it a value. */
7412 sym_hashes = elf_sym_hashes (bfd_with_globals);
7413 h = sym_hashes [symidx - extsymoff];
7414 while (h->root.type == bfd_link_hash_indirect
7415 || h->root.type == bfd_link_hash_warning)
7416 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7417 h->root.type = bfd_link_hash_defined;
7418 h->root.u.def.value = val;
7419 h->root.u.def.section = bfd_abs_section_ptr;
7423 resolve_symbol (const char *name,
7425 struct elf_final_link_info *finfo,
7427 Elf_Internal_Sym *isymbuf,
7430 Elf_Internal_Sym *sym;
7431 struct bfd_link_hash_entry *global_entry;
7432 const char *candidate = NULL;
7433 Elf_Internal_Shdr *symtab_hdr;
7436 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7438 for (i = 0; i < locsymcount; ++ i)
7442 if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7445 candidate = bfd_elf_string_from_elf_section (input_bfd,
7446 symtab_hdr->sh_link,
7449 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7450 name, candidate, (unsigned long) sym->st_value);
7452 if (candidate && strcmp (candidate, name) == 0)
7454 asection *sec = finfo->sections [i];
7456 *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7457 *result += sec->output_offset + sec->output_section->vma;
7459 printf ("Found symbol with value %8.8lx\n",
7460 (unsigned long) *result);
7466 /* Hmm, haven't found it yet. perhaps it is a global. */
7467 global_entry = bfd_link_hash_lookup (finfo->info->hash, name,
7468 FALSE, FALSE, TRUE);
7472 if (global_entry->type == bfd_link_hash_defined
7473 || global_entry->type == bfd_link_hash_defweak)
7475 *result = (global_entry->u.def.value
7476 + global_entry->u.def.section->output_section->vma
7477 + global_entry->u.def.section->output_offset);
7479 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7480 global_entry->root.string, (unsigned long) *result);
7489 resolve_section (const char *name,
7496 for (curr = sections; curr; curr = curr->next)
7497 if (strcmp (curr->name, name) == 0)
7499 *result = curr->vma;
7503 /* Hmm. still haven't found it. try pseudo-section names. */
7504 for (curr = sections; curr; curr = curr->next)
7506 len = strlen (curr->name);
7507 if (len > strlen (name))
7510 if (strncmp (curr->name, name, len) == 0)
7512 if (strncmp (".end", name + len, 4) == 0)
7514 *result = curr->vma + curr->size;
7518 /* Insert more pseudo-section names here, if you like. */
7526 undefined_reference (const char *reftype, const char *name)
7528 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7533 eval_symbol (bfd_vma *result,
7536 struct elf_final_link_info *finfo,
7538 Elf_Internal_Sym *isymbuf,
7547 const char *sym = *symp;
7549 bfd_boolean symbol_is_section = FALSE;
7554 if (len < 1 || len > sizeof (symbuf))
7556 bfd_set_error (bfd_error_invalid_operation);
7569 *result = strtoul (sym, (char **) symp, 16);
7573 symbol_is_section = TRUE;
7576 symlen = strtol (sym, (char **) symp, 10);
7577 sym = *symp + 1; /* Skip the trailing ':'. */
7579 if (symend < sym || symlen + 1 > sizeof (symbuf))
7581 bfd_set_error (bfd_error_invalid_operation);
7585 memcpy (symbuf, sym, symlen);
7586 symbuf[symlen] = '\0';
7587 *symp = sym + symlen;
7589 /* Is it always possible, with complex symbols, that gas "mis-guessed"
7590 the symbol as a section, or vice-versa. so we're pretty liberal in our
7591 interpretation here; section means "try section first", not "must be a
7592 section", and likewise with symbol. */
7594 if (symbol_is_section)
7596 if (!resolve_section (symbuf, finfo->output_bfd->sections, result)
7597 && !resolve_symbol (symbuf, input_bfd, finfo, result,
7598 isymbuf, locsymcount))
7600 undefined_reference ("section", symbuf);
7606 if (!resolve_symbol (symbuf, input_bfd, finfo, result,
7607 isymbuf, locsymcount)
7608 && !resolve_section (symbuf, finfo->output_bfd->sections,
7611 undefined_reference ("symbol", symbuf);
7618 /* All that remains are operators. */
7620 #define UNARY_OP(op) \
7621 if (strncmp (sym, #op, strlen (#op)) == 0) \
7623 sym += strlen (#op); \
7627 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
7628 isymbuf, locsymcount, signed_p)) \
7631 *result = op ((bfd_signed_vma) a); \
7637 #define BINARY_OP(op) \
7638 if (strncmp (sym, #op, strlen (#op)) == 0) \
7640 sym += strlen (#op); \
7644 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
7645 isymbuf, locsymcount, signed_p)) \
7648 if (!eval_symbol (&b, symp, input_bfd, finfo, dot, \
7649 isymbuf, locsymcount, signed_p)) \
7652 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7682 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7683 bfd_set_error (bfd_error_invalid_operation);
7689 put_value (bfd_vma size,
7690 unsigned long chunksz,
7695 location += (size - chunksz);
7697 for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
7705 bfd_put_8 (input_bfd, x, location);
7708 bfd_put_16 (input_bfd, x, location);
7711 bfd_put_32 (input_bfd, x, location);
7715 bfd_put_64 (input_bfd, x, location);
7725 get_value (bfd_vma size,
7726 unsigned long chunksz,
7732 for (; size; size -= chunksz, location += chunksz)
7740 x = (x << (8 * chunksz)) | bfd_get_8 (input_bfd, location);
7743 x = (x << (8 * chunksz)) | bfd_get_16 (input_bfd, location);
7746 x = (x << (8 * chunksz)) | bfd_get_32 (input_bfd, location);
7750 x = (x << (8 * chunksz)) | bfd_get_64 (input_bfd, location);
7761 decode_complex_addend (unsigned long *start, /* in bits */
7762 unsigned long *oplen, /* in bits */
7763 unsigned long *len, /* in bits */
7764 unsigned long *wordsz, /* in bytes */
7765 unsigned long *chunksz, /* in bytes */
7766 unsigned long *lsb0_p,
7767 unsigned long *signed_p,
7768 unsigned long *trunc_p,
7769 unsigned long encoded)
7771 * start = encoded & 0x3F;
7772 * len = (encoded >> 6) & 0x3F;
7773 * oplen = (encoded >> 12) & 0x3F;
7774 * wordsz = (encoded >> 18) & 0xF;
7775 * chunksz = (encoded >> 22) & 0xF;
7776 * lsb0_p = (encoded >> 27) & 1;
7777 * signed_p = (encoded >> 28) & 1;
7778 * trunc_p = (encoded >> 29) & 1;
7781 bfd_reloc_status_type
7782 bfd_elf_perform_complex_relocation (bfd *input_bfd,
7783 asection *input_section ATTRIBUTE_UNUSED,
7785 Elf_Internal_Rela *rel,
7788 bfd_vma shift, x, mask;
7789 unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
7790 bfd_reloc_status_type r;
7792 /* Perform this reloc, since it is complex.
7793 (this is not to say that it necessarily refers to a complex
7794 symbol; merely that it is a self-describing CGEN based reloc.
7795 i.e. the addend has the complete reloc information (bit start, end,
7796 word size, etc) encoded within it.). */
7798 decode_complex_addend (&start, &oplen, &len, &wordsz,
7799 &chunksz, &lsb0_p, &signed_p,
7800 &trunc_p, rel->r_addend);
7802 mask = (((1L << (len - 1)) - 1) << 1) | 1;
7805 shift = (start + 1) - len;
7807 shift = (8 * wordsz) - (start + len);
7809 /* FIXME: octets_per_byte. */
7810 x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
7813 printf ("Doing complex reloc: "
7814 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7815 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7816 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7817 lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7818 oplen, x, mask, relocation);
7823 /* Now do an overflow check. */
7824 r = bfd_check_overflow ((signed_p
7825 ? complain_overflow_signed
7826 : complain_overflow_unsigned),
7827 len, 0, (8 * wordsz),
7831 x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7834 printf (" relocation: %8.8lx\n"
7835 " shifted mask: %8.8lx\n"
7836 " shifted/masked reloc: %8.8lx\n"
7837 " result: %8.8lx\n",
7838 relocation, (mask << shift),
7839 ((relocation & mask) << shift), x);
7841 /* FIXME: octets_per_byte. */
7842 put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
7846 /* When performing a relocatable link, the input relocations are
7847 preserved. But, if they reference global symbols, the indices
7848 referenced must be updated. Update all the relocations in
7849 REL_HDR (there are COUNT of them), using the data in REL_HASH. */
7852 elf_link_adjust_relocs (bfd *abfd,
7853 Elf_Internal_Shdr *rel_hdr,
7855 struct elf_link_hash_entry **rel_hash)
7858 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7860 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
7861 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
7862 bfd_vma r_type_mask;
7865 if (rel_hdr->sh_entsize == bed->s->sizeof_rel)
7867 swap_in = bed->s->swap_reloc_in;
7868 swap_out = bed->s->swap_reloc_out;
7870 else if (rel_hdr->sh_entsize == bed->s->sizeof_rela)
7872 swap_in = bed->s->swap_reloca_in;
7873 swap_out = bed->s->swap_reloca_out;
7878 if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
7881 if (bed->s->arch_size == 32)
7888 r_type_mask = 0xffffffff;
7892 erela = rel_hdr->contents;
7893 for (i = 0; i < count; i++, rel_hash++, erela += rel_hdr->sh_entsize)
7895 Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
7898 if (*rel_hash == NULL)
7901 BFD_ASSERT ((*rel_hash)->indx >= 0);
7903 (*swap_in) (abfd, erela, irela);
7904 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
7905 irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
7906 | (irela[j].r_info & r_type_mask));
7907 (*swap_out) (abfd, irela, erela);
7911 struct elf_link_sort_rela
7917 enum elf_reloc_type_class type;
7918 /* We use this as an array of size int_rels_per_ext_rel. */
7919 Elf_Internal_Rela rela[1];
7923 elf_link_sort_cmp1 (const void *A, const void *B)
7925 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
7926 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
7927 int relativea, relativeb;
7929 relativea = a->type == reloc_class_relative;
7930 relativeb = b->type == reloc_class_relative;
7932 if (relativea < relativeb)
7934 if (relativea > relativeb)
7936 if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
7938 if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
7940 if (a->rela->r_offset < b->rela->r_offset)
7942 if (a->rela->r_offset > b->rela->r_offset)
7948 elf_link_sort_cmp2 (const void *A, const void *B)
7950 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
7951 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
7954 if (a->u.offset < b->u.offset)
7956 if (a->u.offset > b->u.offset)
7958 copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt);
7959 copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt);
7964 if (a->rela->r_offset < b->rela->r_offset)
7966 if (a->rela->r_offset > b->rela->r_offset)
7972 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
7974 asection *dynamic_relocs;
7977 bfd_size_type count, size;
7978 size_t i, ret, sort_elt, ext_size;
7979 bfd_byte *sort, *s_non_relative, *p;
7980 struct elf_link_sort_rela *sq;
7981 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7982 int i2e = bed->s->int_rels_per_ext_rel;
7983 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
7984 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
7985 struct bfd_link_order *lo;
7987 bfd_boolean use_rela;
7989 /* Find a dynamic reloc section. */
7990 rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
7991 rel_dyn = bfd_get_section_by_name (abfd, ".rel.dyn");
7992 if (rela_dyn != NULL && rela_dyn->size > 0
7993 && rel_dyn != NULL && rel_dyn->size > 0)
7995 bfd_boolean use_rela_initialised = FALSE;
7997 /* This is just here to stop gcc from complaining.
7998 It's initialization checking code is not perfect. */
8001 /* Both sections are present. Examine the sizes
8002 of the indirect sections to help us choose. */
8003 for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8004 if (lo->type == bfd_indirect_link_order)
8006 asection *o = lo->u.indirect.section;
8008 if ((o->size % bed->s->sizeof_rela) == 0)
8010 if ((o->size % bed->s->sizeof_rel) == 0)
8011 /* Section size is divisible by both rel and rela sizes.
8012 It is of no help to us. */
8016 /* Section size is only divisible by rela. */
8017 if (use_rela_initialised && (use_rela == FALSE))
8020 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8021 bfd_set_error (bfd_error_invalid_operation);
8027 use_rela_initialised = TRUE;
8031 else if ((o->size % bed->s->sizeof_rel) == 0)
8033 /* Section size is only divisible by rel. */
8034 if (use_rela_initialised && (use_rela == TRUE))
8037 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8038 bfd_set_error (bfd_error_invalid_operation);
8044 use_rela_initialised = TRUE;
8049 /* The section size is not divisible by either - something is wrong. */
8051 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8052 bfd_set_error (bfd_error_invalid_operation);
8057 for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8058 if (lo->type == bfd_indirect_link_order)
8060 asection *o = lo->u.indirect.section;
8062 if ((o->size % bed->s->sizeof_rela) == 0)
8064 if ((o->size % bed->s->sizeof_rel) == 0)
8065 /* Section size is divisible by both rel and rela sizes.
8066 It is of no help to us. */
8070 /* Section size is only divisible by rela. */
8071 if (use_rela_initialised && (use_rela == FALSE))
8074 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8075 bfd_set_error (bfd_error_invalid_operation);
8081 use_rela_initialised = TRUE;
8085 else if ((o->size % bed->s->sizeof_rel) == 0)
8087 /* Section size is only divisible by rel. */
8088 if (use_rela_initialised && (use_rela == TRUE))
8091 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8092 bfd_set_error (bfd_error_invalid_operation);
8098 use_rela_initialised = TRUE;
8103 /* The section size is not divisible by either - something is wrong. */
8105 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8106 bfd_set_error (bfd_error_invalid_operation);
8111 if (! use_rela_initialised)
8115 else if (rela_dyn != NULL && rela_dyn->size > 0)
8117 else if (rel_dyn != NULL && rel_dyn->size > 0)
8124 dynamic_relocs = rela_dyn;
8125 ext_size = bed->s->sizeof_rela;
8126 swap_in = bed->s->swap_reloca_in;
8127 swap_out = bed->s->swap_reloca_out;
8131 dynamic_relocs = rel_dyn;
8132 ext_size = bed->s->sizeof_rel;
8133 swap_in = bed->s->swap_reloc_in;
8134 swap_out = bed->s->swap_reloc_out;
8138 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8139 if (lo->type == bfd_indirect_link_order)
8140 size += lo->u.indirect.section->size;
8142 if (size != dynamic_relocs->size)
8145 sort_elt = (sizeof (struct elf_link_sort_rela)
8146 + (i2e - 1) * sizeof (Elf_Internal_Rela));
8148 count = dynamic_relocs->size / ext_size;
8151 sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8155 (*info->callbacks->warning)
8156 (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8160 if (bed->s->arch_size == 32)
8161 r_sym_mask = ~(bfd_vma) 0xff;
8163 r_sym_mask = ~(bfd_vma) 0xffffffff;
8165 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8166 if (lo->type == bfd_indirect_link_order)
8168 bfd_byte *erel, *erelend;
8169 asection *o = lo->u.indirect.section;
8171 if (o->contents == NULL && o->size != 0)
8173 /* This is a reloc section that is being handled as a normal
8174 section. See bfd_section_from_shdr. We can't combine
8175 relocs in this case. */
8180 erelend = o->contents + o->size;
8181 /* FIXME: octets_per_byte. */
8182 p = sort + o->output_offset / ext_size * sort_elt;
8184 while (erel < erelend)
8186 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8188 (*swap_in) (abfd, erel, s->rela);
8189 s->type = (*bed->elf_backend_reloc_type_class) (s->rela);
8190 s->u.sym_mask = r_sym_mask;
8196 qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8198 for (i = 0, p = sort; i < count; i++, p += sort_elt)
8200 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8201 if (s->type != reloc_class_relative)
8207 sq = (struct elf_link_sort_rela *) s_non_relative;
8208 for (; i < count; i++, p += sort_elt)
8210 struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8211 if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8213 sp->u.offset = sq->rela->r_offset;
8216 qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8218 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8219 if (lo->type == bfd_indirect_link_order)
8221 bfd_byte *erel, *erelend;
8222 asection *o = lo->u.indirect.section;
8225 erelend = o->contents + o->size;
8226 /* FIXME: octets_per_byte. */
8227 p = sort + o->output_offset / ext_size * sort_elt;
8228 while (erel < erelend)
8230 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8231 (*swap_out) (abfd, s->rela, erel);
8238 *psec = dynamic_relocs;
8242 /* Flush the output symbols to the file. */
8245 elf_link_flush_output_syms (struct elf_final_link_info *finfo,
8246 const struct elf_backend_data *bed)
8248 if (finfo->symbuf_count > 0)
8250 Elf_Internal_Shdr *hdr;
8254 hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
8255 pos = hdr->sh_offset + hdr->sh_size;
8256 amt = finfo->symbuf_count * bed->s->sizeof_sym;
8257 if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
8258 || bfd_bwrite (finfo->symbuf, amt, finfo->output_bfd) != amt)
8261 hdr->sh_size += amt;
8262 finfo->symbuf_count = 0;
8268 /* Add a symbol to the output symbol table. */
8271 elf_link_output_sym (struct elf_final_link_info *finfo,
8273 Elf_Internal_Sym *elfsym,
8274 asection *input_sec,
8275 struct elf_link_hash_entry *h)
8278 Elf_External_Sym_Shndx *destshndx;
8279 int (*output_symbol_hook)
8280 (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8281 struct elf_link_hash_entry *);
8282 const struct elf_backend_data *bed;
8284 bed = get_elf_backend_data (finfo->output_bfd);
8285 output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8286 if (output_symbol_hook != NULL)
8288 int ret = (*output_symbol_hook) (finfo->info, name, elfsym, input_sec, h);
8293 if (name == NULL || *name == '\0')
8294 elfsym->st_name = 0;
8295 else if (input_sec->flags & SEC_EXCLUDE)
8296 elfsym->st_name = 0;
8299 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
8301 if (elfsym->st_name == (unsigned long) -1)
8305 if (finfo->symbuf_count >= finfo->symbuf_size)
8307 if (! elf_link_flush_output_syms (finfo, bed))
8311 dest = finfo->symbuf + finfo->symbuf_count * bed->s->sizeof_sym;
8312 destshndx = finfo->symshndxbuf;
8313 if (destshndx != NULL)
8315 if (bfd_get_symcount (finfo->output_bfd) >= finfo->shndxbuf_size)
8319 amt = finfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
8320 destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
8322 if (destshndx == NULL)
8324 finfo->symshndxbuf = destshndx;
8325 memset ((char *) destshndx + amt, 0, amt);
8326 finfo->shndxbuf_size *= 2;
8328 destshndx += bfd_get_symcount (finfo->output_bfd);
8331 bed->s->swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx);
8332 finfo->symbuf_count += 1;
8333 bfd_get_symcount (finfo->output_bfd) += 1;
8338 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8341 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8343 if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8344 && sym->st_shndx < SHN_LORESERVE)
8346 /* The gABI doesn't support dynamic symbols in output sections
8348 (*_bfd_error_handler)
8349 (_("%B: Too many sections: %d (>= %d)"),
8350 abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8351 bfd_set_error (bfd_error_nonrepresentable_section);
8357 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8358 allowing an unsatisfied unversioned symbol in the DSO to match a
8359 versioned symbol that would normally require an explicit version.
8360 We also handle the case that a DSO references a hidden symbol
8361 which may be satisfied by a versioned symbol in another DSO. */
8364 elf_link_check_versioned_symbol (struct bfd_link_info *info,
8365 const struct elf_backend_data *bed,
8366 struct elf_link_hash_entry *h)
8369 struct elf_link_loaded_list *loaded;
8371 if (!is_elf_hash_table (info->hash))
8374 switch (h->root.type)
8380 case bfd_link_hash_undefined:
8381 case bfd_link_hash_undefweak:
8382 abfd = h->root.u.undef.abfd;
8383 if ((abfd->flags & DYNAMIC) == 0
8384 || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8388 case bfd_link_hash_defined:
8389 case bfd_link_hash_defweak:
8390 abfd = h->root.u.def.section->owner;
8393 case bfd_link_hash_common:
8394 abfd = h->root.u.c.p->section->owner;
8397 BFD_ASSERT (abfd != NULL);
8399 for (loaded = elf_hash_table (info)->loaded;
8401 loaded = loaded->next)
8404 Elf_Internal_Shdr *hdr;
8405 bfd_size_type symcount;
8406 bfd_size_type extsymcount;
8407 bfd_size_type extsymoff;
8408 Elf_Internal_Shdr *versymhdr;
8409 Elf_Internal_Sym *isym;
8410 Elf_Internal_Sym *isymend;
8411 Elf_Internal_Sym *isymbuf;
8412 Elf_External_Versym *ever;
8413 Elf_External_Versym *extversym;
8415 input = loaded->abfd;
8417 /* We check each DSO for a possible hidden versioned definition. */
8419 || (input->flags & DYNAMIC) == 0
8420 || elf_dynversym (input) == 0)
8423 hdr = &elf_tdata (input)->dynsymtab_hdr;
8425 symcount = hdr->sh_size / bed->s->sizeof_sym;
8426 if (elf_bad_symtab (input))
8428 extsymcount = symcount;
8433 extsymcount = symcount - hdr->sh_info;
8434 extsymoff = hdr->sh_info;
8437 if (extsymcount == 0)
8440 isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8442 if (isymbuf == NULL)
8445 /* Read in any version definitions. */
8446 versymhdr = &elf_tdata (input)->dynversym_hdr;
8447 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
8448 if (extversym == NULL)
8451 if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8452 || (bfd_bread (extversym, versymhdr->sh_size, input)
8453 != versymhdr->sh_size))
8461 ever = extversym + extsymoff;
8462 isymend = isymbuf + extsymcount;
8463 for (isym = isymbuf; isym < isymend; isym++, ever++)
8466 Elf_Internal_Versym iver;
8467 unsigned short version_index;
8469 if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8470 || isym->st_shndx == SHN_UNDEF)
8473 name = bfd_elf_string_from_elf_section (input,
8476 if (strcmp (name, h->root.root.string) != 0)
8479 _bfd_elf_swap_versym_in (input, ever, &iver);
8481 if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
8483 /* If we have a non-hidden versioned sym, then it should
8484 have provided a definition for the undefined sym. */
8488 version_index = iver.vs_vers & VERSYM_VERSION;
8489 if (version_index == 1 || version_index == 2)
8491 /* This is the base or first version. We can use it. */
8505 /* Add an external symbol to the symbol table. This is called from
8506 the hash table traversal routine. When generating a shared object,
8507 we go through the symbol table twice. The first time we output
8508 anything that might have been forced to local scope in a version
8509 script. The second time we output the symbols that are still
8513 elf_link_output_extsym (struct elf_link_hash_entry *h, void *data)
8515 struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
8516 struct elf_final_link_info *finfo = eoinfo->finfo;
8518 Elf_Internal_Sym sym;
8519 asection *input_sec;
8520 const struct elf_backend_data *bed;
8524 if (h->root.type == bfd_link_hash_warning)
8526 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8527 if (h->root.type == bfd_link_hash_new)
8531 /* Decide whether to output this symbol in this pass. */
8532 if (eoinfo->localsyms)
8534 if (!h->forced_local)
8539 if (h->forced_local)
8543 bed = get_elf_backend_data (finfo->output_bfd);
8545 if (h->root.type == bfd_link_hash_undefined)
8547 /* If we have an undefined symbol reference here then it must have
8548 come from a shared library that is being linked in. (Undefined
8549 references in regular files have already been handled). */
8550 bfd_boolean ignore_undef = FALSE;
8552 /* Some symbols may be special in that the fact that they're
8553 undefined can be safely ignored - let backend determine that. */
8554 if (bed->elf_backend_ignore_undef_symbol)
8555 ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8557 /* If we are reporting errors for this situation then do so now. */
8558 if (ignore_undef == FALSE
8561 && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
8562 && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
8564 if (! (finfo->info->callbacks->undefined_symbol
8565 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
8566 NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
8568 eoinfo->failed = TRUE;
8574 /* We should also warn if a forced local symbol is referenced from
8575 shared libraries. */
8576 if (! finfo->info->relocatable
8577 && (! finfo->info->shared)
8582 && ! elf_link_check_versioned_symbol (finfo->info, bed, h))
8584 (*_bfd_error_handler)
8585 (_("%B: %s symbol `%s' in %B is referenced by DSO"),
8587 h->root.u.def.section == bfd_abs_section_ptr
8588 ? finfo->output_bfd : h->root.u.def.section->owner,
8589 ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
8591 : ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
8592 ? "hidden" : "local",
8593 h->root.root.string);
8594 eoinfo->failed = TRUE;
8598 /* We don't want to output symbols that have never been mentioned by
8599 a regular file, or that we have been told to strip. However, if
8600 h->indx is set to -2, the symbol is used by a reloc and we must
8604 else if ((h->def_dynamic
8606 || h->root.type == bfd_link_hash_new)
8610 else if (finfo->info->strip == strip_all)
8612 else if (finfo->info->strip == strip_some
8613 && bfd_hash_lookup (finfo->info->keep_hash,
8614 h->root.root.string, FALSE, FALSE) == NULL)
8616 else if (finfo->info->strip_discarded
8617 && (h->root.type == bfd_link_hash_defined
8618 || h->root.type == bfd_link_hash_defweak)
8619 && elf_discarded_section (h->root.u.def.section))
8624 /* If we're stripping it, and it's not a dynamic symbol, there's
8625 nothing else to do unless it is a forced local symbol. */
8628 && !h->forced_local)
8632 sym.st_size = h->size;
8633 sym.st_other = h->other;
8634 if (h->forced_local)
8635 sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8636 else if (h->unique_global)
8637 sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
8638 else if (h->root.type == bfd_link_hash_undefweak
8639 || h->root.type == bfd_link_hash_defweak)
8640 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8642 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8644 switch (h->root.type)
8647 case bfd_link_hash_new:
8648 case bfd_link_hash_warning:
8652 case bfd_link_hash_undefined:
8653 case bfd_link_hash_undefweak:
8654 input_sec = bfd_und_section_ptr;
8655 sym.st_shndx = SHN_UNDEF;
8658 case bfd_link_hash_defined:
8659 case bfd_link_hash_defweak:
8661 input_sec = h->root.u.def.section;
8662 if (input_sec->output_section != NULL)
8665 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
8666 input_sec->output_section);
8667 if (sym.st_shndx == SHN_BAD)
8669 (*_bfd_error_handler)
8670 (_("%B: could not find output section %A for input section %A"),
8671 finfo->output_bfd, input_sec->output_section, input_sec);
8672 eoinfo->failed = TRUE;
8676 /* ELF symbols in relocatable files are section relative,
8677 but in nonrelocatable files they are virtual
8679 sym.st_value = h->root.u.def.value + input_sec->output_offset;
8680 if (! finfo->info->relocatable)
8682 sym.st_value += input_sec->output_section->vma;
8683 if (h->type == STT_TLS)
8685 asection *tls_sec = elf_hash_table (finfo->info)->tls_sec;
8686 if (tls_sec != NULL)
8687 sym.st_value -= tls_sec->vma;
8690 /* The TLS section may have been garbage collected. */
8691 BFD_ASSERT (finfo->info->gc_sections
8692 && !input_sec->gc_mark);
8699 BFD_ASSERT (input_sec->owner == NULL
8700 || (input_sec->owner->flags & DYNAMIC) != 0);
8701 sym.st_shndx = SHN_UNDEF;
8702 input_sec = bfd_und_section_ptr;
8707 case bfd_link_hash_common:
8708 input_sec = h->root.u.c.p->section;
8709 sym.st_shndx = bed->common_section_index (input_sec);
8710 sym.st_value = 1 << h->root.u.c.p->alignment_power;
8713 case bfd_link_hash_indirect:
8714 /* These symbols are created by symbol versioning. They point
8715 to the decorated version of the name. For example, if the
8716 symbol foo@@GNU_1.2 is the default, which should be used when
8717 foo is used with no version, then we add an indirect symbol
8718 foo which points to foo@@GNU_1.2. We ignore these symbols,
8719 since the indirected symbol is already in the hash table. */
8723 /* Give the processor backend a chance to tweak the symbol value,
8724 and also to finish up anything that needs to be done for this
8725 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
8726 forced local syms when non-shared is due to a historical quirk.
8727 STT_GNU_IFUNC symbol must go through PLT. */
8728 if ((h->type == STT_GNU_IFUNC
8730 && !finfo->info->relocatable)
8731 || ((h->dynindx != -1
8733 && ((finfo->info->shared
8734 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8735 || h->root.type != bfd_link_hash_undefweak))
8736 || !h->forced_local)
8737 && elf_hash_table (finfo->info)->dynamic_sections_created))
8739 if (! ((*bed->elf_backend_finish_dynamic_symbol)
8740 (finfo->output_bfd, finfo->info, h, &sym)))
8742 eoinfo->failed = TRUE;
8747 /* If we are marking the symbol as undefined, and there are no
8748 non-weak references to this symbol from a regular object, then
8749 mark the symbol as weak undefined; if there are non-weak
8750 references, mark the symbol as strong. We can't do this earlier,
8751 because it might not be marked as undefined until the
8752 finish_dynamic_symbol routine gets through with it. */
8753 if (sym.st_shndx == SHN_UNDEF
8755 && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
8756 || ELF_ST_BIND (sym.st_info) == STB_WEAK))
8759 unsigned int type = ELF_ST_TYPE (sym.st_info);
8761 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
8762 if (type == STT_GNU_IFUNC)
8765 if (h->ref_regular_nonweak)
8766 bindtype = STB_GLOBAL;
8768 bindtype = STB_WEAK;
8769 sym.st_info = ELF_ST_INFO (bindtype, type);
8772 /* If this is a symbol defined in a dynamic library, don't use the
8773 symbol size from the dynamic library. Relinking an executable
8774 against a new library may introduce gratuitous changes in the
8775 executable's symbols if we keep the size. */
8776 if (sym.st_shndx == SHN_UNDEF
8781 /* If a non-weak symbol with non-default visibility is not defined
8782 locally, it is a fatal error. */
8783 if (! finfo->info->relocatable
8784 && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
8785 && ELF_ST_BIND (sym.st_info) != STB_WEAK
8786 && h->root.type == bfd_link_hash_undefined
8789 (*_bfd_error_handler)
8790 (_("%B: %s symbol `%s' isn't defined"),
8792 ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED
8794 : ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL
8795 ? "internal" : "hidden",
8796 h->root.root.string);
8797 eoinfo->failed = TRUE;
8801 /* If this symbol should be put in the .dynsym section, then put it
8802 there now. We already know the symbol index. We also fill in
8803 the entry in the .hash section. */
8804 if (h->dynindx != -1
8805 && elf_hash_table (finfo->info)->dynamic_sections_created)
8809 sym.st_name = h->dynstr_index;
8810 esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
8811 if (! check_dynsym (finfo->output_bfd, &sym))
8813 eoinfo->failed = TRUE;
8816 bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
8818 if (finfo->hash_sec != NULL)
8820 size_t hash_entry_size;
8821 bfd_byte *bucketpos;
8826 bucketcount = elf_hash_table (finfo->info)->bucketcount;
8827 bucket = h->u.elf_hash_value % bucketcount;
8830 = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
8831 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
8832 + (bucket + 2) * hash_entry_size);
8833 chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
8834 bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
8835 bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
8836 ((bfd_byte *) finfo->hash_sec->contents
8837 + (bucketcount + 2 + h->dynindx) * hash_entry_size));
8840 if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
8842 Elf_Internal_Versym iversym;
8843 Elf_External_Versym *eversym;
8845 if (!h->def_regular)
8847 if (h->verinfo.verdef == NULL)
8848 iversym.vs_vers = 0;
8850 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
8854 if (h->verinfo.vertree == NULL)
8855 iversym.vs_vers = 1;
8857 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
8858 if (finfo->info->create_default_symver)
8863 iversym.vs_vers |= VERSYM_HIDDEN;
8865 eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
8866 eversym += h->dynindx;
8867 _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
8871 /* If we're stripping it, then it was just a dynamic symbol, and
8872 there's nothing else to do. */
8873 if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
8876 indx = bfd_get_symcount (finfo->output_bfd);
8877 ret = elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec, h);
8880 eoinfo->failed = TRUE;
8885 else if (h->indx == -2)
8891 /* Return TRUE if special handling is done for relocs in SEC against
8892 symbols defined in discarded sections. */
8895 elf_section_ignore_discarded_relocs (asection *sec)
8897 const struct elf_backend_data *bed;
8899 switch (sec->sec_info_type)
8901 case ELF_INFO_TYPE_STABS:
8902 case ELF_INFO_TYPE_EH_FRAME:
8908 bed = get_elf_backend_data (sec->owner);
8909 if (bed->elf_backend_ignore_discarded_relocs != NULL
8910 && (*bed->elf_backend_ignore_discarded_relocs) (sec))
8916 /* Return a mask saying how ld should treat relocations in SEC against
8917 symbols defined in discarded sections. If this function returns
8918 COMPLAIN set, ld will issue a warning message. If this function
8919 returns PRETEND set, and the discarded section was link-once and the
8920 same size as the kept link-once section, ld will pretend that the
8921 symbol was actually defined in the kept section. Otherwise ld will
8922 zero the reloc (at least that is the intent, but some cooperation by
8923 the target dependent code is needed, particularly for REL targets). */
8926 _bfd_elf_default_action_discarded (asection *sec)
8928 if (sec->flags & SEC_DEBUGGING)
8931 if (strcmp (".eh_frame", sec->name) == 0)
8934 if (strcmp (".gcc_except_table", sec->name) == 0)
8937 return COMPLAIN | PRETEND;
8940 /* Find a match between a section and a member of a section group. */
8943 match_group_member (asection *sec, asection *group,
8944 struct bfd_link_info *info)
8946 asection *first = elf_next_in_group (group);
8947 asection *s = first;
8951 if (bfd_elf_match_symbols_in_sections (s, sec, info))
8954 s = elf_next_in_group (s);
8962 /* Check if the kept section of a discarded section SEC can be used
8963 to replace it. Return the replacement if it is OK. Otherwise return
8967 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
8971 kept = sec->kept_section;
8974 if ((kept->flags & SEC_GROUP) != 0)
8975 kept = match_group_member (sec, kept, info);
8977 && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
8978 != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
8980 sec->kept_section = kept;
8985 /* Link an input file into the linker output file. This function
8986 handles all the sections and relocations of the input file at once.
8987 This is so that we only have to read the local symbols once, and
8988 don't have to keep them in memory. */
8991 elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
8993 int (*relocate_section)
8994 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
8995 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
8997 Elf_Internal_Shdr *symtab_hdr;
9000 Elf_Internal_Sym *isymbuf;
9001 Elf_Internal_Sym *isym;
9002 Elf_Internal_Sym *isymend;
9004 asection **ppsection;
9006 const struct elf_backend_data *bed;
9007 struct elf_link_hash_entry **sym_hashes;
9009 output_bfd = finfo->output_bfd;
9010 bed = get_elf_backend_data (output_bfd);
9011 relocate_section = bed->elf_backend_relocate_section;
9013 /* If this is a dynamic object, we don't want to do anything here:
9014 we don't want the local symbols, and we don't want the section
9016 if ((input_bfd->flags & DYNAMIC) != 0)
9019 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9020 if (elf_bad_symtab (input_bfd))
9022 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9027 locsymcount = symtab_hdr->sh_info;
9028 extsymoff = symtab_hdr->sh_info;
9031 /* Read the local symbols. */
9032 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9033 if (isymbuf == NULL && locsymcount != 0)
9035 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9036 finfo->internal_syms,
9037 finfo->external_syms,
9038 finfo->locsym_shndx);
9039 if (isymbuf == NULL)
9043 /* Find local symbol sections and adjust values of symbols in
9044 SEC_MERGE sections. Write out those local symbols we know are
9045 going into the output file. */
9046 isymend = isymbuf + locsymcount;
9047 for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
9049 isym++, pindex++, ppsection++)
9053 Elf_Internal_Sym osym;
9059 if (elf_bad_symtab (input_bfd))
9061 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9068 if (isym->st_shndx == SHN_UNDEF)
9069 isec = bfd_und_section_ptr;
9070 else if (isym->st_shndx == SHN_ABS)
9071 isec = bfd_abs_section_ptr;
9072 else if (isym->st_shndx == SHN_COMMON)
9073 isec = bfd_com_section_ptr;
9076 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9079 /* Don't attempt to output symbols with st_shnx in the
9080 reserved range other than SHN_ABS and SHN_COMMON. */
9084 else if (isec->sec_info_type == ELF_INFO_TYPE_MERGE
9085 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9087 _bfd_merged_section_offset (output_bfd, &isec,
9088 elf_section_data (isec)->sec_info,
9094 /* Don't output the first, undefined, symbol. */
9095 if (ppsection == finfo->sections)
9098 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9100 /* We never output section symbols. Instead, we use the
9101 section symbol of the corresponding section in the output
9106 /* If we are stripping all symbols, we don't want to output this
9108 if (finfo->info->strip == strip_all)
9111 /* If we are discarding all local symbols, we don't want to
9112 output this one. If we are generating a relocatable output
9113 file, then some of the local symbols may be required by
9114 relocs; we output them below as we discover that they are
9116 if (finfo->info->discard == discard_all)
9119 /* If this symbol is defined in a section which we are
9120 discarding, we don't need to keep it. */
9121 if (isym->st_shndx != SHN_UNDEF
9122 && isym->st_shndx < SHN_LORESERVE
9123 && bfd_section_removed_from_list (output_bfd,
9124 isec->output_section))
9127 /* Get the name of the symbol. */
9128 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9133 /* See if we are discarding symbols with this name. */
9134 if ((finfo->info->strip == strip_some
9135 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
9137 || (((finfo->info->discard == discard_sec_merge
9138 && (isec->flags & SEC_MERGE) && ! finfo->info->relocatable)
9139 || finfo->info->discard == discard_l)
9140 && bfd_is_local_label_name (input_bfd, name)))
9145 /* Adjust the section index for the output file. */
9146 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9147 isec->output_section);
9148 if (osym.st_shndx == SHN_BAD)
9151 /* ELF symbols in relocatable files are section relative, but
9152 in executable files they are virtual addresses. Note that
9153 this code assumes that all ELF sections have an associated
9154 BFD section with a reasonable value for output_offset; below
9155 we assume that they also have a reasonable value for
9156 output_section. Any special sections must be set up to meet
9157 these requirements. */
9158 osym.st_value += isec->output_offset;
9159 if (! finfo->info->relocatable)
9161 osym.st_value += isec->output_section->vma;
9162 if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9164 /* STT_TLS symbols are relative to PT_TLS segment base. */
9165 BFD_ASSERT (elf_hash_table (finfo->info)->tls_sec != NULL);
9166 osym.st_value -= elf_hash_table (finfo->info)->tls_sec->vma;
9170 indx = bfd_get_symcount (output_bfd);
9171 ret = elf_link_output_sym (finfo, name, &osym, isec, NULL);
9178 /* Relocate the contents of each section. */
9179 sym_hashes = elf_sym_hashes (input_bfd);
9180 for (o = input_bfd->sections; o != NULL; o = o->next)
9184 if (! o->linker_mark)
9186 /* This section was omitted from the link. */
9190 if (finfo->info->relocatable
9191 && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9193 /* Deal with the group signature symbol. */
9194 struct bfd_elf_section_data *sec_data = elf_section_data (o);
9195 unsigned long symndx = sec_data->this_hdr.sh_info;
9196 asection *osec = o->output_section;
9198 if (symndx >= locsymcount
9199 || (elf_bad_symtab (input_bfd)
9200 && finfo->sections[symndx] == NULL))
9202 struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9203 while (h->root.type == bfd_link_hash_indirect
9204 || h->root.type == bfd_link_hash_warning)
9205 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9206 /* Arrange for symbol to be output. */
9208 elf_section_data (osec)->this_hdr.sh_info = -2;
9210 else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9212 /* We'll use the output section target_index. */
9213 asection *sec = finfo->sections[symndx]->output_section;
9214 elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9218 if (finfo->indices[symndx] == -1)
9220 /* Otherwise output the local symbol now. */
9221 Elf_Internal_Sym sym = isymbuf[symndx];
9222 asection *sec = finfo->sections[symndx]->output_section;
9227 name = bfd_elf_string_from_elf_section (input_bfd,
9228 symtab_hdr->sh_link,
9233 sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9235 if (sym.st_shndx == SHN_BAD)
9238 sym.st_value += o->output_offset;
9240 indx = bfd_get_symcount (output_bfd);
9241 ret = elf_link_output_sym (finfo, name, &sym, o, NULL);
9245 finfo->indices[symndx] = indx;
9249 elf_section_data (osec)->this_hdr.sh_info
9250 = finfo->indices[symndx];
9254 if ((o->flags & SEC_HAS_CONTENTS) == 0
9255 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
9258 if ((o->flags & SEC_LINKER_CREATED) != 0)
9260 /* Section was created by _bfd_elf_link_create_dynamic_sections
9265 /* Get the contents of the section. They have been cached by a
9266 relaxation routine. Note that o is a section in an input
9267 file, so the contents field will not have been set by any of
9268 the routines which work on output files. */
9269 if (elf_section_data (o)->this_hdr.contents != NULL)
9270 contents = elf_section_data (o)->this_hdr.contents;
9273 bfd_size_type amt = o->rawsize ? o->rawsize : o->size;
9275 contents = finfo->contents;
9276 if (! bfd_get_section_contents (input_bfd, o, contents, 0, amt))
9280 if ((o->flags & SEC_RELOC) != 0)
9282 Elf_Internal_Rela *internal_relocs;
9283 Elf_Internal_Rela *rel, *relend;
9284 bfd_vma r_type_mask;
9286 int action_discarded;
9289 /* Get the swapped relocs. */
9291 = _bfd_elf_link_read_relocs (input_bfd, o, finfo->external_relocs,
9292 finfo->internal_relocs, FALSE);
9293 if (internal_relocs == NULL
9294 && o->reloc_count > 0)
9297 if (bed->s->arch_size == 32)
9304 r_type_mask = 0xffffffff;
9308 action_discarded = -1;
9309 if (!elf_section_ignore_discarded_relocs (o))
9310 action_discarded = (*bed->action_discarded) (o);
9312 /* Run through the relocs evaluating complex reloc symbols and
9313 looking for relocs against symbols from discarded sections
9314 or section symbols from removed link-once sections.
9315 Complain about relocs against discarded sections. Zero
9316 relocs against removed link-once sections. */
9318 rel = internal_relocs;
9319 relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9320 for ( ; rel < relend; rel++)
9322 unsigned long r_symndx = rel->r_info >> r_sym_shift;
9323 unsigned int s_type;
9324 asection **ps, *sec;
9325 struct elf_link_hash_entry *h = NULL;
9326 const char *sym_name;
9328 if (r_symndx == STN_UNDEF)
9331 if (r_symndx >= locsymcount
9332 || (elf_bad_symtab (input_bfd)
9333 && finfo->sections[r_symndx] == NULL))
9335 h = sym_hashes[r_symndx - extsymoff];
9337 /* Badly formatted input files can contain relocs that
9338 reference non-existant symbols. Check here so that
9339 we do not seg fault. */
9344 sprintf_vma (buffer, rel->r_info);
9345 (*_bfd_error_handler)
9346 (_("error: %B contains a reloc (0x%s) for section %A "
9347 "that references a non-existent global symbol"),
9348 input_bfd, o, buffer);
9349 bfd_set_error (bfd_error_bad_value);
9353 while (h->root.type == bfd_link_hash_indirect
9354 || h->root.type == bfd_link_hash_warning)
9355 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9360 if (h->root.type == bfd_link_hash_defined
9361 || h->root.type == bfd_link_hash_defweak)
9362 ps = &h->root.u.def.section;
9364 sym_name = h->root.root.string;
9368 Elf_Internal_Sym *sym = isymbuf + r_symndx;
9370 s_type = ELF_ST_TYPE (sym->st_info);
9371 ps = &finfo->sections[r_symndx];
9372 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9376 if ((s_type == STT_RELC || s_type == STT_SRELC)
9377 && !finfo->info->relocatable)
9380 bfd_vma dot = (rel->r_offset
9381 + o->output_offset + o->output_section->vma);
9383 printf ("Encountered a complex symbol!");
9384 printf (" (input_bfd %s, section %s, reloc %ld\n",
9385 input_bfd->filename, o->name, rel - internal_relocs);
9386 printf (" symbol: idx %8.8lx, name %s\n",
9387 r_symndx, sym_name);
9388 printf (" reloc : info %8.8lx, addr %8.8lx\n",
9389 (unsigned long) rel->r_info,
9390 (unsigned long) rel->r_offset);
9392 if (!eval_symbol (&val, &sym_name, input_bfd, finfo, dot,
9393 isymbuf, locsymcount, s_type == STT_SRELC))
9396 /* Symbol evaluated OK. Update to absolute value. */
9397 set_symbol_value (input_bfd, isymbuf, locsymcount,
9402 if (action_discarded != -1 && ps != NULL)
9404 /* Complain if the definition comes from a
9405 discarded section. */
9406 if ((sec = *ps) != NULL && elf_discarded_section (sec))
9408 BFD_ASSERT (r_symndx != 0);
9409 if (action_discarded & COMPLAIN)
9410 (*finfo->info->callbacks->einfo)
9411 (_("%X`%s' referenced in section `%A' of %B: "
9412 "defined in discarded section `%A' of %B\n"),
9413 sym_name, o, input_bfd, sec, sec->owner);
9415 /* Try to do the best we can to support buggy old
9416 versions of gcc. Pretend that the symbol is
9417 really defined in the kept linkonce section.
9418 FIXME: This is quite broken. Modifying the
9419 symbol here means we will be changing all later
9420 uses of the symbol, not just in this section. */
9421 if (action_discarded & PRETEND)
9425 kept = _bfd_elf_check_kept_section (sec,
9437 /* Relocate the section by invoking a back end routine.
9439 The back end routine is responsible for adjusting the
9440 section contents as necessary, and (if using Rela relocs
9441 and generating a relocatable output file) adjusting the
9442 reloc addend as necessary.
9444 The back end routine does not have to worry about setting
9445 the reloc address or the reloc symbol index.
9447 The back end routine is given a pointer to the swapped in
9448 internal symbols, and can access the hash table entries
9449 for the external symbols via elf_sym_hashes (input_bfd).
9451 When generating relocatable output, the back end routine
9452 must handle STB_LOCAL/STT_SECTION symbols specially. The
9453 output symbol is going to be a section symbol
9454 corresponding to the output section, which will require
9455 the addend to be adjusted. */
9457 ret = (*relocate_section) (output_bfd, finfo->info,
9458 input_bfd, o, contents,
9466 || finfo->info->relocatable
9467 || finfo->info->emitrelocations)
9469 Elf_Internal_Rela *irela;
9470 Elf_Internal_Rela *irelaend;
9471 bfd_vma last_offset;
9472 struct elf_link_hash_entry **rel_hash;
9473 struct elf_link_hash_entry **rel_hash_list;
9474 Elf_Internal_Shdr *input_rel_hdr, *input_rel_hdr2;
9475 unsigned int next_erel;
9476 bfd_boolean rela_normal;
9478 input_rel_hdr = &elf_section_data (o)->rel_hdr;
9479 rela_normal = (bed->rela_normal
9480 && (input_rel_hdr->sh_entsize
9481 == bed->s->sizeof_rela));
9483 /* Adjust the reloc addresses and symbol indices. */
9485 irela = internal_relocs;
9486 irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9487 rel_hash = (elf_section_data (o->output_section)->rel_hashes
9488 + elf_section_data (o->output_section)->rel_count
9489 + elf_section_data (o->output_section)->rel_count2);
9490 rel_hash_list = rel_hash;
9491 last_offset = o->output_offset;
9492 if (!finfo->info->relocatable)
9493 last_offset += o->output_section->vma;
9494 for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9496 unsigned long r_symndx;
9498 Elf_Internal_Sym sym;
9500 if (next_erel == bed->s->int_rels_per_ext_rel)
9506 irela->r_offset = _bfd_elf_section_offset (output_bfd,
9509 if (irela->r_offset >= (bfd_vma) -2)
9511 /* This is a reloc for a deleted entry or somesuch.
9512 Turn it into an R_*_NONE reloc, at the same
9513 offset as the last reloc. elf_eh_frame.c and
9514 bfd_elf_discard_info rely on reloc offsets
9516 irela->r_offset = last_offset;
9518 irela->r_addend = 0;
9522 irela->r_offset += o->output_offset;
9524 /* Relocs in an executable have to be virtual addresses. */
9525 if (!finfo->info->relocatable)
9526 irela->r_offset += o->output_section->vma;
9528 last_offset = irela->r_offset;
9530 r_symndx = irela->r_info >> r_sym_shift;
9531 if (r_symndx == STN_UNDEF)
9534 if (r_symndx >= locsymcount
9535 || (elf_bad_symtab (input_bfd)
9536 && finfo->sections[r_symndx] == NULL))
9538 struct elf_link_hash_entry *rh;
9541 /* This is a reloc against a global symbol. We
9542 have not yet output all the local symbols, so
9543 we do not know the symbol index of any global
9544 symbol. We set the rel_hash entry for this
9545 reloc to point to the global hash table entry
9546 for this symbol. The symbol index is then
9547 set at the end of bfd_elf_final_link. */
9548 indx = r_symndx - extsymoff;
9549 rh = elf_sym_hashes (input_bfd)[indx];
9550 while (rh->root.type == bfd_link_hash_indirect
9551 || rh->root.type == bfd_link_hash_warning)
9552 rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
9554 /* Setting the index to -2 tells
9555 elf_link_output_extsym that this symbol is
9557 BFD_ASSERT (rh->indx < 0);
9565 /* This is a reloc against a local symbol. */
9568 sym = isymbuf[r_symndx];
9569 sec = finfo->sections[r_symndx];
9570 if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
9572 /* I suppose the backend ought to fill in the
9573 section of any STT_SECTION symbol against a
9574 processor specific section. */
9576 if (bfd_is_abs_section (sec))
9578 else if (sec == NULL || sec->owner == NULL)
9580 bfd_set_error (bfd_error_bad_value);
9585 asection *osec = sec->output_section;
9587 /* If we have discarded a section, the output
9588 section will be the absolute section. In
9589 case of discarded SEC_MERGE sections, use
9590 the kept section. relocate_section should
9591 have already handled discarded linkonce
9593 if (bfd_is_abs_section (osec)
9594 && sec->kept_section != NULL
9595 && sec->kept_section->output_section != NULL)
9597 osec = sec->kept_section->output_section;
9598 irela->r_addend -= osec->vma;
9601 if (!bfd_is_abs_section (osec))
9603 r_symndx = osec->target_index;
9606 struct elf_link_hash_table *htab;
9609 htab = elf_hash_table (finfo->info);
9610 oi = htab->text_index_section;
9611 if ((osec->flags & SEC_READONLY) == 0
9612 && htab->data_index_section != NULL)
9613 oi = htab->data_index_section;
9617 irela->r_addend += osec->vma - oi->vma;
9618 r_symndx = oi->target_index;
9622 BFD_ASSERT (r_symndx != 0);
9626 /* Adjust the addend according to where the
9627 section winds up in the output section. */
9629 irela->r_addend += sec->output_offset;
9633 if (finfo->indices[r_symndx] == -1)
9635 unsigned long shlink;
9640 if (finfo->info->strip == strip_all)
9642 /* You can't do ld -r -s. */
9643 bfd_set_error (bfd_error_invalid_operation);
9647 /* This symbol was skipped earlier, but
9648 since it is needed by a reloc, we
9649 must output it now. */
9650 shlink = symtab_hdr->sh_link;
9651 name = (bfd_elf_string_from_elf_section
9652 (input_bfd, shlink, sym.st_name));
9656 osec = sec->output_section;
9658 _bfd_elf_section_from_bfd_section (output_bfd,
9660 if (sym.st_shndx == SHN_BAD)
9663 sym.st_value += sec->output_offset;
9664 if (! finfo->info->relocatable)
9666 sym.st_value += osec->vma;
9667 if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
9669 /* STT_TLS symbols are relative to PT_TLS
9671 BFD_ASSERT (elf_hash_table (finfo->info)
9673 sym.st_value -= (elf_hash_table (finfo->info)
9678 indx = bfd_get_symcount (output_bfd);
9679 ret = elf_link_output_sym (finfo, name, &sym, sec,
9684 finfo->indices[r_symndx] = indx;
9689 r_symndx = finfo->indices[r_symndx];
9692 irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
9693 | (irela->r_info & r_type_mask));
9696 /* Swap out the relocs. */
9697 if (input_rel_hdr->sh_size != 0
9698 && !bed->elf_backend_emit_relocs (output_bfd, o,
9704 input_rel_hdr2 = elf_section_data (o)->rel_hdr2;
9705 if (input_rel_hdr2 && input_rel_hdr2->sh_size != 0)
9707 internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
9708 * bed->s->int_rels_per_ext_rel);
9709 rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
9710 if (!bed->elf_backend_emit_relocs (output_bfd, o,
9719 /* Write out the modified section contents. */
9720 if (bed->elf_backend_write_section
9721 && (*bed->elf_backend_write_section) (output_bfd, finfo->info, o,
9724 /* Section written out. */
9726 else switch (o->sec_info_type)
9728 case ELF_INFO_TYPE_STABS:
9729 if (! (_bfd_write_section_stabs
9731 &elf_hash_table (finfo->info)->stab_info,
9732 o, &elf_section_data (o)->sec_info, contents)))
9735 case ELF_INFO_TYPE_MERGE:
9736 if (! _bfd_write_merged_section (output_bfd, o,
9737 elf_section_data (o)->sec_info))
9740 case ELF_INFO_TYPE_EH_FRAME:
9742 if (! _bfd_elf_write_section_eh_frame (output_bfd, finfo->info,
9749 /* FIXME: octets_per_byte. */
9750 if (! (o->flags & SEC_EXCLUDE)
9751 && ! (o->output_section->flags & SEC_NEVER_LOAD)
9752 && ! bfd_set_section_contents (output_bfd, o->output_section,
9754 (file_ptr) o->output_offset,
9765 /* Generate a reloc when linking an ELF file. This is a reloc
9766 requested by the linker, and does not come from any input file. This
9767 is used to build constructor and destructor tables when linking
9771 elf_reloc_link_order (bfd *output_bfd,
9772 struct bfd_link_info *info,
9773 asection *output_section,
9774 struct bfd_link_order *link_order)
9776 reloc_howto_type *howto;
9780 struct elf_link_hash_entry **rel_hash_ptr;
9781 Elf_Internal_Shdr *rel_hdr;
9782 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9783 Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
9787 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
9790 bfd_set_error (bfd_error_bad_value);
9794 addend = link_order->u.reloc.p->addend;
9796 /* Figure out the symbol index. */
9797 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
9798 + elf_section_data (output_section)->rel_count
9799 + elf_section_data (output_section)->rel_count2);
9800 if (link_order->type == bfd_section_reloc_link_order)
9802 indx = link_order->u.reloc.p->u.section->target_index;
9803 BFD_ASSERT (indx != 0);
9804 *rel_hash_ptr = NULL;
9808 struct elf_link_hash_entry *h;
9810 /* Treat a reloc against a defined symbol as though it were
9811 actually against the section. */
9812 h = ((struct elf_link_hash_entry *)
9813 bfd_wrapped_link_hash_lookup (output_bfd, info,
9814 link_order->u.reloc.p->u.name,
9815 FALSE, FALSE, TRUE));
9817 && (h->root.type == bfd_link_hash_defined
9818 || h->root.type == bfd_link_hash_defweak))
9822 section = h->root.u.def.section;
9823 indx = section->output_section->target_index;
9824 *rel_hash_ptr = NULL;
9825 /* It seems that we ought to add the symbol value to the
9826 addend here, but in practice it has already been added
9827 because it was passed to constructor_callback. */
9828 addend += section->output_section->vma + section->output_offset;
9832 /* Setting the index to -2 tells elf_link_output_extsym that
9833 this symbol is used by a reloc. */
9840 if (! ((*info->callbacks->unattached_reloc)
9841 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
9847 /* If this is an inplace reloc, we must write the addend into the
9849 if (howto->partial_inplace && addend != 0)
9852 bfd_reloc_status_type rstat;
9855 const char *sym_name;
9857 size = (bfd_size_type) bfd_get_reloc_size (howto);
9858 buf = (bfd_byte *) bfd_zmalloc (size);
9861 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
9868 case bfd_reloc_outofrange:
9871 case bfd_reloc_overflow:
9872 if (link_order->type == bfd_section_reloc_link_order)
9873 sym_name = bfd_section_name (output_bfd,
9874 link_order->u.reloc.p->u.section);
9876 sym_name = link_order->u.reloc.p->u.name;
9877 if (! ((*info->callbacks->reloc_overflow)
9878 (info, NULL, sym_name, howto->name, addend, NULL,
9879 NULL, (bfd_vma) 0)))
9886 ok = bfd_set_section_contents (output_bfd, output_section, buf,
9887 link_order->offset, size);
9893 /* The address of a reloc is relative to the section in a
9894 relocatable file, and is a virtual address in an executable
9896 offset = link_order->offset;
9897 if (! info->relocatable)
9898 offset += output_section->vma;
9900 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
9902 irel[i].r_offset = offset;
9904 irel[i].r_addend = 0;
9906 if (bed->s->arch_size == 32)
9907 irel[0].r_info = ELF32_R_INFO (indx, howto->type);
9909 irel[0].r_info = ELF64_R_INFO (indx, howto->type);
9911 rel_hdr = &elf_section_data (output_section)->rel_hdr;
9912 erel = rel_hdr->contents;
9913 if (rel_hdr->sh_type == SHT_REL)
9915 erel += (elf_section_data (output_section)->rel_count
9916 * bed->s->sizeof_rel);
9917 (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
9921 irel[0].r_addend = addend;
9922 erel += (elf_section_data (output_section)->rel_count
9923 * bed->s->sizeof_rela);
9924 (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
9927 ++elf_section_data (output_section)->rel_count;
9933 /* Get the output vma of the section pointed to by the sh_link field. */
9936 elf_get_linked_section_vma (struct bfd_link_order *p)
9938 Elf_Internal_Shdr **elf_shdrp;
9942 s = p->u.indirect.section;
9943 elf_shdrp = elf_elfsections (s->owner);
9944 elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
9945 elfsec = elf_shdrp[elfsec]->sh_link;
9947 The Intel C compiler generates SHT_IA_64_UNWIND with
9948 SHF_LINK_ORDER. But it doesn't set the sh_link or
9949 sh_info fields. Hence we could get the situation
9950 where elfsec is 0. */
9953 const struct elf_backend_data *bed
9954 = get_elf_backend_data (s->owner);
9955 if (bed->link_order_error_handler)
9956 bed->link_order_error_handler
9957 (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
9962 s = elf_shdrp[elfsec]->bfd_section;
9963 return s->output_section->vma + s->output_offset;
9968 /* Compare two sections based on the locations of the sections they are
9969 linked to. Used by elf_fixup_link_order. */
9972 compare_link_order (const void * a, const void * b)
9977 apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
9978 bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
9985 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
9986 order as their linked sections. Returns false if this could not be done
9987 because an output section includes both ordered and unordered
9988 sections. Ideally we'd do this in the linker proper. */
9991 elf_fixup_link_order (bfd *abfd, asection *o)
9996 struct bfd_link_order *p;
9998 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10000 struct bfd_link_order **sections;
10001 asection *s, *other_sec, *linkorder_sec;
10005 linkorder_sec = NULL;
10007 seen_linkorder = 0;
10008 for (p = o->map_head.link_order; p != NULL; p = p->next)
10010 if (p->type == bfd_indirect_link_order)
10012 s = p->u.indirect.section;
10014 if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10015 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10016 && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10017 && elfsec < elf_numsections (sub)
10018 && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10019 && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10033 if (seen_other && seen_linkorder)
10035 if (other_sec && linkorder_sec)
10036 (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10038 linkorder_sec->owner, other_sec,
10041 (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10043 bfd_set_error (bfd_error_bad_value);
10048 if (!seen_linkorder)
10051 sections = (struct bfd_link_order **)
10052 bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10053 if (sections == NULL)
10055 seen_linkorder = 0;
10057 for (p = o->map_head.link_order; p != NULL; p = p->next)
10059 sections[seen_linkorder++] = p;
10061 /* Sort the input sections in the order of their linked section. */
10062 qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10063 compare_link_order);
10065 /* Change the offsets of the sections. */
10067 for (n = 0; n < seen_linkorder; n++)
10069 s = sections[n]->u.indirect.section;
10070 offset &= ~(bfd_vma) 0 << s->alignment_power;
10071 s->output_offset = offset;
10072 sections[n]->offset = offset;
10073 /* FIXME: octets_per_byte. */
10074 offset += sections[n]->size;
10082 /* Do the final step of an ELF link. */
10085 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10087 bfd_boolean dynamic;
10088 bfd_boolean emit_relocs;
10090 struct elf_final_link_info finfo;
10091 register asection *o;
10092 register struct bfd_link_order *p;
10094 bfd_size_type max_contents_size;
10095 bfd_size_type max_external_reloc_size;
10096 bfd_size_type max_internal_reloc_count;
10097 bfd_size_type max_sym_count;
10098 bfd_size_type max_sym_shndx_count;
10100 Elf_Internal_Sym elfsym;
10102 Elf_Internal_Shdr *symtab_hdr;
10103 Elf_Internal_Shdr *symtab_shndx_hdr;
10104 Elf_Internal_Shdr *symstrtab_hdr;
10105 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10106 struct elf_outext_info eoinfo;
10107 bfd_boolean merged;
10108 size_t relativecount = 0;
10109 asection *reldyn = 0;
10111 asection *attr_section = NULL;
10112 bfd_vma attr_size = 0;
10113 const char *std_attrs_section;
10115 if (! is_elf_hash_table (info->hash))
10119 abfd->flags |= DYNAMIC;
10121 dynamic = elf_hash_table (info)->dynamic_sections_created;
10122 dynobj = elf_hash_table (info)->dynobj;
10124 emit_relocs = (info->relocatable
10125 || info->emitrelocations);
10128 finfo.output_bfd = abfd;
10129 finfo.symstrtab = _bfd_elf_stringtab_init ();
10130 if (finfo.symstrtab == NULL)
10135 finfo.dynsym_sec = NULL;
10136 finfo.hash_sec = NULL;
10137 finfo.symver_sec = NULL;
10141 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
10142 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
10143 BFD_ASSERT (finfo.dynsym_sec != NULL);
10144 finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
10145 /* Note that it is OK if symver_sec is NULL. */
10148 finfo.contents = NULL;
10149 finfo.external_relocs = NULL;
10150 finfo.internal_relocs = NULL;
10151 finfo.external_syms = NULL;
10152 finfo.locsym_shndx = NULL;
10153 finfo.internal_syms = NULL;
10154 finfo.indices = NULL;
10155 finfo.sections = NULL;
10156 finfo.symbuf = NULL;
10157 finfo.symshndxbuf = NULL;
10158 finfo.symbuf_count = 0;
10159 finfo.shndxbuf_size = 0;
10161 /* The object attributes have been merged. Remove the input
10162 sections from the link, and set the contents of the output
10164 std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10165 for (o = abfd->sections; o != NULL; o = o->next)
10167 if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10168 || strcmp (o->name, ".gnu.attributes") == 0)
10170 for (p = o->map_head.link_order; p != NULL; p = p->next)
10172 asection *input_section;
10174 if (p->type != bfd_indirect_link_order)
10176 input_section = p->u.indirect.section;
10177 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10178 elf_link_input_bfd ignores this section. */
10179 input_section->flags &= ~SEC_HAS_CONTENTS;
10182 attr_size = bfd_elf_obj_attr_size (abfd);
10185 bfd_set_section_size (abfd, o, attr_size);
10187 /* Skip this section later on. */
10188 o->map_head.link_order = NULL;
10191 o->flags |= SEC_EXCLUDE;
10195 /* Count up the number of relocations we will output for each output
10196 section, so that we know the sizes of the reloc sections. We
10197 also figure out some maximum sizes. */
10198 max_contents_size = 0;
10199 max_external_reloc_size = 0;
10200 max_internal_reloc_count = 0;
10202 max_sym_shndx_count = 0;
10204 for (o = abfd->sections; o != NULL; o = o->next)
10206 struct bfd_elf_section_data *esdo = elf_section_data (o);
10207 o->reloc_count = 0;
10209 for (p = o->map_head.link_order; p != NULL; p = p->next)
10211 unsigned int reloc_count = 0;
10212 struct bfd_elf_section_data *esdi = NULL;
10213 unsigned int *rel_count1;
10215 if (p->type == bfd_section_reloc_link_order
10216 || p->type == bfd_symbol_reloc_link_order)
10218 else if (p->type == bfd_indirect_link_order)
10222 sec = p->u.indirect.section;
10223 esdi = elf_section_data (sec);
10225 /* Mark all sections which are to be included in the
10226 link. This will normally be every section. We need
10227 to do this so that we can identify any sections which
10228 the linker has decided to not include. */
10229 sec->linker_mark = TRUE;
10231 if (sec->flags & SEC_MERGE)
10234 if (info->relocatable || info->emitrelocations)
10235 reloc_count = sec->reloc_count;
10236 else if (bed->elf_backend_count_relocs)
10237 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10239 if (sec->rawsize > max_contents_size)
10240 max_contents_size = sec->rawsize;
10241 if (sec->size > max_contents_size)
10242 max_contents_size = sec->size;
10244 /* We are interested in just local symbols, not all
10246 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10247 && (sec->owner->flags & DYNAMIC) == 0)
10251 if (elf_bad_symtab (sec->owner))
10252 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10253 / bed->s->sizeof_sym);
10255 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10257 if (sym_count > max_sym_count)
10258 max_sym_count = sym_count;
10260 if (sym_count > max_sym_shndx_count
10261 && elf_symtab_shndx (sec->owner) != 0)
10262 max_sym_shndx_count = sym_count;
10264 if ((sec->flags & SEC_RELOC) != 0)
10268 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
10269 if (ext_size > max_external_reloc_size)
10270 max_external_reloc_size = ext_size;
10271 if (sec->reloc_count > max_internal_reloc_count)
10272 max_internal_reloc_count = sec->reloc_count;
10277 if (reloc_count == 0)
10280 o->reloc_count += reloc_count;
10282 /* MIPS may have a mix of REL and RELA relocs on sections.
10283 To support this curious ABI we keep reloc counts in
10284 elf_section_data too. We must be careful to add the
10285 relocations from the input section to the right output
10286 count. FIXME: Get rid of one count. We have
10287 o->reloc_count == esdo->rel_count + esdo->rel_count2. */
10288 rel_count1 = &esdo->rel_count;
10291 bfd_boolean same_size;
10292 bfd_size_type entsize1;
10294 entsize1 = esdi->rel_hdr.sh_entsize;
10295 /* PR 9827: If the header size has not been set yet then
10296 assume that it will match the output section's reloc type. */
10298 entsize1 = o->use_rela_p ? bed->s->sizeof_rela : bed->s->sizeof_rel;
10300 BFD_ASSERT (entsize1 == bed->s->sizeof_rel
10301 || entsize1 == bed->s->sizeof_rela);
10302 same_size = !o->use_rela_p == (entsize1 == bed->s->sizeof_rel);
10305 rel_count1 = &esdo->rel_count2;
10307 if (esdi->rel_hdr2 != NULL)
10309 bfd_size_type entsize2 = esdi->rel_hdr2->sh_entsize;
10310 unsigned int alt_count;
10311 unsigned int *rel_count2;
10313 BFD_ASSERT (entsize2 != entsize1
10314 && (entsize2 == bed->s->sizeof_rel
10315 || entsize2 == bed->s->sizeof_rela));
10317 rel_count2 = &esdo->rel_count2;
10319 rel_count2 = &esdo->rel_count;
10321 /* The following is probably too simplistic if the
10322 backend counts output relocs unusually. */
10323 BFD_ASSERT (bed->elf_backend_count_relocs == NULL);
10324 alt_count = NUM_SHDR_ENTRIES (esdi->rel_hdr2);
10325 *rel_count2 += alt_count;
10326 reloc_count -= alt_count;
10329 *rel_count1 += reloc_count;
10332 if (o->reloc_count > 0)
10333 o->flags |= SEC_RELOC;
10336 /* Explicitly clear the SEC_RELOC flag. The linker tends to
10337 set it (this is probably a bug) and if it is set
10338 assign_section_numbers will create a reloc section. */
10339 o->flags &=~ SEC_RELOC;
10342 /* If the SEC_ALLOC flag is not set, force the section VMA to
10343 zero. This is done in elf_fake_sections as well, but forcing
10344 the VMA to 0 here will ensure that relocs against these
10345 sections are handled correctly. */
10346 if ((o->flags & SEC_ALLOC) == 0
10347 && ! o->user_set_vma)
10351 if (! info->relocatable && merged)
10352 elf_link_hash_traverse (elf_hash_table (info),
10353 _bfd_elf_link_sec_merge_syms, abfd);
10355 /* Figure out the file positions for everything but the symbol table
10356 and the relocs. We set symcount to force assign_section_numbers
10357 to create a symbol table. */
10358 bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
10359 BFD_ASSERT (! abfd->output_has_begun);
10360 if (! _bfd_elf_compute_section_file_positions (abfd, info))
10363 /* Set sizes, and assign file positions for reloc sections. */
10364 for (o = abfd->sections; o != NULL; o = o->next)
10366 if ((o->flags & SEC_RELOC) != 0)
10368 if (!(_bfd_elf_link_size_reloc_section
10369 (abfd, &elf_section_data (o)->rel_hdr, o)))
10372 if (elf_section_data (o)->rel_hdr2
10373 && !(_bfd_elf_link_size_reloc_section
10374 (abfd, elf_section_data (o)->rel_hdr2, o)))
10378 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10379 to count upwards while actually outputting the relocations. */
10380 elf_section_data (o)->rel_count = 0;
10381 elf_section_data (o)->rel_count2 = 0;
10384 _bfd_elf_assign_file_positions_for_relocs (abfd);
10386 /* We have now assigned file positions for all the sections except
10387 .symtab and .strtab. We start the .symtab section at the current
10388 file position, and write directly to it. We build the .strtab
10389 section in memory. */
10390 bfd_get_symcount (abfd) = 0;
10391 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10392 /* sh_name is set in prep_headers. */
10393 symtab_hdr->sh_type = SHT_SYMTAB;
10394 /* sh_flags, sh_addr and sh_size all start off zero. */
10395 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10396 /* sh_link is set in assign_section_numbers. */
10397 /* sh_info is set below. */
10398 /* sh_offset is set just below. */
10399 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10401 off = elf_tdata (abfd)->next_file_pos;
10402 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10404 /* Note that at this point elf_tdata (abfd)->next_file_pos is
10405 incorrect. We do not yet know the size of the .symtab section.
10406 We correct next_file_pos below, after we do know the size. */
10408 /* Allocate a buffer to hold swapped out symbols. This is to avoid
10409 continuously seeking to the right position in the file. */
10410 if (! info->keep_memory || max_sym_count < 20)
10411 finfo.symbuf_size = 20;
10413 finfo.symbuf_size = max_sym_count;
10414 amt = finfo.symbuf_size;
10415 amt *= bed->s->sizeof_sym;
10416 finfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10417 if (finfo.symbuf == NULL)
10419 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10421 /* Wild guess at number of output symbols. realloc'd as needed. */
10422 amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10423 finfo.shndxbuf_size = amt;
10424 amt *= sizeof (Elf_External_Sym_Shndx);
10425 finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10426 if (finfo.symshndxbuf == NULL)
10430 /* Start writing out the symbol table. The first symbol is always a
10432 if (info->strip != strip_all
10435 elfsym.st_value = 0;
10436 elfsym.st_size = 0;
10437 elfsym.st_info = 0;
10438 elfsym.st_other = 0;
10439 elfsym.st_shndx = SHN_UNDEF;
10440 if (elf_link_output_sym (&finfo, NULL, &elfsym, bfd_und_section_ptr,
10445 /* Output a symbol for each section. We output these even if we are
10446 discarding local symbols, since they are used for relocs. These
10447 symbols have no names. We store the index of each one in the
10448 index field of the section, so that we can find it again when
10449 outputting relocs. */
10450 if (info->strip != strip_all
10453 elfsym.st_size = 0;
10454 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10455 elfsym.st_other = 0;
10456 elfsym.st_value = 0;
10457 for (i = 1; i < elf_numsections (abfd); i++)
10459 o = bfd_section_from_elf_index (abfd, i);
10462 o->target_index = bfd_get_symcount (abfd);
10463 elfsym.st_shndx = i;
10464 if (!info->relocatable)
10465 elfsym.st_value = o->vma;
10466 if (elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL) != 1)
10472 /* Allocate some memory to hold information read in from the input
10474 if (max_contents_size != 0)
10476 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10477 if (finfo.contents == NULL)
10481 if (max_external_reloc_size != 0)
10483 finfo.external_relocs = bfd_malloc (max_external_reloc_size);
10484 if (finfo.external_relocs == NULL)
10488 if (max_internal_reloc_count != 0)
10490 amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10491 amt *= sizeof (Elf_Internal_Rela);
10492 finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10493 if (finfo.internal_relocs == NULL)
10497 if (max_sym_count != 0)
10499 amt = max_sym_count * bed->s->sizeof_sym;
10500 finfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10501 if (finfo.external_syms == NULL)
10504 amt = max_sym_count * sizeof (Elf_Internal_Sym);
10505 finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
10506 if (finfo.internal_syms == NULL)
10509 amt = max_sym_count * sizeof (long);
10510 finfo.indices = (long int *) bfd_malloc (amt);
10511 if (finfo.indices == NULL)
10514 amt = max_sym_count * sizeof (asection *);
10515 finfo.sections = (asection **) bfd_malloc (amt);
10516 if (finfo.sections == NULL)
10520 if (max_sym_shndx_count != 0)
10522 amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
10523 finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
10524 if (finfo.locsym_shndx == NULL)
10528 if (elf_hash_table (info)->tls_sec)
10530 bfd_vma base, end = 0;
10533 for (sec = elf_hash_table (info)->tls_sec;
10534 sec && (sec->flags & SEC_THREAD_LOCAL);
10537 bfd_size_type size = sec->size;
10540 && (sec->flags & SEC_HAS_CONTENTS) == 0)
10542 struct bfd_link_order *o = sec->map_tail.link_order;
10544 size = o->offset + o->size;
10546 end = sec->vma + size;
10548 base = elf_hash_table (info)->tls_sec->vma;
10549 end = align_power (end, elf_hash_table (info)->tls_sec->alignment_power);
10550 elf_hash_table (info)->tls_size = end - base;
10553 /* Reorder SHF_LINK_ORDER sections. */
10554 for (o = abfd->sections; o != NULL; o = o->next)
10556 if (!elf_fixup_link_order (abfd, o))
10560 /* Since ELF permits relocations to be against local symbols, we
10561 must have the local symbols available when we do the relocations.
10562 Since we would rather only read the local symbols once, and we
10563 would rather not keep them in memory, we handle all the
10564 relocations for a single input file at the same time.
10566 Unfortunately, there is no way to know the total number of local
10567 symbols until we have seen all of them, and the local symbol
10568 indices precede the global symbol indices. This means that when
10569 we are generating relocatable output, and we see a reloc against
10570 a global symbol, we can not know the symbol index until we have
10571 finished examining all the local symbols to see which ones we are
10572 going to output. To deal with this, we keep the relocations in
10573 memory, and don't output them until the end of the link. This is
10574 an unfortunate waste of memory, but I don't see a good way around
10575 it. Fortunately, it only happens when performing a relocatable
10576 link, which is not the common case. FIXME: If keep_memory is set
10577 we could write the relocs out and then read them again; I don't
10578 know how bad the memory loss will be. */
10580 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10581 sub->output_has_begun = FALSE;
10582 for (o = abfd->sections; o != NULL; o = o->next)
10584 for (p = o->map_head.link_order; p != NULL; p = p->next)
10586 if (p->type == bfd_indirect_link_order
10587 && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
10588 == bfd_target_elf_flavour)
10589 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
10591 if (! sub->output_has_begun)
10593 if (! elf_link_input_bfd (&finfo, sub))
10595 sub->output_has_begun = TRUE;
10598 else if (p->type == bfd_section_reloc_link_order
10599 || p->type == bfd_symbol_reloc_link_order)
10601 if (! elf_reloc_link_order (abfd, info, o, p))
10606 if (! _bfd_default_link_order (abfd, info, o, p))
10612 /* Free symbol buffer if needed. */
10613 if (!info->reduce_memory_overheads)
10615 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10616 if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10617 && elf_tdata (sub)->symbuf)
10619 free (elf_tdata (sub)->symbuf);
10620 elf_tdata (sub)->symbuf = NULL;
10624 /* Output any global symbols that got converted to local in a
10625 version script or due to symbol visibility. We do this in a
10626 separate step since ELF requires all local symbols to appear
10627 prior to any global symbols. FIXME: We should only do this if
10628 some global symbols were, in fact, converted to become local.
10629 FIXME: Will this work correctly with the Irix 5 linker? */
10630 eoinfo.failed = FALSE;
10631 eoinfo.finfo = &finfo;
10632 eoinfo.localsyms = TRUE;
10633 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
10638 /* If backend needs to output some local symbols not present in the hash
10639 table, do it now. */
10640 if (bed->elf_backend_output_arch_local_syms)
10642 typedef int (*out_sym_func)
10643 (void *, const char *, Elf_Internal_Sym *, asection *,
10644 struct elf_link_hash_entry *);
10646 if (! ((*bed->elf_backend_output_arch_local_syms)
10647 (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10651 /* That wrote out all the local symbols. Finish up the symbol table
10652 with the global symbols. Even if we want to strip everything we
10653 can, we still need to deal with those global symbols that got
10654 converted to local in a version script. */
10656 /* The sh_info field records the index of the first non local symbol. */
10657 symtab_hdr->sh_info = bfd_get_symcount (abfd);
10660 && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
10662 Elf_Internal_Sym sym;
10663 bfd_byte *dynsym = finfo.dynsym_sec->contents;
10664 long last_local = 0;
10666 /* Write out the section symbols for the output sections. */
10667 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
10673 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10676 for (s = abfd->sections; s != NULL; s = s->next)
10682 dynindx = elf_section_data (s)->dynindx;
10685 indx = elf_section_data (s)->this_idx;
10686 BFD_ASSERT (indx > 0);
10687 sym.st_shndx = indx;
10688 if (! check_dynsym (abfd, &sym))
10690 sym.st_value = s->vma;
10691 dest = dynsym + dynindx * bed->s->sizeof_sym;
10692 if (last_local < dynindx)
10693 last_local = dynindx;
10694 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10698 /* Write out the local dynsyms. */
10699 if (elf_hash_table (info)->dynlocal)
10701 struct elf_link_local_dynamic_entry *e;
10702 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
10707 sym.st_size = e->isym.st_size;
10708 sym.st_other = e->isym.st_other;
10710 /* Copy the internal symbol as is.
10711 Note that we saved a word of storage and overwrote
10712 the original st_name with the dynstr_index. */
10715 s = bfd_section_from_elf_index (e->input_bfd,
10720 elf_section_data (s->output_section)->this_idx;
10721 if (! check_dynsym (abfd, &sym))
10723 sym.st_value = (s->output_section->vma
10725 + e->isym.st_value);
10728 if (last_local < e->dynindx)
10729 last_local = e->dynindx;
10731 dest = dynsym + e->dynindx * bed->s->sizeof_sym;
10732 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10736 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
10740 /* We get the global symbols from the hash table. */
10741 eoinfo.failed = FALSE;
10742 eoinfo.localsyms = FALSE;
10743 eoinfo.finfo = &finfo;
10744 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
10749 /* If backend needs to output some symbols not present in the hash
10750 table, do it now. */
10751 if (bed->elf_backend_output_arch_syms)
10753 typedef int (*out_sym_func)
10754 (void *, const char *, Elf_Internal_Sym *, asection *,
10755 struct elf_link_hash_entry *);
10757 if (! ((*bed->elf_backend_output_arch_syms)
10758 (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10762 /* Flush all symbols to the file. */
10763 if (! elf_link_flush_output_syms (&finfo, bed))
10766 /* Now we know the size of the symtab section. */
10767 off += symtab_hdr->sh_size;
10769 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
10770 if (symtab_shndx_hdr->sh_name != 0)
10772 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
10773 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
10774 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
10775 amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
10776 symtab_shndx_hdr->sh_size = amt;
10778 off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
10781 if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
10782 || (bfd_bwrite (finfo.symshndxbuf, amt, abfd) != amt))
10787 /* Finish up and write out the symbol string table (.strtab)
10789 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
10790 /* sh_name was set in prep_headers. */
10791 symstrtab_hdr->sh_type = SHT_STRTAB;
10792 symstrtab_hdr->sh_flags = 0;
10793 symstrtab_hdr->sh_addr = 0;
10794 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
10795 symstrtab_hdr->sh_entsize = 0;
10796 symstrtab_hdr->sh_link = 0;
10797 symstrtab_hdr->sh_info = 0;
10798 /* sh_offset is set just below. */
10799 symstrtab_hdr->sh_addralign = 1;
10801 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
10802 elf_tdata (abfd)->next_file_pos = off;
10804 if (bfd_get_symcount (abfd) > 0)
10806 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
10807 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
10811 /* Adjust the relocs to have the correct symbol indices. */
10812 for (o = abfd->sections; o != NULL; o = o->next)
10814 if ((o->flags & SEC_RELOC) == 0)
10817 elf_link_adjust_relocs (abfd, &elf_section_data (o)->rel_hdr,
10818 elf_section_data (o)->rel_count,
10819 elf_section_data (o)->rel_hashes);
10820 if (elf_section_data (o)->rel_hdr2 != NULL)
10821 elf_link_adjust_relocs (abfd, elf_section_data (o)->rel_hdr2,
10822 elf_section_data (o)->rel_count2,
10823 (elf_section_data (o)->rel_hashes
10824 + elf_section_data (o)->rel_count));
10826 /* Set the reloc_count field to 0 to prevent write_relocs from
10827 trying to swap the relocs out itself. */
10828 o->reloc_count = 0;
10831 if (dynamic && info->combreloc && dynobj != NULL)
10832 relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
10834 /* If we are linking against a dynamic object, or generating a
10835 shared library, finish up the dynamic linking information. */
10838 bfd_byte *dyncon, *dynconend;
10840 /* Fix up .dynamic entries. */
10841 o = bfd_get_section_by_name (dynobj, ".dynamic");
10842 BFD_ASSERT (o != NULL);
10844 dyncon = o->contents;
10845 dynconend = o->contents + o->size;
10846 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
10848 Elf_Internal_Dyn dyn;
10852 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
10859 if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
10861 switch (elf_section_data (reldyn)->this_hdr.sh_type)
10863 case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
10864 case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
10867 dyn.d_un.d_val = relativecount;
10874 name = info->init_function;
10877 name = info->fini_function;
10880 struct elf_link_hash_entry *h;
10882 h = elf_link_hash_lookup (elf_hash_table (info), name,
10883 FALSE, FALSE, TRUE);
10885 && (h->root.type == bfd_link_hash_defined
10886 || h->root.type == bfd_link_hash_defweak))
10888 dyn.d_un.d_ptr = h->root.u.def.value;
10889 o = h->root.u.def.section;
10890 if (o->output_section != NULL)
10891 dyn.d_un.d_ptr += (o->output_section->vma
10892 + o->output_offset);
10895 /* The symbol is imported from another shared
10896 library and does not apply to this one. */
10897 dyn.d_un.d_ptr = 0;
10904 case DT_PREINIT_ARRAYSZ:
10905 name = ".preinit_array";
10907 case DT_INIT_ARRAYSZ:
10908 name = ".init_array";
10910 case DT_FINI_ARRAYSZ:
10911 name = ".fini_array";
10913 o = bfd_get_section_by_name (abfd, name);
10916 (*_bfd_error_handler)
10917 (_("%B: could not find output section %s"), abfd, name);
10921 (*_bfd_error_handler)
10922 (_("warning: %s section has zero size"), name);
10923 dyn.d_un.d_val = o->size;
10926 case DT_PREINIT_ARRAY:
10927 name = ".preinit_array";
10929 case DT_INIT_ARRAY:
10930 name = ".init_array";
10932 case DT_FINI_ARRAY:
10933 name = ".fini_array";
10940 name = ".gnu.hash";
10949 name = ".gnu.version_d";
10952 name = ".gnu.version_r";
10955 name = ".gnu.version";
10957 o = bfd_get_section_by_name (abfd, name);
10960 (*_bfd_error_handler)
10961 (_("%B: could not find output section %s"), abfd, name);
10964 dyn.d_un.d_ptr = o->vma;
10971 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
10975 dyn.d_un.d_val = 0;
10976 dyn.d_un.d_ptr = 0;
10977 for (i = 1; i < elf_numsections (abfd); i++)
10979 Elf_Internal_Shdr *hdr;
10981 hdr = elf_elfsections (abfd)[i];
10982 if (hdr->sh_type == type
10983 && (hdr->sh_flags & SHF_ALLOC) != 0)
10985 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
10986 dyn.d_un.d_val += hdr->sh_size;
10989 if (dyn.d_un.d_ptr == 0
10990 || hdr->sh_addr < dyn.d_un.d_ptr)
10991 dyn.d_un.d_ptr = hdr->sh_addr;
10997 bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11001 /* If we have created any dynamic sections, then output them. */
11002 if (dynobj != NULL)
11004 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11007 /* Check for DT_TEXTREL (late, in case the backend removes it). */
11008 if (info->warn_shared_textrel && info->shared)
11010 bfd_byte *dyncon, *dynconend;
11012 /* Fix up .dynamic entries. */
11013 o = bfd_get_section_by_name (dynobj, ".dynamic");
11014 BFD_ASSERT (o != NULL);
11016 dyncon = o->contents;
11017 dynconend = o->contents + o->size;
11018 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11020 Elf_Internal_Dyn dyn;
11022 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11024 if (dyn.d_tag == DT_TEXTREL)
11026 info->callbacks->einfo
11027 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11033 for (o = dynobj->sections; o != NULL; o = o->next)
11035 if ((o->flags & SEC_HAS_CONTENTS) == 0
11037 || o->output_section == bfd_abs_section_ptr)
11039 if ((o->flags & SEC_LINKER_CREATED) == 0)
11041 /* At this point, we are only interested in sections
11042 created by _bfd_elf_link_create_dynamic_sections. */
11045 if (elf_hash_table (info)->stab_info.stabstr == o)
11047 if (elf_hash_table (info)->eh_info.hdr_sec == o)
11049 if ((elf_section_data (o->output_section)->this_hdr.sh_type
11051 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
11053 /* FIXME: octets_per_byte. */
11054 if (! bfd_set_section_contents (abfd, o->output_section,
11056 (file_ptr) o->output_offset,
11062 /* The contents of the .dynstr section are actually in a
11064 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11065 if (bfd_seek (abfd, off, SEEK_SET) != 0
11066 || ! _bfd_elf_strtab_emit (abfd,
11067 elf_hash_table (info)->dynstr))
11073 if (info->relocatable)
11075 bfd_boolean failed = FALSE;
11077 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11082 /* If we have optimized stabs strings, output them. */
11083 if (elf_hash_table (info)->stab_info.stabstr != NULL)
11085 if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11089 if (info->eh_frame_hdr)
11091 if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11095 if (finfo.symstrtab != NULL)
11096 _bfd_stringtab_free (finfo.symstrtab);
11097 if (finfo.contents != NULL)
11098 free (finfo.contents);
11099 if (finfo.external_relocs != NULL)
11100 free (finfo.external_relocs);
11101 if (finfo.internal_relocs != NULL)
11102 free (finfo.internal_relocs);
11103 if (finfo.external_syms != NULL)
11104 free (finfo.external_syms);
11105 if (finfo.locsym_shndx != NULL)
11106 free (finfo.locsym_shndx);
11107 if (finfo.internal_syms != NULL)
11108 free (finfo.internal_syms);
11109 if (finfo.indices != NULL)
11110 free (finfo.indices);
11111 if (finfo.sections != NULL)
11112 free (finfo.sections);
11113 if (finfo.symbuf != NULL)
11114 free (finfo.symbuf);
11115 if (finfo.symshndxbuf != NULL)
11116 free (finfo.symshndxbuf);
11117 for (o = abfd->sections; o != NULL; o = o->next)
11119 if ((o->flags & SEC_RELOC) != 0
11120 && elf_section_data (o)->rel_hashes != NULL)
11121 free (elf_section_data (o)->rel_hashes);
11124 elf_tdata (abfd)->linker = TRUE;
11128 bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11129 if (contents == NULL)
11130 return FALSE; /* Bail out and fail. */
11131 bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11132 bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11139 if (finfo.symstrtab != NULL)
11140 _bfd_stringtab_free (finfo.symstrtab);
11141 if (finfo.contents != NULL)
11142 free (finfo.contents);
11143 if (finfo.external_relocs != NULL)
11144 free (finfo.external_relocs);
11145 if (finfo.internal_relocs != NULL)
11146 free (finfo.internal_relocs);
11147 if (finfo.external_syms != NULL)
11148 free (finfo.external_syms);
11149 if (finfo.locsym_shndx != NULL)
11150 free (finfo.locsym_shndx);
11151 if (finfo.internal_syms != NULL)
11152 free (finfo.internal_syms);
11153 if (finfo.indices != NULL)
11154 free (finfo.indices);
11155 if (finfo.sections != NULL)
11156 free (finfo.sections);
11157 if (finfo.symbuf != NULL)
11158 free (finfo.symbuf);
11159 if (finfo.symshndxbuf != NULL)
11160 free (finfo.symshndxbuf);
11161 for (o = abfd->sections; o != NULL; o = o->next)
11163 if ((o->flags & SEC_RELOC) != 0
11164 && elf_section_data (o)->rel_hashes != NULL)
11165 free (elf_section_data (o)->rel_hashes);
11171 /* Initialize COOKIE for input bfd ABFD. */
11174 init_reloc_cookie (struct elf_reloc_cookie *cookie,
11175 struct bfd_link_info *info, bfd *abfd)
11177 Elf_Internal_Shdr *symtab_hdr;
11178 const struct elf_backend_data *bed;
11180 bed = get_elf_backend_data (abfd);
11181 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11183 cookie->abfd = abfd;
11184 cookie->sym_hashes = elf_sym_hashes (abfd);
11185 cookie->bad_symtab = elf_bad_symtab (abfd);
11186 if (cookie->bad_symtab)
11188 cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11189 cookie->extsymoff = 0;
11193 cookie->locsymcount = symtab_hdr->sh_info;
11194 cookie->extsymoff = symtab_hdr->sh_info;
11197 if (bed->s->arch_size == 32)
11198 cookie->r_sym_shift = 8;
11200 cookie->r_sym_shift = 32;
11202 cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11203 if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11205 cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11206 cookie->locsymcount, 0,
11208 if (cookie->locsyms == NULL)
11210 info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11213 if (info->keep_memory)
11214 symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11219 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
11222 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11224 Elf_Internal_Shdr *symtab_hdr;
11226 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11227 if (cookie->locsyms != NULL
11228 && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11229 free (cookie->locsyms);
11232 /* Initialize the relocation information in COOKIE for input section SEC
11233 of input bfd ABFD. */
11236 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11237 struct bfd_link_info *info, bfd *abfd,
11240 const struct elf_backend_data *bed;
11242 if (sec->reloc_count == 0)
11244 cookie->rels = NULL;
11245 cookie->relend = NULL;
11249 bed = get_elf_backend_data (abfd);
11251 cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11252 info->keep_memory);
11253 if (cookie->rels == NULL)
11255 cookie->rel = cookie->rels;
11256 cookie->relend = (cookie->rels
11257 + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11259 cookie->rel = cookie->rels;
11263 /* Free the memory allocated by init_reloc_cookie_rels,
11267 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11270 if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11271 free (cookie->rels);
11274 /* Initialize the whole of COOKIE for input section SEC. */
11277 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11278 struct bfd_link_info *info,
11281 if (!init_reloc_cookie (cookie, info, sec->owner))
11283 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11288 fini_reloc_cookie (cookie, sec->owner);
11293 /* Free the memory allocated by init_reloc_cookie_for_section,
11297 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11300 fini_reloc_cookie_rels (cookie, sec);
11301 fini_reloc_cookie (cookie, sec->owner);
11304 /* Garbage collect unused sections. */
11306 /* Default gc_mark_hook. */
11309 _bfd_elf_gc_mark_hook (asection *sec,
11310 struct bfd_link_info *info ATTRIBUTE_UNUSED,
11311 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11312 struct elf_link_hash_entry *h,
11313 Elf_Internal_Sym *sym)
11317 switch (h->root.type)
11319 case bfd_link_hash_defined:
11320 case bfd_link_hash_defweak:
11321 return h->root.u.def.section;
11323 case bfd_link_hash_common:
11324 return h->root.u.c.p->section;
11331 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11336 /* COOKIE->rel describes a relocation against section SEC, which is
11337 a section we've decided to keep. Return the section that contains
11338 the relocation symbol, or NULL if no section contains it. */
11341 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11342 elf_gc_mark_hook_fn gc_mark_hook,
11343 struct elf_reloc_cookie *cookie)
11345 unsigned long r_symndx;
11346 struct elf_link_hash_entry *h;
11348 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11352 if (r_symndx >= cookie->locsymcount
11353 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11355 h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11356 while (h->root.type == bfd_link_hash_indirect
11357 || h->root.type == bfd_link_hash_warning)
11358 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11359 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11362 return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11363 &cookie->locsyms[r_symndx]);
11366 /* COOKIE->rel describes a relocation against section SEC, which is
11367 a section we've decided to keep. Mark the section that contains
11368 the relocation symbol. */
11371 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11373 elf_gc_mark_hook_fn gc_mark_hook,
11374 struct elf_reloc_cookie *cookie)
11378 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11379 if (rsec && !rsec->gc_mark)
11381 if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour)
11383 else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11389 /* The mark phase of garbage collection. For a given section, mark
11390 it and any sections in this section's group, and all the sections
11391 which define symbols to which it refers. */
11394 _bfd_elf_gc_mark (struct bfd_link_info *info,
11396 elf_gc_mark_hook_fn gc_mark_hook)
11399 asection *group_sec, *eh_frame;
11403 /* Mark all the sections in the group. */
11404 group_sec = elf_section_data (sec)->next_in_group;
11405 if (group_sec && !group_sec->gc_mark)
11406 if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11409 /* Look through the section relocs. */
11411 eh_frame = elf_eh_frame_section (sec->owner);
11412 if ((sec->flags & SEC_RELOC) != 0
11413 && sec->reloc_count > 0
11414 && sec != eh_frame)
11416 struct elf_reloc_cookie cookie;
11418 if (!init_reloc_cookie_for_section (&cookie, info, sec))
11422 for (; cookie.rel < cookie.relend; cookie.rel++)
11423 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11428 fini_reloc_cookie_for_section (&cookie, sec);
11432 if (ret && eh_frame && elf_fde_list (sec))
11434 struct elf_reloc_cookie cookie;
11436 if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11440 if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11441 gc_mark_hook, &cookie))
11443 fini_reloc_cookie_for_section (&cookie, eh_frame);
11450 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
11452 struct elf_gc_sweep_symbol_info
11454 struct bfd_link_info *info;
11455 void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
11460 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
11462 if (h->root.type == bfd_link_hash_warning)
11463 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11465 if ((h->root.type == bfd_link_hash_defined
11466 || h->root.type == bfd_link_hash_defweak)
11467 && !h->root.u.def.section->gc_mark
11468 && !(h->root.u.def.section->owner->flags & DYNAMIC))
11470 struct elf_gc_sweep_symbol_info *inf =
11471 (struct elf_gc_sweep_symbol_info *) data;
11472 (*inf->hide_symbol) (inf->info, h, TRUE);
11478 /* The sweep phase of garbage collection. Remove all garbage sections. */
11480 typedef bfd_boolean (*gc_sweep_hook_fn)
11481 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
11484 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
11487 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11488 gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
11489 unsigned long section_sym_count;
11490 struct elf_gc_sweep_symbol_info sweep_info;
11492 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11496 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
11499 for (o = sub->sections; o != NULL; o = o->next)
11501 /* When any section in a section group is kept, we keep all
11502 sections in the section group. If the first member of
11503 the section group is excluded, we will also exclude the
11505 if (o->flags & SEC_GROUP)
11507 asection *first = elf_next_in_group (o);
11508 o->gc_mark = first->gc_mark;
11510 else if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
11511 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
11513 /* Keep debug and special sections. */
11520 /* Skip sweeping sections already excluded. */
11521 if (o->flags & SEC_EXCLUDE)
11524 /* Since this is early in the link process, it is simple
11525 to remove a section from the output. */
11526 o->flags |= SEC_EXCLUDE;
11528 if (info->print_gc_sections && o->size != 0)
11529 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
11531 /* But we also have to update some of the relocation
11532 info we collected before. */
11534 && (o->flags & SEC_RELOC) != 0
11535 && o->reloc_count > 0
11536 && !bfd_is_abs_section (o->output_section))
11538 Elf_Internal_Rela *internal_relocs;
11542 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
11543 info->keep_memory);
11544 if (internal_relocs == NULL)
11547 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
11549 if (elf_section_data (o)->relocs != internal_relocs)
11550 free (internal_relocs);
11558 /* Remove the symbols that were in the swept sections from the dynamic
11559 symbol table. GCFIXME: Anyone know how to get them out of the
11560 static symbol table as well? */
11561 sweep_info.info = info;
11562 sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
11563 elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
11566 _bfd_elf_link_renumber_dynsyms (abfd, info, §ion_sym_count);
11570 /* Propagate collected vtable information. This is called through
11571 elf_link_hash_traverse. */
11574 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
11576 if (h->root.type == bfd_link_hash_warning)
11577 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11579 /* Those that are not vtables. */
11580 if (h->vtable == NULL || h->vtable->parent == NULL)
11583 /* Those vtables that do not have parents, we cannot merge. */
11584 if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
11587 /* If we've already been done, exit. */
11588 if (h->vtable->used && h->vtable->used[-1])
11591 /* Make sure the parent's table is up to date. */
11592 elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
11594 if (h->vtable->used == NULL)
11596 /* None of this table's entries were referenced. Re-use the
11598 h->vtable->used = h->vtable->parent->vtable->used;
11599 h->vtable->size = h->vtable->parent->vtable->size;
11604 bfd_boolean *cu, *pu;
11606 /* Or the parent's entries into ours. */
11607 cu = h->vtable->used;
11609 pu = h->vtable->parent->vtable->used;
11612 const struct elf_backend_data *bed;
11613 unsigned int log_file_align;
11615 bed = get_elf_backend_data (h->root.u.def.section->owner);
11616 log_file_align = bed->s->log_file_align;
11617 n = h->vtable->parent->vtable->size >> log_file_align;
11632 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
11635 bfd_vma hstart, hend;
11636 Elf_Internal_Rela *relstart, *relend, *rel;
11637 const struct elf_backend_data *bed;
11638 unsigned int log_file_align;
11640 if (h->root.type == bfd_link_hash_warning)
11641 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11643 /* Take care of both those symbols that do not describe vtables as
11644 well as those that are not loaded. */
11645 if (h->vtable == NULL || h->vtable->parent == NULL)
11648 BFD_ASSERT (h->root.type == bfd_link_hash_defined
11649 || h->root.type == bfd_link_hash_defweak);
11651 sec = h->root.u.def.section;
11652 hstart = h->root.u.def.value;
11653 hend = hstart + h->size;
11655 relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
11657 return *(bfd_boolean *) okp = FALSE;
11658 bed = get_elf_backend_data (sec->owner);
11659 log_file_align = bed->s->log_file_align;
11661 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
11663 for (rel = relstart; rel < relend; ++rel)
11664 if (rel->r_offset >= hstart && rel->r_offset < hend)
11666 /* If the entry is in use, do nothing. */
11667 if (h->vtable->used
11668 && (rel->r_offset - hstart) < h->vtable->size)
11670 bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
11671 if (h->vtable->used[entry])
11674 /* Otherwise, kill it. */
11675 rel->r_offset = rel->r_info = rel->r_addend = 0;
11681 /* Mark sections containing dynamically referenced symbols. When
11682 building shared libraries, we must assume that any visible symbol is
11686 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
11688 struct bfd_link_info *info = (struct bfd_link_info *) inf;
11690 if (h->root.type == bfd_link_hash_warning)
11691 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11693 if ((h->root.type == bfd_link_hash_defined
11694 || h->root.type == bfd_link_hash_defweak)
11696 || (!info->executable
11698 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
11699 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN)))
11700 h->root.u.def.section->flags |= SEC_KEEP;
11705 /* Keep all sections containing symbols undefined on the command-line,
11706 and the section containing the entry symbol. */
11709 _bfd_elf_gc_keep (struct bfd_link_info *info)
11711 struct bfd_sym_chain *sym;
11713 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
11715 struct elf_link_hash_entry *h;
11717 h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
11718 FALSE, FALSE, FALSE);
11721 && (h->root.type == bfd_link_hash_defined
11722 || h->root.type == bfd_link_hash_defweak)
11723 && !bfd_is_abs_section (h->root.u.def.section))
11724 h->root.u.def.section->flags |= SEC_KEEP;
11728 /* Do mark and sweep of unused sections. */
11731 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
11733 bfd_boolean ok = TRUE;
11735 elf_gc_mark_hook_fn gc_mark_hook;
11736 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11738 if (!bed->can_gc_sections
11739 || !is_elf_hash_table (info->hash))
11741 (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
11745 bed->gc_keep (info);
11747 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
11748 at the .eh_frame section if we can mark the FDEs individually. */
11749 _bfd_elf_begin_eh_frame_parsing (info);
11750 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11753 struct elf_reloc_cookie cookie;
11755 sec = bfd_get_section_by_name (sub, ".eh_frame");
11756 if (sec && init_reloc_cookie_for_section (&cookie, info, sec))
11758 _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
11759 if (elf_section_data (sec)->sec_info)
11760 elf_eh_frame_section (sub) = sec;
11761 fini_reloc_cookie_for_section (&cookie, sec);
11764 _bfd_elf_end_eh_frame_parsing (info);
11766 /* Apply transitive closure to the vtable entry usage info. */
11767 elf_link_hash_traverse (elf_hash_table (info),
11768 elf_gc_propagate_vtable_entries_used,
11773 /* Kill the vtable relocations that were not used. */
11774 elf_link_hash_traverse (elf_hash_table (info),
11775 elf_gc_smash_unused_vtentry_relocs,
11780 /* Mark dynamically referenced symbols. */
11781 if (elf_hash_table (info)->dynamic_sections_created)
11782 elf_link_hash_traverse (elf_hash_table (info),
11783 bed->gc_mark_dynamic_ref,
11786 /* Grovel through relocs to find out who stays ... */
11787 gc_mark_hook = bed->gc_mark_hook;
11788 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11792 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
11795 for (o = sub->sections; o != NULL; o = o->next)
11796 if ((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP && !o->gc_mark)
11797 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
11801 /* Allow the backend to mark additional target specific sections. */
11802 if (bed->gc_mark_extra_sections)
11803 bed->gc_mark_extra_sections (info, gc_mark_hook);
11805 /* ... and mark SEC_EXCLUDE for those that go. */
11806 return elf_gc_sweep (abfd, info);
11809 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
11812 bfd_elf_gc_record_vtinherit (bfd *abfd,
11814 struct elf_link_hash_entry *h,
11817 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
11818 struct elf_link_hash_entry **search, *child;
11819 bfd_size_type extsymcount;
11820 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11822 /* The sh_info field of the symtab header tells us where the
11823 external symbols start. We don't care about the local symbols at
11825 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
11826 if (!elf_bad_symtab (abfd))
11827 extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
11829 sym_hashes = elf_sym_hashes (abfd);
11830 sym_hashes_end = sym_hashes + extsymcount;
11832 /* Hunt down the child symbol, which is in this section at the same
11833 offset as the relocation. */
11834 for (search = sym_hashes; search != sym_hashes_end; ++search)
11836 if ((child = *search) != NULL
11837 && (child->root.type == bfd_link_hash_defined
11838 || child->root.type == bfd_link_hash_defweak)
11839 && child->root.u.def.section == sec
11840 && child->root.u.def.value == offset)
11844 (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
11845 abfd, sec, (unsigned long) offset);
11846 bfd_set_error (bfd_error_invalid_operation);
11850 if (!child->vtable)
11852 child->vtable = (struct elf_link_virtual_table_entry *)
11853 bfd_zalloc (abfd, sizeof (*child->vtable));
11854 if (!child->vtable)
11859 /* This *should* only be the absolute section. It could potentially
11860 be that someone has defined a non-global vtable though, which
11861 would be bad. It isn't worth paging in the local symbols to be
11862 sure though; that case should simply be handled by the assembler. */
11864 child->vtable->parent = (struct elf_link_hash_entry *) -1;
11867 child->vtable->parent = h;
11872 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
11875 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
11876 asection *sec ATTRIBUTE_UNUSED,
11877 struct elf_link_hash_entry *h,
11880 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11881 unsigned int log_file_align = bed->s->log_file_align;
11885 h->vtable = (struct elf_link_virtual_table_entry *)
11886 bfd_zalloc (abfd, sizeof (*h->vtable));
11891 if (addend >= h->vtable->size)
11893 size_t size, bytes, file_align;
11894 bfd_boolean *ptr = h->vtable->used;
11896 /* While the symbol is undefined, we have to be prepared to handle
11898 file_align = 1 << log_file_align;
11899 if (h->root.type == bfd_link_hash_undefined)
11900 size = addend + file_align;
11904 if (addend >= size)
11906 /* Oops! We've got a reference past the defined end of
11907 the table. This is probably a bug -- shall we warn? */
11908 size = addend + file_align;
11911 size = (size + file_align - 1) & -file_align;
11913 /* Allocate one extra entry for use as a "done" flag for the
11914 consolidation pass. */
11915 bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
11919 ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
11925 oldbytes = (((h->vtable->size >> log_file_align) + 1)
11926 * sizeof (bfd_boolean));
11927 memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
11931 ptr = (bfd_boolean *) bfd_zmalloc (bytes);
11936 /* And arrange for that done flag to be at index -1. */
11937 h->vtable->used = ptr + 1;
11938 h->vtable->size = size;
11941 h->vtable->used[addend >> log_file_align] = TRUE;
11946 struct alloc_got_off_arg {
11948 struct bfd_link_info *info;
11951 /* We need a special top-level link routine to convert got reference counts
11952 to real got offsets. */
11955 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
11957 struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
11958 bfd *obfd = gofarg->info->output_bfd;
11959 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
11961 if (h->root.type == bfd_link_hash_warning)
11962 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11964 if (h->got.refcount > 0)
11966 h->got.offset = gofarg->gotoff;
11967 gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
11970 h->got.offset = (bfd_vma) -1;
11975 /* And an accompanying bit to work out final got entry offsets once
11976 we're done. Should be called from final_link. */
11979 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
11980 struct bfd_link_info *info)
11983 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11985 struct alloc_got_off_arg gofarg;
11987 BFD_ASSERT (abfd == info->output_bfd);
11989 if (! is_elf_hash_table (info->hash))
11992 /* The GOT offset is relative to the .got section, but the GOT header is
11993 put into the .got.plt section, if the backend uses it. */
11994 if (bed->want_got_plt)
11997 gotoff = bed->got_header_size;
11999 /* Do the local .got entries first. */
12000 for (i = info->input_bfds; i; i = i->link_next)
12002 bfd_signed_vma *local_got;
12003 bfd_size_type j, locsymcount;
12004 Elf_Internal_Shdr *symtab_hdr;
12006 if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12009 local_got = elf_local_got_refcounts (i);
12013 symtab_hdr = &elf_tdata (i)->symtab_hdr;
12014 if (elf_bad_symtab (i))
12015 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12017 locsymcount = symtab_hdr->sh_info;
12019 for (j = 0; j < locsymcount; ++j)
12021 if (local_got[j] > 0)
12023 local_got[j] = gotoff;
12024 gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12027 local_got[j] = (bfd_vma) -1;
12031 /* Then the global .got entries. .plt refcounts are handled by
12032 adjust_dynamic_symbol */
12033 gofarg.gotoff = gotoff;
12034 gofarg.info = info;
12035 elf_link_hash_traverse (elf_hash_table (info),
12036 elf_gc_allocate_got_offsets,
12041 /* Many folk need no more in the way of final link than this, once
12042 got entry reference counting is enabled. */
12045 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12047 if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12050 /* Invoke the regular ELF backend linker to do all the work. */
12051 return bfd_elf_final_link (abfd, info);
12055 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12057 struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12059 if (rcookie->bad_symtab)
12060 rcookie->rel = rcookie->rels;
12062 for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12064 unsigned long r_symndx;
12066 if (! rcookie->bad_symtab)
12067 if (rcookie->rel->r_offset > offset)
12069 if (rcookie->rel->r_offset != offset)
12072 r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12073 if (r_symndx == SHN_UNDEF)
12076 if (r_symndx >= rcookie->locsymcount
12077 || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12079 struct elf_link_hash_entry *h;
12081 h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12083 while (h->root.type == bfd_link_hash_indirect
12084 || h->root.type == bfd_link_hash_warning)
12085 h = (struct elf_link_hash_entry *) h->root.u.i.link;
12087 if ((h->root.type == bfd_link_hash_defined
12088 || h->root.type == bfd_link_hash_defweak)
12089 && elf_discarded_section (h->root.u.def.section))
12096 /* It's not a relocation against a global symbol,
12097 but it could be a relocation against a local
12098 symbol for a discarded section. */
12100 Elf_Internal_Sym *isym;
12102 /* Need to: get the symbol; get the section. */
12103 isym = &rcookie->locsyms[r_symndx];
12104 isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12105 if (isec != NULL && elf_discarded_section (isec))
12113 /* Discard unneeded references to discarded sections.
12114 Returns TRUE if any section's size was changed. */
12115 /* This function assumes that the relocations are in sorted order,
12116 which is true for all known assemblers. */
12119 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12121 struct elf_reloc_cookie cookie;
12122 asection *stab, *eh;
12123 const struct elf_backend_data *bed;
12125 bfd_boolean ret = FALSE;
12127 if (info->traditional_format
12128 || !is_elf_hash_table (info->hash))
12131 _bfd_elf_begin_eh_frame_parsing (info);
12132 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
12134 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12137 bed = get_elf_backend_data (abfd);
12139 if ((abfd->flags & DYNAMIC) != 0)
12143 if (!info->relocatable)
12145 eh = bfd_get_section_by_name (abfd, ".eh_frame");
12148 || bfd_is_abs_section (eh->output_section)))
12152 stab = bfd_get_section_by_name (abfd, ".stab");
12154 && (stab->size == 0
12155 || bfd_is_abs_section (stab->output_section)
12156 || stab->sec_info_type != ELF_INFO_TYPE_STABS))
12161 && bed->elf_backend_discard_info == NULL)
12164 if (!init_reloc_cookie (&cookie, info, abfd))
12168 && stab->reloc_count > 0
12169 && init_reloc_cookie_rels (&cookie, info, abfd, stab))
12171 if (_bfd_discard_section_stabs (abfd, stab,
12172 elf_section_data (stab)->sec_info,
12173 bfd_elf_reloc_symbol_deleted_p,
12176 fini_reloc_cookie_rels (&cookie, stab);
12180 && init_reloc_cookie_rels (&cookie, info, abfd, eh))
12182 _bfd_elf_parse_eh_frame (abfd, info, eh, &cookie);
12183 if (_bfd_elf_discard_section_eh_frame (abfd, info, eh,
12184 bfd_elf_reloc_symbol_deleted_p,
12187 fini_reloc_cookie_rels (&cookie, eh);
12190 if (bed->elf_backend_discard_info != NULL
12191 && (*bed->elf_backend_discard_info) (abfd, &cookie, info))
12194 fini_reloc_cookie (&cookie, abfd);
12196 _bfd_elf_end_eh_frame_parsing (info);
12198 if (info->eh_frame_hdr
12199 && !info->relocatable
12200 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12206 /* For a SHT_GROUP section, return the group signature. For other
12207 sections, return the normal section name. */
12209 static const char *
12210 section_signature (asection *sec)
12212 if ((sec->flags & SEC_GROUP) != 0
12213 && elf_next_in_group (sec) != NULL
12214 && elf_group_name (elf_next_in_group (sec)) != NULL)
12215 return elf_group_name (elf_next_in_group (sec));
12220 _bfd_elf_section_already_linked (bfd *abfd, asection *sec,
12221 struct bfd_link_info *info)
12224 const char *name, *p;
12225 struct bfd_section_already_linked *l;
12226 struct bfd_section_already_linked_hash_entry *already_linked_list;
12228 if (sec->output_section == bfd_abs_section_ptr)
12231 flags = sec->flags;
12233 /* Return if it isn't a linkonce section. A comdat group section
12234 also has SEC_LINK_ONCE set. */
12235 if ((flags & SEC_LINK_ONCE) == 0)
12238 /* Don't put group member sections on our list of already linked
12239 sections. They are handled as a group via their group section. */
12240 if (elf_sec_group (sec) != NULL)
12243 /* FIXME: When doing a relocatable link, we may have trouble
12244 copying relocations in other sections that refer to local symbols
12245 in the section being discarded. Those relocations will have to
12246 be converted somehow; as of this writing I'm not sure that any of
12247 the backends handle that correctly.
12249 It is tempting to instead not discard link once sections when
12250 doing a relocatable link (technically, they should be discarded
12251 whenever we are building constructors). However, that fails,
12252 because the linker winds up combining all the link once sections
12253 into a single large link once section, which defeats the purpose
12254 of having link once sections in the first place.
12256 Also, not merging link once sections in a relocatable link
12257 causes trouble for MIPS ELF, which relies on link once semantics
12258 to handle the .reginfo section correctly. */
12260 name = section_signature (sec);
12262 if (CONST_STRNEQ (name, ".gnu.linkonce.")
12263 && (p = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
12268 already_linked_list = bfd_section_already_linked_table_lookup (p);
12270 for (l = already_linked_list->entry; l != NULL; l = l->next)
12272 /* We may have 2 different types of sections on the list: group
12273 sections and linkonce sections. Match like sections. */
12274 if ((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
12275 && strcmp (name, section_signature (l->sec)) == 0
12276 && bfd_coff_get_comdat_section (l->sec->owner, l->sec) == NULL)
12278 /* The section has already been linked. See if we should
12279 issue a warning. */
12280 switch (flags & SEC_LINK_DUPLICATES)
12285 case SEC_LINK_DUPLICATES_DISCARD:
12288 case SEC_LINK_DUPLICATES_ONE_ONLY:
12289 (*_bfd_error_handler)
12290 (_("%B: ignoring duplicate section `%A'"),
12294 case SEC_LINK_DUPLICATES_SAME_SIZE:
12295 if (sec->size != l->sec->size)
12296 (*_bfd_error_handler)
12297 (_("%B: duplicate section `%A' has different size"),
12301 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
12302 if (sec->size != l->sec->size)
12303 (*_bfd_error_handler)
12304 (_("%B: duplicate section `%A' has different size"),
12306 else if (sec->size != 0)
12308 bfd_byte *sec_contents, *l_sec_contents;
12310 if (!bfd_malloc_and_get_section (abfd, sec, &sec_contents))
12311 (*_bfd_error_handler)
12312 (_("%B: warning: could not read contents of section `%A'"),
12314 else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec,
12316 (*_bfd_error_handler)
12317 (_("%B: warning: could not read contents of section `%A'"),
12318 l->sec->owner, l->sec);
12319 else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0)
12320 (*_bfd_error_handler)
12321 (_("%B: warning: duplicate section `%A' has different contents"),
12325 free (sec_contents);
12326 if (l_sec_contents)
12327 free (l_sec_contents);
12332 /* Set the output_section field so that lang_add_section
12333 does not create a lang_input_section structure for this
12334 section. Since there might be a symbol in the section
12335 being discarded, we must retain a pointer to the section
12336 which we are really going to use. */
12337 sec->output_section = bfd_abs_section_ptr;
12338 sec->kept_section = l->sec;
12340 if (flags & SEC_GROUP)
12342 asection *first = elf_next_in_group (sec);
12343 asection *s = first;
12347 s->output_section = bfd_abs_section_ptr;
12348 /* Record which group discards it. */
12349 s->kept_section = l->sec;
12350 s = elf_next_in_group (s);
12351 /* These lists are circular. */
12361 /* A single member comdat group section may be discarded by a
12362 linkonce section and vice versa. */
12364 if ((flags & SEC_GROUP) != 0)
12366 asection *first = elf_next_in_group (sec);
12368 if (first != NULL && elf_next_in_group (first) == first)
12369 /* Check this single member group against linkonce sections. */
12370 for (l = already_linked_list->entry; l != NULL; l = l->next)
12371 if ((l->sec->flags & SEC_GROUP) == 0
12372 && bfd_coff_get_comdat_section (l->sec->owner, l->sec) == NULL
12373 && bfd_elf_match_symbols_in_sections (l->sec, first, info))
12375 first->output_section = bfd_abs_section_ptr;
12376 first->kept_section = l->sec;
12377 sec->output_section = bfd_abs_section_ptr;
12382 /* Check this linkonce section against single member groups. */
12383 for (l = already_linked_list->entry; l != NULL; l = l->next)
12384 if (l->sec->flags & SEC_GROUP)
12386 asection *first = elf_next_in_group (l->sec);
12389 && elf_next_in_group (first) == first
12390 && bfd_elf_match_symbols_in_sections (first, sec, info))
12392 sec->output_section = bfd_abs_section_ptr;
12393 sec->kept_section = first;
12398 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12399 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12400 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12401 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
12402 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
12403 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12404 `.gnu.linkonce.t.F' section from a different bfd not requiring any
12405 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
12406 The reverse order cannot happen as there is never a bfd with only the
12407 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
12408 matter as here were are looking only for cross-bfd sections. */
12410 if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
12411 for (l = already_linked_list->entry; l != NULL; l = l->next)
12412 if ((l->sec->flags & SEC_GROUP) == 0
12413 && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
12415 if (abfd != l->sec->owner)
12416 sec->output_section = bfd_abs_section_ptr;
12420 /* This is the first section with this name. Record it. */
12421 if (! bfd_section_already_linked_table_insert (already_linked_list, sec))
12422 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
12426 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
12428 return sym->st_shndx == SHN_COMMON;
12432 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
12438 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
12440 return bfd_com_section_ptr;
12444 _bfd_elf_default_got_elt_size (bfd *abfd,
12445 struct bfd_link_info *info ATTRIBUTE_UNUSED,
12446 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
12447 bfd *ibfd ATTRIBUTE_UNUSED,
12448 unsigned long symndx ATTRIBUTE_UNUSED)
12450 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12451 return bed->s->arch_size / 8;
12454 /* Routines to support the creation of dynamic relocs. */
12456 /* Return true if NAME is a name of a relocation
12457 section associated with section S. */
12460 is_reloc_section (bfd_boolean rela, const char * name, asection * s)
12463 return CONST_STRNEQ (name, ".rela")
12464 && strcmp (bfd_get_section_name (NULL, s), name + 5) == 0;
12466 return CONST_STRNEQ (name, ".rel")
12467 && strcmp (bfd_get_section_name (NULL, s), name + 4) == 0;
12470 /* Returns the name of the dynamic reloc section associated with SEC. */
12472 static const char *
12473 get_dynamic_reloc_section_name (bfd * abfd,
12475 bfd_boolean is_rela)
12478 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
12479 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
12481 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
12485 if (! is_reloc_section (is_rela, name, sec))
12487 static bfd_boolean complained = FALSE;
12491 (*_bfd_error_handler)
12492 (_("%B: bad relocation section name `%s\'"), abfd, name);
12501 /* Returns the dynamic reloc section associated with SEC.
12502 If necessary compute the name of the dynamic reloc section based
12503 on SEC's name (looked up in ABFD's string table) and the setting
12507 _bfd_elf_get_dynamic_reloc_section (bfd * abfd,
12509 bfd_boolean is_rela)
12511 asection * reloc_sec = elf_section_data (sec)->sreloc;
12513 if (reloc_sec == NULL)
12515 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12519 reloc_sec = bfd_get_section_by_name (abfd, name);
12521 if (reloc_sec != NULL)
12522 elf_section_data (sec)->sreloc = reloc_sec;
12529 /* Returns the dynamic reloc section associated with SEC. If the
12530 section does not exist it is created and attached to the DYNOBJ
12531 bfd and stored in the SRELOC field of SEC's elf_section_data
12534 ALIGNMENT is the alignment for the newly created section and
12535 IS_RELA defines whether the name should be .rela.<SEC's name>
12536 or .rel.<SEC's name>. The section name is looked up in the
12537 string table associated with ABFD. */
12540 _bfd_elf_make_dynamic_reloc_section (asection * sec,
12542 unsigned int alignment,
12544 bfd_boolean is_rela)
12546 asection * reloc_sec = elf_section_data (sec)->sreloc;
12548 if (reloc_sec == NULL)
12550 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12555 reloc_sec = bfd_get_section_by_name (dynobj, name);
12557 if (reloc_sec == NULL)
12561 flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_IN_MEMORY | SEC_LINKER_CREATED);
12562 if ((sec->flags & SEC_ALLOC) != 0)
12563 flags |= SEC_ALLOC | SEC_LOAD;
12565 reloc_sec = bfd_make_section_with_flags (dynobj, name, flags);
12566 if (reloc_sec != NULL)
12568 if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
12573 elf_section_data (sec)->sreloc = reloc_sec;