1 /* ELF linking support for BFD.
2 Copyright (C) 1995-2015 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "bfd_stdint.h"
28 #include "safe-ctype.h"
29 #include "libiberty.h"
32 /* This struct is used to pass information to routines called via
33 elf_link_hash_traverse which must return failure. */
35 struct elf_info_failed
37 struct bfd_link_info *info;
41 /* This structure is used to pass information to
42 _bfd_elf_link_find_version_dependencies. */
44 struct elf_find_verdep_info
46 /* General link information. */
47 struct bfd_link_info *info;
48 /* The number of dependencies. */
50 /* Whether we had a failure. */
54 static bfd_boolean _bfd_elf_fix_symbol_flags
55 (struct elf_link_hash_entry *, struct elf_info_failed *);
57 /* Define a symbol in a dynamic linkage section. */
59 struct elf_link_hash_entry *
60 _bfd_elf_define_linkage_sym (bfd *abfd,
61 struct bfd_link_info *info,
65 struct elf_link_hash_entry *h;
66 struct bfd_link_hash_entry *bh;
67 const struct elf_backend_data *bed;
69 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
72 /* Zap symbol defined in an as-needed lib that wasn't linked.
73 This is a symptom of a larger problem: Absolute symbols
74 defined in shared libraries can't be overridden, because we
75 lose the link to the bfd which is via the symbol section. */
76 h->root.type = bfd_link_hash_new;
80 bed = get_elf_backend_data (abfd);
81 if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
82 sec, 0, NULL, FALSE, bed->collect,
85 h = (struct elf_link_hash_entry *) bh;
88 h->root.linker_def = 1;
90 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
91 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
93 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
98 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
102 struct elf_link_hash_entry *h;
103 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
104 struct elf_link_hash_table *htab = elf_hash_table (info);
106 /* This function may be called more than once. */
107 s = bfd_get_linker_section (abfd, ".got");
111 flags = bed->dynamic_sec_flags;
113 s = bfd_make_section_anyway_with_flags (abfd,
114 (bed->rela_plts_and_copies_p
115 ? ".rela.got" : ".rel.got"),
116 (bed->dynamic_sec_flags
119 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
123 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
125 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
129 if (bed->want_got_plt)
131 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
133 || !bfd_set_section_alignment (abfd, s,
134 bed->s->log_file_align))
139 /* The first bit of the global offset table is the header. */
140 s->size += bed->got_header_size;
142 if (bed->want_got_sym)
144 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
145 (or .got.plt) section. We don't do this in the linker script
146 because we don't want to define the symbol if we are not creating
147 a global offset table. */
148 h = _bfd_elf_define_linkage_sym (abfd, info, s,
149 "_GLOBAL_OFFSET_TABLE_");
150 elf_hash_table (info)->hgot = h;
158 /* Create a strtab to hold the dynamic symbol names. */
160 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
162 struct elf_link_hash_table *hash_table;
164 hash_table = elf_hash_table (info);
165 if (hash_table->dynobj == NULL)
166 hash_table->dynobj = abfd;
168 if (hash_table->dynstr == NULL)
170 hash_table->dynstr = _bfd_elf_strtab_init ();
171 if (hash_table->dynstr == NULL)
177 /* Create some sections which will be filled in with dynamic linking
178 information. ABFD is an input file which requires dynamic sections
179 to be created. The dynamic sections take up virtual memory space
180 when the final executable is run, so we need to create them before
181 addresses are assigned to the output sections. We work out the
182 actual contents and size of these sections later. */
185 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
189 const struct elf_backend_data *bed;
190 struct elf_link_hash_entry *h;
192 if (! is_elf_hash_table (info->hash))
195 if (elf_hash_table (info)->dynamic_sections_created)
198 if (!_bfd_elf_link_create_dynstrtab (abfd, info))
201 abfd = elf_hash_table (info)->dynobj;
202 bed = get_elf_backend_data (abfd);
204 flags = bed->dynamic_sec_flags;
206 /* A dynamically linked executable has a .interp section, but a
207 shared library does not. */
208 if (info->executable)
210 s = bfd_make_section_anyway_with_flags (abfd, ".interp",
211 flags | SEC_READONLY);
216 /* Create sections to hold version informations. These are removed
217 if they are not needed. */
218 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
219 flags | SEC_READONLY);
221 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
224 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
225 flags | SEC_READONLY);
227 || ! bfd_set_section_alignment (abfd, s, 1))
230 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
231 flags | SEC_READONLY);
233 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
236 s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
237 flags | SEC_READONLY);
239 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
242 s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
243 flags | SEC_READONLY);
247 s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
249 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
252 /* The special symbol _DYNAMIC is always set to the start of the
253 .dynamic section. We could set _DYNAMIC in a linker script, but we
254 only want to define it if we are, in fact, creating a .dynamic
255 section. We don't want to define it if there is no .dynamic
256 section, since on some ELF platforms the start up code examines it
257 to decide how to initialize the process. */
258 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
259 elf_hash_table (info)->hdynamic = h;
265 s = bfd_make_section_anyway_with_flags (abfd, ".hash",
266 flags | SEC_READONLY);
268 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
270 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
273 if (info->emit_gnu_hash)
275 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
276 flags | SEC_READONLY);
278 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
280 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
281 4 32-bit words followed by variable count of 64-bit words, then
282 variable count of 32-bit words. */
283 if (bed->s->arch_size == 64)
284 elf_section_data (s)->this_hdr.sh_entsize = 0;
286 elf_section_data (s)->this_hdr.sh_entsize = 4;
289 /* Let the backend create the rest of the sections. This lets the
290 backend set the right flags. The backend will normally create
291 the .got and .plt sections. */
292 if (bed->elf_backend_create_dynamic_sections == NULL
293 || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
296 elf_hash_table (info)->dynamic_sections_created = TRUE;
301 /* Create dynamic sections when linking against a dynamic object. */
304 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
306 flagword flags, pltflags;
307 struct elf_link_hash_entry *h;
309 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
310 struct elf_link_hash_table *htab = elf_hash_table (info);
312 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
313 .rel[a].bss sections. */
314 flags = bed->dynamic_sec_flags;
317 if (bed->plt_not_loaded)
318 /* We do not clear SEC_ALLOC here because we still want the OS to
319 allocate space for the section; it's just that there's nothing
320 to read in from the object file. */
321 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
323 pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
324 if (bed->plt_readonly)
325 pltflags |= SEC_READONLY;
327 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
329 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
333 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
335 if (bed->want_plt_sym)
337 h = _bfd_elf_define_linkage_sym (abfd, info, s,
338 "_PROCEDURE_LINKAGE_TABLE_");
339 elf_hash_table (info)->hplt = h;
344 s = bfd_make_section_anyway_with_flags (abfd,
345 (bed->rela_plts_and_copies_p
346 ? ".rela.plt" : ".rel.plt"),
347 flags | SEC_READONLY);
349 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
353 if (! _bfd_elf_create_got_section (abfd, info))
356 if (bed->want_dynbss)
358 /* The .dynbss section is a place to put symbols which are defined
359 by dynamic objects, are referenced by regular objects, and are
360 not functions. We must allocate space for them in the process
361 image and use a R_*_COPY reloc to tell the dynamic linker to
362 initialize them at run time. The linker script puts the .dynbss
363 section into the .bss section of the final image. */
364 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
365 (SEC_ALLOC | SEC_LINKER_CREATED));
369 /* The .rel[a].bss section holds copy relocs. This section is not
370 normally needed. We need to create it here, though, so that the
371 linker will map it to an output section. We can't just create it
372 only if we need it, because we will not know whether we need it
373 until we have seen all the input files, and the first time the
374 main linker code calls BFD after examining all the input files
375 (size_dynamic_sections) the input sections have already been
376 mapped to the output sections. If the section turns out not to
377 be needed, we can discard it later. We will never need this
378 section when generating a shared object, since they do not use
382 s = bfd_make_section_anyway_with_flags (abfd,
383 (bed->rela_plts_and_copies_p
384 ? ".rela.bss" : ".rel.bss"),
385 flags | SEC_READONLY);
387 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
395 /* Record a new dynamic symbol. We record the dynamic symbols as we
396 read the input files, since we need to have a list of all of them
397 before we can determine the final sizes of the output sections.
398 Note that we may actually call this function even though we are not
399 going to output any dynamic symbols; in some cases we know that a
400 symbol should be in the dynamic symbol table, but only if there is
404 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
405 struct elf_link_hash_entry *h)
407 if (h->dynindx == -1)
409 struct elf_strtab_hash *dynstr;
414 /* XXX: The ABI draft says the linker must turn hidden and
415 internal symbols into STB_LOCAL symbols when producing the
416 DSO. However, if ld.so honors st_other in the dynamic table,
417 this would not be necessary. */
418 switch (ELF_ST_VISIBILITY (h->other))
422 if (h->root.type != bfd_link_hash_undefined
423 && h->root.type != bfd_link_hash_undefweak)
426 if (!elf_hash_table (info)->is_relocatable_executable)
434 h->dynindx = elf_hash_table (info)->dynsymcount;
435 ++elf_hash_table (info)->dynsymcount;
437 dynstr = elf_hash_table (info)->dynstr;
440 /* Create a strtab to hold the dynamic symbol names. */
441 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
446 /* We don't put any version information in the dynamic string
448 name = h->root.root.string;
449 p = strchr (name, ELF_VER_CHR);
451 /* We know that the p points into writable memory. In fact,
452 there are only a few symbols that have read-only names, being
453 those like _GLOBAL_OFFSET_TABLE_ that are created specially
454 by the backends. Most symbols will have names pointing into
455 an ELF string table read from a file, or to objalloc memory. */
458 indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
463 if (indx == (bfd_size_type) -1)
465 h->dynstr_index = indx;
471 /* Mark a symbol dynamic. */
474 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
475 struct elf_link_hash_entry *h,
476 Elf_Internal_Sym *sym)
478 struct bfd_elf_dynamic_list *d = info->dynamic_list;
480 /* It may be called more than once on the same H. */
481 if(h->dynamic || info->relocatable)
484 if ((info->dynamic_data
485 && (h->type == STT_OBJECT
487 && ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
489 && h->root.type == bfd_link_hash_new
490 && (*d->match) (&d->head, NULL, h->root.root.string)))
494 /* Record an assignment to a symbol made by a linker script. We need
495 this in case some dynamic object refers to this symbol. */
498 bfd_elf_record_link_assignment (bfd *output_bfd,
499 struct bfd_link_info *info,
504 struct elf_link_hash_entry *h, *hv;
505 struct elf_link_hash_table *htab;
506 const struct elf_backend_data *bed;
508 if (!is_elf_hash_table (info->hash))
511 htab = elf_hash_table (info);
512 h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
516 switch (h->root.type)
518 case bfd_link_hash_defined:
519 case bfd_link_hash_defweak:
520 case bfd_link_hash_common:
522 case bfd_link_hash_undefweak:
523 case bfd_link_hash_undefined:
524 /* Since we're defining the symbol, don't let it seem to have not
525 been defined. record_dynamic_symbol and size_dynamic_sections
526 may depend on this. */
527 h->root.type = bfd_link_hash_new;
528 if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
529 bfd_link_repair_undef_list (&htab->root);
531 case bfd_link_hash_new:
532 bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
535 case bfd_link_hash_indirect:
536 /* We had a versioned symbol in a dynamic library. We make the
537 the versioned symbol point to this one. */
538 bed = get_elf_backend_data (output_bfd);
540 while (hv->root.type == bfd_link_hash_indirect
541 || hv->root.type == bfd_link_hash_warning)
542 hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
543 /* We don't need to update h->root.u since linker will set them
545 h->root.type = bfd_link_hash_undefined;
546 hv->root.type = bfd_link_hash_indirect;
547 hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
548 (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
550 case bfd_link_hash_warning:
555 /* If this symbol is being provided by the linker script, and it is
556 currently defined by a dynamic object, but not by a regular
557 object, then mark it as undefined so that the generic linker will
558 force the correct value. */
562 h->root.type = bfd_link_hash_undefined;
564 /* If this symbol is not being provided by the linker script, and it is
565 currently defined by a dynamic object, but not by a regular object,
566 then clear out any version information because the symbol will not be
567 associated with the dynamic object any more. */
571 h->verinfo.verdef = NULL;
577 bed = get_elf_backend_data (output_bfd);
578 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
579 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
580 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
583 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
585 if (!info->relocatable
587 && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
588 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
594 || (info->executable && elf_hash_table (info)->is_relocatable_executable))
597 if (! bfd_elf_link_record_dynamic_symbol (info, h))
600 /* If this is a weak defined symbol, and we know a corresponding
601 real symbol from the same dynamic object, make sure the real
602 symbol is also made into a dynamic symbol. */
603 if (h->u.weakdef != NULL
604 && h->u.weakdef->dynindx == -1)
606 if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
614 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
615 success, and 2 on a failure caused by attempting to record a symbol
616 in a discarded section, eg. a discarded link-once section symbol. */
619 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
624 struct elf_link_local_dynamic_entry *entry;
625 struct elf_link_hash_table *eht;
626 struct elf_strtab_hash *dynstr;
627 unsigned long dynstr_index;
629 Elf_External_Sym_Shndx eshndx;
630 char esym[sizeof (Elf64_External_Sym)];
632 if (! is_elf_hash_table (info->hash))
635 /* See if the entry exists already. */
636 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
637 if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
640 amt = sizeof (*entry);
641 entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
645 /* Go find the symbol, so that we can find it's name. */
646 if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
647 1, input_indx, &entry->isym, esym, &eshndx))
649 bfd_release (input_bfd, entry);
653 if (entry->isym.st_shndx != SHN_UNDEF
654 && entry->isym.st_shndx < SHN_LORESERVE)
658 s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
659 if (s == NULL || bfd_is_abs_section (s->output_section))
661 /* We can still bfd_release here as nothing has done another
662 bfd_alloc. We can't do this later in this function. */
663 bfd_release (input_bfd, entry);
668 name = (bfd_elf_string_from_elf_section
669 (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
670 entry->isym.st_name));
672 dynstr = elf_hash_table (info)->dynstr;
675 /* Create a strtab to hold the dynamic symbol names. */
676 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
681 dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
682 if (dynstr_index == (unsigned long) -1)
684 entry->isym.st_name = dynstr_index;
686 eht = elf_hash_table (info);
688 entry->next = eht->dynlocal;
689 eht->dynlocal = entry;
690 entry->input_bfd = input_bfd;
691 entry->input_indx = input_indx;
694 /* Whatever binding the symbol had before, it's now local. */
696 = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
698 /* The dynindx will be set at the end of size_dynamic_sections. */
703 /* Return the dynindex of a local dynamic symbol. */
706 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
710 struct elf_link_local_dynamic_entry *e;
712 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
713 if (e->input_bfd == input_bfd && e->input_indx == input_indx)
718 /* This function is used to renumber the dynamic symbols, if some of
719 them are removed because they are marked as local. This is called
720 via elf_link_hash_traverse. */
723 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
726 size_t *count = (size_t *) data;
731 if (h->dynindx != -1)
732 h->dynindx = ++(*count);
738 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
739 STB_LOCAL binding. */
742 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
745 size_t *count = (size_t *) data;
747 if (!h->forced_local)
750 if (h->dynindx != -1)
751 h->dynindx = ++(*count);
756 /* Return true if the dynamic symbol for a given section should be
757 omitted when creating a shared library. */
759 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
760 struct bfd_link_info *info,
763 struct elf_link_hash_table *htab;
766 switch (elf_section_data (p)->this_hdr.sh_type)
770 /* If sh_type is yet undecided, assume it could be
771 SHT_PROGBITS/SHT_NOBITS. */
773 htab = elf_hash_table (info);
774 if (p == htab->tls_sec)
777 if (htab->text_index_section != NULL)
778 return p != htab->text_index_section && p != htab->data_index_section;
780 return (htab->dynobj != NULL
781 && (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
782 && ip->output_section == p);
784 /* There shouldn't be section relative relocations
785 against any other section. */
791 /* Assign dynsym indices. In a shared library we generate a section
792 symbol for each output section, which come first. Next come symbols
793 which have been forced to local binding. Then all of the back-end
794 allocated local dynamic syms, followed by the rest of the global
798 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
799 struct bfd_link_info *info,
800 unsigned long *section_sym_count)
802 unsigned long dynsymcount = 0;
804 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
806 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
808 for (p = output_bfd->sections; p ; p = p->next)
809 if ((p->flags & SEC_EXCLUDE) == 0
810 && (p->flags & SEC_ALLOC) != 0
811 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
812 elf_section_data (p)->dynindx = ++dynsymcount;
814 elf_section_data (p)->dynindx = 0;
816 *section_sym_count = dynsymcount;
818 elf_link_hash_traverse (elf_hash_table (info),
819 elf_link_renumber_local_hash_table_dynsyms,
822 if (elf_hash_table (info)->dynlocal)
824 struct elf_link_local_dynamic_entry *p;
825 for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
826 p->dynindx = ++dynsymcount;
829 elf_link_hash_traverse (elf_hash_table (info),
830 elf_link_renumber_hash_table_dynsyms,
833 /* There is an unused NULL entry at the head of the table which
834 we must account for in our count. Unless there weren't any
835 symbols, which means we'll have no table at all. */
836 if (dynsymcount != 0)
839 elf_hash_table (info)->dynsymcount = dynsymcount;
843 /* Merge st_other field. */
846 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
847 const Elf_Internal_Sym *isym,
848 bfd_boolean definition, bfd_boolean dynamic)
850 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
852 /* If st_other has a processor-specific meaning, specific
853 code might be needed here. */
854 if (bed->elf_backend_merge_symbol_attribute)
855 (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
860 unsigned symvis = ELF_ST_VISIBILITY (isym->st_other);
861 unsigned hvis = ELF_ST_VISIBILITY (h->other);
863 /* Keep the most constraining visibility. Leave the remainder
864 of the st_other field to elf_backend_merge_symbol_attribute. */
865 if (symvis - 1 < hvis - 1)
866 h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1));
868 else if (definition && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT)
869 h->protected_def = 1;
872 /* This function is called when we want to merge a new symbol with an
873 existing symbol. It handles the various cases which arise when we
874 find a definition in a dynamic object, or when there is already a
875 definition in a dynamic object. The new symbol is described by
876 NAME, SYM, PSEC, and PVALUE. We set SYM_HASH to the hash table
877 entry. We set POLDBFD to the old symbol's BFD. We set POLD_WEAK
878 if the old symbol was weak. We set POLD_ALIGNMENT to the alignment
879 of an old common symbol. We set OVERRIDE if the old symbol is
880 overriding a new definition. We set TYPE_CHANGE_OK if it is OK for
881 the type to change. We set SIZE_CHANGE_OK if it is OK for the size
882 to change. By OK to change, we mean that we shouldn't warn if the
883 type or size does change. */
886 _bfd_elf_merge_symbol (bfd *abfd,
887 struct bfd_link_info *info,
889 Elf_Internal_Sym *sym,
892 struct elf_link_hash_entry **sym_hash,
894 bfd_boolean *pold_weak,
895 unsigned int *pold_alignment,
897 bfd_boolean *override,
898 bfd_boolean *type_change_ok,
899 bfd_boolean *size_change_ok)
901 asection *sec, *oldsec;
902 struct elf_link_hash_entry *h;
903 struct elf_link_hash_entry *hi;
904 struct elf_link_hash_entry *flip;
907 bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
908 bfd_boolean newweak, oldweak, newfunc, oldfunc;
909 const struct elf_backend_data *bed;
915 bind = ELF_ST_BIND (sym->st_info);
917 if (! bfd_is_und_section (sec))
918 h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
920 h = ((struct elf_link_hash_entry *)
921 bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
926 bed = get_elf_backend_data (abfd);
928 /* For merging, we only care about real symbols. But we need to make
929 sure that indirect symbol dynamic flags are updated. */
931 while (h->root.type == bfd_link_hash_indirect
932 || h->root.type == bfd_link_hash_warning)
933 h = (struct elf_link_hash_entry *) h->root.u.i.link;
935 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
940 switch (h->root.type)
945 case bfd_link_hash_undefined:
946 case bfd_link_hash_undefweak:
947 oldbfd = h->root.u.undef.abfd;
950 case bfd_link_hash_defined:
951 case bfd_link_hash_defweak:
952 oldbfd = h->root.u.def.section->owner;
953 oldsec = h->root.u.def.section;
956 case bfd_link_hash_common:
957 oldbfd = h->root.u.c.p->section->owner;
958 oldsec = h->root.u.c.p->section;
960 *pold_alignment = h->root.u.c.p->alignment_power;
963 if (poldbfd && *poldbfd == NULL)
966 /* Differentiate strong and weak symbols. */
967 newweak = bind == STB_WEAK;
968 oldweak = (h->root.type == bfd_link_hash_defweak
969 || h->root.type == bfd_link_hash_undefweak);
971 *pold_weak = oldweak;
973 /* This code is for coping with dynamic objects, and is only useful
974 if we are doing an ELF link. */
975 if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
978 /* We have to check it for every instance since the first few may be
979 references and not all compilers emit symbol type for undefined
981 bfd_elf_link_mark_dynamic_symbol (info, h, sym);
983 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
984 respectively, is from a dynamic object. */
986 newdyn = (abfd->flags & DYNAMIC) != 0;
988 /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
989 syms and defined syms in dynamic libraries respectively.
990 ref_dynamic on the other hand can be set for a symbol defined in
991 a dynamic library, and def_dynamic may not be set; When the
992 definition in a dynamic lib is overridden by a definition in the
993 executable use of the symbol in the dynamic lib becomes a
994 reference to the executable symbol. */
997 if (bfd_is_und_section (sec))
999 if (bind != STB_WEAK)
1001 h->ref_dynamic_nonweak = 1;
1002 hi->ref_dynamic_nonweak = 1;
1008 hi->dynamic_def = 1;
1012 /* If we just created the symbol, mark it as being an ELF symbol.
1013 Other than that, there is nothing to do--there is no merge issue
1014 with a newly defined symbol--so we just return. */
1016 if (h->root.type == bfd_link_hash_new)
1022 /* In cases involving weak versioned symbols, we may wind up trying
1023 to merge a symbol with itself. Catch that here, to avoid the
1024 confusion that results if we try to override a symbol with
1025 itself. The additional tests catch cases like
1026 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1027 dynamic object, which we do want to handle here. */
1029 && (newweak || oldweak)
1030 && ((abfd->flags & DYNAMIC) == 0
1031 || !h->def_regular))
1036 olddyn = (oldbfd->flags & DYNAMIC) != 0;
1037 else if (oldsec != NULL)
1039 /* This handles the special SHN_MIPS_{TEXT,DATA} section
1040 indices used by MIPS ELF. */
1041 olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1044 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1045 respectively, appear to be a definition rather than reference. */
1047 newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1049 olddef = (h->root.type != bfd_link_hash_undefined
1050 && h->root.type != bfd_link_hash_undefweak
1051 && h->root.type != bfd_link_hash_common);
1053 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1054 respectively, appear to be a function. */
1056 newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1057 && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1059 oldfunc = (h->type != STT_NOTYPE
1060 && bed->is_function_type (h->type));
1062 /* When we try to create a default indirect symbol from the dynamic
1063 definition with the default version, we skip it if its type and
1064 the type of existing regular definition mismatch. */
1065 if (pold_alignment == NULL
1069 && (((olddef || h->root.type == bfd_link_hash_common)
1070 && ELF_ST_TYPE (sym->st_info) != h->type
1071 && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1072 && h->type != STT_NOTYPE
1073 && !(newfunc && oldfunc))
1075 && ((h->type == STT_GNU_IFUNC)
1076 != (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))))
1082 /* Check TLS symbols. We don't check undefined symbols introduced
1083 by "ld -u" which have no type (and oldbfd NULL), and we don't
1084 check symbols from plugins because they also have no type. */
1086 && (oldbfd->flags & BFD_PLUGIN) == 0
1087 && (abfd->flags & BFD_PLUGIN) == 0
1088 && ELF_ST_TYPE (sym->st_info) != h->type
1089 && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
1092 bfd_boolean ntdef, tdef;
1093 asection *ntsec, *tsec;
1095 if (h->type == STT_TLS)
1115 (*_bfd_error_handler)
1116 (_("%s: TLS definition in %B section %A "
1117 "mismatches non-TLS definition in %B section %A"),
1118 tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1119 else if (!tdef && !ntdef)
1120 (*_bfd_error_handler)
1121 (_("%s: TLS reference in %B "
1122 "mismatches non-TLS reference in %B"),
1123 tbfd, ntbfd, h->root.root.string);
1125 (*_bfd_error_handler)
1126 (_("%s: TLS definition in %B section %A "
1127 "mismatches non-TLS reference in %B"),
1128 tbfd, tsec, ntbfd, h->root.root.string);
1130 (*_bfd_error_handler)
1131 (_("%s: TLS reference in %B "
1132 "mismatches non-TLS definition in %B section %A"),
1133 tbfd, ntbfd, ntsec, h->root.root.string);
1135 bfd_set_error (bfd_error_bad_value);
1139 /* If the old symbol has non-default visibility, we ignore the new
1140 definition from a dynamic object. */
1142 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1143 && !bfd_is_und_section (sec))
1146 /* Make sure this symbol is dynamic. */
1148 hi->ref_dynamic = 1;
1149 /* A protected symbol has external availability. Make sure it is
1150 recorded as dynamic.
1152 FIXME: Should we check type and size for protected symbol? */
1153 if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1154 return bfd_elf_link_record_dynamic_symbol (info, h);
1159 && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1162 /* If the new symbol with non-default visibility comes from a
1163 relocatable file and the old definition comes from a dynamic
1164 object, we remove the old definition. */
1165 if (hi->root.type == bfd_link_hash_indirect)
1167 /* Handle the case where the old dynamic definition is
1168 default versioned. We need to copy the symbol info from
1169 the symbol with default version to the normal one if it
1170 was referenced before. */
1173 hi->root.type = h->root.type;
1174 h->root.type = bfd_link_hash_indirect;
1175 (*bed->elf_backend_copy_indirect_symbol) (info, hi, h);
1177 h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1178 if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1180 /* If the new symbol is hidden or internal, completely undo
1181 any dynamic link state. */
1182 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1183 h->forced_local = 0;
1190 /* FIXME: Should we check type and size for protected symbol? */
1200 /* If the old symbol was undefined before, then it will still be
1201 on the undefs list. If the new symbol is undefined or
1202 common, we can't make it bfd_link_hash_new here, because new
1203 undefined or common symbols will be added to the undefs list
1204 by _bfd_generic_link_add_one_symbol. Symbols may not be
1205 added twice to the undefs list. Also, if the new symbol is
1206 undefweak then we don't want to lose the strong undef. */
1207 if (h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1209 h->root.type = bfd_link_hash_undefined;
1210 h->root.u.undef.abfd = abfd;
1214 h->root.type = bfd_link_hash_new;
1215 h->root.u.undef.abfd = NULL;
1218 if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1220 /* If the new symbol is hidden or internal, completely undo
1221 any dynamic link state. */
1222 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1223 h->forced_local = 0;
1229 /* FIXME: Should we check type and size for protected symbol? */
1235 /* If a new weak symbol definition comes from a regular file and the
1236 old symbol comes from a dynamic library, we treat the new one as
1237 strong. Similarly, an old weak symbol definition from a regular
1238 file is treated as strong when the new symbol comes from a dynamic
1239 library. Further, an old weak symbol from a dynamic library is
1240 treated as strong if the new symbol is from a dynamic library.
1241 This reflects the way glibc's ld.so works.
1243 Do this before setting *type_change_ok or *size_change_ok so that
1244 we warn properly when dynamic library symbols are overridden. */
1246 if (newdef && !newdyn && olddyn)
1248 if (olddef && newdyn)
1251 /* Allow changes between different types of function symbol. */
1252 if (newfunc && oldfunc)
1253 *type_change_ok = TRUE;
1255 /* It's OK to change the type if either the existing symbol or the
1256 new symbol is weak. A type change is also OK if the old symbol
1257 is undefined and the new symbol is defined. */
1262 && h->root.type == bfd_link_hash_undefined))
1263 *type_change_ok = TRUE;
1265 /* It's OK to change the size if either the existing symbol or the
1266 new symbol is weak, or if the old symbol is undefined. */
1269 || h->root.type == bfd_link_hash_undefined)
1270 *size_change_ok = TRUE;
1272 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1273 symbol, respectively, appears to be a common symbol in a dynamic
1274 object. If a symbol appears in an uninitialized section, and is
1275 not weak, and is not a function, then it may be a common symbol
1276 which was resolved when the dynamic object was created. We want
1277 to treat such symbols specially, because they raise special
1278 considerations when setting the symbol size: if the symbol
1279 appears as a common symbol in a regular object, and the size in
1280 the regular object is larger, we must make sure that we use the
1281 larger size. This problematic case can always be avoided in C,
1282 but it must be handled correctly when using Fortran shared
1285 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1286 likewise for OLDDYNCOMMON and OLDDEF.
1288 Note that this test is just a heuristic, and that it is quite
1289 possible to have an uninitialized symbol in a shared object which
1290 is really a definition, rather than a common symbol. This could
1291 lead to some minor confusion when the symbol really is a common
1292 symbol in some regular object. However, I think it will be
1298 && (sec->flags & SEC_ALLOC) != 0
1299 && (sec->flags & SEC_LOAD) == 0
1302 newdyncommon = TRUE;
1304 newdyncommon = FALSE;
1308 && h->root.type == bfd_link_hash_defined
1310 && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1311 && (h->root.u.def.section->flags & SEC_LOAD) == 0
1314 olddyncommon = TRUE;
1316 olddyncommon = FALSE;
1318 /* We now know everything about the old and new symbols. We ask the
1319 backend to check if we can merge them. */
1320 if (bed->merge_symbol != NULL)
1322 if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
1327 /* If both the old and the new symbols look like common symbols in a
1328 dynamic object, set the size of the symbol to the larger of the
1333 && sym->st_size != h->size)
1335 /* Since we think we have two common symbols, issue a multiple
1336 common warning if desired. Note that we only warn if the
1337 size is different. If the size is the same, we simply let
1338 the old symbol override the new one as normally happens with
1339 symbols defined in dynamic objects. */
1341 if (! ((*info->callbacks->multiple_common)
1342 (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1345 if (sym->st_size > h->size)
1346 h->size = sym->st_size;
1348 *size_change_ok = TRUE;
1351 /* If we are looking at a dynamic object, and we have found a
1352 definition, we need to see if the symbol was already defined by
1353 some other object. If so, we want to use the existing
1354 definition, and we do not want to report a multiple symbol
1355 definition error; we do this by clobbering *PSEC to be
1356 bfd_und_section_ptr.
1358 We treat a common symbol as a definition if the symbol in the
1359 shared library is a function, since common symbols always
1360 represent variables; this can cause confusion in principle, but
1361 any such confusion would seem to indicate an erroneous program or
1362 shared library. We also permit a common symbol in a regular
1363 object to override a weak symbol in a shared object. */
1368 || (h->root.type == bfd_link_hash_common
1369 && (newweak || newfunc))))
1373 newdyncommon = FALSE;
1375 *psec = sec = bfd_und_section_ptr;
1376 *size_change_ok = TRUE;
1378 /* If we get here when the old symbol is a common symbol, then
1379 we are explicitly letting it override a weak symbol or
1380 function in a dynamic object, and we don't want to warn about
1381 a type change. If the old symbol is a defined symbol, a type
1382 change warning may still be appropriate. */
1384 if (h->root.type == bfd_link_hash_common)
1385 *type_change_ok = TRUE;
1388 /* Handle the special case of an old common symbol merging with a
1389 new symbol which looks like a common symbol in a shared object.
1390 We change *PSEC and *PVALUE to make the new symbol look like a
1391 common symbol, and let _bfd_generic_link_add_one_symbol do the
1395 && h->root.type == bfd_link_hash_common)
1399 newdyncommon = FALSE;
1400 *pvalue = sym->st_size;
1401 *psec = sec = bed->common_section (oldsec);
1402 *size_change_ok = TRUE;
1405 /* Skip weak definitions of symbols that are already defined. */
1406 if (newdef && olddef && newweak)
1408 /* Don't skip new non-IR weak syms. */
1409 if (!(oldbfd != NULL
1410 && (oldbfd->flags & BFD_PLUGIN) != 0
1411 && (abfd->flags & BFD_PLUGIN) == 0))
1417 /* Merge st_other. If the symbol already has a dynamic index,
1418 but visibility says it should not be visible, turn it into a
1420 elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1421 if (h->dynindx != -1)
1422 switch (ELF_ST_VISIBILITY (h->other))
1426 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1431 /* If the old symbol is from a dynamic object, and the new symbol is
1432 a definition which is not from a dynamic object, then the new
1433 symbol overrides the old symbol. Symbols from regular files
1434 always take precedence over symbols from dynamic objects, even if
1435 they are defined after the dynamic object in the link.
1437 As above, we again permit a common symbol in a regular object to
1438 override a definition in a shared object if the shared object
1439 symbol is a function or is weak. */
1444 || (bfd_is_com_section (sec)
1445 && (oldweak || oldfunc)))
1450 /* Change the hash table entry to undefined, and let
1451 _bfd_generic_link_add_one_symbol do the right thing with the
1454 h->root.type = bfd_link_hash_undefined;
1455 h->root.u.undef.abfd = h->root.u.def.section->owner;
1456 *size_change_ok = TRUE;
1459 olddyncommon = FALSE;
1461 /* We again permit a type change when a common symbol may be
1462 overriding a function. */
1464 if (bfd_is_com_section (sec))
1468 /* If a common symbol overrides a function, make sure
1469 that it isn't defined dynamically nor has type
1472 h->type = STT_NOTYPE;
1474 *type_change_ok = TRUE;
1477 if (hi->root.type == bfd_link_hash_indirect)
1480 /* This union may have been set to be non-NULL when this symbol
1481 was seen in a dynamic object. We must force the union to be
1482 NULL, so that it is correct for a regular symbol. */
1483 h->verinfo.vertree = NULL;
1486 /* Handle the special case of a new common symbol merging with an
1487 old symbol that looks like it might be a common symbol defined in
1488 a shared object. Note that we have already handled the case in
1489 which a new common symbol should simply override the definition
1490 in the shared library. */
1493 && bfd_is_com_section (sec)
1496 /* It would be best if we could set the hash table entry to a
1497 common symbol, but we don't know what to use for the section
1498 or the alignment. */
1499 if (! ((*info->callbacks->multiple_common)
1500 (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1503 /* If the presumed common symbol in the dynamic object is
1504 larger, pretend that the new symbol has its size. */
1506 if (h->size > *pvalue)
1509 /* We need to remember the alignment required by the symbol
1510 in the dynamic object. */
1511 BFD_ASSERT (pold_alignment);
1512 *pold_alignment = h->root.u.def.section->alignment_power;
1515 olddyncommon = FALSE;
1517 h->root.type = bfd_link_hash_undefined;
1518 h->root.u.undef.abfd = h->root.u.def.section->owner;
1520 *size_change_ok = TRUE;
1521 *type_change_ok = TRUE;
1523 if (hi->root.type == bfd_link_hash_indirect)
1526 h->verinfo.vertree = NULL;
1531 /* Handle the case where we had a versioned symbol in a dynamic
1532 library and now find a definition in a normal object. In this
1533 case, we make the versioned symbol point to the normal one. */
1534 flip->root.type = h->root.type;
1535 flip->root.u.undef.abfd = h->root.u.undef.abfd;
1536 h->root.type = bfd_link_hash_indirect;
1537 h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1538 (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1542 flip->ref_dynamic = 1;
1549 /* This function is called to create an indirect symbol from the
1550 default for the symbol with the default version if needed. The
1551 symbol is described by H, NAME, SYM, SEC, and VALUE. We
1552 set DYNSYM if the new indirect symbol is dynamic. */
1555 _bfd_elf_add_default_symbol (bfd *abfd,
1556 struct bfd_link_info *info,
1557 struct elf_link_hash_entry *h,
1559 Elf_Internal_Sym *sym,
1563 bfd_boolean *dynsym)
1565 bfd_boolean type_change_ok;
1566 bfd_boolean size_change_ok;
1569 struct elf_link_hash_entry *hi;
1570 struct bfd_link_hash_entry *bh;
1571 const struct elf_backend_data *bed;
1572 bfd_boolean collect;
1573 bfd_boolean dynamic;
1574 bfd_boolean override;
1576 size_t len, shortlen;
1579 /* If this symbol has a version, and it is the default version, we
1580 create an indirect symbol from the default name to the fully
1581 decorated name. This will cause external references which do not
1582 specify a version to be bound to this version of the symbol. */
1583 p = strchr (name, ELF_VER_CHR);
1584 if (p == NULL || p[1] != ELF_VER_CHR)
1587 bed = get_elf_backend_data (abfd);
1588 collect = bed->collect;
1589 dynamic = (abfd->flags & DYNAMIC) != 0;
1591 shortlen = p - name;
1592 shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1593 if (shortname == NULL)
1595 memcpy (shortname, name, shortlen);
1596 shortname[shortlen] = '\0';
1598 /* We are going to create a new symbol. Merge it with any existing
1599 symbol with this name. For the purposes of the merge, act as
1600 though we were defining the symbol we just defined, although we
1601 actually going to define an indirect symbol. */
1602 type_change_ok = FALSE;
1603 size_change_ok = FALSE;
1605 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1606 &hi, poldbfd, NULL, NULL, &skip, &override,
1607 &type_change_ok, &size_change_ok))
1616 if (! (_bfd_generic_link_add_one_symbol
1617 (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1618 0, name, FALSE, collect, &bh)))
1620 hi = (struct elf_link_hash_entry *) bh;
1624 /* In this case the symbol named SHORTNAME is overriding the
1625 indirect symbol we want to add. We were planning on making
1626 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1627 is the name without a version. NAME is the fully versioned
1628 name, and it is the default version.
1630 Overriding means that we already saw a definition for the
1631 symbol SHORTNAME in a regular object, and it is overriding
1632 the symbol defined in the dynamic object.
1634 When this happens, we actually want to change NAME, the
1635 symbol we just added, to refer to SHORTNAME. This will cause
1636 references to NAME in the shared object to become references
1637 to SHORTNAME in the regular object. This is what we expect
1638 when we override a function in a shared object: that the
1639 references in the shared object will be mapped to the
1640 definition in the regular object. */
1642 while (hi->root.type == bfd_link_hash_indirect
1643 || hi->root.type == bfd_link_hash_warning)
1644 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1646 h->root.type = bfd_link_hash_indirect;
1647 h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1651 hi->ref_dynamic = 1;
1655 if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1660 /* Now set HI to H, so that the following code will set the
1661 other fields correctly. */
1665 /* Check if HI is a warning symbol. */
1666 if (hi->root.type == bfd_link_hash_warning)
1667 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1669 /* If there is a duplicate definition somewhere, then HI may not
1670 point to an indirect symbol. We will have reported an error to
1671 the user in that case. */
1673 if (hi->root.type == bfd_link_hash_indirect)
1675 struct elf_link_hash_entry *ht;
1677 ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1678 (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1680 /* A reference to the SHORTNAME symbol from a dynamic library
1681 will be satisfied by the versioned symbol at runtime. In
1682 effect, we have a reference to the versioned symbol. */
1683 ht->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1684 hi->dynamic_def |= ht->dynamic_def;
1686 /* See if the new flags lead us to realize that the symbol must
1692 if (! info->executable
1699 if (hi->ref_regular)
1705 /* We also need to define an indirection from the nondefault version
1709 len = strlen (name);
1710 shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1711 if (shortname == NULL)
1713 memcpy (shortname, name, shortlen);
1714 memcpy (shortname + shortlen, p + 1, len - shortlen);
1716 /* Once again, merge with any existing symbol. */
1717 type_change_ok = FALSE;
1718 size_change_ok = FALSE;
1720 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1721 &hi, poldbfd, NULL, NULL, &skip, &override,
1722 &type_change_ok, &size_change_ok))
1730 /* Here SHORTNAME is a versioned name, so we don't expect to see
1731 the type of override we do in the case above unless it is
1732 overridden by a versioned definition. */
1733 if (hi->root.type != bfd_link_hash_defined
1734 && hi->root.type != bfd_link_hash_defweak)
1735 (*_bfd_error_handler)
1736 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1742 if (! (_bfd_generic_link_add_one_symbol
1743 (info, abfd, shortname, BSF_INDIRECT,
1744 bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1746 hi = (struct elf_link_hash_entry *) bh;
1748 /* If there is a duplicate definition somewhere, then HI may not
1749 point to an indirect symbol. We will have reported an error
1750 to the user in that case. */
1752 if (hi->root.type == bfd_link_hash_indirect)
1754 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1755 h->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1756 hi->dynamic_def |= h->dynamic_def;
1758 /* See if the new flags lead us to realize that the symbol
1764 if (! info->executable
1770 if (hi->ref_regular)
1780 /* This routine is used to export all defined symbols into the dynamic
1781 symbol table. It is called via elf_link_hash_traverse. */
1784 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1786 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1788 /* Ignore indirect symbols. These are added by the versioning code. */
1789 if (h->root.type == bfd_link_hash_indirect)
1792 /* Ignore this if we won't export it. */
1793 if (!eif->info->export_dynamic && !h->dynamic)
1796 if (h->dynindx == -1
1797 && (h->def_regular || h->ref_regular)
1798 && ! bfd_hide_sym_by_version (eif->info->version_info,
1799 h->root.root.string))
1801 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1811 /* Look through the symbols which are defined in other shared
1812 libraries and referenced here. Update the list of version
1813 dependencies. This will be put into the .gnu.version_r section.
1814 This function is called via elf_link_hash_traverse. */
1817 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1820 struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1821 Elf_Internal_Verneed *t;
1822 Elf_Internal_Vernaux *a;
1825 /* We only care about symbols defined in shared objects with version
1830 || h->verinfo.verdef == NULL
1831 || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
1832 & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
1835 /* See if we already know about this version. */
1836 for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1840 if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1843 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1844 if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1850 /* This is a new version. Add it to tree we are building. */
1855 t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1858 rinfo->failed = TRUE;
1862 t->vn_bfd = h->verinfo.verdef->vd_bfd;
1863 t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1864 elf_tdata (rinfo->info->output_bfd)->verref = t;
1868 a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1871 rinfo->failed = TRUE;
1875 /* Note that we are copying a string pointer here, and testing it
1876 above. If bfd_elf_string_from_elf_section is ever changed to
1877 discard the string data when low in memory, this will have to be
1879 a->vna_nodename = h->verinfo.verdef->vd_nodename;
1881 a->vna_flags = h->verinfo.verdef->vd_flags;
1882 a->vna_nextptr = t->vn_auxptr;
1884 h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1887 a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1894 /* Figure out appropriate versions for all the symbols. We may not
1895 have the version number script until we have read all of the input
1896 files, so until that point we don't know which symbols should be
1897 local. This function is called via elf_link_hash_traverse. */
1900 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1902 struct elf_info_failed *sinfo;
1903 struct bfd_link_info *info;
1904 const struct elf_backend_data *bed;
1905 struct elf_info_failed eif;
1909 sinfo = (struct elf_info_failed *) data;
1912 /* Fix the symbol flags. */
1915 if (! _bfd_elf_fix_symbol_flags (h, &eif))
1918 sinfo->failed = TRUE;
1922 /* We only need version numbers for symbols defined in regular
1924 if (!h->def_regular)
1927 bed = get_elf_backend_data (info->output_bfd);
1928 p = strchr (h->root.root.string, ELF_VER_CHR);
1929 if (p != NULL && h->verinfo.vertree == NULL)
1931 struct bfd_elf_version_tree *t;
1936 /* There are two consecutive ELF_VER_CHR characters if this is
1937 not a hidden symbol. */
1939 if (*p == ELF_VER_CHR)
1945 /* If there is no version string, we can just return out. */
1953 /* Look for the version. If we find it, it is no longer weak. */
1954 for (t = sinfo->info->version_info; t != NULL; t = t->next)
1956 if (strcmp (t->name, p) == 0)
1960 struct bfd_elf_version_expr *d;
1962 len = p - h->root.root.string;
1963 alc = (char *) bfd_malloc (len);
1966 sinfo->failed = TRUE;
1969 memcpy (alc, h->root.root.string, len - 1);
1970 alc[len - 1] = '\0';
1971 if (alc[len - 2] == ELF_VER_CHR)
1972 alc[len - 2] = '\0';
1974 h->verinfo.vertree = t;
1978 if (t->globals.list != NULL)
1979 d = (*t->match) (&t->globals, NULL, alc);
1981 /* See if there is anything to force this symbol to
1983 if (d == NULL && t->locals.list != NULL)
1985 d = (*t->match) (&t->locals, NULL, alc);
1988 && ! info->export_dynamic)
1989 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1997 /* If we are building an application, we need to create a
1998 version node for this version. */
1999 if (t == NULL && info->executable)
2001 struct bfd_elf_version_tree **pp;
2004 /* If we aren't going to export this symbol, we don't need
2005 to worry about it. */
2006 if (h->dynindx == -1)
2010 t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2013 sinfo->failed = TRUE;
2018 t->name_indx = (unsigned int) -1;
2022 /* Don't count anonymous version tag. */
2023 if (sinfo->info->version_info != NULL
2024 && sinfo->info->version_info->vernum == 0)
2026 for (pp = &sinfo->info->version_info;
2030 t->vernum = version_index;
2034 h->verinfo.vertree = t;
2038 /* We could not find the version for a symbol when
2039 generating a shared archive. Return an error. */
2040 (*_bfd_error_handler)
2041 (_("%B: version node not found for symbol %s"),
2042 info->output_bfd, h->root.root.string);
2043 bfd_set_error (bfd_error_bad_value);
2044 sinfo->failed = TRUE;
2052 /* If we don't have a version for this symbol, see if we can find
2054 if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
2059 = bfd_find_version_for_sym (sinfo->info->version_info,
2060 h->root.root.string, &hide);
2061 if (h->verinfo.vertree != NULL && hide)
2062 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2068 /* Read and swap the relocs from the section indicated by SHDR. This
2069 may be either a REL or a RELA section. The relocations are
2070 translated into RELA relocations and stored in INTERNAL_RELOCS,
2071 which should have already been allocated to contain enough space.
2072 The EXTERNAL_RELOCS are a buffer where the external form of the
2073 relocations should be stored.
2075 Returns FALSE if something goes wrong. */
2078 elf_link_read_relocs_from_section (bfd *abfd,
2080 Elf_Internal_Shdr *shdr,
2081 void *external_relocs,
2082 Elf_Internal_Rela *internal_relocs)
2084 const struct elf_backend_data *bed;
2085 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2086 const bfd_byte *erela;
2087 const bfd_byte *erelaend;
2088 Elf_Internal_Rela *irela;
2089 Elf_Internal_Shdr *symtab_hdr;
2092 /* Position ourselves at the start of the section. */
2093 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2096 /* Read the relocations. */
2097 if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2100 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2101 nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2103 bed = get_elf_backend_data (abfd);
2105 /* Convert the external relocations to the internal format. */
2106 if (shdr->sh_entsize == bed->s->sizeof_rel)
2107 swap_in = bed->s->swap_reloc_in;
2108 else if (shdr->sh_entsize == bed->s->sizeof_rela)
2109 swap_in = bed->s->swap_reloca_in;
2112 bfd_set_error (bfd_error_wrong_format);
2116 erela = (const bfd_byte *) external_relocs;
2117 erelaend = erela + shdr->sh_size;
2118 irela = internal_relocs;
2119 while (erela < erelaend)
2123 (*swap_in) (abfd, erela, irela);
2124 r_symndx = ELF32_R_SYM (irela->r_info);
2125 if (bed->s->arch_size == 64)
2129 if ((size_t) r_symndx >= nsyms)
2131 (*_bfd_error_handler)
2132 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2133 " for offset 0x%lx in section `%A'"),
2135 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2136 bfd_set_error (bfd_error_bad_value);
2140 else if (r_symndx != STN_UNDEF)
2142 (*_bfd_error_handler)
2143 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2144 " when the object file has no symbol table"),
2146 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2147 bfd_set_error (bfd_error_bad_value);
2150 irela += bed->s->int_rels_per_ext_rel;
2151 erela += shdr->sh_entsize;
2157 /* Read and swap the relocs for a section O. They may have been
2158 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2159 not NULL, they are used as buffers to read into. They are known to
2160 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2161 the return value is allocated using either malloc or bfd_alloc,
2162 according to the KEEP_MEMORY argument. If O has two relocation
2163 sections (both REL and RELA relocations), then the REL_HDR
2164 relocations will appear first in INTERNAL_RELOCS, followed by the
2165 RELA_HDR relocations. */
2168 _bfd_elf_link_read_relocs (bfd *abfd,
2170 void *external_relocs,
2171 Elf_Internal_Rela *internal_relocs,
2172 bfd_boolean keep_memory)
2174 void *alloc1 = NULL;
2175 Elf_Internal_Rela *alloc2 = NULL;
2176 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2177 struct bfd_elf_section_data *esdo = elf_section_data (o);
2178 Elf_Internal_Rela *internal_rela_relocs;
2180 if (esdo->relocs != NULL)
2181 return esdo->relocs;
2183 if (o->reloc_count == 0)
2186 if (internal_relocs == NULL)
2190 size = o->reloc_count;
2191 size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2193 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2195 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2196 if (internal_relocs == NULL)
2200 if (external_relocs == NULL)
2202 bfd_size_type size = 0;
2205 size += esdo->rel.hdr->sh_size;
2207 size += esdo->rela.hdr->sh_size;
2209 alloc1 = bfd_malloc (size);
2212 external_relocs = alloc1;
2215 internal_rela_relocs = internal_relocs;
2218 if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2222 external_relocs = (((bfd_byte *) external_relocs)
2223 + esdo->rel.hdr->sh_size);
2224 internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2225 * bed->s->int_rels_per_ext_rel);
2229 && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2231 internal_rela_relocs)))
2234 /* Cache the results for next time, if we can. */
2236 esdo->relocs = internal_relocs;
2241 /* Don't free alloc2, since if it was allocated we are passing it
2242 back (under the name of internal_relocs). */
2244 return internal_relocs;
2252 bfd_release (abfd, alloc2);
2259 /* Compute the size of, and allocate space for, REL_HDR which is the
2260 section header for a section containing relocations for O. */
2263 _bfd_elf_link_size_reloc_section (bfd *abfd,
2264 struct bfd_elf_section_reloc_data *reldata)
2266 Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2268 /* That allows us to calculate the size of the section. */
2269 rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2271 /* The contents field must last into write_object_contents, so we
2272 allocate it with bfd_alloc rather than malloc. Also since we
2273 cannot be sure that the contents will actually be filled in,
2274 we zero the allocated space. */
2275 rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2276 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2279 if (reldata->hashes == NULL && reldata->count)
2281 struct elf_link_hash_entry **p;
2283 p = ((struct elf_link_hash_entry **)
2284 bfd_zmalloc (reldata->count * sizeof (*p)));
2288 reldata->hashes = p;
2294 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2295 originated from the section given by INPUT_REL_HDR) to the
2299 _bfd_elf_link_output_relocs (bfd *output_bfd,
2300 asection *input_section,
2301 Elf_Internal_Shdr *input_rel_hdr,
2302 Elf_Internal_Rela *internal_relocs,
2303 struct elf_link_hash_entry **rel_hash
2306 Elf_Internal_Rela *irela;
2307 Elf_Internal_Rela *irelaend;
2309 struct bfd_elf_section_reloc_data *output_reldata;
2310 asection *output_section;
2311 const struct elf_backend_data *bed;
2312 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2313 struct bfd_elf_section_data *esdo;
2315 output_section = input_section->output_section;
2317 bed = get_elf_backend_data (output_bfd);
2318 esdo = elf_section_data (output_section);
2319 if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2321 output_reldata = &esdo->rel;
2322 swap_out = bed->s->swap_reloc_out;
2324 else if (esdo->rela.hdr
2325 && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2327 output_reldata = &esdo->rela;
2328 swap_out = bed->s->swap_reloca_out;
2332 (*_bfd_error_handler)
2333 (_("%B: relocation size mismatch in %B section %A"),
2334 output_bfd, input_section->owner, input_section);
2335 bfd_set_error (bfd_error_wrong_format);
2339 erel = output_reldata->hdr->contents;
2340 erel += output_reldata->count * input_rel_hdr->sh_entsize;
2341 irela = internal_relocs;
2342 irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2343 * bed->s->int_rels_per_ext_rel);
2344 while (irela < irelaend)
2346 (*swap_out) (output_bfd, irela, erel);
2347 irela += bed->s->int_rels_per_ext_rel;
2348 erel += input_rel_hdr->sh_entsize;
2351 /* Bump the counter, so that we know where to add the next set of
2353 output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2358 /* Make weak undefined symbols in PIE dynamic. */
2361 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2362 struct elf_link_hash_entry *h)
2366 && h->root.type == bfd_link_hash_undefweak)
2367 return bfd_elf_link_record_dynamic_symbol (info, h);
2372 /* Fix up the flags for a symbol. This handles various cases which
2373 can only be fixed after all the input files are seen. This is
2374 currently called by both adjust_dynamic_symbol and
2375 assign_sym_version, which is unnecessary but perhaps more robust in
2376 the face of future changes. */
2379 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2380 struct elf_info_failed *eif)
2382 const struct elf_backend_data *bed;
2384 /* If this symbol was mentioned in a non-ELF file, try to set
2385 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2386 permit a non-ELF file to correctly refer to a symbol defined in
2387 an ELF dynamic object. */
2390 while (h->root.type == bfd_link_hash_indirect)
2391 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2393 if (h->root.type != bfd_link_hash_defined
2394 && h->root.type != bfd_link_hash_defweak)
2397 h->ref_regular_nonweak = 1;
2401 if (h->root.u.def.section->owner != NULL
2402 && (bfd_get_flavour (h->root.u.def.section->owner)
2403 == bfd_target_elf_flavour))
2406 h->ref_regular_nonweak = 1;
2412 if (h->dynindx == -1
2416 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2425 /* Unfortunately, NON_ELF is only correct if the symbol
2426 was first seen in a non-ELF file. Fortunately, if the symbol
2427 was first seen in an ELF file, we're probably OK unless the
2428 symbol was defined in a non-ELF file. Catch that case here.
2429 FIXME: We're still in trouble if the symbol was first seen in
2430 a dynamic object, and then later in a non-ELF regular object. */
2431 if ((h->root.type == bfd_link_hash_defined
2432 || h->root.type == bfd_link_hash_defweak)
2434 && (h->root.u.def.section->owner != NULL
2435 ? (bfd_get_flavour (h->root.u.def.section->owner)
2436 != bfd_target_elf_flavour)
2437 : (bfd_is_abs_section (h->root.u.def.section)
2438 && !h->def_dynamic)))
2442 /* Backend specific symbol fixup. */
2443 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2444 if (bed->elf_backend_fixup_symbol
2445 && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2448 /* If this is a final link, and the symbol was defined as a common
2449 symbol in a regular object file, and there was no definition in
2450 any dynamic object, then the linker will have allocated space for
2451 the symbol in a common section but the DEF_REGULAR
2452 flag will not have been set. */
2453 if (h->root.type == bfd_link_hash_defined
2457 && (h->root.u.def.section->owner->flags & (DYNAMIC | BFD_PLUGIN)) == 0)
2460 /* If -Bsymbolic was used (which means to bind references to global
2461 symbols to the definition within the shared object), and this
2462 symbol was defined in a regular object, then it actually doesn't
2463 need a PLT entry. Likewise, if the symbol has non-default
2464 visibility. If the symbol has hidden or internal visibility, we
2465 will force it local. */
2467 && eif->info->shared
2468 && is_elf_hash_table (eif->info->hash)
2469 && (SYMBOLIC_BIND (eif->info, h)
2470 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2473 bfd_boolean force_local;
2475 force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2476 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2477 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2480 /* If a weak undefined symbol has non-default visibility, we also
2481 hide it from the dynamic linker. */
2482 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2483 && h->root.type == bfd_link_hash_undefweak)
2484 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2486 /* If this is a weak defined symbol in a dynamic object, and we know
2487 the real definition in the dynamic object, copy interesting flags
2488 over to the real definition. */
2489 if (h->u.weakdef != NULL)
2491 /* If the real definition is defined by a regular object file,
2492 don't do anything special. See the longer description in
2493 _bfd_elf_adjust_dynamic_symbol, below. */
2494 if (h->u.weakdef->def_regular)
2495 h->u.weakdef = NULL;
2498 struct elf_link_hash_entry *weakdef = h->u.weakdef;
2500 while (h->root.type == bfd_link_hash_indirect)
2501 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2503 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2504 || h->root.type == bfd_link_hash_defweak);
2505 BFD_ASSERT (weakdef->def_dynamic);
2506 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2507 || weakdef->root.type == bfd_link_hash_defweak);
2508 (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2515 /* Make the backend pick a good value for a dynamic symbol. This is
2516 called via elf_link_hash_traverse, and also calls itself
2520 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2522 struct elf_info_failed *eif = (struct elf_info_failed *) data;
2524 const struct elf_backend_data *bed;
2526 if (! is_elf_hash_table (eif->info->hash))
2529 /* Ignore indirect symbols. These are added by the versioning code. */
2530 if (h->root.type == bfd_link_hash_indirect)
2533 /* Fix the symbol flags. */
2534 if (! _bfd_elf_fix_symbol_flags (h, eif))
2537 /* If this symbol does not require a PLT entry, and it is not
2538 defined by a dynamic object, or is not referenced by a regular
2539 object, ignore it. We do have to handle a weak defined symbol,
2540 even if no regular object refers to it, if we decided to add it
2541 to the dynamic symbol table. FIXME: Do we normally need to worry
2542 about symbols which are defined by one dynamic object and
2543 referenced by another one? */
2545 && h->type != STT_GNU_IFUNC
2549 && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2551 h->plt = elf_hash_table (eif->info)->init_plt_offset;
2555 /* If we've already adjusted this symbol, don't do it again. This
2556 can happen via a recursive call. */
2557 if (h->dynamic_adjusted)
2560 /* Don't look at this symbol again. Note that we must set this
2561 after checking the above conditions, because we may look at a
2562 symbol once, decide not to do anything, and then get called
2563 recursively later after REF_REGULAR is set below. */
2564 h->dynamic_adjusted = 1;
2566 /* If this is a weak definition, and we know a real definition, and
2567 the real symbol is not itself defined by a regular object file,
2568 then get a good value for the real definition. We handle the
2569 real symbol first, for the convenience of the backend routine.
2571 Note that there is a confusing case here. If the real definition
2572 is defined by a regular object file, we don't get the real symbol
2573 from the dynamic object, but we do get the weak symbol. If the
2574 processor backend uses a COPY reloc, then if some routine in the
2575 dynamic object changes the real symbol, we will not see that
2576 change in the corresponding weak symbol. This is the way other
2577 ELF linkers work as well, and seems to be a result of the shared
2580 I will clarify this issue. Most SVR4 shared libraries define the
2581 variable _timezone and define timezone as a weak synonym. The
2582 tzset call changes _timezone. If you write
2583 extern int timezone;
2585 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2586 you might expect that, since timezone is a synonym for _timezone,
2587 the same number will print both times. However, if the processor
2588 backend uses a COPY reloc, then actually timezone will be copied
2589 into your process image, and, since you define _timezone
2590 yourself, _timezone will not. Thus timezone and _timezone will
2591 wind up at different memory locations. The tzset call will set
2592 _timezone, leaving timezone unchanged. */
2594 if (h->u.weakdef != NULL)
2596 /* If we get to this point, there is an implicit reference to
2597 H->U.WEAKDEF by a regular object file via the weak symbol H. */
2598 h->u.weakdef->ref_regular = 1;
2600 /* Ensure that the backend adjust_dynamic_symbol function sees
2601 H->U.WEAKDEF before H by recursively calling ourselves. */
2602 if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2606 /* If a symbol has no type and no size and does not require a PLT
2607 entry, then we are probably about to do the wrong thing here: we
2608 are probably going to create a COPY reloc for an empty object.
2609 This case can arise when a shared object is built with assembly
2610 code, and the assembly code fails to set the symbol type. */
2612 && h->type == STT_NOTYPE
2614 (*_bfd_error_handler)
2615 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2616 h->root.root.string);
2618 dynobj = elf_hash_table (eif->info)->dynobj;
2619 bed = get_elf_backend_data (dynobj);
2621 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2630 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2634 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
2635 struct elf_link_hash_entry *h,
2638 unsigned int power_of_two;
2640 asection *sec = h->root.u.def.section;
2642 /* The section aligment of definition is the maximum alignment
2643 requirement of symbols defined in the section. Since we don't
2644 know the symbol alignment requirement, we start with the
2645 maximum alignment and check low bits of the symbol address
2646 for the minimum alignment. */
2647 power_of_two = bfd_get_section_alignment (sec->owner, sec);
2648 mask = ((bfd_vma) 1 << power_of_two) - 1;
2649 while ((h->root.u.def.value & mask) != 0)
2655 if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2658 /* Adjust the section alignment if needed. */
2659 if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2664 /* We make sure that the symbol will be aligned properly. */
2665 dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2667 /* Define the symbol as being at this point in DYNBSS. */
2668 h->root.u.def.section = dynbss;
2669 h->root.u.def.value = dynbss->size;
2671 /* Increment the size of DYNBSS to make room for the symbol. */
2672 dynbss->size += h->size;
2674 if (h->protected_def)
2676 info->callbacks->einfo
2677 (_("%P: copy reloc against protected `%T' is invalid\n"),
2678 h->root.root.string);
2679 bfd_set_error (bfd_error_bad_value);
2686 /* Adjust all external symbols pointing into SEC_MERGE sections
2687 to reflect the object merging within the sections. */
2690 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2694 if ((h->root.type == bfd_link_hash_defined
2695 || h->root.type == bfd_link_hash_defweak)
2696 && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2697 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
2699 bfd *output_bfd = (bfd *) data;
2701 h->root.u.def.value =
2702 _bfd_merged_section_offset (output_bfd,
2703 &h->root.u.def.section,
2704 elf_section_data (sec)->sec_info,
2705 h->root.u.def.value);
2711 /* Returns false if the symbol referred to by H should be considered
2712 to resolve local to the current module, and true if it should be
2713 considered to bind dynamically. */
2716 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2717 struct bfd_link_info *info,
2718 bfd_boolean not_local_protected)
2720 bfd_boolean binding_stays_local_p;
2721 const struct elf_backend_data *bed;
2722 struct elf_link_hash_table *hash_table;
2727 while (h->root.type == bfd_link_hash_indirect
2728 || h->root.type == bfd_link_hash_warning)
2729 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2731 /* If it was forced local, then clearly it's not dynamic. */
2732 if (h->dynindx == -1)
2734 if (h->forced_local)
2737 /* Identify the cases where name binding rules say that a
2738 visible symbol resolves locally. */
2739 binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2741 switch (ELF_ST_VISIBILITY (h->other))
2748 hash_table = elf_hash_table (info);
2749 if (!is_elf_hash_table (hash_table))
2752 bed = get_elf_backend_data (hash_table->dynobj);
2754 /* Proper resolution for function pointer equality may require
2755 that these symbols perhaps be resolved dynamically, even though
2756 we should be resolving them to the current module. */
2757 if (!not_local_protected || !bed->is_function_type (h->type))
2758 binding_stays_local_p = TRUE;
2765 /* If it isn't defined locally, then clearly it's dynamic. */
2766 if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2769 /* Otherwise, the symbol is dynamic if binding rules don't tell
2770 us that it remains local. */
2771 return !binding_stays_local_p;
2774 /* Return true if the symbol referred to by H should be considered
2775 to resolve local to the current module, and false otherwise. Differs
2776 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2777 undefined symbols. The two functions are virtually identical except
2778 for the place where forced_local and dynindx == -1 are tested. If
2779 either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2780 the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2781 the symbol is local only for defined symbols.
2782 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2783 !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2784 treatment of undefined weak symbols. For those that do not make
2785 undefined weak symbols dynamic, both functions may return false. */
2788 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2789 struct bfd_link_info *info,
2790 bfd_boolean local_protected)
2792 const struct elf_backend_data *bed;
2793 struct elf_link_hash_table *hash_table;
2795 /* If it's a local sym, of course we resolve locally. */
2799 /* STV_HIDDEN or STV_INTERNAL ones must be local. */
2800 if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2801 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2804 /* Common symbols that become definitions don't get the DEF_REGULAR
2805 flag set, so test it first, and don't bail out. */
2806 if (ELF_COMMON_DEF_P (h))
2808 /* If we don't have a definition in a regular file, then we can't
2809 resolve locally. The sym is either undefined or dynamic. */
2810 else if (!h->def_regular)
2813 /* Forced local symbols resolve locally. */
2814 if (h->forced_local)
2817 /* As do non-dynamic symbols. */
2818 if (h->dynindx == -1)
2821 /* At this point, we know the symbol is defined and dynamic. In an
2822 executable it must resolve locally, likewise when building symbolic
2823 shared libraries. */
2824 if (info->executable || SYMBOLIC_BIND (info, h))
2827 /* Now deal with defined dynamic symbols in shared libraries. Ones
2828 with default visibility might not resolve locally. */
2829 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2832 hash_table = elf_hash_table (info);
2833 if (!is_elf_hash_table (hash_table))
2836 bed = get_elf_backend_data (hash_table->dynobj);
2838 /* STV_PROTECTED non-function symbols are local. */
2839 if (!bed->is_function_type (h->type))
2842 /* Function pointer equality tests may require that STV_PROTECTED
2843 symbols be treated as dynamic symbols. If the address of a
2844 function not defined in an executable is set to that function's
2845 plt entry in the executable, then the address of the function in
2846 a shared library must also be the plt entry in the executable. */
2847 return local_protected;
2850 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2851 aligned. Returns the first TLS output section. */
2853 struct bfd_section *
2854 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2856 struct bfd_section *sec, *tls;
2857 unsigned int align = 0;
2859 for (sec = obfd->sections; sec != NULL; sec = sec->next)
2860 if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2864 for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2865 if (sec->alignment_power > align)
2866 align = sec->alignment_power;
2868 elf_hash_table (info)->tls_sec = tls;
2870 /* Ensure the alignment of the first section is the largest alignment,
2871 so that the tls segment starts aligned. */
2873 tls->alignment_power = align;
2878 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2880 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2881 Elf_Internal_Sym *sym)
2883 const struct elf_backend_data *bed;
2885 /* Local symbols do not count, but target specific ones might. */
2886 if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2887 && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2890 bed = get_elf_backend_data (abfd);
2891 /* Function symbols do not count. */
2892 if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2895 /* If the section is undefined, then so is the symbol. */
2896 if (sym->st_shndx == SHN_UNDEF)
2899 /* If the symbol is defined in the common section, then
2900 it is a common definition and so does not count. */
2901 if (bed->common_definition (sym))
2904 /* If the symbol is in a target specific section then we
2905 must rely upon the backend to tell us what it is. */
2906 if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2907 /* FIXME - this function is not coded yet:
2909 return _bfd_is_global_symbol_definition (abfd, sym);
2911 Instead for now assume that the definition is not global,
2912 Even if this is wrong, at least the linker will behave
2913 in the same way that it used to do. */
2919 /* Search the symbol table of the archive element of the archive ABFD
2920 whose archive map contains a mention of SYMDEF, and determine if
2921 the symbol is defined in this element. */
2923 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2925 Elf_Internal_Shdr * hdr;
2926 bfd_size_type symcount;
2927 bfd_size_type extsymcount;
2928 bfd_size_type extsymoff;
2929 Elf_Internal_Sym *isymbuf;
2930 Elf_Internal_Sym *isym;
2931 Elf_Internal_Sym *isymend;
2934 abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2938 if (! bfd_check_format (abfd, bfd_object))
2941 /* Select the appropriate symbol table. */
2942 if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2943 hdr = &elf_tdata (abfd)->symtab_hdr;
2945 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2947 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2949 /* The sh_info field of the symtab header tells us where the
2950 external symbols start. We don't care about the local symbols. */
2951 if (elf_bad_symtab (abfd))
2953 extsymcount = symcount;
2958 extsymcount = symcount - hdr->sh_info;
2959 extsymoff = hdr->sh_info;
2962 if (extsymcount == 0)
2965 /* Read in the symbol table. */
2966 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
2968 if (isymbuf == NULL)
2971 /* Scan the symbol table looking for SYMDEF. */
2973 for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
2977 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
2982 if (strcmp (name, symdef->name) == 0)
2984 result = is_global_data_symbol_definition (abfd, isym);
2994 /* Add an entry to the .dynamic table. */
2997 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3001 struct elf_link_hash_table *hash_table;
3002 const struct elf_backend_data *bed;
3004 bfd_size_type newsize;
3005 bfd_byte *newcontents;
3006 Elf_Internal_Dyn dyn;
3008 hash_table = elf_hash_table (info);
3009 if (! is_elf_hash_table (hash_table))
3012 bed = get_elf_backend_data (hash_table->dynobj);
3013 s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3014 BFD_ASSERT (s != NULL);
3016 newsize = s->size + bed->s->sizeof_dyn;
3017 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3018 if (newcontents == NULL)
3022 dyn.d_un.d_val = val;
3023 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3026 s->contents = newcontents;
3031 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3032 otherwise just check whether one already exists. Returns -1 on error,
3033 1 if a DT_NEEDED tag already exists, and 0 on success. */
3036 elf_add_dt_needed_tag (bfd *abfd,
3037 struct bfd_link_info *info,
3041 struct elf_link_hash_table *hash_table;
3042 bfd_size_type strindex;
3044 if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3047 hash_table = elf_hash_table (info);
3048 strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3049 if (strindex == (bfd_size_type) -1)
3052 if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
3055 const struct elf_backend_data *bed;
3058 bed = get_elf_backend_data (hash_table->dynobj);
3059 sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3061 for (extdyn = sdyn->contents;
3062 extdyn < sdyn->contents + sdyn->size;
3063 extdyn += bed->s->sizeof_dyn)
3065 Elf_Internal_Dyn dyn;
3067 bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3068 if (dyn.d_tag == DT_NEEDED
3069 && dyn.d_un.d_val == strindex)
3071 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3079 if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3082 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3086 /* We were just checking for existence of the tag. */
3087 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3093 on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3095 for (; needed != NULL; needed = needed->next)
3096 if ((elf_dyn_lib_class (needed->by) & DYN_AS_NEEDED) == 0
3097 && strcmp (soname, needed->name) == 0)
3103 /* Sort symbol by value, section, and size. */
3105 elf_sort_symbol (const void *arg1, const void *arg2)
3107 const struct elf_link_hash_entry *h1;
3108 const struct elf_link_hash_entry *h2;
3109 bfd_signed_vma vdiff;
3111 h1 = *(const struct elf_link_hash_entry **) arg1;
3112 h2 = *(const struct elf_link_hash_entry **) arg2;
3113 vdiff = h1->root.u.def.value - h2->root.u.def.value;
3115 return vdiff > 0 ? 1 : -1;
3118 long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3120 return sdiff > 0 ? 1 : -1;
3122 vdiff = h1->size - h2->size;
3123 return vdiff == 0 ? 0 : vdiff > 0 ? 1 : -1;
3126 /* This function is used to adjust offsets into .dynstr for
3127 dynamic symbols. This is called via elf_link_hash_traverse. */
3130 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3132 struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3134 if (h->dynindx != -1)
3135 h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3139 /* Assign string offsets in .dynstr, update all structures referencing
3143 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3145 struct elf_link_hash_table *hash_table = elf_hash_table (info);
3146 struct elf_link_local_dynamic_entry *entry;
3147 struct elf_strtab_hash *dynstr = hash_table->dynstr;
3148 bfd *dynobj = hash_table->dynobj;
3151 const struct elf_backend_data *bed;
3154 _bfd_elf_strtab_finalize (dynstr);
3155 size = _bfd_elf_strtab_size (dynstr);
3157 bed = get_elf_backend_data (dynobj);
3158 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3159 BFD_ASSERT (sdyn != NULL);
3161 /* Update all .dynamic entries referencing .dynstr strings. */
3162 for (extdyn = sdyn->contents;
3163 extdyn < sdyn->contents + sdyn->size;
3164 extdyn += bed->s->sizeof_dyn)
3166 Elf_Internal_Dyn dyn;
3168 bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3172 dyn.d_un.d_val = size;
3182 dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3187 bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3190 /* Now update local dynamic symbols. */
3191 for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3192 entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3193 entry->isym.st_name);
3195 /* And the rest of dynamic symbols. */
3196 elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3198 /* Adjust version definitions. */
3199 if (elf_tdata (output_bfd)->cverdefs)
3204 Elf_Internal_Verdef def;
3205 Elf_Internal_Verdaux defaux;
3207 s = bfd_get_linker_section (dynobj, ".gnu.version_d");
3211 _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3213 p += sizeof (Elf_External_Verdef);
3214 if (def.vd_aux != sizeof (Elf_External_Verdef))
3216 for (i = 0; i < def.vd_cnt; ++i)
3218 _bfd_elf_swap_verdaux_in (output_bfd,
3219 (Elf_External_Verdaux *) p, &defaux);
3220 defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3222 _bfd_elf_swap_verdaux_out (output_bfd,
3223 &defaux, (Elf_External_Verdaux *) p);
3224 p += sizeof (Elf_External_Verdaux);
3227 while (def.vd_next);
3230 /* Adjust version references. */
3231 if (elf_tdata (output_bfd)->verref)
3236 Elf_Internal_Verneed need;
3237 Elf_Internal_Vernaux needaux;
3239 s = bfd_get_linker_section (dynobj, ".gnu.version_r");
3243 _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3245 need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3246 _bfd_elf_swap_verneed_out (output_bfd, &need,
3247 (Elf_External_Verneed *) p);
3248 p += sizeof (Elf_External_Verneed);
3249 for (i = 0; i < need.vn_cnt; ++i)
3251 _bfd_elf_swap_vernaux_in (output_bfd,
3252 (Elf_External_Vernaux *) p, &needaux);
3253 needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3255 _bfd_elf_swap_vernaux_out (output_bfd,
3257 (Elf_External_Vernaux *) p);
3258 p += sizeof (Elf_External_Vernaux);
3261 while (need.vn_next);
3267 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3268 The default is to only match when the INPUT and OUTPUT are exactly
3272 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3273 const bfd_target *output)
3275 return input == output;
3278 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3279 This version is used when different targets for the same architecture
3280 are virtually identical. */
3283 _bfd_elf_relocs_compatible (const bfd_target *input,
3284 const bfd_target *output)
3286 const struct elf_backend_data *obed, *ibed;
3288 if (input == output)
3291 ibed = xvec_get_elf_backend_data (input);
3292 obed = xvec_get_elf_backend_data (output);
3294 if (ibed->arch != obed->arch)
3297 /* If both backends are using this function, deem them compatible. */
3298 return ibed->relocs_compatible == obed->relocs_compatible;
3301 /* Make a special call to the linker "notice" function to tell it that
3302 we are about to handle an as-needed lib, or have finished
3303 processing the lib. */
3306 _bfd_elf_notice_as_needed (bfd *ibfd,
3307 struct bfd_link_info *info,
3308 enum notice_asneeded_action act)
3310 return (*info->callbacks->notice) (info, NULL, NULL, ibfd, NULL, act, 0);
3313 /* Add symbols from an ELF object file to the linker hash table. */
3316 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3318 Elf_Internal_Ehdr *ehdr;
3319 Elf_Internal_Shdr *hdr;
3320 bfd_size_type symcount;
3321 bfd_size_type extsymcount;
3322 bfd_size_type extsymoff;
3323 struct elf_link_hash_entry **sym_hash;
3324 bfd_boolean dynamic;
3325 Elf_External_Versym *extversym = NULL;
3326 Elf_External_Versym *ever;
3327 struct elf_link_hash_entry *weaks;
3328 struct elf_link_hash_entry **nondeflt_vers = NULL;
3329 bfd_size_type nondeflt_vers_cnt = 0;
3330 Elf_Internal_Sym *isymbuf = NULL;
3331 Elf_Internal_Sym *isym;
3332 Elf_Internal_Sym *isymend;
3333 const struct elf_backend_data *bed;
3334 bfd_boolean add_needed;
3335 struct elf_link_hash_table *htab;
3337 void *alloc_mark = NULL;
3338 struct bfd_hash_entry **old_table = NULL;
3339 unsigned int old_size = 0;
3340 unsigned int old_count = 0;
3341 void *old_tab = NULL;
3343 struct bfd_link_hash_entry *old_undefs = NULL;
3344 struct bfd_link_hash_entry *old_undefs_tail = NULL;
3345 long old_dynsymcount = 0;
3346 bfd_size_type old_dynstr_size = 0;
3349 bfd_boolean just_syms;
3351 htab = elf_hash_table (info);
3352 bed = get_elf_backend_data (abfd);
3354 if ((abfd->flags & DYNAMIC) == 0)
3360 /* You can't use -r against a dynamic object. Also, there's no
3361 hope of using a dynamic object which does not exactly match
3362 the format of the output file. */
3363 if (info->relocatable
3364 || !is_elf_hash_table (htab)
3365 || info->output_bfd->xvec != abfd->xvec)
3367 if (info->relocatable)
3368 bfd_set_error (bfd_error_invalid_operation);
3370 bfd_set_error (bfd_error_wrong_format);
3375 ehdr = elf_elfheader (abfd);
3376 if (info->warn_alternate_em
3377 && bed->elf_machine_code != ehdr->e_machine
3378 && ((bed->elf_machine_alt1 != 0
3379 && ehdr->e_machine == bed->elf_machine_alt1)
3380 || (bed->elf_machine_alt2 != 0
3381 && ehdr->e_machine == bed->elf_machine_alt2)))
3382 info->callbacks->einfo
3383 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3384 ehdr->e_machine, abfd, bed->elf_machine_code);
3386 /* As a GNU extension, any input sections which are named
3387 .gnu.warning.SYMBOL are treated as warning symbols for the given
3388 symbol. This differs from .gnu.warning sections, which generate
3389 warnings when they are included in an output file. */
3390 /* PR 12761: Also generate this warning when building shared libraries. */
3391 for (s = abfd->sections; s != NULL; s = s->next)
3395 name = bfd_get_section_name (abfd, s);
3396 if (CONST_STRNEQ (name, ".gnu.warning."))
3401 name += sizeof ".gnu.warning." - 1;
3403 /* If this is a shared object, then look up the symbol
3404 in the hash table. If it is there, and it is already
3405 been defined, then we will not be using the entry
3406 from this shared object, so we don't need to warn.
3407 FIXME: If we see the definition in a regular object
3408 later on, we will warn, but we shouldn't. The only
3409 fix is to keep track of what warnings we are supposed
3410 to emit, and then handle them all at the end of the
3414 struct elf_link_hash_entry *h;
3416 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3418 /* FIXME: What about bfd_link_hash_common? */
3420 && (h->root.type == bfd_link_hash_defined
3421 || h->root.type == bfd_link_hash_defweak))
3426 msg = (char *) bfd_alloc (abfd, sz + 1);
3430 if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3435 if (! (_bfd_generic_link_add_one_symbol
3436 (info, abfd, name, BSF_WARNING, s, 0, msg,
3437 FALSE, bed->collect, NULL)))
3440 if (!info->relocatable && info->executable)
3442 /* Clobber the section size so that the warning does
3443 not get copied into the output file. */
3446 /* Also set SEC_EXCLUDE, so that symbols defined in
3447 the warning section don't get copied to the output. */
3448 s->flags |= SEC_EXCLUDE;
3453 just_syms = ((s = abfd->sections) != NULL
3454 && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS);
3459 /* If we are creating a shared library, create all the dynamic
3460 sections immediately. We need to attach them to something,
3461 so we attach them to this BFD, provided it is the right
3462 format and is not from ld --just-symbols. FIXME: If there
3463 are no input BFD's of the same format as the output, we can't
3464 make a shared library. */
3467 && is_elf_hash_table (htab)
3468 && info->output_bfd->xvec == abfd->xvec
3469 && !htab->dynamic_sections_created)
3471 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3475 else if (!is_elf_hash_table (htab))
3479 const char *soname = NULL;
3481 struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3484 /* ld --just-symbols and dynamic objects don't mix very well.
3485 ld shouldn't allow it. */
3489 /* If this dynamic lib was specified on the command line with
3490 --as-needed in effect, then we don't want to add a DT_NEEDED
3491 tag unless the lib is actually used. Similary for libs brought
3492 in by another lib's DT_NEEDED. When --no-add-needed is used
3493 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3494 any dynamic library in DT_NEEDED tags in the dynamic lib at
3496 add_needed = (elf_dyn_lib_class (abfd)
3497 & (DYN_AS_NEEDED | DYN_DT_NEEDED
3498 | DYN_NO_NEEDED)) == 0;
3500 s = bfd_get_section_by_name (abfd, ".dynamic");
3505 unsigned int elfsec;
3506 unsigned long shlink;
3508 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3515 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3516 if (elfsec == SHN_BAD)
3517 goto error_free_dyn;
3518 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3520 for (extdyn = dynbuf;
3521 extdyn < dynbuf + s->size;
3522 extdyn += bed->s->sizeof_dyn)
3524 Elf_Internal_Dyn dyn;
3526 bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3527 if (dyn.d_tag == DT_SONAME)
3529 unsigned int tagv = dyn.d_un.d_val;
3530 soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3532 goto error_free_dyn;
3534 if (dyn.d_tag == DT_NEEDED)
3536 struct bfd_link_needed_list *n, **pn;
3538 unsigned int tagv = dyn.d_un.d_val;
3540 amt = sizeof (struct bfd_link_needed_list);
3541 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3542 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3543 if (n == NULL || fnm == NULL)
3544 goto error_free_dyn;
3545 amt = strlen (fnm) + 1;
3546 anm = (char *) bfd_alloc (abfd, amt);
3548 goto error_free_dyn;
3549 memcpy (anm, fnm, amt);
3553 for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3557 if (dyn.d_tag == DT_RUNPATH)
3559 struct bfd_link_needed_list *n, **pn;
3561 unsigned int tagv = dyn.d_un.d_val;
3563 amt = sizeof (struct bfd_link_needed_list);
3564 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3565 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3566 if (n == NULL || fnm == NULL)
3567 goto error_free_dyn;
3568 amt = strlen (fnm) + 1;
3569 anm = (char *) bfd_alloc (abfd, amt);
3571 goto error_free_dyn;
3572 memcpy (anm, fnm, amt);
3576 for (pn = & runpath;
3582 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3583 if (!runpath && dyn.d_tag == DT_RPATH)
3585 struct bfd_link_needed_list *n, **pn;
3587 unsigned int tagv = dyn.d_un.d_val;
3589 amt = sizeof (struct bfd_link_needed_list);
3590 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3591 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3592 if (n == NULL || fnm == NULL)
3593 goto error_free_dyn;
3594 amt = strlen (fnm) + 1;
3595 anm = (char *) bfd_alloc (abfd, amt);
3597 goto error_free_dyn;
3598 memcpy (anm, fnm, amt);
3608 if (dyn.d_tag == DT_AUDIT)
3610 unsigned int tagv = dyn.d_un.d_val;
3611 audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3618 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3619 frees all more recently bfd_alloc'd blocks as well. */
3625 struct bfd_link_needed_list **pn;
3626 for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3631 /* We do not want to include any of the sections in a dynamic
3632 object in the output file. We hack by simply clobbering the
3633 list of sections in the BFD. This could be handled more
3634 cleanly by, say, a new section flag; the existing
3635 SEC_NEVER_LOAD flag is not the one we want, because that one
3636 still implies that the section takes up space in the output
3638 bfd_section_list_clear (abfd);
3640 /* Find the name to use in a DT_NEEDED entry that refers to this
3641 object. If the object has a DT_SONAME entry, we use it.
3642 Otherwise, if the generic linker stuck something in
3643 elf_dt_name, we use that. Otherwise, we just use the file
3645 if (soname == NULL || *soname == '\0')
3647 soname = elf_dt_name (abfd);
3648 if (soname == NULL || *soname == '\0')
3649 soname = bfd_get_filename (abfd);
3652 /* Save the SONAME because sometimes the linker emulation code
3653 will need to know it. */
3654 elf_dt_name (abfd) = soname;
3656 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3660 /* If we have already included this dynamic object in the
3661 link, just ignore it. There is no reason to include a
3662 particular dynamic object more than once. */
3666 /* Save the DT_AUDIT entry for the linker emulation code. */
3667 elf_dt_audit (abfd) = audit;
3670 /* If this is a dynamic object, we always link against the .dynsym
3671 symbol table, not the .symtab symbol table. The dynamic linker
3672 will only see the .dynsym symbol table, so there is no reason to
3673 look at .symtab for a dynamic object. */
3675 if (! dynamic || elf_dynsymtab (abfd) == 0)
3676 hdr = &elf_tdata (abfd)->symtab_hdr;
3678 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3680 symcount = hdr->sh_size / bed->s->sizeof_sym;
3682 /* The sh_info field of the symtab header tells us where the
3683 external symbols start. We don't care about the local symbols at
3685 if (elf_bad_symtab (abfd))
3687 extsymcount = symcount;
3692 extsymcount = symcount - hdr->sh_info;
3693 extsymoff = hdr->sh_info;
3696 sym_hash = elf_sym_hashes (abfd);
3697 if (extsymcount != 0)
3699 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3701 if (isymbuf == NULL)
3704 if (sym_hash == NULL)
3706 /* We store a pointer to the hash table entry for each
3708 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3709 sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt);
3710 if (sym_hash == NULL)
3711 goto error_free_sym;
3712 elf_sym_hashes (abfd) = sym_hash;
3718 /* Read in any version definitions. */
3719 if (!_bfd_elf_slurp_version_tables (abfd,
3720 info->default_imported_symver))
3721 goto error_free_sym;
3723 /* Read in the symbol versions, but don't bother to convert them
3724 to internal format. */
3725 if (elf_dynversym (abfd) != 0)
3727 Elf_Internal_Shdr *versymhdr;
3729 versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3730 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3731 if (extversym == NULL)
3732 goto error_free_sym;
3733 amt = versymhdr->sh_size;
3734 if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3735 || bfd_bread (extversym, amt, abfd) != amt)
3736 goto error_free_vers;
3740 /* If we are loading an as-needed shared lib, save the symbol table
3741 state before we start adding symbols. If the lib turns out
3742 to be unneeded, restore the state. */
3743 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3748 for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3750 struct bfd_hash_entry *p;
3751 struct elf_link_hash_entry *h;
3753 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3755 h = (struct elf_link_hash_entry *) p;
3756 entsize += htab->root.table.entsize;
3757 if (h->root.type == bfd_link_hash_warning)
3758 entsize += htab->root.table.entsize;
3762 tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3763 old_tab = bfd_malloc (tabsize + entsize);
3764 if (old_tab == NULL)
3765 goto error_free_vers;
3767 /* Remember the current objalloc pointer, so that all mem for
3768 symbols added can later be reclaimed. */
3769 alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3770 if (alloc_mark == NULL)
3771 goto error_free_vers;
3773 /* Make a special call to the linker "notice" function to
3774 tell it that we are about to handle an as-needed lib. */
3775 if (!(*bed->notice_as_needed) (abfd, info, notice_as_needed))
3776 goto error_free_vers;
3778 /* Clone the symbol table. Remember some pointers into the
3779 symbol table, and dynamic symbol count. */
3780 old_ent = (char *) old_tab + tabsize;
3781 memcpy (old_tab, htab->root.table.table, tabsize);
3782 old_undefs = htab->root.undefs;
3783 old_undefs_tail = htab->root.undefs_tail;
3784 old_table = htab->root.table.table;
3785 old_size = htab->root.table.size;
3786 old_count = htab->root.table.count;
3787 old_dynsymcount = htab->dynsymcount;
3788 old_dynstr_size = _bfd_elf_strtab_size (htab->dynstr);
3790 for (i = 0; i < htab->root.table.size; i++)
3792 struct bfd_hash_entry *p;
3793 struct elf_link_hash_entry *h;
3795 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3797 memcpy (old_ent, p, htab->root.table.entsize);
3798 old_ent = (char *) old_ent + htab->root.table.entsize;
3799 h = (struct elf_link_hash_entry *) p;
3800 if (h->root.type == bfd_link_hash_warning)
3802 memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3803 old_ent = (char *) old_ent + htab->root.table.entsize;
3810 ever = extversym != NULL ? extversym + extsymoff : NULL;
3811 for (isym = isymbuf, isymend = isymbuf + extsymcount;
3813 isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3817 asection *sec, *new_sec;
3820 struct elf_link_hash_entry *h;
3821 struct elf_link_hash_entry *hi;
3822 bfd_boolean definition;
3823 bfd_boolean size_change_ok;
3824 bfd_boolean type_change_ok;
3825 bfd_boolean new_weakdef;
3826 bfd_boolean new_weak;
3827 bfd_boolean old_weak;
3828 bfd_boolean override;
3830 unsigned int old_alignment;
3835 flags = BSF_NO_FLAGS;
3837 value = isym->st_value;
3838 common = bed->common_definition (isym);
3840 bind = ELF_ST_BIND (isym->st_info);
3844 /* This should be impossible, since ELF requires that all
3845 global symbols follow all local symbols, and that sh_info
3846 point to the first global symbol. Unfortunately, Irix 5
3851 if (isym->st_shndx != SHN_UNDEF && !common)
3859 case STB_GNU_UNIQUE:
3860 flags = BSF_GNU_UNIQUE;
3864 /* Leave it up to the processor backend. */
3868 if (isym->st_shndx == SHN_UNDEF)
3869 sec = bfd_und_section_ptr;
3870 else if (isym->st_shndx == SHN_ABS)
3871 sec = bfd_abs_section_ptr;
3872 else if (isym->st_shndx == SHN_COMMON)
3874 sec = bfd_com_section_ptr;
3875 /* What ELF calls the size we call the value. What ELF
3876 calls the value we call the alignment. */
3877 value = isym->st_size;
3881 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3883 sec = bfd_abs_section_ptr;
3884 else if (discarded_section (sec))
3886 /* Symbols from discarded section are undefined. We keep
3888 sec = bfd_und_section_ptr;
3889 isym->st_shndx = SHN_UNDEF;
3891 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3895 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3898 goto error_free_vers;
3900 if (isym->st_shndx == SHN_COMMON
3901 && (abfd->flags & BFD_PLUGIN) != 0)
3903 asection *xc = bfd_get_section_by_name (abfd, "COMMON");
3907 flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
3909 xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
3911 goto error_free_vers;
3915 else if (isym->st_shndx == SHN_COMMON
3916 && ELF_ST_TYPE (isym->st_info) == STT_TLS
3917 && !info->relocatable)
3919 asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3923 flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
3924 | SEC_LINKER_CREATED);
3925 tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
3927 goto error_free_vers;
3931 else if (bed->elf_add_symbol_hook)
3933 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3935 goto error_free_vers;
3937 /* The hook function sets the name to NULL if this symbol
3938 should be skipped for some reason. */
3943 /* Sanity check that all possibilities were handled. */
3946 bfd_set_error (bfd_error_bad_value);
3947 goto error_free_vers;
3950 /* Silently discard TLS symbols from --just-syms. There's
3951 no way to combine a static TLS block with a new TLS block
3952 for this executable. */
3953 if (ELF_ST_TYPE (isym->st_info) == STT_TLS
3954 && sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
3957 if (bfd_is_und_section (sec)
3958 || bfd_is_com_section (sec))
3963 size_change_ok = FALSE;
3964 type_change_ok = bed->type_change_ok;
3970 if (is_elf_hash_table (htab))
3972 Elf_Internal_Versym iver;
3973 unsigned int vernum = 0;
3978 if (info->default_imported_symver)
3979 /* Use the default symbol version created earlier. */
3980 iver.vs_vers = elf_tdata (abfd)->cverdefs;
3985 _bfd_elf_swap_versym_in (abfd, ever, &iver);
3987 vernum = iver.vs_vers & VERSYM_VERSION;
3989 /* If this is a hidden symbol, or if it is not version
3990 1, we append the version name to the symbol name.
3991 However, we do not modify a non-hidden absolute symbol
3992 if it is not a function, because it might be the version
3993 symbol itself. FIXME: What if it isn't? */
3994 if ((iver.vs_vers & VERSYM_HIDDEN) != 0
3996 && (!bfd_is_abs_section (sec)
3997 || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4000 size_t namelen, verlen, newlen;
4003 if (isym->st_shndx != SHN_UNDEF)
4005 if (vernum > elf_tdata (abfd)->cverdefs)
4007 else if (vernum > 1)
4009 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4015 (*_bfd_error_handler)
4016 (_("%B: %s: invalid version %u (max %d)"),
4018 elf_tdata (abfd)->cverdefs);
4019 bfd_set_error (bfd_error_bad_value);
4020 goto error_free_vers;
4025 /* We cannot simply test for the number of
4026 entries in the VERNEED section since the
4027 numbers for the needed versions do not start
4029 Elf_Internal_Verneed *t;
4032 for (t = elf_tdata (abfd)->verref;
4036 Elf_Internal_Vernaux *a;
4038 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4040 if (a->vna_other == vernum)
4042 verstr = a->vna_nodename;
4051 (*_bfd_error_handler)
4052 (_("%B: %s: invalid needed version %d"),
4053 abfd, name, vernum);
4054 bfd_set_error (bfd_error_bad_value);
4055 goto error_free_vers;
4059 namelen = strlen (name);
4060 verlen = strlen (verstr);
4061 newlen = namelen + verlen + 2;
4062 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4063 && isym->st_shndx != SHN_UNDEF)
4066 newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4067 if (newname == NULL)
4068 goto error_free_vers;
4069 memcpy (newname, name, namelen);
4070 p = newname + namelen;
4072 /* If this is a defined non-hidden version symbol,
4073 we add another @ to the name. This indicates the
4074 default version of the symbol. */
4075 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4076 && isym->st_shndx != SHN_UNDEF)
4078 memcpy (p, verstr, verlen + 1);
4083 /* If this symbol has default visibility and the user has
4084 requested we not re-export it, then mark it as hidden. */
4088 && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
4089 isym->st_other = (STV_HIDDEN
4090 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
4092 if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value,
4093 sym_hash, &old_bfd, &old_weak,
4094 &old_alignment, &skip, &override,
4095 &type_change_ok, &size_change_ok))
4096 goto error_free_vers;
4105 while (h->root.type == bfd_link_hash_indirect
4106 || h->root.type == bfd_link_hash_warning)
4107 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4109 if (elf_tdata (abfd)->verdef != NULL
4112 h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4115 if (! (_bfd_generic_link_add_one_symbol
4116 (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4117 (struct bfd_link_hash_entry **) sym_hash)))
4118 goto error_free_vers;
4121 /* We need to make sure that indirect symbol dynamic flags are
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;
4130 new_weak = (flags & BSF_WEAK) != 0;
4131 new_weakdef = FALSE;
4135 && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4136 && is_elf_hash_table (htab)
4137 && h->u.weakdef == NULL)
4139 /* Keep a list of all weak defined non function symbols from
4140 a dynamic object, using the weakdef field. Later in this
4141 function we will set the weakdef field to the correct
4142 value. We only put non-function symbols from dynamic
4143 objects on this list, because that happens to be the only
4144 time we need to know the normal symbol corresponding to a
4145 weak symbol, and the information is time consuming to
4146 figure out. If the weakdef field is not already NULL,
4147 then this symbol was already defined by some previous
4148 dynamic object, and we will be using that previous
4149 definition anyhow. */
4151 h->u.weakdef = weaks;
4156 /* Set the alignment of a common symbol. */
4157 if ((common || bfd_is_com_section (sec))
4158 && h->root.type == bfd_link_hash_common)
4163 align = bfd_log2 (isym->st_value);
4166 /* The new symbol is a common symbol in a shared object.
4167 We need to get the alignment from the section. */
4168 align = new_sec->alignment_power;
4170 if (align > old_alignment)
4171 h->root.u.c.p->alignment_power = align;
4173 h->root.u.c.p->alignment_power = old_alignment;
4176 if (is_elf_hash_table (htab))
4178 /* Set a flag in the hash table entry indicating the type of
4179 reference or definition we just found. A dynamic symbol
4180 is one which is referenced or defined by both a regular
4181 object and a shared object. */
4182 bfd_boolean dynsym = FALSE;
4184 /* Plugin symbols aren't normal. Don't set def_regular or
4185 ref_regular for them, or make them dynamic. */
4186 if ((abfd->flags & BFD_PLUGIN) != 0)
4193 if (bind != STB_WEAK)
4194 h->ref_regular_nonweak = 1;
4206 /* If the indirect symbol has been forced local, don't
4207 make the real symbol dynamic. */
4208 if ((h == hi || !hi->forced_local)
4209 && (! info->executable
4219 hi->ref_dynamic = 1;
4224 hi->def_dynamic = 1;
4227 /* If the indirect symbol has been forced local, don't
4228 make the real symbol dynamic. */
4229 if ((h == hi || !hi->forced_local)
4232 || (h->u.weakdef != NULL
4234 && h->u.weakdef->dynindx != -1)))
4238 /* Check to see if we need to add an indirect symbol for
4239 the default name. */
4241 || (!override && h->root.type == bfd_link_hash_common))
4242 if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4243 sec, value, &old_bfd, &dynsym))
4244 goto error_free_vers;
4246 /* Check the alignment when a common symbol is involved. This
4247 can change when a common symbol is overridden by a normal
4248 definition or a common symbol is ignored due to the old
4249 normal definition. We need to make sure the maximum
4250 alignment is maintained. */
4251 if ((old_alignment || common)
4252 && h->root.type != bfd_link_hash_common)
4254 unsigned int common_align;
4255 unsigned int normal_align;
4256 unsigned int symbol_align;
4260 BFD_ASSERT (h->root.type == bfd_link_hash_defined
4261 || h->root.type == bfd_link_hash_defweak);
4263 symbol_align = ffs (h->root.u.def.value) - 1;
4264 if (h->root.u.def.section->owner != NULL
4265 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4267 normal_align = h->root.u.def.section->alignment_power;
4268 if (normal_align > symbol_align)
4269 normal_align = symbol_align;
4272 normal_align = symbol_align;
4276 common_align = old_alignment;
4277 common_bfd = old_bfd;
4282 common_align = bfd_log2 (isym->st_value);
4284 normal_bfd = old_bfd;
4287 if (normal_align < common_align)
4289 /* PR binutils/2735 */
4290 if (normal_bfd == NULL)
4291 (*_bfd_error_handler)
4292 (_("Warning: alignment %u of common symbol `%s' in %B is"
4293 " greater than the alignment (%u) of its section %A"),
4294 common_bfd, h->root.u.def.section,
4295 1 << common_align, name, 1 << normal_align);
4297 (*_bfd_error_handler)
4298 (_("Warning: alignment %u of symbol `%s' in %B"
4299 " is smaller than %u in %B"),
4300 normal_bfd, common_bfd,
4301 1 << normal_align, name, 1 << common_align);
4305 /* Remember the symbol size if it isn't undefined. */
4306 if (isym->st_size != 0
4307 && isym->st_shndx != SHN_UNDEF
4308 && (definition || h->size == 0))
4311 && h->size != isym->st_size
4312 && ! size_change_ok)
4313 (*_bfd_error_handler)
4314 (_("Warning: size of symbol `%s' changed"
4315 " from %lu in %B to %lu in %B"),
4317 name, (unsigned long) h->size,
4318 (unsigned long) isym->st_size);
4320 h->size = isym->st_size;
4323 /* If this is a common symbol, then we always want H->SIZE
4324 to be the size of the common symbol. The code just above
4325 won't fix the size if a common symbol becomes larger. We
4326 don't warn about a size change here, because that is
4327 covered by --warn-common. Allow changes between different
4329 if (h->root.type == bfd_link_hash_common)
4330 h->size = h->root.u.c.size;
4332 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4333 && ((definition && !new_weak)
4334 || (old_weak && h->root.type == bfd_link_hash_common)
4335 || h->type == STT_NOTYPE))
4337 unsigned int type = ELF_ST_TYPE (isym->st_info);
4339 /* Turn an IFUNC symbol from a DSO into a normal FUNC
4341 if (type == STT_GNU_IFUNC
4342 && (abfd->flags & DYNAMIC) != 0)
4345 if (h->type != type)
4347 if (h->type != STT_NOTYPE && ! type_change_ok)
4348 (*_bfd_error_handler)
4349 (_("Warning: type of symbol `%s' changed"
4350 " from %d to %d in %B"),
4351 abfd, name, h->type, type);
4357 /* Merge st_other field. */
4358 elf_merge_st_other (abfd, h, isym, definition, dynamic);
4360 /* We don't want to make debug symbol dynamic. */
4361 if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
4364 /* Nor should we make plugin symbols dynamic. */
4365 if ((abfd->flags & BFD_PLUGIN) != 0)
4370 h->target_internal = isym->st_target_internal;
4371 h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4374 if (definition && !dynamic)
4376 char *p = strchr (name, ELF_VER_CHR);
4377 if (p != NULL && p[1] != ELF_VER_CHR)
4379 /* Queue non-default versions so that .symver x, x@FOO
4380 aliases can be checked. */
4383 amt = ((isymend - isym + 1)
4384 * sizeof (struct elf_link_hash_entry *));
4386 = (struct elf_link_hash_entry **) bfd_malloc (amt);
4388 goto error_free_vers;
4390 nondeflt_vers[nondeflt_vers_cnt++] = h;
4394 if (dynsym && h->dynindx == -1)
4396 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4397 goto error_free_vers;
4398 if (h->u.weakdef != NULL
4400 && h->u.weakdef->dynindx == -1)
4402 if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4403 goto error_free_vers;
4406 else if (dynsym && h->dynindx != -1)
4407 /* If the symbol already has a dynamic index, but
4408 visibility says it should not be visible, turn it into
4410 switch (ELF_ST_VISIBILITY (h->other))
4414 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4419 /* Don't add DT_NEEDED for references from the dummy bfd. */
4423 && h->ref_regular_nonweak
4425 || (old_bfd->flags & BFD_PLUGIN) == 0))
4426 || (h->ref_dynamic_nonweak
4427 && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4428 && !on_needed_list (elf_dt_name (abfd), htab->needed))))
4431 const char *soname = elf_dt_name (abfd);
4433 info->callbacks->minfo ("%!", soname, old_bfd,
4434 h->root.root.string);
4436 /* A symbol from a library loaded via DT_NEEDED of some
4437 other library is referenced by a regular object.
4438 Add a DT_NEEDED entry for it. Issue an error if
4439 --no-add-needed is used and the reference was not
4442 && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4444 (*_bfd_error_handler)
4445 (_("%B: undefined reference to symbol '%s'"),
4447 bfd_set_error (bfd_error_missing_dso);
4448 goto error_free_vers;
4451 elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4452 (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4455 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4457 goto error_free_vers;
4459 BFD_ASSERT (ret == 0);
4464 if (extversym != NULL)
4470 if (isymbuf != NULL)
4476 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4480 /* Restore the symbol table. */
4481 old_ent = (char *) old_tab + tabsize;
4482 memset (elf_sym_hashes (abfd), 0,
4483 extsymcount * sizeof (struct elf_link_hash_entry *));
4484 htab->root.table.table = old_table;
4485 htab->root.table.size = old_size;
4486 htab->root.table.count = old_count;
4487 memcpy (htab->root.table.table, old_tab, tabsize);
4488 htab->root.undefs = old_undefs;
4489 htab->root.undefs_tail = old_undefs_tail;
4490 _bfd_elf_strtab_restore_size (htab->dynstr, old_dynstr_size);
4491 for (i = 0; i < htab->root.table.size; i++)
4493 struct bfd_hash_entry *p;
4494 struct elf_link_hash_entry *h;
4496 unsigned int alignment_power;
4498 for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4500 h = (struct elf_link_hash_entry *) p;
4501 if (h->root.type == bfd_link_hash_warning)
4502 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4503 if (h->dynindx >= old_dynsymcount
4504 && h->dynstr_index < old_dynstr_size)
4505 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4507 /* Preserve the maximum alignment and size for common
4508 symbols even if this dynamic lib isn't on DT_NEEDED
4509 since it can still be loaded at run time by another
4511 if (h->root.type == bfd_link_hash_common)
4513 size = h->root.u.c.size;
4514 alignment_power = h->root.u.c.p->alignment_power;
4519 alignment_power = 0;
4521 memcpy (p, old_ent, htab->root.table.entsize);
4522 old_ent = (char *) old_ent + htab->root.table.entsize;
4523 h = (struct elf_link_hash_entry *) p;
4524 if (h->root.type == bfd_link_hash_warning)
4526 memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4527 old_ent = (char *) old_ent + htab->root.table.entsize;
4528 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4530 if (h->root.type == bfd_link_hash_common)
4532 if (size > h->root.u.c.size)
4533 h->root.u.c.size = size;
4534 if (alignment_power > h->root.u.c.p->alignment_power)
4535 h->root.u.c.p->alignment_power = alignment_power;
4540 /* Make a special call to the linker "notice" function to
4541 tell it that symbols added for crefs may need to be removed. */
4542 if (!(*bed->notice_as_needed) (abfd, info, notice_not_needed))
4543 goto error_free_vers;
4546 objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4548 if (nondeflt_vers != NULL)
4549 free (nondeflt_vers);
4553 if (old_tab != NULL)
4555 if (!(*bed->notice_as_needed) (abfd, info, notice_needed))
4556 goto error_free_vers;
4561 /* Now that all the symbols from this input file are created, handle
4562 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4563 if (nondeflt_vers != NULL)
4565 bfd_size_type cnt, symidx;
4567 for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4569 struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4570 char *shortname, *p;
4572 p = strchr (h->root.root.string, ELF_VER_CHR);
4574 || (h->root.type != bfd_link_hash_defined
4575 && h->root.type != bfd_link_hash_defweak))
4578 amt = p - h->root.root.string;
4579 shortname = (char *) bfd_malloc (amt + 1);
4581 goto error_free_vers;
4582 memcpy (shortname, h->root.root.string, amt);
4583 shortname[amt] = '\0';
4585 hi = (struct elf_link_hash_entry *)
4586 bfd_link_hash_lookup (&htab->root, shortname,
4587 FALSE, FALSE, FALSE);
4589 && hi->root.type == h->root.type
4590 && hi->root.u.def.value == h->root.u.def.value
4591 && hi->root.u.def.section == h->root.u.def.section)
4593 (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4594 hi->root.type = bfd_link_hash_indirect;
4595 hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4596 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4597 sym_hash = elf_sym_hashes (abfd);
4599 for (symidx = 0; symidx < extsymcount; ++symidx)
4600 if (sym_hash[symidx] == hi)
4602 sym_hash[symidx] = h;
4608 free (nondeflt_vers);
4609 nondeflt_vers = NULL;
4612 /* Now set the weakdefs field correctly for all the weak defined
4613 symbols we found. The only way to do this is to search all the
4614 symbols. Since we only need the information for non functions in
4615 dynamic objects, that's the only time we actually put anything on
4616 the list WEAKS. We need this information so that if a regular
4617 object refers to a symbol defined weakly in a dynamic object, the
4618 real symbol in the dynamic object is also put in the dynamic
4619 symbols; we also must arrange for both symbols to point to the
4620 same memory location. We could handle the general case of symbol
4621 aliasing, but a general symbol alias can only be generated in
4622 assembler code, handling it correctly would be very time
4623 consuming, and other ELF linkers don't handle general aliasing
4627 struct elf_link_hash_entry **hpp;
4628 struct elf_link_hash_entry **hppend;
4629 struct elf_link_hash_entry **sorted_sym_hash;
4630 struct elf_link_hash_entry *h;
4633 /* Since we have to search the whole symbol list for each weak
4634 defined symbol, search time for N weak defined symbols will be
4635 O(N^2). Binary search will cut it down to O(NlogN). */
4636 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4637 sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4638 if (sorted_sym_hash == NULL)
4640 sym_hash = sorted_sym_hash;
4641 hpp = elf_sym_hashes (abfd);
4642 hppend = hpp + extsymcount;
4644 for (; hpp < hppend; hpp++)
4648 && h->root.type == bfd_link_hash_defined
4649 && !bed->is_function_type (h->type))
4657 qsort (sorted_sym_hash, sym_count,
4658 sizeof (struct elf_link_hash_entry *),
4661 while (weaks != NULL)
4663 struct elf_link_hash_entry *hlook;
4666 size_t i, j, idx = 0;
4669 weaks = hlook->u.weakdef;
4670 hlook->u.weakdef = NULL;
4672 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4673 || hlook->root.type == bfd_link_hash_defweak
4674 || hlook->root.type == bfd_link_hash_common
4675 || hlook->root.type == bfd_link_hash_indirect);
4676 slook = hlook->root.u.def.section;
4677 vlook = hlook->root.u.def.value;
4683 bfd_signed_vma vdiff;
4685 h = sorted_sym_hash[idx];
4686 vdiff = vlook - h->root.u.def.value;
4693 long sdiff = slook->id - h->root.u.def.section->id;
4703 /* We didn't find a value/section match. */
4707 /* With multiple aliases, or when the weak symbol is already
4708 strongly defined, we have multiple matching symbols and
4709 the binary search above may land on any of them. Step
4710 one past the matching symbol(s). */
4713 h = sorted_sym_hash[idx];
4714 if (h->root.u.def.section != slook
4715 || h->root.u.def.value != vlook)
4719 /* Now look back over the aliases. Since we sorted by size
4720 as well as value and section, we'll choose the one with
4721 the largest size. */
4724 h = sorted_sym_hash[idx];
4726 /* Stop if value or section doesn't match. */
4727 if (h->root.u.def.section != slook
4728 || h->root.u.def.value != vlook)
4730 else if (h != hlook)
4732 hlook->u.weakdef = h;
4734 /* If the weak definition is in the list of dynamic
4735 symbols, make sure the real definition is put
4737 if (hlook->dynindx != -1 && h->dynindx == -1)
4739 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4742 free (sorted_sym_hash);
4747 /* If the real definition is in the list of dynamic
4748 symbols, make sure the weak definition is put
4749 there as well. If we don't do this, then the
4750 dynamic loader might not merge the entries for the
4751 real definition and the weak definition. */
4752 if (h->dynindx != -1 && hlook->dynindx == -1)
4754 if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4755 goto err_free_sym_hash;
4762 free (sorted_sym_hash);
4765 if (bed->check_directives
4766 && !(*bed->check_directives) (abfd, info))
4769 /* If this object is the same format as the output object, and it is
4770 not a shared library, then let the backend look through the
4773 This is required to build global offset table entries and to
4774 arrange for dynamic relocs. It is not required for the
4775 particular common case of linking non PIC code, even when linking
4776 against shared libraries, but unfortunately there is no way of
4777 knowing whether an object file has been compiled PIC or not.
4778 Looking through the relocs is not particularly time consuming.
4779 The problem is that we must either (1) keep the relocs in memory,
4780 which causes the linker to require additional runtime memory or
4781 (2) read the relocs twice from the input file, which wastes time.
4782 This would be a good case for using mmap.
4784 I have no idea how to handle linking PIC code into a file of a
4785 different format. It probably can't be done. */
4787 && is_elf_hash_table (htab)
4788 && bed->check_relocs != NULL
4789 && elf_object_id (abfd) == elf_hash_table_id (htab)
4790 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4794 for (o = abfd->sections; o != NULL; o = o->next)
4796 Elf_Internal_Rela *internal_relocs;
4799 if ((o->flags & SEC_RELOC) == 0
4800 || o->reloc_count == 0
4801 || ((info->strip == strip_all || info->strip == strip_debugger)
4802 && (o->flags & SEC_DEBUGGING) != 0)
4803 || bfd_is_abs_section (o->output_section))
4806 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4808 if (internal_relocs == NULL)
4811 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4813 if (elf_section_data (o)->relocs != internal_relocs)
4814 free (internal_relocs);
4821 /* If this is a non-traditional link, try to optimize the handling
4822 of the .stab/.stabstr sections. */
4824 && ! info->traditional_format
4825 && is_elf_hash_table (htab)
4826 && (info->strip != strip_all && info->strip != strip_debugger))
4830 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4831 if (stabstr != NULL)
4833 bfd_size_type string_offset = 0;
4836 for (stab = abfd->sections; stab; stab = stab->next)
4837 if (CONST_STRNEQ (stab->name, ".stab")
4838 && (!stab->name[5] ||
4839 (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4840 && (stab->flags & SEC_MERGE) == 0
4841 && !bfd_is_abs_section (stab->output_section))
4843 struct bfd_elf_section_data *secdata;
4845 secdata = elf_section_data (stab);
4846 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4847 stabstr, &secdata->sec_info,
4850 if (secdata->sec_info)
4851 stab->sec_info_type = SEC_INFO_TYPE_STABS;
4856 if (is_elf_hash_table (htab) && add_needed)
4858 /* Add this bfd to the loaded list. */
4859 struct elf_link_loaded_list *n;
4861 n = (struct elf_link_loaded_list *) bfd_alloc (abfd, sizeof (*n));
4865 n->next = htab->loaded;
4872 if (old_tab != NULL)
4874 if (nondeflt_vers != NULL)
4875 free (nondeflt_vers);
4876 if (extversym != NULL)
4879 if (isymbuf != NULL)
4885 /* Return the linker hash table entry of a symbol that might be
4886 satisfied by an archive symbol. Return -1 on error. */
4888 struct elf_link_hash_entry *
4889 _bfd_elf_archive_symbol_lookup (bfd *abfd,
4890 struct bfd_link_info *info,
4893 struct elf_link_hash_entry *h;
4897 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
4901 /* If this is a default version (the name contains @@), look up the
4902 symbol again with only one `@' as well as without the version.
4903 The effect is that references to the symbol with and without the
4904 version will be matched by the default symbol in the archive. */
4906 p = strchr (name, ELF_VER_CHR);
4907 if (p == NULL || p[1] != ELF_VER_CHR)
4910 /* First check with only one `@'. */
4911 len = strlen (name);
4912 copy = (char *) bfd_alloc (abfd, len);
4914 return (struct elf_link_hash_entry *) 0 - 1;
4916 first = p - name + 1;
4917 memcpy (copy, name, first);
4918 memcpy (copy + first, name + first + 1, len - first);
4920 h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
4923 /* We also need to check references to the symbol without the
4925 copy[first - 1] = '\0';
4926 h = elf_link_hash_lookup (elf_hash_table (info), copy,
4927 FALSE, FALSE, TRUE);
4930 bfd_release (abfd, copy);
4934 /* Add symbols from an ELF archive file to the linker hash table. We
4935 don't use _bfd_generic_link_add_archive_symbols because we need to
4936 handle versioned symbols.
4938 Fortunately, ELF archive handling is simpler than that done by
4939 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4940 oddities. In ELF, if we find a symbol in the archive map, and the
4941 symbol is currently undefined, we know that we must pull in that
4944 Unfortunately, we do have to make multiple passes over the symbol
4945 table until nothing further is resolved. */
4948 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
4951 unsigned char *included = NULL;
4955 const struct elf_backend_data *bed;
4956 struct elf_link_hash_entry * (*archive_symbol_lookup)
4957 (bfd *, struct bfd_link_info *, const char *);
4959 if (! bfd_has_map (abfd))
4961 /* An empty archive is a special case. */
4962 if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4964 bfd_set_error (bfd_error_no_armap);
4968 /* Keep track of all symbols we know to be already defined, and all
4969 files we know to be already included. This is to speed up the
4970 second and subsequent passes. */
4971 c = bfd_ardata (abfd)->symdef_count;
4975 amt *= sizeof (*included);
4976 included = (unsigned char *) bfd_zmalloc (amt);
4977 if (included == NULL)
4980 symdefs = bfd_ardata (abfd)->symdefs;
4981 bed = get_elf_backend_data (abfd);
4982 archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
4995 symdefend = symdef + c;
4996 for (i = 0; symdef < symdefend; symdef++, i++)
4998 struct elf_link_hash_entry *h;
5000 struct bfd_link_hash_entry *undefs_tail;
5005 if (symdef->file_offset == last)
5011 h = archive_symbol_lookup (abfd, info, symdef->name);
5012 if (h == (struct elf_link_hash_entry *) 0 - 1)
5018 if (h->root.type == bfd_link_hash_common)
5020 /* We currently have a common symbol. The archive map contains
5021 a reference to this symbol, so we may want to include it. We
5022 only want to include it however, if this archive element
5023 contains a definition of the symbol, not just another common
5026 Unfortunately some archivers (including GNU ar) will put
5027 declarations of common symbols into their archive maps, as
5028 well as real definitions, so we cannot just go by the archive
5029 map alone. Instead we must read in the element's symbol
5030 table and check that to see what kind of symbol definition
5032 if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5035 else if (h->root.type != bfd_link_hash_undefined)
5037 if (h->root.type != bfd_link_hash_undefweak)
5038 /* Symbol must be defined. Don't check it again. */
5043 /* We need to include this archive member. */
5044 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5045 if (element == NULL)
5048 if (! bfd_check_format (element, bfd_object))
5051 undefs_tail = info->hash->undefs_tail;
5053 if (!(*info->callbacks
5054 ->add_archive_element) (info, element, symdef->name, &element))
5056 if (!bfd_link_add_symbols (element, info))
5059 /* If there are any new undefined symbols, we need to make
5060 another pass through the archive in order to see whether
5061 they can be defined. FIXME: This isn't perfect, because
5062 common symbols wind up on undefs_tail and because an
5063 undefined symbol which is defined later on in this pass
5064 does not require another pass. This isn't a bug, but it
5065 does make the code less efficient than it could be. */
5066 if (undefs_tail != info->hash->undefs_tail)
5069 /* Look backward to mark all symbols from this object file
5070 which we have already seen in this pass. */
5074 included[mark] = TRUE;
5079 while (symdefs[mark].file_offset == symdef->file_offset);
5081 /* We mark subsequent symbols from this object file as we go
5082 on through the loop. */
5083 last = symdef->file_offset;
5093 if (included != NULL)
5098 /* Given an ELF BFD, add symbols to the global hash table as
5102 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5104 switch (bfd_get_format (abfd))
5107 return elf_link_add_object_symbols (abfd, info);
5109 return elf_link_add_archive_symbols (abfd, info);
5111 bfd_set_error (bfd_error_wrong_format);
5116 struct hash_codes_info
5118 unsigned long *hashcodes;
5122 /* This function will be called though elf_link_hash_traverse to store
5123 all hash value of the exported symbols in an array. */
5126 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5128 struct hash_codes_info *inf = (struct hash_codes_info *) data;
5134 /* Ignore indirect symbols. These are added by the versioning code. */
5135 if (h->dynindx == -1)
5138 name = h->root.root.string;
5139 p = strchr (name, ELF_VER_CHR);
5142 alc = (char *) bfd_malloc (p - name + 1);
5148 memcpy (alc, name, p - name);
5149 alc[p - name] = '\0';
5153 /* Compute the hash value. */
5154 ha = bfd_elf_hash (name);
5156 /* Store the found hash value in the array given as the argument. */
5157 *(inf->hashcodes)++ = ha;
5159 /* And store it in the struct so that we can put it in the hash table
5161 h->u.elf_hash_value = ha;
5169 struct collect_gnu_hash_codes
5172 const struct elf_backend_data *bed;
5173 unsigned long int nsyms;
5174 unsigned long int maskbits;
5175 unsigned long int *hashcodes;
5176 unsigned long int *hashval;
5177 unsigned long int *indx;
5178 unsigned long int *counts;
5181 long int min_dynindx;
5182 unsigned long int bucketcount;
5183 unsigned long int symindx;
5184 long int local_indx;
5185 long int shift1, shift2;
5186 unsigned long int mask;
5190 /* This function will be called though elf_link_hash_traverse to store
5191 all hash value of the exported symbols in an array. */
5194 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5196 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5202 /* Ignore indirect symbols. These are added by the versioning code. */
5203 if (h->dynindx == -1)
5206 /* Ignore also local symbols and undefined symbols. */
5207 if (! (*s->bed->elf_hash_symbol) (h))
5210 name = h->root.root.string;
5211 p = strchr (name, ELF_VER_CHR);
5214 alc = (char *) bfd_malloc (p - name + 1);
5220 memcpy (alc, name, p - name);
5221 alc[p - name] = '\0';
5225 /* Compute the hash value. */
5226 ha = bfd_elf_gnu_hash (name);
5228 /* Store the found hash value in the array for compute_bucket_count,
5229 and also for .dynsym reordering purposes. */
5230 s->hashcodes[s->nsyms] = ha;
5231 s->hashval[h->dynindx] = ha;
5233 if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5234 s->min_dynindx = h->dynindx;
5242 /* This function will be called though elf_link_hash_traverse to do
5243 final dynaminc symbol renumbering. */
5246 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5248 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5249 unsigned long int bucket;
5250 unsigned long int val;
5252 /* Ignore indirect symbols. */
5253 if (h->dynindx == -1)
5256 /* Ignore also local symbols and undefined symbols. */
5257 if (! (*s->bed->elf_hash_symbol) (h))
5259 if (h->dynindx >= s->min_dynindx)
5260 h->dynindx = s->local_indx++;
5264 bucket = s->hashval[h->dynindx] % s->bucketcount;
5265 val = (s->hashval[h->dynindx] >> s->shift1)
5266 & ((s->maskbits >> s->shift1) - 1);
5267 s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5269 |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5270 val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5271 if (s->counts[bucket] == 1)
5272 /* Last element terminates the chain. */
5274 bfd_put_32 (s->output_bfd, val,
5275 s->contents + (s->indx[bucket] - s->symindx) * 4);
5276 --s->counts[bucket];
5277 h->dynindx = s->indx[bucket]++;
5281 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5284 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5286 return !(h->forced_local
5287 || h->root.type == bfd_link_hash_undefined
5288 || h->root.type == bfd_link_hash_undefweak
5289 || ((h->root.type == bfd_link_hash_defined
5290 || h->root.type == bfd_link_hash_defweak)
5291 && h->root.u.def.section->output_section == NULL));
5294 /* Array used to determine the number of hash table buckets to use
5295 based on the number of symbols there are. If there are fewer than
5296 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5297 fewer than 37 we use 17 buckets, and so forth. We never use more
5298 than 32771 buckets. */
5300 static const size_t elf_buckets[] =
5302 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5306 /* Compute bucket count for hashing table. We do not use a static set
5307 of possible tables sizes anymore. Instead we determine for all
5308 possible reasonable sizes of the table the outcome (i.e., the
5309 number of collisions etc) and choose the best solution. The
5310 weighting functions are not too simple to allow the table to grow
5311 without bounds. Instead one of the weighting factors is the size.
5312 Therefore the result is always a good payoff between few collisions
5313 (= short chain lengths) and table size. */
5315 compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5316 unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5317 unsigned long int nsyms,
5320 size_t best_size = 0;
5321 unsigned long int i;
5323 /* We have a problem here. The following code to optimize the table
5324 size requires an integer type with more the 32 bits. If
5325 BFD_HOST_U_64_BIT is set we know about such a type. */
5326 #ifdef BFD_HOST_U_64_BIT
5331 BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5332 bfd *dynobj = elf_hash_table (info)->dynobj;
5333 size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5334 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5335 unsigned long int *counts;
5337 unsigned int no_improvement_count = 0;
5339 /* Possible optimization parameters: if we have NSYMS symbols we say
5340 that the hashing table must at least have NSYMS/4 and at most
5342 minsize = nsyms / 4;
5345 best_size = maxsize = nsyms * 2;
5350 if ((best_size & 31) == 0)
5354 /* Create array where we count the collisions in. We must use bfd_malloc
5355 since the size could be large. */
5357 amt *= sizeof (unsigned long int);
5358 counts = (unsigned long int *) bfd_malloc (amt);
5362 /* Compute the "optimal" size for the hash table. The criteria is a
5363 minimal chain length. The minor criteria is (of course) the size
5365 for (i = minsize; i < maxsize; ++i)
5367 /* Walk through the array of hashcodes and count the collisions. */
5368 BFD_HOST_U_64_BIT max;
5369 unsigned long int j;
5370 unsigned long int fact;
5372 if (gnu_hash && (i & 31) == 0)
5375 memset (counts, '\0', i * sizeof (unsigned long int));
5377 /* Determine how often each hash bucket is used. */
5378 for (j = 0; j < nsyms; ++j)
5379 ++counts[hashcodes[j] % i];
5381 /* For the weight function we need some information about the
5382 pagesize on the target. This is information need not be 100%
5383 accurate. Since this information is not available (so far) we
5384 define it here to a reasonable default value. If it is crucial
5385 to have a better value some day simply define this value. */
5386 # ifndef BFD_TARGET_PAGESIZE
5387 # define BFD_TARGET_PAGESIZE (4096)
5390 /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5392 max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5395 /* Variant 1: optimize for short chains. We add the squares
5396 of all the chain lengths (which favors many small chain
5397 over a few long chains). */
5398 for (j = 0; j < i; ++j)
5399 max += counts[j] * counts[j];
5401 /* This adds penalties for the overall size of the table. */
5402 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5405 /* Variant 2: Optimize a lot more for small table. Here we
5406 also add squares of the size but we also add penalties for
5407 empty slots (the +1 term). */
5408 for (j = 0; j < i; ++j)
5409 max += (1 + counts[j]) * (1 + counts[j]);
5411 /* The overall size of the table is considered, but not as
5412 strong as in variant 1, where it is squared. */
5413 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5417 /* Compare with current best results. */
5418 if (max < best_chlen)
5422 no_improvement_count = 0;
5424 /* PR 11843: Avoid futile long searches for the best bucket size
5425 when there are a large number of symbols. */
5426 else if (++no_improvement_count == 100)
5433 #endif /* defined (BFD_HOST_U_64_BIT) */
5435 /* This is the fallback solution if no 64bit type is available or if we
5436 are not supposed to spend much time on optimizations. We select the
5437 bucket count using a fixed set of numbers. */
5438 for (i = 0; elf_buckets[i] != 0; i++)
5440 best_size = elf_buckets[i];
5441 if (nsyms < elf_buckets[i + 1])
5444 if (gnu_hash && best_size < 2)
5451 /* Size any SHT_GROUP section for ld -r. */
5454 _bfd_elf_size_group_sections (struct bfd_link_info *info)
5458 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5459 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5460 && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5465 /* Set a default stack segment size. The value in INFO wins. If it
5466 is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5467 undefined it is initialized. */
5470 bfd_elf_stack_segment_size (bfd *output_bfd,
5471 struct bfd_link_info *info,
5472 const char *legacy_symbol,
5473 bfd_vma default_size)
5475 struct elf_link_hash_entry *h = NULL;
5477 /* Look for legacy symbol. */
5479 h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
5480 FALSE, FALSE, FALSE);
5481 if (h && (h->root.type == bfd_link_hash_defined
5482 || h->root.type == bfd_link_hash_defweak)
5484 && (h->type == STT_NOTYPE || h->type == STT_OBJECT))
5486 /* The symbol has no type if specified on the command line. */
5487 h->type = STT_OBJECT;
5488 if (info->stacksize)
5489 (*_bfd_error_handler) (_("%B: stack size specified and %s set"),
5490 output_bfd, legacy_symbol);
5491 else if (h->root.u.def.section != bfd_abs_section_ptr)
5492 (*_bfd_error_handler) (_("%B: %s not absolute"),
5493 output_bfd, legacy_symbol);
5495 info->stacksize = h->root.u.def.value;
5498 if (!info->stacksize)
5499 /* If the user didn't set a size, or explicitly inhibit the
5500 size, set it now. */
5501 info->stacksize = default_size;
5503 /* Provide the legacy symbol, if it is referenced. */
5504 if (h && (h->root.type == bfd_link_hash_undefined
5505 || h->root.type == bfd_link_hash_undefweak))
5507 struct bfd_link_hash_entry *bh = NULL;
5509 if (!(_bfd_generic_link_add_one_symbol
5510 (info, output_bfd, legacy_symbol,
5511 BSF_GLOBAL, bfd_abs_section_ptr,
5512 info->stacksize >= 0 ? info->stacksize : 0,
5513 NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
5516 h = (struct elf_link_hash_entry *) bh;
5518 h->type = STT_OBJECT;
5524 /* Set up the sizes and contents of the ELF dynamic sections. This is
5525 called by the ELF linker emulation before_allocation routine. We
5526 must set the sizes of the sections before the linker sets the
5527 addresses of the various sections. */
5530 bfd_elf_size_dynamic_sections (bfd *output_bfd,
5533 const char *filter_shlib,
5535 const char *depaudit,
5536 const char * const *auxiliary_filters,
5537 struct bfd_link_info *info,
5538 asection **sinterpptr)
5540 bfd_size_type soname_indx;
5542 const struct elf_backend_data *bed;
5543 struct elf_info_failed asvinfo;
5547 soname_indx = (bfd_size_type) -1;
5549 if (!is_elf_hash_table (info->hash))
5552 bed = get_elf_backend_data (output_bfd);
5554 /* Any syms created from now on start with -1 in
5555 got.refcount/offset and plt.refcount/offset. */
5556 elf_hash_table (info)->init_got_refcount
5557 = elf_hash_table (info)->init_got_offset;
5558 elf_hash_table (info)->init_plt_refcount
5559 = elf_hash_table (info)->init_plt_offset;
5561 if (info->relocatable
5562 && !_bfd_elf_size_group_sections (info))
5565 /* The backend may have to create some sections regardless of whether
5566 we're dynamic or not. */
5567 if (bed->elf_backend_always_size_sections
5568 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5571 /* Determine any GNU_STACK segment requirements, after the backend
5572 has had a chance to set a default segment size. */
5573 if (info->execstack)
5574 elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X;
5575 else if (info->noexecstack)
5576 elf_stack_flags (output_bfd) = PF_R | PF_W;
5580 asection *notesec = NULL;
5583 for (inputobj = info->input_bfds;
5585 inputobj = inputobj->link.next)
5590 & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
5592 s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5595 if (s->flags & SEC_CODE)
5599 else if (bed->default_execstack)
5602 if (notesec || info->stacksize > 0)
5603 elf_stack_flags (output_bfd) = PF_R | PF_W | exec;
5604 if (notesec && exec && info->relocatable
5605 && notesec->output_section != bfd_abs_section_ptr)
5606 notesec->output_section->flags |= SEC_CODE;
5609 dynobj = elf_hash_table (info)->dynobj;
5611 if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5613 struct elf_info_failed eif;
5614 struct elf_link_hash_entry *h;
5616 struct bfd_elf_version_tree *t;
5617 struct bfd_elf_version_expr *d;
5619 bfd_boolean all_defined;
5621 *sinterpptr = bfd_get_linker_section (dynobj, ".interp");
5622 BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5626 soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5628 if (soname_indx == (bfd_size_type) -1
5629 || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5635 if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5637 info->flags |= DF_SYMBOLIC;
5645 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5647 if (indx == (bfd_size_type) -1)
5650 tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
5651 if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
5655 if (filter_shlib != NULL)
5659 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5660 filter_shlib, TRUE);
5661 if (indx == (bfd_size_type) -1
5662 || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5666 if (auxiliary_filters != NULL)
5668 const char * const *p;
5670 for (p = auxiliary_filters; *p != NULL; p++)
5674 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5676 if (indx == (bfd_size_type) -1
5677 || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5686 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5688 if (indx == (bfd_size_type) -1
5689 || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5693 if (depaudit != NULL)
5697 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5699 if (indx == (bfd_size_type) -1
5700 || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5707 /* If we are supposed to export all symbols into the dynamic symbol
5708 table (this is not the normal case), then do so. */
5709 if (info->export_dynamic
5710 || (info->executable && info->dynamic))
5712 elf_link_hash_traverse (elf_hash_table (info),
5713 _bfd_elf_export_symbol,
5719 /* Make all global versions with definition. */
5720 for (t = info->version_info; t != NULL; t = t->next)
5721 for (d = t->globals.list; d != NULL; d = d->next)
5722 if (!d->symver && d->literal)
5724 const char *verstr, *name;
5725 size_t namelen, verlen, newlen;
5726 char *newname, *p, leading_char;
5727 struct elf_link_hash_entry *newh;
5729 leading_char = bfd_get_symbol_leading_char (output_bfd);
5731 namelen = strlen (name) + (leading_char != '\0');
5733 verlen = strlen (verstr);
5734 newlen = namelen + verlen + 3;
5736 newname = (char *) bfd_malloc (newlen);
5737 if (newname == NULL)
5739 newname[0] = leading_char;
5740 memcpy (newname + (leading_char != '\0'), name, namelen);
5742 /* Check the hidden versioned definition. */
5743 p = newname + namelen;
5745 memcpy (p, verstr, verlen + 1);
5746 newh = elf_link_hash_lookup (elf_hash_table (info),
5747 newname, FALSE, FALSE,
5750 || (newh->root.type != bfd_link_hash_defined
5751 && newh->root.type != bfd_link_hash_defweak))
5753 /* Check the default versioned definition. */
5755 memcpy (p, verstr, verlen + 1);
5756 newh = elf_link_hash_lookup (elf_hash_table (info),
5757 newname, FALSE, FALSE,
5762 /* Mark this version if there is a definition and it is
5763 not defined in a shared object. */
5765 && !newh->def_dynamic
5766 && (newh->root.type == bfd_link_hash_defined
5767 || newh->root.type == bfd_link_hash_defweak))
5771 /* Attach all the symbols to their version information. */
5772 asvinfo.info = info;
5773 asvinfo.failed = FALSE;
5775 elf_link_hash_traverse (elf_hash_table (info),
5776 _bfd_elf_link_assign_sym_version,
5781 if (!info->allow_undefined_version)
5783 /* Check if all global versions have a definition. */
5785 for (t = info->version_info; t != NULL; t = t->next)
5786 for (d = t->globals.list; d != NULL; d = d->next)
5787 if (d->literal && !d->symver && !d->script)
5789 (*_bfd_error_handler)
5790 (_("%s: undefined version: %s"),
5791 d->pattern, t->name);
5792 all_defined = FALSE;
5797 bfd_set_error (bfd_error_bad_value);
5802 /* Find all symbols which were defined in a dynamic object and make
5803 the backend pick a reasonable value for them. */
5804 elf_link_hash_traverse (elf_hash_table (info),
5805 _bfd_elf_adjust_dynamic_symbol,
5810 /* Add some entries to the .dynamic section. We fill in some of the
5811 values later, in bfd_elf_final_link, but we must add the entries
5812 now so that we know the final size of the .dynamic section. */
5814 /* If there are initialization and/or finalization functions to
5815 call then add the corresponding DT_INIT/DT_FINI entries. */
5816 h = (info->init_function
5817 ? elf_link_hash_lookup (elf_hash_table (info),
5818 info->init_function, FALSE,
5825 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5828 h = (info->fini_function
5829 ? elf_link_hash_lookup (elf_hash_table (info),
5830 info->fini_function, FALSE,
5837 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5841 s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5842 if (s != NULL && s->linker_has_input)
5844 /* DT_PREINIT_ARRAY is not allowed in shared library. */
5845 if (! info->executable)
5850 for (sub = info->input_bfds; sub != NULL;
5851 sub = sub->link.next)
5852 if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5853 for (o = sub->sections; o != NULL; o = o->next)
5854 if (elf_section_data (o)->this_hdr.sh_type
5855 == SHT_PREINIT_ARRAY)
5857 (*_bfd_error_handler)
5858 (_("%B: .preinit_array section is not allowed in DSO"),
5863 bfd_set_error (bfd_error_nonrepresentable_section);
5867 if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5868 || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5871 s = bfd_get_section_by_name (output_bfd, ".init_array");
5872 if (s != NULL && s->linker_has_input)
5874 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5875 || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5878 s = bfd_get_section_by_name (output_bfd, ".fini_array");
5879 if (s != NULL && s->linker_has_input)
5881 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5882 || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5886 dynstr = bfd_get_linker_section (dynobj, ".dynstr");
5887 /* If .dynstr is excluded from the link, we don't want any of
5888 these tags. Strictly, we should be checking each section
5889 individually; This quick check covers for the case where
5890 someone does a /DISCARD/ : { *(*) }. */
5891 if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5893 bfd_size_type strsize;
5895 strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5896 if ((info->emit_hash
5897 && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5898 || (info->emit_gnu_hash
5899 && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5900 || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5901 || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5902 || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5903 || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5904 bed->s->sizeof_sym))
5909 /* The backend must work out the sizes of all the other dynamic
5912 && bed->elf_backend_size_dynamic_sections != NULL
5913 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5916 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5919 if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5921 unsigned long section_sym_count;
5922 struct bfd_elf_version_tree *verdefs;
5925 /* Set up the version definition section. */
5926 s = bfd_get_linker_section (dynobj, ".gnu.version_d");
5927 BFD_ASSERT (s != NULL);
5929 /* We may have created additional version definitions if we are
5930 just linking a regular application. */
5931 verdefs = info->version_info;
5933 /* Skip anonymous version tag. */
5934 if (verdefs != NULL && verdefs->vernum == 0)
5935 verdefs = verdefs->next;
5937 if (verdefs == NULL && !info->create_default_symver)
5938 s->flags |= SEC_EXCLUDE;
5943 struct bfd_elf_version_tree *t;
5945 Elf_Internal_Verdef def;
5946 Elf_Internal_Verdaux defaux;
5947 struct bfd_link_hash_entry *bh;
5948 struct elf_link_hash_entry *h;
5954 /* Make space for the base version. */
5955 size += sizeof (Elf_External_Verdef);
5956 size += sizeof (Elf_External_Verdaux);
5959 /* Make space for the default version. */
5960 if (info->create_default_symver)
5962 size += sizeof (Elf_External_Verdef);
5966 for (t = verdefs; t != NULL; t = t->next)
5968 struct bfd_elf_version_deps *n;
5970 /* Don't emit base version twice. */
5974 size += sizeof (Elf_External_Verdef);
5975 size += sizeof (Elf_External_Verdaux);
5978 for (n = t->deps; n != NULL; n = n->next)
5979 size += sizeof (Elf_External_Verdaux);
5983 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
5984 if (s->contents == NULL && s->size != 0)
5987 /* Fill in the version definition section. */
5991 def.vd_version = VER_DEF_CURRENT;
5992 def.vd_flags = VER_FLG_BASE;
5995 if (info->create_default_symver)
5997 def.vd_aux = 2 * sizeof (Elf_External_Verdef);
5998 def.vd_next = sizeof (Elf_External_Verdef);
6002 def.vd_aux = sizeof (Elf_External_Verdef);
6003 def.vd_next = (sizeof (Elf_External_Verdef)
6004 + sizeof (Elf_External_Verdaux));
6007 if (soname_indx != (bfd_size_type) -1)
6009 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6011 def.vd_hash = bfd_elf_hash (soname);
6012 defaux.vda_name = soname_indx;
6019 name = lbasename (output_bfd->filename);
6020 def.vd_hash = bfd_elf_hash (name);
6021 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6023 if (indx == (bfd_size_type) -1)
6025 defaux.vda_name = indx;
6027 defaux.vda_next = 0;
6029 _bfd_elf_swap_verdef_out (output_bfd, &def,
6030 (Elf_External_Verdef *) p);
6031 p += sizeof (Elf_External_Verdef);
6032 if (info->create_default_symver)
6034 /* Add a symbol representing this version. */
6036 if (! (_bfd_generic_link_add_one_symbol
6037 (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6039 get_elf_backend_data (dynobj)->collect, &bh)))
6041 h = (struct elf_link_hash_entry *) bh;
6044 h->type = STT_OBJECT;
6045 h->verinfo.vertree = NULL;
6047 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6050 /* Create a duplicate of the base version with the same
6051 aux block, but different flags. */
6054 def.vd_aux = sizeof (Elf_External_Verdef);
6056 def.vd_next = (sizeof (Elf_External_Verdef)
6057 + sizeof (Elf_External_Verdaux));
6060 _bfd_elf_swap_verdef_out (output_bfd, &def,
6061 (Elf_External_Verdef *) p);
6062 p += sizeof (Elf_External_Verdef);
6064 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6065 (Elf_External_Verdaux *) p);
6066 p += sizeof (Elf_External_Verdaux);
6068 for (t = verdefs; t != NULL; t = t->next)
6071 struct bfd_elf_version_deps *n;
6073 /* Don't emit the base version twice. */
6078 for (n = t->deps; n != NULL; n = n->next)
6081 /* Add a symbol representing this version. */
6083 if (! (_bfd_generic_link_add_one_symbol
6084 (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6086 get_elf_backend_data (dynobj)->collect, &bh)))
6088 h = (struct elf_link_hash_entry *) bh;
6091 h->type = STT_OBJECT;
6092 h->verinfo.vertree = t;
6094 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6097 def.vd_version = VER_DEF_CURRENT;
6099 if (t->globals.list == NULL
6100 && t->locals.list == NULL
6102 def.vd_flags |= VER_FLG_WEAK;
6103 def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6104 def.vd_cnt = cdeps + 1;
6105 def.vd_hash = bfd_elf_hash (t->name);
6106 def.vd_aux = sizeof (Elf_External_Verdef);
6109 /* If a basever node is next, it *must* be the last node in
6110 the chain, otherwise Verdef construction breaks. */
6111 if (t->next != NULL && t->next->vernum == 0)
6112 BFD_ASSERT (t->next->next == NULL);
6114 if (t->next != NULL && t->next->vernum != 0)
6115 def.vd_next = (sizeof (Elf_External_Verdef)
6116 + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6118 _bfd_elf_swap_verdef_out (output_bfd, &def,
6119 (Elf_External_Verdef *) p);
6120 p += sizeof (Elf_External_Verdef);
6122 defaux.vda_name = h->dynstr_index;
6123 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6125 defaux.vda_next = 0;
6126 if (t->deps != NULL)
6127 defaux.vda_next = sizeof (Elf_External_Verdaux);
6128 t->name_indx = defaux.vda_name;
6130 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6131 (Elf_External_Verdaux *) p);
6132 p += sizeof (Elf_External_Verdaux);
6134 for (n = t->deps; n != NULL; n = n->next)
6136 if (n->version_needed == NULL)
6138 /* This can happen if there was an error in the
6140 defaux.vda_name = 0;
6144 defaux.vda_name = n->version_needed->name_indx;
6145 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6148 if (n->next == NULL)
6149 defaux.vda_next = 0;
6151 defaux.vda_next = sizeof (Elf_External_Verdaux);
6153 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6154 (Elf_External_Verdaux *) p);
6155 p += sizeof (Elf_External_Verdaux);
6159 if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6160 || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6163 elf_tdata (output_bfd)->cverdefs = cdefs;
6166 if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6168 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6171 else if (info->flags & DF_BIND_NOW)
6173 if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6179 if (info->executable)
6180 info->flags_1 &= ~ (DF_1_INITFIRST
6183 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6187 /* Work out the size of the version reference section. */
6189 s = bfd_get_linker_section (dynobj, ".gnu.version_r");
6190 BFD_ASSERT (s != NULL);
6192 struct elf_find_verdep_info sinfo;
6195 sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6196 if (sinfo.vers == 0)
6198 sinfo.failed = FALSE;
6200 elf_link_hash_traverse (elf_hash_table (info),
6201 _bfd_elf_link_find_version_dependencies,
6206 if (elf_tdata (output_bfd)->verref == NULL)
6207 s->flags |= SEC_EXCLUDE;
6210 Elf_Internal_Verneed *t;
6215 /* Build the version dependency section. */
6218 for (t = elf_tdata (output_bfd)->verref;
6222 Elf_Internal_Vernaux *a;
6224 size += sizeof (Elf_External_Verneed);
6226 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6227 size += sizeof (Elf_External_Vernaux);
6231 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6232 if (s->contents == NULL)
6236 for (t = elf_tdata (output_bfd)->verref;
6241 Elf_Internal_Vernaux *a;
6245 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6248 t->vn_version = VER_NEED_CURRENT;
6250 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6251 elf_dt_name (t->vn_bfd) != NULL
6252 ? elf_dt_name (t->vn_bfd)
6253 : lbasename (t->vn_bfd->filename),
6255 if (indx == (bfd_size_type) -1)
6258 t->vn_aux = sizeof (Elf_External_Verneed);
6259 if (t->vn_nextref == NULL)
6262 t->vn_next = (sizeof (Elf_External_Verneed)
6263 + caux * sizeof (Elf_External_Vernaux));
6265 _bfd_elf_swap_verneed_out (output_bfd, t,
6266 (Elf_External_Verneed *) p);
6267 p += sizeof (Elf_External_Verneed);
6269 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6271 a->vna_hash = bfd_elf_hash (a->vna_nodename);
6272 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6273 a->vna_nodename, FALSE);
6274 if (indx == (bfd_size_type) -1)
6277 if (a->vna_nextptr == NULL)
6280 a->vna_next = sizeof (Elf_External_Vernaux);
6282 _bfd_elf_swap_vernaux_out (output_bfd, a,
6283 (Elf_External_Vernaux *) p);
6284 p += sizeof (Elf_External_Vernaux);
6288 if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6289 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6292 elf_tdata (output_bfd)->cverrefs = crefs;
6296 if ((elf_tdata (output_bfd)->cverrefs == 0
6297 && elf_tdata (output_bfd)->cverdefs == 0)
6298 || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6299 §ion_sym_count) == 0)
6301 s = bfd_get_linker_section (dynobj, ".gnu.version");
6302 s->flags |= SEC_EXCLUDE;
6308 /* Find the first non-excluded output section. We'll use its
6309 section symbol for some emitted relocs. */
6311 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6315 for (s = output_bfd->sections; s != NULL; s = s->next)
6316 if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6317 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6319 elf_hash_table (info)->text_index_section = s;
6324 /* Find two non-excluded output sections, one for code, one for data.
6325 We'll use their section symbols for some emitted relocs. */
6327 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6331 /* Data first, since setting text_index_section changes
6332 _bfd_elf_link_omit_section_dynsym. */
6333 for (s = output_bfd->sections; s != NULL; s = s->next)
6334 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6335 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6337 elf_hash_table (info)->data_index_section = s;
6341 for (s = output_bfd->sections; s != NULL; s = s->next)
6342 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6343 == (SEC_ALLOC | SEC_READONLY))
6344 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6346 elf_hash_table (info)->text_index_section = s;
6350 if (elf_hash_table (info)->text_index_section == NULL)
6351 elf_hash_table (info)->text_index_section
6352 = elf_hash_table (info)->data_index_section;
6356 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6358 const struct elf_backend_data *bed;
6360 if (!is_elf_hash_table (info->hash))
6363 bed = get_elf_backend_data (output_bfd);
6364 (*bed->elf_backend_init_index_section) (output_bfd, info);
6366 if (elf_hash_table (info)->dynamic_sections_created)
6370 bfd_size_type dynsymcount;
6371 unsigned long section_sym_count;
6372 unsigned int dtagcount;
6374 dynobj = elf_hash_table (info)->dynobj;
6376 /* Assign dynsym indicies. In a shared library we generate a
6377 section symbol for each output section, which come first.
6378 Next come all of the back-end allocated local dynamic syms,
6379 followed by the rest of the global symbols. */
6381 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6382 §ion_sym_count);
6384 /* Work out the size of the symbol version section. */
6385 s = bfd_get_linker_section (dynobj, ".gnu.version");
6386 BFD_ASSERT (s != NULL);
6387 if (dynsymcount != 0
6388 && (s->flags & SEC_EXCLUDE) == 0)
6390 s->size = dynsymcount * sizeof (Elf_External_Versym);
6391 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6392 if (s->contents == NULL)
6395 if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6399 /* Set the size of the .dynsym and .hash sections. We counted
6400 the number of dynamic symbols in elf_link_add_object_symbols.
6401 We will build the contents of .dynsym and .hash when we build
6402 the final symbol table, because until then we do not know the
6403 correct value to give the symbols. We built the .dynstr
6404 section as we went along in elf_link_add_object_symbols. */
6405 s = bfd_get_linker_section (dynobj, ".dynsym");
6406 BFD_ASSERT (s != NULL);
6407 s->size = dynsymcount * bed->s->sizeof_sym;
6409 if (dynsymcount != 0)
6411 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6412 if (s->contents == NULL)
6415 /* The first entry in .dynsym is a dummy symbol.
6416 Clear all the section syms, in case we don't output them all. */
6417 ++section_sym_count;
6418 memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6421 elf_hash_table (info)->bucketcount = 0;
6423 /* Compute the size of the hashing table. As a side effect this
6424 computes the hash values for all the names we export. */
6425 if (info->emit_hash)
6427 unsigned long int *hashcodes;
6428 struct hash_codes_info hashinf;
6430 unsigned long int nsyms;
6432 size_t hash_entry_size;
6434 /* Compute the hash values for all exported symbols. At the same
6435 time store the values in an array so that we could use them for
6437 amt = dynsymcount * sizeof (unsigned long int);
6438 hashcodes = (unsigned long int *) bfd_malloc (amt);
6439 if (hashcodes == NULL)
6441 hashinf.hashcodes = hashcodes;
6442 hashinf.error = FALSE;
6444 /* Put all hash values in HASHCODES. */
6445 elf_link_hash_traverse (elf_hash_table (info),
6446 elf_collect_hash_codes, &hashinf);
6453 nsyms = hashinf.hashcodes - hashcodes;
6455 = compute_bucket_count (info, hashcodes, nsyms, 0);
6458 if (bucketcount == 0)
6461 elf_hash_table (info)->bucketcount = bucketcount;
6463 s = bfd_get_linker_section (dynobj, ".hash");
6464 BFD_ASSERT (s != NULL);
6465 hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6466 s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6467 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6468 if (s->contents == NULL)
6471 bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6472 bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6473 s->contents + hash_entry_size);
6476 if (info->emit_gnu_hash)
6479 unsigned char *contents;
6480 struct collect_gnu_hash_codes cinfo;
6484 memset (&cinfo, 0, sizeof (cinfo));
6486 /* Compute the hash values for all exported symbols. At the same
6487 time store the values in an array so that we could use them for
6489 amt = dynsymcount * 2 * sizeof (unsigned long int);
6490 cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6491 if (cinfo.hashcodes == NULL)
6494 cinfo.hashval = cinfo.hashcodes + dynsymcount;
6495 cinfo.min_dynindx = -1;
6496 cinfo.output_bfd = output_bfd;
6499 /* Put all hash values in HASHCODES. */
6500 elf_link_hash_traverse (elf_hash_table (info),
6501 elf_collect_gnu_hash_codes, &cinfo);
6504 free (cinfo.hashcodes);
6509 = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6511 if (bucketcount == 0)
6513 free (cinfo.hashcodes);
6517 s = bfd_get_linker_section (dynobj, ".gnu.hash");
6518 BFD_ASSERT (s != NULL);
6520 if (cinfo.nsyms == 0)
6522 /* Empty .gnu.hash section is special. */
6523 BFD_ASSERT (cinfo.min_dynindx == -1);
6524 free (cinfo.hashcodes);
6525 s->size = 5 * 4 + bed->s->arch_size / 8;
6526 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6527 if (contents == NULL)
6529 s->contents = contents;
6530 /* 1 empty bucket. */
6531 bfd_put_32 (output_bfd, 1, contents);
6532 /* SYMIDX above the special symbol 0. */
6533 bfd_put_32 (output_bfd, 1, contents + 4);
6534 /* Just one word for bitmask. */
6535 bfd_put_32 (output_bfd, 1, contents + 8);
6536 /* Only hash fn bloom filter. */
6537 bfd_put_32 (output_bfd, 0, contents + 12);
6538 /* No hashes are valid - empty bitmask. */
6539 bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6540 /* No hashes in the only bucket. */
6541 bfd_put_32 (output_bfd, 0,
6542 contents + 16 + bed->s->arch_size / 8);
6546 unsigned long int maskwords, maskbitslog2, x;
6547 BFD_ASSERT (cinfo.min_dynindx != -1);
6551 while ((x >>= 1) != 0)
6553 if (maskbitslog2 < 3)
6555 else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6556 maskbitslog2 = maskbitslog2 + 3;
6558 maskbitslog2 = maskbitslog2 + 2;
6559 if (bed->s->arch_size == 64)
6561 if (maskbitslog2 == 5)
6567 cinfo.mask = (1 << cinfo.shift1) - 1;
6568 cinfo.shift2 = maskbitslog2;
6569 cinfo.maskbits = 1 << maskbitslog2;
6570 maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6571 amt = bucketcount * sizeof (unsigned long int) * 2;
6572 amt += maskwords * sizeof (bfd_vma);
6573 cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6574 if (cinfo.bitmask == NULL)
6576 free (cinfo.hashcodes);
6580 cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6581 cinfo.indx = cinfo.counts + bucketcount;
6582 cinfo.symindx = dynsymcount - cinfo.nsyms;
6583 memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6585 /* Determine how often each hash bucket is used. */
6586 memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6587 for (i = 0; i < cinfo.nsyms; ++i)
6588 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6590 for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6591 if (cinfo.counts[i] != 0)
6593 cinfo.indx[i] = cnt;
6594 cnt += cinfo.counts[i];
6596 BFD_ASSERT (cnt == dynsymcount);
6597 cinfo.bucketcount = bucketcount;
6598 cinfo.local_indx = cinfo.min_dynindx;
6600 s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6601 s->size += cinfo.maskbits / 8;
6602 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6603 if (contents == NULL)
6605 free (cinfo.bitmask);
6606 free (cinfo.hashcodes);
6610 s->contents = contents;
6611 bfd_put_32 (output_bfd, bucketcount, contents);
6612 bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6613 bfd_put_32 (output_bfd, maskwords, contents + 8);
6614 bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6615 contents += 16 + cinfo.maskbits / 8;
6617 for (i = 0; i < bucketcount; ++i)
6619 if (cinfo.counts[i] == 0)
6620 bfd_put_32 (output_bfd, 0, contents);
6622 bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6626 cinfo.contents = contents;
6628 /* Renumber dynamic symbols, populate .gnu.hash section. */
6629 elf_link_hash_traverse (elf_hash_table (info),
6630 elf_renumber_gnu_hash_syms, &cinfo);
6632 contents = s->contents + 16;
6633 for (i = 0; i < maskwords; ++i)
6635 bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6637 contents += bed->s->arch_size / 8;
6640 free (cinfo.bitmask);
6641 free (cinfo.hashcodes);
6645 s = bfd_get_linker_section (dynobj, ".dynstr");
6646 BFD_ASSERT (s != NULL);
6648 elf_finalize_dynstr (output_bfd, info);
6650 s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6652 for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6653 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6660 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
6663 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6666 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE);
6667 sec->sec_info_type = SEC_INFO_TYPE_NONE;
6670 /* Finish SHF_MERGE section merging. */
6673 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6678 if (!is_elf_hash_table (info->hash))
6681 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6682 if ((ibfd->flags & DYNAMIC) == 0)
6683 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6684 if ((sec->flags & SEC_MERGE) != 0
6685 && !bfd_is_abs_section (sec->output_section))
6687 struct bfd_elf_section_data *secdata;
6689 secdata = elf_section_data (sec);
6690 if (! _bfd_add_merge_section (abfd,
6691 &elf_hash_table (info)->merge_info,
6692 sec, &secdata->sec_info))
6694 else if (secdata->sec_info)
6695 sec->sec_info_type = SEC_INFO_TYPE_MERGE;
6698 if (elf_hash_table (info)->merge_info != NULL)
6699 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6700 merge_sections_remove_hook);
6704 /* Create an entry in an ELF linker hash table. */
6706 struct bfd_hash_entry *
6707 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6708 struct bfd_hash_table *table,
6711 /* Allocate the structure if it has not already been allocated by a
6715 entry = (struct bfd_hash_entry *)
6716 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6721 /* Call the allocation method of the superclass. */
6722 entry = _bfd_link_hash_newfunc (entry, table, string);
6725 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6726 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6728 /* Set local fields. */
6731 ret->got = htab->init_got_refcount;
6732 ret->plt = htab->init_plt_refcount;
6733 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6734 - offsetof (struct elf_link_hash_entry, size)));
6735 /* Assume that we have been called by a non-ELF symbol reader.
6736 This flag is then reset by the code which reads an ELF input
6737 file. This ensures that a symbol created by a non-ELF symbol
6738 reader will have the flag set correctly. */
6745 /* Copy data from an indirect symbol to its direct symbol, hiding the
6746 old indirect symbol. Also used for copying flags to a weakdef. */
6749 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6750 struct elf_link_hash_entry *dir,
6751 struct elf_link_hash_entry *ind)
6753 struct elf_link_hash_table *htab;
6755 /* Copy down any references that we may have already seen to the
6756 symbol which just became indirect. */
6758 dir->ref_dynamic |= ind->ref_dynamic;
6759 dir->ref_regular |= ind->ref_regular;
6760 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6761 dir->non_got_ref |= ind->non_got_ref;
6762 dir->needs_plt |= ind->needs_plt;
6763 dir->pointer_equality_needed |= ind->pointer_equality_needed;
6765 if (ind->root.type != bfd_link_hash_indirect)
6768 /* Copy over the global and procedure linkage table refcount entries.
6769 These may have been already set up by a check_relocs routine. */
6770 htab = elf_hash_table (info);
6771 if (ind->got.refcount > htab->init_got_refcount.refcount)
6773 if (dir->got.refcount < 0)
6774 dir->got.refcount = 0;
6775 dir->got.refcount += ind->got.refcount;
6776 ind->got.refcount = htab->init_got_refcount.refcount;
6779 if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6781 if (dir->plt.refcount < 0)
6782 dir->plt.refcount = 0;
6783 dir->plt.refcount += ind->plt.refcount;
6784 ind->plt.refcount = htab->init_plt_refcount.refcount;
6787 if (ind->dynindx != -1)
6789 if (dir->dynindx != -1)
6790 _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6791 dir->dynindx = ind->dynindx;
6792 dir->dynstr_index = ind->dynstr_index;
6794 ind->dynstr_index = 0;
6799 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6800 struct elf_link_hash_entry *h,
6801 bfd_boolean force_local)
6803 /* STT_GNU_IFUNC symbol must go through PLT. */
6804 if (h->type != STT_GNU_IFUNC)
6806 h->plt = elf_hash_table (info)->init_plt_offset;
6811 h->forced_local = 1;
6812 if (h->dynindx != -1)
6815 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6821 /* Initialize an ELF linker hash table. *TABLE has been zeroed by our
6825 _bfd_elf_link_hash_table_init
6826 (struct elf_link_hash_table *table,
6828 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6829 struct bfd_hash_table *,
6831 unsigned int entsize,
6832 enum elf_target_id target_id)
6835 int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6837 table->init_got_refcount.refcount = can_refcount - 1;
6838 table->init_plt_refcount.refcount = can_refcount - 1;
6839 table->init_got_offset.offset = -(bfd_vma) 1;
6840 table->init_plt_offset.offset = -(bfd_vma) 1;
6841 /* The first dynamic symbol is a dummy. */
6842 table->dynsymcount = 1;
6844 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6846 table->root.type = bfd_link_elf_hash_table;
6847 table->hash_table_id = target_id;
6852 /* Create an ELF linker hash table. */
6854 struct bfd_link_hash_table *
6855 _bfd_elf_link_hash_table_create (bfd *abfd)
6857 struct elf_link_hash_table *ret;
6858 bfd_size_type amt = sizeof (struct elf_link_hash_table);
6860 ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
6864 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6865 sizeof (struct elf_link_hash_entry),
6871 ret->root.hash_table_free = _bfd_elf_link_hash_table_free;
6876 /* Destroy an ELF linker hash table. */
6879 _bfd_elf_link_hash_table_free (bfd *obfd)
6881 struct elf_link_hash_table *htab;
6883 htab = (struct elf_link_hash_table *) obfd->link.hash;
6884 if (htab->dynstr != NULL)
6885 _bfd_elf_strtab_free (htab->dynstr);
6886 _bfd_merge_sections_free (htab->merge_info);
6887 _bfd_generic_link_hash_table_free (obfd);
6890 /* This is a hook for the ELF emulation code in the generic linker to
6891 tell the backend linker what file name to use for the DT_NEEDED
6892 entry for a dynamic object. */
6895 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6897 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6898 && bfd_get_format (abfd) == bfd_object)
6899 elf_dt_name (abfd) = name;
6903 bfd_elf_get_dyn_lib_class (bfd *abfd)
6906 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6907 && bfd_get_format (abfd) == bfd_object)
6908 lib_class = elf_dyn_lib_class (abfd);
6915 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6917 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6918 && bfd_get_format (abfd) == bfd_object)
6919 elf_dyn_lib_class (abfd) = lib_class;
6922 /* Get the list of DT_NEEDED entries for a link. This is a hook for
6923 the linker ELF emulation code. */
6925 struct bfd_link_needed_list *
6926 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6927 struct bfd_link_info *info)
6929 if (! is_elf_hash_table (info->hash))
6931 return elf_hash_table (info)->needed;
6934 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
6935 hook for the linker ELF emulation code. */
6937 struct bfd_link_needed_list *
6938 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6939 struct bfd_link_info *info)
6941 if (! is_elf_hash_table (info->hash))
6943 return elf_hash_table (info)->runpath;
6946 /* Get the name actually used for a dynamic object for a link. This
6947 is the SONAME entry if there is one. Otherwise, it is the string
6948 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
6951 bfd_elf_get_dt_soname (bfd *abfd)
6953 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6954 && bfd_get_format (abfd) == bfd_object)
6955 return elf_dt_name (abfd);
6959 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
6960 the ELF linker emulation code. */
6963 bfd_elf_get_bfd_needed_list (bfd *abfd,
6964 struct bfd_link_needed_list **pneeded)
6967 bfd_byte *dynbuf = NULL;
6968 unsigned int elfsec;
6969 unsigned long shlink;
6970 bfd_byte *extdyn, *extdynend;
6972 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6976 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6977 || bfd_get_format (abfd) != bfd_object)
6980 s = bfd_get_section_by_name (abfd, ".dynamic");
6981 if (s == NULL || s->size == 0)
6984 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
6987 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
6988 if (elfsec == SHN_BAD)
6991 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
6993 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
6994 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
6997 extdynend = extdyn + s->size;
6998 for (; extdyn < extdynend; extdyn += extdynsize)
7000 Elf_Internal_Dyn dyn;
7002 (*swap_dyn_in) (abfd, extdyn, &dyn);
7004 if (dyn.d_tag == DT_NULL)
7007 if (dyn.d_tag == DT_NEEDED)
7010 struct bfd_link_needed_list *l;
7011 unsigned int tagv = dyn.d_un.d_val;
7014 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
7019 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7040 struct elf_symbuf_symbol
7042 unsigned long st_name; /* Symbol name, index in string tbl */
7043 unsigned char st_info; /* Type and binding attributes */
7044 unsigned char st_other; /* Visibilty, and target specific */
7047 struct elf_symbuf_head
7049 struct elf_symbuf_symbol *ssym;
7050 bfd_size_type count;
7051 unsigned int st_shndx;
7058 Elf_Internal_Sym *isym;
7059 struct elf_symbuf_symbol *ssym;
7064 /* Sort references to symbols by ascending section number. */
7067 elf_sort_elf_symbol (const void *arg1, const void *arg2)
7069 const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7070 const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7072 return s1->st_shndx - s2->st_shndx;
7076 elf_sym_name_compare (const void *arg1, const void *arg2)
7078 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7079 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7080 return strcmp (s1->name, s2->name);
7083 static struct elf_symbuf_head *
7084 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
7086 Elf_Internal_Sym **ind, **indbufend, **indbuf;
7087 struct elf_symbuf_symbol *ssym;
7088 struct elf_symbuf_head *ssymbuf, *ssymhead;
7089 bfd_size_type i, shndx_count, total_size;
7091 indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7095 for (ind = indbuf, i = 0; i < symcount; i++)
7096 if (isymbuf[i].st_shndx != SHN_UNDEF)
7097 *ind++ = &isymbuf[i];
7100 qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7101 elf_sort_elf_symbol);
7104 if (indbufend > indbuf)
7105 for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7106 if (ind[0]->st_shndx != ind[1]->st_shndx)
7109 total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7110 + (indbufend - indbuf) * sizeof (*ssym));
7111 ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7112 if (ssymbuf == NULL)
7118 ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7119 ssymbuf->ssym = NULL;
7120 ssymbuf->count = shndx_count;
7121 ssymbuf->st_shndx = 0;
7122 for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7124 if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7127 ssymhead->ssym = ssym;
7128 ssymhead->count = 0;
7129 ssymhead->st_shndx = (*ind)->st_shndx;
7131 ssym->st_name = (*ind)->st_name;
7132 ssym->st_info = (*ind)->st_info;
7133 ssym->st_other = (*ind)->st_other;
7136 BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7137 && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7144 /* Check if 2 sections define the same set of local and global
7148 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7149 struct bfd_link_info *info)
7152 const struct elf_backend_data *bed1, *bed2;
7153 Elf_Internal_Shdr *hdr1, *hdr2;
7154 bfd_size_type symcount1, symcount2;
7155 Elf_Internal_Sym *isymbuf1, *isymbuf2;
7156 struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7157 Elf_Internal_Sym *isym, *isymend;
7158 struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7159 bfd_size_type count1, count2, i;
7160 unsigned int shndx1, shndx2;
7166 /* Both sections have to be in ELF. */
7167 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7168 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7171 if (elf_section_type (sec1) != elf_section_type (sec2))
7174 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7175 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7176 if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7179 bed1 = get_elf_backend_data (bfd1);
7180 bed2 = get_elf_backend_data (bfd2);
7181 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7182 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7183 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7184 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7186 if (symcount1 == 0 || symcount2 == 0)
7192 ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7193 ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7195 if (ssymbuf1 == NULL)
7197 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7199 if (isymbuf1 == NULL)
7202 if (!info->reduce_memory_overheads)
7203 elf_tdata (bfd1)->symbuf = ssymbuf1
7204 = elf_create_symbuf (symcount1, isymbuf1);
7207 if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7209 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7211 if (isymbuf2 == NULL)
7214 if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7215 elf_tdata (bfd2)->symbuf = ssymbuf2
7216 = elf_create_symbuf (symcount2, isymbuf2);
7219 if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7221 /* Optimized faster version. */
7222 bfd_size_type lo, hi, mid;
7223 struct elf_symbol *symp;
7224 struct elf_symbuf_symbol *ssym, *ssymend;
7227 hi = ssymbuf1->count;
7232 mid = (lo + hi) / 2;
7233 if (shndx1 < ssymbuf1[mid].st_shndx)
7235 else if (shndx1 > ssymbuf1[mid].st_shndx)
7239 count1 = ssymbuf1[mid].count;
7246 hi = ssymbuf2->count;
7251 mid = (lo + hi) / 2;
7252 if (shndx2 < ssymbuf2[mid].st_shndx)
7254 else if (shndx2 > ssymbuf2[mid].st_shndx)
7258 count2 = ssymbuf2[mid].count;
7264 if (count1 == 0 || count2 == 0 || count1 != count2)
7268 = (struct elf_symbol *) bfd_malloc (count1 * sizeof (*symtable1));
7270 = (struct elf_symbol *) bfd_malloc (count2 * sizeof (*symtable2));
7271 if (symtable1 == NULL || symtable2 == NULL)
7275 for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7276 ssym < ssymend; ssym++, symp++)
7278 symp->u.ssym = ssym;
7279 symp->name = bfd_elf_string_from_elf_section (bfd1,
7285 for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7286 ssym < ssymend; ssym++, symp++)
7288 symp->u.ssym = ssym;
7289 symp->name = bfd_elf_string_from_elf_section (bfd2,
7294 /* Sort symbol by name. */
7295 qsort (symtable1, count1, sizeof (struct elf_symbol),
7296 elf_sym_name_compare);
7297 qsort (symtable2, count1, sizeof (struct elf_symbol),
7298 elf_sym_name_compare);
7300 for (i = 0; i < count1; i++)
7301 /* Two symbols must have the same binding, type and name. */
7302 if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7303 || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7304 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7311 symtable1 = (struct elf_symbol *)
7312 bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7313 symtable2 = (struct elf_symbol *)
7314 bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7315 if (symtable1 == NULL || symtable2 == NULL)
7318 /* Count definitions in the section. */
7320 for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7321 if (isym->st_shndx == shndx1)
7322 symtable1[count1++].u.isym = isym;
7325 for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7326 if (isym->st_shndx == shndx2)
7327 symtable2[count2++].u.isym = isym;
7329 if (count1 == 0 || count2 == 0 || count1 != count2)
7332 for (i = 0; i < count1; i++)
7334 = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7335 symtable1[i].u.isym->st_name);
7337 for (i = 0; i < count2; i++)
7339 = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7340 symtable2[i].u.isym->st_name);
7342 /* Sort symbol by name. */
7343 qsort (symtable1, count1, sizeof (struct elf_symbol),
7344 elf_sym_name_compare);
7345 qsort (symtable2, count1, sizeof (struct elf_symbol),
7346 elf_sym_name_compare);
7348 for (i = 0; i < count1; i++)
7349 /* Two symbols must have the same binding, type and name. */
7350 if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7351 || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7352 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7370 /* Return TRUE if 2 section types are compatible. */
7373 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7374 bfd *bbfd, const asection *bsec)
7378 || abfd->xvec->flavour != bfd_target_elf_flavour
7379 || bbfd->xvec->flavour != bfd_target_elf_flavour)
7382 return elf_section_type (asec) == elf_section_type (bsec);
7385 /* Final phase of ELF linker. */
7387 /* A structure we use to avoid passing large numbers of arguments. */
7389 struct elf_final_link_info
7391 /* General link information. */
7392 struct bfd_link_info *info;
7395 /* Symbol string table. */
7396 struct bfd_strtab_hash *symstrtab;
7397 /* .dynsym section. */
7398 asection *dynsym_sec;
7399 /* .hash section. */
7401 /* symbol version section (.gnu.version). */
7402 asection *symver_sec;
7403 /* Buffer large enough to hold contents of any section. */
7405 /* Buffer large enough to hold external relocs of any section. */
7406 void *external_relocs;
7407 /* Buffer large enough to hold internal relocs of any section. */
7408 Elf_Internal_Rela *internal_relocs;
7409 /* Buffer large enough to hold external local symbols of any input
7411 bfd_byte *external_syms;
7412 /* And a buffer for symbol section indices. */
7413 Elf_External_Sym_Shndx *locsym_shndx;
7414 /* Buffer large enough to hold internal local symbols of any input
7416 Elf_Internal_Sym *internal_syms;
7417 /* Array large enough to hold a symbol index for each local symbol
7418 of any input BFD. */
7420 /* Array large enough to hold a section pointer for each local
7421 symbol of any input BFD. */
7422 asection **sections;
7423 /* Buffer to hold swapped out symbols. */
7425 /* And one for symbol section indices. */
7426 Elf_External_Sym_Shndx *symshndxbuf;
7427 /* Number of swapped out symbols in buffer. */
7428 size_t symbuf_count;
7429 /* Number of symbols which fit in symbuf. */
7431 /* And same for symshndxbuf. */
7432 size_t shndxbuf_size;
7433 /* Number of STT_FILE syms seen. */
7434 size_t filesym_count;
7437 /* This struct is used to pass information to elf_link_output_extsym. */
7439 struct elf_outext_info
7442 bfd_boolean localsyms;
7443 bfd_boolean file_sym_done;
7444 struct elf_final_link_info *flinfo;
7448 /* Support for evaluating a complex relocation.
7450 Complex relocations are generalized, self-describing relocations. The
7451 implementation of them consists of two parts: complex symbols, and the
7452 relocations themselves.
7454 The relocations are use a reserved elf-wide relocation type code (R_RELC
7455 external / BFD_RELOC_RELC internal) and an encoding of relocation field
7456 information (start bit, end bit, word width, etc) into the addend. This
7457 information is extracted from CGEN-generated operand tables within gas.
7459 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7460 internal) representing prefix-notation expressions, including but not
7461 limited to those sorts of expressions normally encoded as addends in the
7462 addend field. The symbol mangling format is:
7465 | <unary-operator> ':' <node>
7466 | <binary-operator> ':' <node> ':' <node>
7469 <literal> := 's' <digits=N> ':' <N character symbol name>
7470 | 'S' <digits=N> ':' <N character section name>
7474 <binary-operator> := as in C
7475 <unary-operator> := as in C, plus "0-" for unambiguous negation. */
7478 set_symbol_value (bfd *bfd_with_globals,
7479 Elf_Internal_Sym *isymbuf,
7484 struct elf_link_hash_entry **sym_hashes;
7485 struct elf_link_hash_entry *h;
7486 size_t extsymoff = locsymcount;
7488 if (symidx < locsymcount)
7490 Elf_Internal_Sym *sym;
7492 sym = isymbuf + symidx;
7493 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7495 /* It is a local symbol: move it to the
7496 "absolute" section and give it a value. */
7497 sym->st_shndx = SHN_ABS;
7498 sym->st_value = val;
7501 BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7505 /* It is a global symbol: set its link type
7506 to "defined" and give it a value. */
7508 sym_hashes = elf_sym_hashes (bfd_with_globals);
7509 h = sym_hashes [symidx - extsymoff];
7510 while (h->root.type == bfd_link_hash_indirect
7511 || h->root.type == bfd_link_hash_warning)
7512 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7513 h->root.type = bfd_link_hash_defined;
7514 h->root.u.def.value = val;
7515 h->root.u.def.section = bfd_abs_section_ptr;
7519 resolve_symbol (const char *name,
7521 struct elf_final_link_info *flinfo,
7523 Elf_Internal_Sym *isymbuf,
7526 Elf_Internal_Sym *sym;
7527 struct bfd_link_hash_entry *global_entry;
7528 const char *candidate = NULL;
7529 Elf_Internal_Shdr *symtab_hdr;
7532 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7534 for (i = 0; i < locsymcount; ++ i)
7538 if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7541 candidate = bfd_elf_string_from_elf_section (input_bfd,
7542 symtab_hdr->sh_link,
7545 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7546 name, candidate, (unsigned long) sym->st_value);
7548 if (candidate && strcmp (candidate, name) == 0)
7550 asection *sec = flinfo->sections [i];
7552 *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7553 *result += sec->output_offset + sec->output_section->vma;
7555 printf ("Found symbol with value %8.8lx\n",
7556 (unsigned long) *result);
7562 /* Hmm, haven't found it yet. perhaps it is a global. */
7563 global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
7564 FALSE, FALSE, TRUE);
7568 if (global_entry->type == bfd_link_hash_defined
7569 || global_entry->type == bfd_link_hash_defweak)
7571 *result = (global_entry->u.def.value
7572 + global_entry->u.def.section->output_section->vma
7573 + global_entry->u.def.section->output_offset);
7575 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7576 global_entry->root.string, (unsigned long) *result);
7585 resolve_section (const char *name,
7592 for (curr = sections; curr; curr = curr->next)
7593 if (strcmp (curr->name, name) == 0)
7595 *result = curr->vma;
7599 /* Hmm. still haven't found it. try pseudo-section names. */
7600 for (curr = sections; curr; curr = curr->next)
7602 len = strlen (curr->name);
7603 if (len > strlen (name))
7606 if (strncmp (curr->name, name, len) == 0)
7608 if (strncmp (".end", name + len, 4) == 0)
7610 *result = curr->vma + curr->size;
7614 /* Insert more pseudo-section names here, if you like. */
7622 undefined_reference (const char *reftype, const char *name)
7624 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7629 eval_symbol (bfd_vma *result,
7632 struct elf_final_link_info *flinfo,
7634 Elf_Internal_Sym *isymbuf,
7643 const char *sym = *symp;
7645 bfd_boolean symbol_is_section = FALSE;
7650 if (len < 1 || len > sizeof (symbuf))
7652 bfd_set_error (bfd_error_invalid_operation);
7665 *result = strtoul (sym, (char **) symp, 16);
7669 symbol_is_section = TRUE;
7672 symlen = strtol (sym, (char **) symp, 10);
7673 sym = *symp + 1; /* Skip the trailing ':'. */
7675 if (symend < sym || symlen + 1 > sizeof (symbuf))
7677 bfd_set_error (bfd_error_invalid_operation);
7681 memcpy (symbuf, sym, symlen);
7682 symbuf[symlen] = '\0';
7683 *symp = sym + symlen;
7685 /* Is it always possible, with complex symbols, that gas "mis-guessed"
7686 the symbol as a section, or vice-versa. so we're pretty liberal in our
7687 interpretation here; section means "try section first", not "must be a
7688 section", and likewise with symbol. */
7690 if (symbol_is_section)
7692 if (!resolve_section (symbuf, flinfo->output_bfd->sections, result)
7693 && !resolve_symbol (symbuf, input_bfd, flinfo, result,
7694 isymbuf, locsymcount))
7696 undefined_reference ("section", symbuf);
7702 if (!resolve_symbol (symbuf, input_bfd, flinfo, result,
7703 isymbuf, locsymcount)
7704 && !resolve_section (symbuf, flinfo->output_bfd->sections,
7707 undefined_reference ("symbol", symbuf);
7714 /* All that remains are operators. */
7716 #define UNARY_OP(op) \
7717 if (strncmp (sym, #op, strlen (#op)) == 0) \
7719 sym += strlen (#op); \
7723 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7724 isymbuf, locsymcount, signed_p)) \
7727 *result = op ((bfd_signed_vma) a); \
7733 #define BINARY_OP(op) \
7734 if (strncmp (sym, #op, strlen (#op)) == 0) \
7736 sym += strlen (#op); \
7740 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7741 isymbuf, locsymcount, signed_p)) \
7744 if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
7745 isymbuf, locsymcount, signed_p)) \
7748 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7778 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7779 bfd_set_error (bfd_error_invalid_operation);
7785 put_value (bfd_vma size,
7786 unsigned long chunksz,
7791 location += (size - chunksz);
7793 for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
7801 bfd_put_8 (input_bfd, x, location);
7804 bfd_put_16 (input_bfd, x, location);
7807 bfd_put_32 (input_bfd, x, location);
7811 bfd_put_64 (input_bfd, x, location);
7821 get_value (bfd_vma size,
7822 unsigned long chunksz,
7829 /* Sanity checks. */
7830 BFD_ASSERT (chunksz <= sizeof (x)
7833 && (size % chunksz) == 0
7834 && input_bfd != NULL
7835 && location != NULL);
7837 if (chunksz == sizeof (x))
7839 BFD_ASSERT (size == chunksz);
7841 /* Make sure that we do not perform an undefined shift operation.
7842 We know that size == chunksz so there will only be one iteration
7843 of the loop below. */
7847 shift = 8 * chunksz;
7849 for (; size; size -= chunksz, location += chunksz)
7854 x = (x << shift) | bfd_get_8 (input_bfd, location);
7857 x = (x << shift) | bfd_get_16 (input_bfd, location);
7860 x = (x << shift) | bfd_get_32 (input_bfd, location);
7864 x = (x << shift) | bfd_get_64 (input_bfd, location);
7875 decode_complex_addend (unsigned long *start, /* in bits */
7876 unsigned long *oplen, /* in bits */
7877 unsigned long *len, /* in bits */
7878 unsigned long *wordsz, /* in bytes */
7879 unsigned long *chunksz, /* in bytes */
7880 unsigned long *lsb0_p,
7881 unsigned long *signed_p,
7882 unsigned long *trunc_p,
7883 unsigned long encoded)
7885 * start = encoded & 0x3F;
7886 * len = (encoded >> 6) & 0x3F;
7887 * oplen = (encoded >> 12) & 0x3F;
7888 * wordsz = (encoded >> 18) & 0xF;
7889 * chunksz = (encoded >> 22) & 0xF;
7890 * lsb0_p = (encoded >> 27) & 1;
7891 * signed_p = (encoded >> 28) & 1;
7892 * trunc_p = (encoded >> 29) & 1;
7895 bfd_reloc_status_type
7896 bfd_elf_perform_complex_relocation (bfd *input_bfd,
7897 asection *input_section ATTRIBUTE_UNUSED,
7899 Elf_Internal_Rela *rel,
7902 bfd_vma shift, x, mask;
7903 unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
7904 bfd_reloc_status_type r;
7906 /* Perform this reloc, since it is complex.
7907 (this is not to say that it necessarily refers to a complex
7908 symbol; merely that it is a self-describing CGEN based reloc.
7909 i.e. the addend has the complete reloc information (bit start, end,
7910 word size, etc) encoded within it.). */
7912 decode_complex_addend (&start, &oplen, &len, &wordsz,
7913 &chunksz, &lsb0_p, &signed_p,
7914 &trunc_p, rel->r_addend);
7916 mask = (((1L << (len - 1)) - 1) << 1) | 1;
7919 shift = (start + 1) - len;
7921 shift = (8 * wordsz) - (start + len);
7923 /* FIXME: octets_per_byte. */
7924 x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
7927 printf ("Doing complex reloc: "
7928 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7929 "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7930 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7931 lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7932 oplen, (unsigned long) x, (unsigned long) mask,
7933 (unsigned long) relocation);
7938 /* Now do an overflow check. */
7939 r = bfd_check_overflow ((signed_p
7940 ? complain_overflow_signed
7941 : complain_overflow_unsigned),
7942 len, 0, (8 * wordsz),
7946 x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7949 printf (" relocation: %8.8lx\n"
7950 " shifted mask: %8.8lx\n"
7951 " shifted/masked reloc: %8.8lx\n"
7952 " result: %8.8lx\n",
7953 (unsigned long) relocation, (unsigned long) (mask << shift),
7954 (unsigned long) ((relocation & mask) << shift), (unsigned long) x);
7956 /* FIXME: octets_per_byte. */
7957 put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
7961 /* qsort comparison functions sorting external relocs by r_offset. */
7964 cmp_ext32l_r_offset (const void *p, const void *q)
7971 const union aligned32 *a
7972 = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
7973 const union aligned32 *b
7974 = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
7976 uint32_t aval = ( (uint32_t) a->c[0]
7977 | (uint32_t) a->c[1] << 8
7978 | (uint32_t) a->c[2] << 16
7979 | (uint32_t) a->c[3] << 24);
7980 uint32_t bval = ( (uint32_t) b->c[0]
7981 | (uint32_t) b->c[1] << 8
7982 | (uint32_t) b->c[2] << 16
7983 | (uint32_t) b->c[3] << 24);
7986 else if (aval > bval)
7992 cmp_ext32b_r_offset (const void *p, const void *q)
7999 const union aligned32 *a
8000 = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
8001 const union aligned32 *b
8002 = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
8004 uint32_t aval = ( (uint32_t) a->c[0] << 24
8005 | (uint32_t) a->c[1] << 16
8006 | (uint32_t) a->c[2] << 8
8007 | (uint32_t) a->c[3]);
8008 uint32_t bval = ( (uint32_t) b->c[0] << 24
8009 | (uint32_t) b->c[1] << 16
8010 | (uint32_t) b->c[2] << 8
8011 | (uint32_t) b->c[3]);
8014 else if (aval > bval)
8019 #ifdef BFD_HOST_64_BIT
8021 cmp_ext64l_r_offset (const void *p, const void *q)
8028 const union aligned64 *a
8029 = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
8030 const union aligned64 *b
8031 = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
8033 uint64_t aval = ( (uint64_t) a->c[0]
8034 | (uint64_t) a->c[1] << 8
8035 | (uint64_t) a->c[2] << 16
8036 | (uint64_t) a->c[3] << 24
8037 | (uint64_t) a->c[4] << 32
8038 | (uint64_t) a->c[5] << 40
8039 | (uint64_t) a->c[6] << 48
8040 | (uint64_t) a->c[7] << 56);
8041 uint64_t bval = ( (uint64_t) b->c[0]
8042 | (uint64_t) b->c[1] << 8
8043 | (uint64_t) b->c[2] << 16
8044 | (uint64_t) b->c[3] << 24
8045 | (uint64_t) b->c[4] << 32
8046 | (uint64_t) b->c[5] << 40
8047 | (uint64_t) b->c[6] << 48
8048 | (uint64_t) b->c[7] << 56);
8051 else if (aval > bval)
8057 cmp_ext64b_r_offset (const void *p, const void *q)
8064 const union aligned64 *a
8065 = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
8066 const union aligned64 *b
8067 = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
8069 uint64_t aval = ( (uint64_t) a->c[0] << 56
8070 | (uint64_t) a->c[1] << 48
8071 | (uint64_t) a->c[2] << 40
8072 | (uint64_t) a->c[3] << 32
8073 | (uint64_t) a->c[4] << 24
8074 | (uint64_t) a->c[5] << 16
8075 | (uint64_t) a->c[6] << 8
8076 | (uint64_t) a->c[7]);
8077 uint64_t bval = ( (uint64_t) b->c[0] << 56
8078 | (uint64_t) b->c[1] << 48
8079 | (uint64_t) b->c[2] << 40
8080 | (uint64_t) b->c[3] << 32
8081 | (uint64_t) b->c[4] << 24
8082 | (uint64_t) b->c[5] << 16
8083 | (uint64_t) b->c[6] << 8
8084 | (uint64_t) b->c[7]);
8087 else if (aval > bval)
8093 /* When performing a relocatable link, the input relocations are
8094 preserved. But, if they reference global symbols, the indices
8095 referenced must be updated. Update all the relocations found in
8099 elf_link_adjust_relocs (bfd *abfd,
8100 struct bfd_elf_section_reloc_data *reldata,
8104 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8106 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8107 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8108 bfd_vma r_type_mask;
8110 unsigned int count = reldata->count;
8111 struct elf_link_hash_entry **rel_hash = reldata->hashes;
8113 if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
8115 swap_in = bed->s->swap_reloc_in;
8116 swap_out = bed->s->swap_reloc_out;
8118 else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
8120 swap_in = bed->s->swap_reloca_in;
8121 swap_out = bed->s->swap_reloca_out;
8126 if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
8129 if (bed->s->arch_size == 32)
8136 r_type_mask = 0xffffffff;
8140 erela = reldata->hdr->contents;
8141 for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
8143 Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
8146 if (*rel_hash == NULL)
8149 BFD_ASSERT ((*rel_hash)->indx >= 0);
8151 (*swap_in) (abfd, erela, irela);
8152 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
8153 irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
8154 | (irela[j].r_info & r_type_mask));
8155 (*swap_out) (abfd, irela, erela);
8160 int (*compare) (const void *, const void *);
8162 if (bed->s->arch_size == 32)
8164 if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8165 compare = cmp_ext32l_r_offset;
8166 else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8167 compare = cmp_ext32b_r_offset;
8173 #ifdef BFD_HOST_64_BIT
8174 if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8175 compare = cmp_ext64l_r_offset;
8176 else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8177 compare = cmp_ext64b_r_offset;
8182 qsort (reldata->hdr->contents, count, reldata->hdr->sh_entsize, compare);
8183 free (reldata->hashes);
8184 reldata->hashes = NULL;
8188 struct elf_link_sort_rela
8194 enum elf_reloc_type_class type;
8195 /* We use this as an array of size int_rels_per_ext_rel. */
8196 Elf_Internal_Rela rela[1];
8200 elf_link_sort_cmp1 (const void *A, const void *B)
8202 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8203 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8204 int relativea, relativeb;
8206 relativea = a->type == reloc_class_relative;
8207 relativeb = b->type == reloc_class_relative;
8209 if (relativea < relativeb)
8211 if (relativea > relativeb)
8213 if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8215 if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8217 if (a->rela->r_offset < b->rela->r_offset)
8219 if (a->rela->r_offset > b->rela->r_offset)
8225 elf_link_sort_cmp2 (const void *A, const void *B)
8227 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8228 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8230 if (a->type < b->type)
8232 if (a->type > b->type)
8234 if (a->u.offset < b->u.offset)
8236 if (a->u.offset > b->u.offset)
8238 if (a->rela->r_offset < b->rela->r_offset)
8240 if (a->rela->r_offset > b->rela->r_offset)
8246 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8248 asection *dynamic_relocs;
8251 bfd_size_type count, size;
8252 size_t i, ret, sort_elt, ext_size;
8253 bfd_byte *sort, *s_non_relative, *p;
8254 struct elf_link_sort_rela *sq;
8255 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8256 int i2e = bed->s->int_rels_per_ext_rel;
8257 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8258 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8259 struct bfd_link_order *lo;
8261 bfd_boolean use_rela;
8263 /* Find a dynamic reloc section. */
8264 rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8265 rel_dyn = bfd_get_section_by_name (abfd, ".rel.dyn");
8266 if (rela_dyn != NULL && rela_dyn->size > 0
8267 && rel_dyn != NULL && rel_dyn->size > 0)
8269 bfd_boolean use_rela_initialised = FALSE;
8271 /* This is just here to stop gcc from complaining.
8272 It's initialization checking code is not perfect. */
8275 /* Both sections are present. Examine the sizes
8276 of the indirect sections to help us choose. */
8277 for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8278 if (lo->type == bfd_indirect_link_order)
8280 asection *o = lo->u.indirect.section;
8282 if ((o->size % bed->s->sizeof_rela) == 0)
8284 if ((o->size % bed->s->sizeof_rel) == 0)
8285 /* Section size is divisible by both rel and rela sizes.
8286 It is of no help to us. */
8290 /* Section size is only divisible by rela. */
8291 if (use_rela_initialised && (use_rela == FALSE))
8294 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8295 bfd_set_error (bfd_error_invalid_operation);
8301 use_rela_initialised = TRUE;
8305 else if ((o->size % bed->s->sizeof_rel) == 0)
8307 /* Section size is only divisible by rel. */
8308 if (use_rela_initialised && (use_rela == TRUE))
8311 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8312 bfd_set_error (bfd_error_invalid_operation);
8318 use_rela_initialised = TRUE;
8323 /* The section size is not divisible by either - something is wrong. */
8325 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8326 bfd_set_error (bfd_error_invalid_operation);
8331 for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8332 if (lo->type == bfd_indirect_link_order)
8334 asection *o = lo->u.indirect.section;
8336 if ((o->size % bed->s->sizeof_rela) == 0)
8338 if ((o->size % bed->s->sizeof_rel) == 0)
8339 /* Section size is divisible by both rel and rela sizes.
8340 It is of no help to us. */
8344 /* Section size is only divisible by rela. */
8345 if (use_rela_initialised && (use_rela == FALSE))
8348 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8349 bfd_set_error (bfd_error_invalid_operation);
8355 use_rela_initialised = TRUE;
8359 else if ((o->size % bed->s->sizeof_rel) == 0)
8361 /* Section size is only divisible by rel. */
8362 if (use_rela_initialised && (use_rela == TRUE))
8365 (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8366 bfd_set_error (bfd_error_invalid_operation);
8372 use_rela_initialised = TRUE;
8377 /* The section size is not divisible by either - something is wrong. */
8379 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8380 bfd_set_error (bfd_error_invalid_operation);
8385 if (! use_rela_initialised)
8389 else if (rela_dyn != NULL && rela_dyn->size > 0)
8391 else if (rel_dyn != NULL && rel_dyn->size > 0)
8398 dynamic_relocs = rela_dyn;
8399 ext_size = bed->s->sizeof_rela;
8400 swap_in = bed->s->swap_reloca_in;
8401 swap_out = bed->s->swap_reloca_out;
8405 dynamic_relocs = rel_dyn;
8406 ext_size = bed->s->sizeof_rel;
8407 swap_in = bed->s->swap_reloc_in;
8408 swap_out = bed->s->swap_reloc_out;
8412 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8413 if (lo->type == bfd_indirect_link_order)
8414 size += lo->u.indirect.section->size;
8416 if (size != dynamic_relocs->size)
8419 sort_elt = (sizeof (struct elf_link_sort_rela)
8420 + (i2e - 1) * sizeof (Elf_Internal_Rela));
8422 count = dynamic_relocs->size / ext_size;
8425 sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8429 (*info->callbacks->warning)
8430 (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8434 if (bed->s->arch_size == 32)
8435 r_sym_mask = ~(bfd_vma) 0xff;
8437 r_sym_mask = ~(bfd_vma) 0xffffffff;
8439 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8440 if (lo->type == bfd_indirect_link_order)
8442 bfd_byte *erel, *erelend;
8443 asection *o = lo->u.indirect.section;
8445 if (o->contents == NULL && o->size != 0)
8447 /* This is a reloc section that is being handled as a normal
8448 section. See bfd_section_from_shdr. We can't combine
8449 relocs in this case. */
8454 erelend = o->contents + o->size;
8455 /* FIXME: octets_per_byte. */
8456 p = sort + o->output_offset / ext_size * sort_elt;
8458 while (erel < erelend)
8460 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8462 (*swap_in) (abfd, erel, s->rela);
8463 s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela);
8464 s->u.sym_mask = r_sym_mask;
8470 qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8472 for (i = 0, p = sort; i < count; i++, p += sort_elt)
8474 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8475 if (s->type != reloc_class_relative)
8481 sq = (struct elf_link_sort_rela *) s_non_relative;
8482 for (; i < count; i++, p += sort_elt)
8484 struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8485 if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8487 sp->u.offset = sq->rela->r_offset;
8490 qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8492 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8493 if (lo->type == bfd_indirect_link_order)
8495 bfd_byte *erel, *erelend;
8496 asection *o = lo->u.indirect.section;
8499 erelend = o->contents + o->size;
8500 /* FIXME: octets_per_byte. */
8501 p = sort + o->output_offset / ext_size * sort_elt;
8502 while (erel < erelend)
8504 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8505 (*swap_out) (abfd, s->rela, erel);
8512 *psec = dynamic_relocs;
8516 /* Flush the output symbols to the file. */
8519 elf_link_flush_output_syms (struct elf_final_link_info *flinfo,
8520 const struct elf_backend_data *bed)
8522 if (flinfo->symbuf_count > 0)
8524 Elf_Internal_Shdr *hdr;
8528 hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
8529 pos = hdr->sh_offset + hdr->sh_size;
8530 amt = flinfo->symbuf_count * bed->s->sizeof_sym;
8531 if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) != 0
8532 || bfd_bwrite (flinfo->symbuf, amt, flinfo->output_bfd) != amt)
8535 hdr->sh_size += amt;
8536 flinfo->symbuf_count = 0;
8542 /* Add a symbol to the output symbol table. */
8545 elf_link_output_sym (struct elf_final_link_info *flinfo,
8547 Elf_Internal_Sym *elfsym,
8548 asection *input_sec,
8549 struct elf_link_hash_entry *h)
8552 Elf_External_Sym_Shndx *destshndx;
8553 int (*output_symbol_hook)
8554 (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8555 struct elf_link_hash_entry *);
8556 const struct elf_backend_data *bed;
8558 BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
8560 bed = get_elf_backend_data (flinfo->output_bfd);
8561 output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8562 if (output_symbol_hook != NULL)
8564 int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h);
8569 if (name == NULL || *name == '\0')
8570 elfsym->st_name = 0;
8571 else if (input_sec->flags & SEC_EXCLUDE)
8572 elfsym->st_name = 0;
8575 elfsym->st_name = (unsigned long) _bfd_stringtab_add (flinfo->symstrtab,
8577 if (elfsym->st_name == (unsigned long) -1)
8581 if (flinfo->symbuf_count >= flinfo->symbuf_size)
8583 if (! elf_link_flush_output_syms (flinfo, bed))
8587 dest = flinfo->symbuf + flinfo->symbuf_count * bed->s->sizeof_sym;
8588 destshndx = flinfo->symshndxbuf;
8589 if (destshndx != NULL)
8591 if (bfd_get_symcount (flinfo->output_bfd) >= flinfo->shndxbuf_size)
8595 amt = flinfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
8596 destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
8598 if (destshndx == NULL)
8600 flinfo->symshndxbuf = destshndx;
8601 memset ((char *) destshndx + amt, 0, amt);
8602 flinfo->shndxbuf_size *= 2;
8604 destshndx += bfd_get_symcount (flinfo->output_bfd);
8607 bed->s->swap_symbol_out (flinfo->output_bfd, elfsym, dest, destshndx);
8608 flinfo->symbuf_count += 1;
8609 bfd_get_symcount (flinfo->output_bfd) += 1;
8614 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8617 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8619 if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8620 && sym->st_shndx < SHN_LORESERVE)
8622 /* The gABI doesn't support dynamic symbols in output sections
8624 (*_bfd_error_handler)
8625 (_("%B: Too many sections: %d (>= %d)"),
8626 abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8627 bfd_set_error (bfd_error_nonrepresentable_section);
8633 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8634 allowing an unsatisfied unversioned symbol in the DSO to match a
8635 versioned symbol that would normally require an explicit version.
8636 We also handle the case that a DSO references a hidden symbol
8637 which may be satisfied by a versioned symbol in another DSO. */
8640 elf_link_check_versioned_symbol (struct bfd_link_info *info,
8641 const struct elf_backend_data *bed,
8642 struct elf_link_hash_entry *h)
8645 struct elf_link_loaded_list *loaded;
8647 if (!is_elf_hash_table (info->hash))
8650 /* Check indirect symbol. */
8651 while (h->root.type == bfd_link_hash_indirect)
8652 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8654 switch (h->root.type)
8660 case bfd_link_hash_undefined:
8661 case bfd_link_hash_undefweak:
8662 abfd = h->root.u.undef.abfd;
8663 if ((abfd->flags & DYNAMIC) == 0
8664 || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8668 case bfd_link_hash_defined:
8669 case bfd_link_hash_defweak:
8670 abfd = h->root.u.def.section->owner;
8673 case bfd_link_hash_common:
8674 abfd = h->root.u.c.p->section->owner;
8677 BFD_ASSERT (abfd != NULL);
8679 for (loaded = elf_hash_table (info)->loaded;
8681 loaded = loaded->next)
8684 Elf_Internal_Shdr *hdr;
8685 bfd_size_type symcount;
8686 bfd_size_type extsymcount;
8687 bfd_size_type extsymoff;
8688 Elf_Internal_Shdr *versymhdr;
8689 Elf_Internal_Sym *isym;
8690 Elf_Internal_Sym *isymend;
8691 Elf_Internal_Sym *isymbuf;
8692 Elf_External_Versym *ever;
8693 Elf_External_Versym *extversym;
8695 input = loaded->abfd;
8697 /* We check each DSO for a possible hidden versioned definition. */
8699 || (input->flags & DYNAMIC) == 0
8700 || elf_dynversym (input) == 0)
8703 hdr = &elf_tdata (input)->dynsymtab_hdr;
8705 symcount = hdr->sh_size / bed->s->sizeof_sym;
8706 if (elf_bad_symtab (input))
8708 extsymcount = symcount;
8713 extsymcount = symcount - hdr->sh_info;
8714 extsymoff = hdr->sh_info;
8717 if (extsymcount == 0)
8720 isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8722 if (isymbuf == NULL)
8725 /* Read in any version definitions. */
8726 versymhdr = &elf_tdata (input)->dynversym_hdr;
8727 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
8728 if (extversym == NULL)
8731 if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8732 || (bfd_bread (extversym, versymhdr->sh_size, input)
8733 != versymhdr->sh_size))
8741 ever = extversym + extsymoff;
8742 isymend = isymbuf + extsymcount;
8743 for (isym = isymbuf; isym < isymend; isym++, ever++)
8746 Elf_Internal_Versym iver;
8747 unsigned short version_index;
8749 if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8750 || isym->st_shndx == SHN_UNDEF)
8753 name = bfd_elf_string_from_elf_section (input,
8756 if (strcmp (name, h->root.root.string) != 0)
8759 _bfd_elf_swap_versym_in (input, ever, &iver);
8761 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
8763 && h->forced_local))
8765 /* If we have a non-hidden versioned sym, then it should
8766 have provided a definition for the undefined sym unless
8767 it is defined in a non-shared object and forced local.
8772 version_index = iver.vs_vers & VERSYM_VERSION;
8773 if (version_index == 1 || version_index == 2)
8775 /* This is the base or first version. We can use it. */
8789 /* Add an external symbol to the symbol table. This is called from
8790 the hash table traversal routine. When generating a shared object,
8791 we go through the symbol table twice. The first time we output
8792 anything that might have been forced to local scope in a version
8793 script. The second time we output the symbols that are still
8797 elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
8799 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
8800 struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
8801 struct elf_final_link_info *flinfo = eoinfo->flinfo;
8803 Elf_Internal_Sym sym;
8804 asection *input_sec;
8805 const struct elf_backend_data *bed;
8809 if (h->root.type == bfd_link_hash_warning)
8811 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8812 if (h->root.type == bfd_link_hash_new)
8816 /* Decide whether to output this symbol in this pass. */
8817 if (eoinfo->localsyms)
8819 if (!h->forced_local)
8824 if (h->forced_local)
8828 bed = get_elf_backend_data (flinfo->output_bfd);
8830 if (h->root.type == bfd_link_hash_undefined)
8832 /* If we have an undefined symbol reference here then it must have
8833 come from a shared library that is being linked in. (Undefined
8834 references in regular files have already been handled unless
8835 they are in unreferenced sections which are removed by garbage
8837 bfd_boolean ignore_undef = FALSE;
8839 /* Some symbols may be special in that the fact that they're
8840 undefined can be safely ignored - let backend determine that. */
8841 if (bed->elf_backend_ignore_undef_symbol)
8842 ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8844 /* If we are reporting errors for this situation then do so now. */
8847 && (!h->ref_regular || flinfo->info->gc_sections)
8848 && !elf_link_check_versioned_symbol (flinfo->info, bed, h)
8849 && flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
8851 if (!(flinfo->info->callbacks->undefined_symbol
8852 (flinfo->info, h->root.root.string,
8853 h->ref_regular ? NULL : h->root.u.undef.abfd,
8855 (flinfo->info->unresolved_syms_in_shared_libs
8856 == RM_GENERATE_ERROR))))
8858 bfd_set_error (bfd_error_bad_value);
8859 eoinfo->failed = TRUE;
8865 /* We should also warn if a forced local symbol is referenced from
8866 shared libraries. */
8867 if (!flinfo->info->relocatable
8868 && flinfo->info->executable
8873 && h->ref_dynamic_nonweak
8874 && !elf_link_check_versioned_symbol (flinfo->info, bed, h))
8878 struct elf_link_hash_entry *hi = h;
8880 /* Check indirect symbol. */
8881 while (hi->root.type == bfd_link_hash_indirect)
8882 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
8884 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
8885 msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
8886 else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
8887 msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
8889 msg = _("%B: local symbol `%s' in %B is referenced by DSO");
8890 def_bfd = flinfo->output_bfd;
8891 if (hi->root.u.def.section != bfd_abs_section_ptr)
8892 def_bfd = hi->root.u.def.section->owner;
8893 (*_bfd_error_handler) (msg, flinfo->output_bfd, def_bfd,
8894 h->root.root.string);
8895 bfd_set_error (bfd_error_bad_value);
8896 eoinfo->failed = TRUE;
8900 /* We don't want to output symbols that have never been mentioned by
8901 a regular file, or that we have been told to strip. However, if
8902 h->indx is set to -2, the symbol is used by a reloc and we must
8907 else if ((h->def_dynamic
8909 || h->root.type == bfd_link_hash_new)
8913 else if (flinfo->info->strip == strip_all)
8915 else if (flinfo->info->strip == strip_some
8916 && bfd_hash_lookup (flinfo->info->keep_hash,
8917 h->root.root.string, FALSE, FALSE) == NULL)
8919 else if ((h->root.type == bfd_link_hash_defined
8920 || h->root.type == bfd_link_hash_defweak)
8921 && ((flinfo->info->strip_discarded
8922 && discarded_section (h->root.u.def.section))
8923 || ((h->root.u.def.section->flags & SEC_LINKER_CREATED) == 0
8924 && h->root.u.def.section->owner != NULL
8925 && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
8927 else if ((h->root.type == bfd_link_hash_undefined
8928 || h->root.type == bfd_link_hash_undefweak)
8929 && h->root.u.undef.abfd != NULL
8930 && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
8933 /* If we're stripping it, and it's not a dynamic symbol, there's
8934 nothing else to do. However, if it is a forced local symbol or
8935 an ifunc symbol we need to give the backend finish_dynamic_symbol
8936 function a chance to make it dynamic. */
8939 && h->type != STT_GNU_IFUNC
8940 && !h->forced_local)
8944 sym.st_size = h->size;
8945 sym.st_other = h->other;
8946 if (h->forced_local)
8948 sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8949 /* Turn off visibility on local symbol. */
8950 sym.st_other &= ~ELF_ST_VISIBILITY (-1);
8952 /* Set STB_GNU_UNIQUE only if symbol is defined in regular object. */
8953 else if (h->unique_global && h->def_regular)
8954 sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
8955 else if (h->root.type == bfd_link_hash_undefweak
8956 || h->root.type == bfd_link_hash_defweak)
8957 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8959 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8960 sym.st_target_internal = h->target_internal;
8962 switch (h->root.type)
8965 case bfd_link_hash_new:
8966 case bfd_link_hash_warning:
8970 case bfd_link_hash_undefined:
8971 case bfd_link_hash_undefweak:
8972 input_sec = bfd_und_section_ptr;
8973 sym.st_shndx = SHN_UNDEF;
8976 case bfd_link_hash_defined:
8977 case bfd_link_hash_defweak:
8979 input_sec = h->root.u.def.section;
8980 if (input_sec->output_section != NULL)
8983 _bfd_elf_section_from_bfd_section (flinfo->output_bfd,
8984 input_sec->output_section);
8985 if (sym.st_shndx == SHN_BAD)
8987 (*_bfd_error_handler)
8988 (_("%B: could not find output section %A for input section %A"),
8989 flinfo->output_bfd, input_sec->output_section, input_sec);
8990 bfd_set_error (bfd_error_nonrepresentable_section);
8991 eoinfo->failed = TRUE;
8995 /* ELF symbols in relocatable files are section relative,
8996 but in nonrelocatable files they are virtual
8998 sym.st_value = h->root.u.def.value + input_sec->output_offset;
8999 if (!flinfo->info->relocatable)
9001 sym.st_value += input_sec->output_section->vma;
9002 if (h->type == STT_TLS)
9004 asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
9005 if (tls_sec != NULL)
9006 sym.st_value -= tls_sec->vma;
9012 BFD_ASSERT (input_sec->owner == NULL
9013 || (input_sec->owner->flags & DYNAMIC) != 0);
9014 sym.st_shndx = SHN_UNDEF;
9015 input_sec = bfd_und_section_ptr;
9020 case bfd_link_hash_common:
9021 input_sec = h->root.u.c.p->section;
9022 sym.st_shndx = bed->common_section_index (input_sec);
9023 sym.st_value = 1 << h->root.u.c.p->alignment_power;
9026 case bfd_link_hash_indirect:
9027 /* These symbols are created by symbol versioning. They point
9028 to the decorated version of the name. For example, if the
9029 symbol foo@@GNU_1.2 is the default, which should be used when
9030 foo is used with no version, then we add an indirect symbol
9031 foo which points to foo@@GNU_1.2. We ignore these symbols,
9032 since the indirected symbol is already in the hash table. */
9036 /* Give the processor backend a chance to tweak the symbol value,
9037 and also to finish up anything that needs to be done for this
9038 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
9039 forced local syms when non-shared is due to a historical quirk.
9040 STT_GNU_IFUNC symbol must go through PLT. */
9041 if ((h->type == STT_GNU_IFUNC
9043 && !flinfo->info->relocatable)
9044 || ((h->dynindx != -1
9046 && ((flinfo->info->shared
9047 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9048 || h->root.type != bfd_link_hash_undefweak))
9049 || !h->forced_local)
9050 && elf_hash_table (flinfo->info)->dynamic_sections_created))
9052 if (! ((*bed->elf_backend_finish_dynamic_symbol)
9053 (flinfo->output_bfd, flinfo->info, h, &sym)))
9055 eoinfo->failed = TRUE;
9060 /* If we are marking the symbol as undefined, and there are no
9061 non-weak references to this symbol from a regular object, then
9062 mark the symbol as weak undefined; if there are non-weak
9063 references, mark the symbol as strong. We can't do this earlier,
9064 because it might not be marked as undefined until the
9065 finish_dynamic_symbol routine gets through with it. */
9066 if (sym.st_shndx == SHN_UNDEF
9068 && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
9069 || ELF_ST_BIND (sym.st_info) == STB_WEAK))
9072 unsigned int type = ELF_ST_TYPE (sym.st_info);
9074 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
9075 if (type == STT_GNU_IFUNC)
9078 if (h->ref_regular_nonweak)
9079 bindtype = STB_GLOBAL;
9081 bindtype = STB_WEAK;
9082 sym.st_info = ELF_ST_INFO (bindtype, type);
9085 /* If this is a symbol defined in a dynamic library, don't use the
9086 symbol size from the dynamic library. Relinking an executable
9087 against a new library may introduce gratuitous changes in the
9088 executable's symbols if we keep the size. */
9089 if (sym.st_shndx == SHN_UNDEF
9094 /* If a non-weak symbol with non-default visibility is not defined
9095 locally, it is a fatal error. */
9096 if (!flinfo->info->relocatable
9097 && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
9098 && ELF_ST_BIND (sym.st_info) != STB_WEAK
9099 && h->root.type == bfd_link_hash_undefined
9104 if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
9105 msg = _("%B: protected symbol `%s' isn't defined");
9106 else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
9107 msg = _("%B: internal symbol `%s' isn't defined");
9109 msg = _("%B: hidden symbol `%s' isn't defined");
9110 (*_bfd_error_handler) (msg, flinfo->output_bfd, h->root.root.string);
9111 bfd_set_error (bfd_error_bad_value);
9112 eoinfo->failed = TRUE;
9116 /* If this symbol should be put in the .dynsym section, then put it
9117 there now. We already know the symbol index. We also fill in
9118 the entry in the .hash section. */
9119 if (flinfo->dynsym_sec != NULL
9121 && elf_hash_table (flinfo->info)->dynamic_sections_created)
9125 /* Since there is no version information in the dynamic string,
9126 if there is no version info in symbol version section, we will
9127 have a run-time problem. */
9128 if (h->verinfo.verdef == NULL)
9130 char *p = strrchr (h->root.root.string, ELF_VER_CHR);
9132 if (p && p [1] != '\0')
9134 (*_bfd_error_handler)
9135 (_("%B: No symbol version section for versioned symbol `%s'"),
9136 flinfo->output_bfd, h->root.root.string);
9137 eoinfo->failed = TRUE;
9142 sym.st_name = h->dynstr_index;
9143 esym = flinfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
9144 if (!check_dynsym (flinfo->output_bfd, &sym))
9146 eoinfo->failed = TRUE;
9149 bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0);
9151 if (flinfo->hash_sec != NULL)
9153 size_t hash_entry_size;
9154 bfd_byte *bucketpos;
9159 bucketcount = elf_hash_table (flinfo->info)->bucketcount;
9160 bucket = h->u.elf_hash_value % bucketcount;
9163 = elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize;
9164 bucketpos = ((bfd_byte *) flinfo->hash_sec->contents
9165 + (bucket + 2) * hash_entry_size);
9166 chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos);
9167 bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx,
9169 bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain,
9170 ((bfd_byte *) flinfo->hash_sec->contents
9171 + (bucketcount + 2 + h->dynindx) * hash_entry_size));
9174 if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL)
9176 Elf_Internal_Versym iversym;
9177 Elf_External_Versym *eversym;
9179 if (!h->def_regular)
9181 if (h->verinfo.verdef == NULL
9182 || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
9183 & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
9184 iversym.vs_vers = 0;
9186 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
9190 if (h->verinfo.vertree == NULL)
9191 iversym.vs_vers = 1;
9193 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
9194 if (flinfo->info->create_default_symver)
9199 iversym.vs_vers |= VERSYM_HIDDEN;
9201 eversym = (Elf_External_Versym *) flinfo->symver_sec->contents;
9202 eversym += h->dynindx;
9203 _bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym);
9207 /* If the symbol is undefined, and we didn't output it to .dynsym,
9208 strip it from .symtab too. Obviously we can't do this for
9209 relocatable output or when needed for --emit-relocs. */
9210 else if (input_sec == bfd_und_section_ptr
9212 && !flinfo->info->relocatable)
9214 /* Also strip others that we couldn't earlier due to dynamic symbol
9218 if ((input_sec->flags & SEC_EXCLUDE) != 0)
9221 /* Output a FILE symbol so that following locals are not associated
9222 with the wrong input file. We need one for forced local symbols
9223 if we've seen more than one FILE symbol or when we have exactly
9224 one FILE symbol but global symbols are present in a file other
9225 than the one with the FILE symbol. We also need one if linker
9226 defined symbols are present. In practice these conditions are
9227 always met, so just emit the FILE symbol unconditionally. */
9228 if (eoinfo->localsyms
9229 && !eoinfo->file_sym_done
9230 && eoinfo->flinfo->filesym_count != 0)
9232 Elf_Internal_Sym fsym;
9234 memset (&fsym, 0, sizeof (fsym));
9235 fsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9236 fsym.st_shndx = SHN_ABS;
9237 if (!elf_link_output_sym (eoinfo->flinfo, NULL, &fsym,
9238 bfd_und_section_ptr, NULL))
9241 eoinfo->file_sym_done = TRUE;
9244 indx = bfd_get_symcount (flinfo->output_bfd);
9245 ret = elf_link_output_sym (flinfo, h->root.root.string, &sym, input_sec, h);
9248 eoinfo->failed = TRUE;
9253 else if (h->indx == -2)
9259 /* Return TRUE if special handling is done for relocs in SEC against
9260 symbols defined in discarded sections. */
9263 elf_section_ignore_discarded_relocs (asection *sec)
9265 const struct elf_backend_data *bed;
9267 switch (sec->sec_info_type)
9269 case SEC_INFO_TYPE_STABS:
9270 case SEC_INFO_TYPE_EH_FRAME:
9276 bed = get_elf_backend_data (sec->owner);
9277 if (bed->elf_backend_ignore_discarded_relocs != NULL
9278 && (*bed->elf_backend_ignore_discarded_relocs) (sec))
9284 /* Return a mask saying how ld should treat relocations in SEC against
9285 symbols defined in discarded sections. If this function returns
9286 COMPLAIN set, ld will issue a warning message. If this function
9287 returns PRETEND set, and the discarded section was link-once and the
9288 same size as the kept link-once section, ld will pretend that the
9289 symbol was actually defined in the kept section. Otherwise ld will
9290 zero the reloc (at least that is the intent, but some cooperation by
9291 the target dependent code is needed, particularly for REL targets). */
9294 _bfd_elf_default_action_discarded (asection *sec)
9296 if (sec->flags & SEC_DEBUGGING)
9299 if (strcmp (".eh_frame", sec->name) == 0)
9302 if (strcmp (".gcc_except_table", sec->name) == 0)
9305 return COMPLAIN | PRETEND;
9308 /* Find a match between a section and a member of a section group. */
9311 match_group_member (asection *sec, asection *group,
9312 struct bfd_link_info *info)
9314 asection *first = elf_next_in_group (group);
9315 asection *s = first;
9319 if (bfd_elf_match_symbols_in_sections (s, sec, info))
9322 s = elf_next_in_group (s);
9330 /* Check if the kept section of a discarded section SEC can be used
9331 to replace it. Return the replacement if it is OK. Otherwise return
9335 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
9339 kept = sec->kept_section;
9342 if ((kept->flags & SEC_GROUP) != 0)
9343 kept = match_group_member (sec, kept, info);
9345 && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
9346 != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9348 sec->kept_section = kept;
9353 /* Link an input file into the linker output file. This function
9354 handles all the sections and relocations of the input file at once.
9355 This is so that we only have to read the local symbols once, and
9356 don't have to keep them in memory. */
9359 elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
9361 int (*relocate_section)
9362 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
9363 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
9365 Elf_Internal_Shdr *symtab_hdr;
9368 Elf_Internal_Sym *isymbuf;
9369 Elf_Internal_Sym *isym;
9370 Elf_Internal_Sym *isymend;
9372 asection **ppsection;
9374 const struct elf_backend_data *bed;
9375 struct elf_link_hash_entry **sym_hashes;
9376 bfd_size_type address_size;
9377 bfd_vma r_type_mask;
9379 bfd_boolean have_file_sym = FALSE;
9381 output_bfd = flinfo->output_bfd;
9382 bed = get_elf_backend_data (output_bfd);
9383 relocate_section = bed->elf_backend_relocate_section;
9385 /* If this is a dynamic object, we don't want to do anything here:
9386 we don't want the local symbols, and we don't want the section
9388 if ((input_bfd->flags & DYNAMIC) != 0)
9391 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9392 if (elf_bad_symtab (input_bfd))
9394 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9399 locsymcount = symtab_hdr->sh_info;
9400 extsymoff = symtab_hdr->sh_info;
9403 /* Read the local symbols. */
9404 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9405 if (isymbuf == NULL && locsymcount != 0)
9407 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9408 flinfo->internal_syms,
9409 flinfo->external_syms,
9410 flinfo->locsym_shndx);
9411 if (isymbuf == NULL)
9415 /* Find local symbol sections and adjust values of symbols in
9416 SEC_MERGE sections. Write out those local symbols we know are
9417 going into the output file. */
9418 isymend = isymbuf + locsymcount;
9419 for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections;
9421 isym++, pindex++, ppsection++)
9425 Elf_Internal_Sym osym;
9431 if (elf_bad_symtab (input_bfd))
9433 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9440 if (isym->st_shndx == SHN_UNDEF)
9441 isec = bfd_und_section_ptr;
9442 else if (isym->st_shndx == SHN_ABS)
9443 isec = bfd_abs_section_ptr;
9444 else if (isym->st_shndx == SHN_COMMON)
9445 isec = bfd_com_section_ptr;
9448 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9451 /* Don't attempt to output symbols with st_shnx in the
9452 reserved range other than SHN_ABS and SHN_COMMON. */
9456 else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE
9457 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9459 _bfd_merged_section_offset (output_bfd, &isec,
9460 elf_section_data (isec)->sec_info,
9466 /* Don't output the first, undefined, symbol. In fact, don't
9467 output any undefined local symbol. */
9468 if (isec == bfd_und_section_ptr)
9471 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9473 /* We never output section symbols. Instead, we use the
9474 section symbol of the corresponding section in the output
9479 /* If we are stripping all symbols, we don't want to output this
9481 if (flinfo->info->strip == strip_all)
9484 /* If we are discarding all local symbols, we don't want to
9485 output this one. If we are generating a relocatable output
9486 file, then some of the local symbols may be required by
9487 relocs; we output them below as we discover that they are
9489 if (flinfo->info->discard == discard_all)
9492 /* If this symbol is defined in a section which we are
9493 discarding, we don't need to keep it. */
9494 if (isym->st_shndx != SHN_UNDEF
9495 && isym->st_shndx < SHN_LORESERVE
9496 && bfd_section_removed_from_list (output_bfd,
9497 isec->output_section))
9500 /* Get the name of the symbol. */
9501 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9506 /* See if we are discarding symbols with this name. */
9507 if ((flinfo->info->strip == strip_some
9508 && (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
9510 || (((flinfo->info->discard == discard_sec_merge
9511 && (isec->flags & SEC_MERGE) && !flinfo->info->relocatable)
9512 || flinfo->info->discard == discard_l)
9513 && bfd_is_local_label_name (input_bfd, name)))
9516 if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
9518 if (input_bfd->lto_output)
9519 /* -flto puts a temp file name here. This means builds
9520 are not reproducible. Discard the symbol. */
9522 have_file_sym = TRUE;
9523 flinfo->filesym_count += 1;
9527 /* In the absence of debug info, bfd_find_nearest_line uses
9528 FILE symbols to determine the source file for local
9529 function symbols. Provide a FILE symbol here if input
9530 files lack such, so that their symbols won't be
9531 associated with a previous input file. It's not the
9532 source file, but the best we can do. */
9533 have_file_sym = TRUE;
9534 flinfo->filesym_count += 1;
9535 memset (&osym, 0, sizeof (osym));
9536 osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9537 osym.st_shndx = SHN_ABS;
9538 if (!elf_link_output_sym (flinfo,
9539 (input_bfd->lto_output ? NULL
9540 : input_bfd->filename),
9541 &osym, bfd_abs_section_ptr, NULL))
9547 /* Adjust the section index for the output file. */
9548 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9549 isec->output_section);
9550 if (osym.st_shndx == SHN_BAD)
9553 /* ELF symbols in relocatable files are section relative, but
9554 in executable files they are virtual addresses. Note that
9555 this code assumes that all ELF sections have an associated
9556 BFD section with a reasonable value for output_offset; below
9557 we assume that they also have a reasonable value for
9558 output_section. Any special sections must be set up to meet
9559 these requirements. */
9560 osym.st_value += isec->output_offset;
9561 if (!flinfo->info->relocatable)
9563 osym.st_value += isec->output_section->vma;
9564 if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9566 /* STT_TLS symbols are relative to PT_TLS segment base. */
9567 BFD_ASSERT (elf_hash_table (flinfo->info)->tls_sec != NULL);
9568 osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma;
9572 indx = bfd_get_symcount (output_bfd);
9573 ret = elf_link_output_sym (flinfo, name, &osym, isec, NULL);
9580 if (bed->s->arch_size == 32)
9588 r_type_mask = 0xffffffff;
9593 /* Relocate the contents of each section. */
9594 sym_hashes = elf_sym_hashes (input_bfd);
9595 for (o = input_bfd->sections; o != NULL; o = o->next)
9599 if (! o->linker_mark)
9601 /* This section was omitted from the link. */
9605 if (flinfo->info->relocatable
9606 && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9608 /* Deal with the group signature symbol. */
9609 struct bfd_elf_section_data *sec_data = elf_section_data (o);
9610 unsigned long symndx = sec_data->this_hdr.sh_info;
9611 asection *osec = o->output_section;
9613 if (symndx >= locsymcount
9614 || (elf_bad_symtab (input_bfd)
9615 && flinfo->sections[symndx] == NULL))
9617 struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9618 while (h->root.type == bfd_link_hash_indirect
9619 || h->root.type == bfd_link_hash_warning)
9620 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9621 /* Arrange for symbol to be output. */
9623 elf_section_data (osec)->this_hdr.sh_info = -2;
9625 else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9627 /* We'll use the output section target_index. */
9628 asection *sec = flinfo->sections[symndx]->output_section;
9629 elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9633 if (flinfo->indices[symndx] == -1)
9635 /* Otherwise output the local symbol now. */
9636 Elf_Internal_Sym sym = isymbuf[symndx];
9637 asection *sec = flinfo->sections[symndx]->output_section;
9642 name = bfd_elf_string_from_elf_section (input_bfd,
9643 symtab_hdr->sh_link,
9648 sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9650 if (sym.st_shndx == SHN_BAD)
9653 sym.st_value += o->output_offset;
9655 indx = bfd_get_symcount (output_bfd);
9656 ret = elf_link_output_sym (flinfo, name, &sym, o, NULL);
9660 flinfo->indices[symndx] = indx;
9664 elf_section_data (osec)->this_hdr.sh_info
9665 = flinfo->indices[symndx];
9669 if ((o->flags & SEC_HAS_CONTENTS) == 0
9670 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
9673 if ((o->flags & SEC_LINKER_CREATED) != 0)
9675 /* Section was created by _bfd_elf_link_create_dynamic_sections
9680 /* Get the contents of the section. They have been cached by a
9681 relaxation routine. Note that o is a section in an input
9682 file, so the contents field will not have been set by any of
9683 the routines which work on output files. */
9684 if (elf_section_data (o)->this_hdr.contents != NULL)
9686 contents = elf_section_data (o)->this_hdr.contents;
9687 if (bed->caches_rawsize
9689 && o->rawsize < o->size)
9691 memcpy (flinfo->contents, contents, o->rawsize);
9692 contents = flinfo->contents;
9697 contents = flinfo->contents;
9698 if (! bfd_get_full_section_contents (input_bfd, o, &contents))
9702 if ((o->flags & SEC_RELOC) != 0)
9704 Elf_Internal_Rela *internal_relocs;
9705 Elf_Internal_Rela *rel, *relend;
9706 int action_discarded;
9709 /* Get the swapped relocs. */
9711 = _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
9712 flinfo->internal_relocs, FALSE);
9713 if (internal_relocs == NULL
9714 && o->reloc_count > 0)
9717 /* We need to reverse-copy input .ctors/.dtors sections if
9718 they are placed in .init_array/.finit_array for output. */
9719 if (o->size > address_size
9720 && ((strncmp (o->name, ".ctors", 6) == 0
9721 && strcmp (o->output_section->name,
9722 ".init_array") == 0)
9723 || (strncmp (o->name, ".dtors", 6) == 0
9724 && strcmp (o->output_section->name,
9725 ".fini_array") == 0))
9726 && (o->name[6] == 0 || o->name[6] == '.'))
9728 if (o->size != o->reloc_count * address_size)
9730 (*_bfd_error_handler)
9731 (_("error: %B: size of section %A is not "
9732 "multiple of address size"),
9734 bfd_set_error (bfd_error_on_input);
9737 o->flags |= SEC_ELF_REVERSE_COPY;
9740 action_discarded = -1;
9741 if (!elf_section_ignore_discarded_relocs (o))
9742 action_discarded = (*bed->action_discarded) (o);
9744 /* Run through the relocs evaluating complex reloc symbols and
9745 looking for relocs against symbols from discarded sections
9746 or section symbols from removed link-once sections.
9747 Complain about relocs against discarded sections. Zero
9748 relocs against removed link-once sections. */
9750 rel = internal_relocs;
9751 relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9752 for ( ; rel < relend; rel++)
9754 unsigned long r_symndx = rel->r_info >> r_sym_shift;
9755 unsigned int s_type;
9756 asection **ps, *sec;
9757 struct elf_link_hash_entry *h = NULL;
9758 const char *sym_name;
9760 if (r_symndx == STN_UNDEF)
9763 if (r_symndx >= locsymcount
9764 || (elf_bad_symtab (input_bfd)
9765 && flinfo->sections[r_symndx] == NULL))
9767 h = sym_hashes[r_symndx - extsymoff];
9769 /* Badly formatted input files can contain relocs that
9770 reference non-existant symbols. Check here so that
9771 we do not seg fault. */
9776 sprintf_vma (buffer, rel->r_info);
9777 (*_bfd_error_handler)
9778 (_("error: %B contains a reloc (0x%s) for section %A "
9779 "that references a non-existent global symbol"),
9780 input_bfd, o, buffer);
9781 bfd_set_error (bfd_error_bad_value);
9785 while (h->root.type == bfd_link_hash_indirect
9786 || h->root.type == bfd_link_hash_warning)
9787 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9791 /* If a plugin symbol is referenced from a non-IR file,
9792 mark the symbol as undefined. Note that the
9793 linker may attach linker created dynamic sections
9794 to the plugin bfd. Symbols defined in linker
9795 created sections are not plugin symbols. */
9796 if (h->root.non_ir_ref
9797 && (h->root.type == bfd_link_hash_defined
9798 || h->root.type == bfd_link_hash_defweak)
9799 && (h->root.u.def.section->flags
9800 & SEC_LINKER_CREATED) == 0
9801 && h->root.u.def.section->owner != NULL
9802 && (h->root.u.def.section->owner->flags
9805 h->root.type = bfd_link_hash_undefined;
9806 h->root.u.undef.abfd = h->root.u.def.section->owner;
9810 if (h->root.type == bfd_link_hash_defined
9811 || h->root.type == bfd_link_hash_defweak)
9812 ps = &h->root.u.def.section;
9814 sym_name = h->root.root.string;
9818 Elf_Internal_Sym *sym = isymbuf + r_symndx;
9820 s_type = ELF_ST_TYPE (sym->st_info);
9821 ps = &flinfo->sections[r_symndx];
9822 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9826 if ((s_type == STT_RELC || s_type == STT_SRELC)
9827 && !flinfo->info->relocatable)
9830 bfd_vma dot = (rel->r_offset
9831 + o->output_offset + o->output_section->vma);
9833 printf ("Encountered a complex symbol!");
9834 printf (" (input_bfd %s, section %s, reloc %ld\n",
9835 input_bfd->filename, o->name,
9836 (long) (rel - internal_relocs));
9837 printf (" symbol: idx %8.8lx, name %s\n",
9838 r_symndx, sym_name);
9839 printf (" reloc : info %8.8lx, addr %8.8lx\n",
9840 (unsigned long) rel->r_info,
9841 (unsigned long) rel->r_offset);
9843 if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
9844 isymbuf, locsymcount, s_type == STT_SRELC))
9847 /* Symbol evaluated OK. Update to absolute value. */
9848 set_symbol_value (input_bfd, isymbuf, locsymcount,
9853 if (action_discarded != -1 && ps != NULL)
9855 /* Complain if the definition comes from a
9856 discarded section. */
9857 if ((sec = *ps) != NULL && discarded_section (sec))
9859 BFD_ASSERT (r_symndx != STN_UNDEF);
9860 if (action_discarded & COMPLAIN)
9861 (*flinfo->info->callbacks->einfo)
9862 (_("%X`%s' referenced in section `%A' of %B: "
9863 "defined in discarded section `%A' of %B\n"),
9864 sym_name, o, input_bfd, sec, sec->owner);
9866 /* Try to do the best we can to support buggy old
9867 versions of gcc. Pretend that the symbol is
9868 really defined in the kept linkonce section.
9869 FIXME: This is quite broken. Modifying the
9870 symbol here means we will be changing all later
9871 uses of the symbol, not just in this section. */
9872 if (action_discarded & PRETEND)
9876 kept = _bfd_elf_check_kept_section (sec,
9888 /* Relocate the section by invoking a back end routine.
9890 The back end routine is responsible for adjusting the
9891 section contents as necessary, and (if using Rela relocs
9892 and generating a relocatable output file) adjusting the
9893 reloc addend as necessary.
9895 The back end routine does not have to worry about setting
9896 the reloc address or the reloc symbol index.
9898 The back end routine is given a pointer to the swapped in
9899 internal symbols, and can access the hash table entries
9900 for the external symbols via elf_sym_hashes (input_bfd).
9902 When generating relocatable output, the back end routine
9903 must handle STB_LOCAL/STT_SECTION symbols specially. The
9904 output symbol is going to be a section symbol
9905 corresponding to the output section, which will require
9906 the addend to be adjusted. */
9908 ret = (*relocate_section) (output_bfd, flinfo->info,
9909 input_bfd, o, contents,
9917 || flinfo->info->relocatable
9918 || flinfo->info->emitrelocations)
9920 Elf_Internal_Rela *irela;
9921 Elf_Internal_Rela *irelaend, *irelamid;
9922 bfd_vma last_offset;
9923 struct elf_link_hash_entry **rel_hash;
9924 struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
9925 Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
9926 unsigned int next_erel;
9927 bfd_boolean rela_normal;
9928 struct bfd_elf_section_data *esdi, *esdo;
9930 esdi = elf_section_data (o);
9931 esdo = elf_section_data (o->output_section);
9932 rela_normal = FALSE;
9934 /* Adjust the reloc addresses and symbol indices. */
9936 irela = internal_relocs;
9937 irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9938 rel_hash = esdo->rel.hashes + esdo->rel.count;
9939 /* We start processing the REL relocs, if any. When we reach
9940 IRELAMID in the loop, we switch to the RELA relocs. */
9942 if (esdi->rel.hdr != NULL)
9943 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
9944 * bed->s->int_rels_per_ext_rel);
9945 rel_hash_list = rel_hash;
9946 rela_hash_list = NULL;
9947 last_offset = o->output_offset;
9948 if (!flinfo->info->relocatable)
9949 last_offset += o->output_section->vma;
9950 for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9952 unsigned long r_symndx;
9954 Elf_Internal_Sym sym;
9956 if (next_erel == bed->s->int_rels_per_ext_rel)
9962 if (irela == irelamid)
9964 rel_hash = esdo->rela.hashes + esdo->rela.count;
9965 rela_hash_list = rel_hash;
9966 rela_normal = bed->rela_normal;
9969 irela->r_offset = _bfd_elf_section_offset (output_bfd,
9972 if (irela->r_offset >= (bfd_vma) -2)
9974 /* This is a reloc for a deleted entry or somesuch.
9975 Turn it into an R_*_NONE reloc, at the same
9976 offset as the last reloc. elf_eh_frame.c and
9977 bfd_elf_discard_info rely on reloc offsets
9979 irela->r_offset = last_offset;
9981 irela->r_addend = 0;
9985 irela->r_offset += o->output_offset;
9987 /* Relocs in an executable have to be virtual addresses. */
9988 if (!flinfo->info->relocatable)
9989 irela->r_offset += o->output_section->vma;
9991 last_offset = irela->r_offset;
9993 r_symndx = irela->r_info >> r_sym_shift;
9994 if (r_symndx == STN_UNDEF)
9997 if (r_symndx >= locsymcount
9998 || (elf_bad_symtab (input_bfd)
9999 && flinfo->sections[r_symndx] == NULL))
10001 struct elf_link_hash_entry *rh;
10002 unsigned long indx;
10004 /* This is a reloc against a global symbol. We
10005 have not yet output all the local symbols, so
10006 we do not know the symbol index of any global
10007 symbol. We set the rel_hash entry for this
10008 reloc to point to the global hash table entry
10009 for this symbol. The symbol index is then
10010 set at the end of bfd_elf_final_link. */
10011 indx = r_symndx - extsymoff;
10012 rh = elf_sym_hashes (input_bfd)[indx];
10013 while (rh->root.type == bfd_link_hash_indirect
10014 || rh->root.type == bfd_link_hash_warning)
10015 rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
10017 /* Setting the index to -2 tells
10018 elf_link_output_extsym that this symbol is
10019 used by a reloc. */
10020 BFD_ASSERT (rh->indx < 0);
10028 /* This is a reloc against a local symbol. */
10031 sym = isymbuf[r_symndx];
10032 sec = flinfo->sections[r_symndx];
10033 if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
10035 /* I suppose the backend ought to fill in the
10036 section of any STT_SECTION symbol against a
10037 processor specific section. */
10038 r_symndx = STN_UNDEF;
10039 if (bfd_is_abs_section (sec))
10041 else if (sec == NULL || sec->owner == NULL)
10043 bfd_set_error (bfd_error_bad_value);
10048 asection *osec = sec->output_section;
10050 /* If we have discarded a section, the output
10051 section will be the absolute section. In
10052 case of discarded SEC_MERGE sections, use
10053 the kept section. relocate_section should
10054 have already handled discarded linkonce
10056 if (bfd_is_abs_section (osec)
10057 && sec->kept_section != NULL
10058 && sec->kept_section->output_section != NULL)
10060 osec = sec->kept_section->output_section;
10061 irela->r_addend -= osec->vma;
10064 if (!bfd_is_abs_section (osec))
10066 r_symndx = osec->target_index;
10067 if (r_symndx == STN_UNDEF)
10069 irela->r_addend += osec->vma;
10070 osec = _bfd_nearby_section (output_bfd, osec,
10072 irela->r_addend -= osec->vma;
10073 r_symndx = osec->target_index;
10078 /* Adjust the addend according to where the
10079 section winds up in the output section. */
10081 irela->r_addend += sec->output_offset;
10085 if (flinfo->indices[r_symndx] == -1)
10087 unsigned long shlink;
10092 if (flinfo->info->strip == strip_all)
10094 /* You can't do ld -r -s. */
10095 bfd_set_error (bfd_error_invalid_operation);
10099 /* This symbol was skipped earlier, but
10100 since it is needed by a reloc, we
10101 must output it now. */
10102 shlink = symtab_hdr->sh_link;
10103 name = (bfd_elf_string_from_elf_section
10104 (input_bfd, shlink, sym.st_name));
10108 osec = sec->output_section;
10110 _bfd_elf_section_from_bfd_section (output_bfd,
10112 if (sym.st_shndx == SHN_BAD)
10115 sym.st_value += sec->output_offset;
10116 if (!flinfo->info->relocatable)
10118 sym.st_value += osec->vma;
10119 if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
10121 /* STT_TLS symbols are relative to PT_TLS
10123 BFD_ASSERT (elf_hash_table (flinfo->info)
10124 ->tls_sec != NULL);
10125 sym.st_value -= (elf_hash_table (flinfo->info)
10130 indx = bfd_get_symcount (output_bfd);
10131 ret = elf_link_output_sym (flinfo, name, &sym, sec,
10136 flinfo->indices[r_symndx] = indx;
10141 r_symndx = flinfo->indices[r_symndx];
10144 irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
10145 | (irela->r_info & r_type_mask));
10148 /* Swap out the relocs. */
10149 input_rel_hdr = esdi->rel.hdr;
10150 if (input_rel_hdr && input_rel_hdr->sh_size != 0)
10152 if (!bed->elf_backend_emit_relocs (output_bfd, o,
10157 internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
10158 * bed->s->int_rels_per_ext_rel);
10159 rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
10162 input_rela_hdr = esdi->rela.hdr;
10163 if (input_rela_hdr && input_rela_hdr->sh_size != 0)
10165 if (!bed->elf_backend_emit_relocs (output_bfd, o,
10174 /* Write out the modified section contents. */
10175 if (bed->elf_backend_write_section
10176 && (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
10179 /* Section written out. */
10181 else switch (o->sec_info_type)
10183 case SEC_INFO_TYPE_STABS:
10184 if (! (_bfd_write_section_stabs
10186 &elf_hash_table (flinfo->info)->stab_info,
10187 o, &elf_section_data (o)->sec_info, contents)))
10190 case SEC_INFO_TYPE_MERGE:
10191 if (! _bfd_write_merged_section (output_bfd, o,
10192 elf_section_data (o)->sec_info))
10195 case SEC_INFO_TYPE_EH_FRAME:
10197 if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
10204 /* FIXME: octets_per_byte. */
10205 if (! (o->flags & SEC_EXCLUDE))
10207 file_ptr offset = (file_ptr) o->output_offset;
10208 bfd_size_type todo = o->size;
10209 if ((o->flags & SEC_ELF_REVERSE_COPY))
10211 /* Reverse-copy input section to output. */
10214 todo -= address_size;
10215 if (! bfd_set_section_contents (output_bfd,
10223 offset += address_size;
10227 else if (! bfd_set_section_contents (output_bfd,
10241 /* Generate a reloc when linking an ELF file. This is a reloc
10242 requested by the linker, and does not come from any input file. This
10243 is used to build constructor and destructor tables when linking
10247 elf_reloc_link_order (bfd *output_bfd,
10248 struct bfd_link_info *info,
10249 asection *output_section,
10250 struct bfd_link_order *link_order)
10252 reloc_howto_type *howto;
10256 struct bfd_elf_section_reloc_data *reldata;
10257 struct elf_link_hash_entry **rel_hash_ptr;
10258 Elf_Internal_Shdr *rel_hdr;
10259 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10260 Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
10263 struct bfd_elf_section_data *esdo = elf_section_data (output_section);
10265 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
10268 bfd_set_error (bfd_error_bad_value);
10272 addend = link_order->u.reloc.p->addend;
10275 reldata = &esdo->rel;
10276 else if (esdo->rela.hdr)
10277 reldata = &esdo->rela;
10284 /* Figure out the symbol index. */
10285 rel_hash_ptr = reldata->hashes + reldata->count;
10286 if (link_order->type == bfd_section_reloc_link_order)
10288 indx = link_order->u.reloc.p->u.section->target_index;
10289 BFD_ASSERT (indx != 0);
10290 *rel_hash_ptr = NULL;
10294 struct elf_link_hash_entry *h;
10296 /* Treat a reloc against a defined symbol as though it were
10297 actually against the section. */
10298 h = ((struct elf_link_hash_entry *)
10299 bfd_wrapped_link_hash_lookup (output_bfd, info,
10300 link_order->u.reloc.p->u.name,
10301 FALSE, FALSE, TRUE));
10303 && (h->root.type == bfd_link_hash_defined
10304 || h->root.type == bfd_link_hash_defweak))
10308 section = h->root.u.def.section;
10309 indx = section->output_section->target_index;
10310 *rel_hash_ptr = NULL;
10311 /* It seems that we ought to add the symbol value to the
10312 addend here, but in practice it has already been added
10313 because it was passed to constructor_callback. */
10314 addend += section->output_section->vma + section->output_offset;
10316 else if (h != NULL)
10318 /* Setting the index to -2 tells elf_link_output_extsym that
10319 this symbol is used by a reloc. */
10326 if (! ((*info->callbacks->unattached_reloc)
10327 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10333 /* If this is an inplace reloc, we must write the addend into the
10335 if (howto->partial_inplace && addend != 0)
10337 bfd_size_type size;
10338 bfd_reloc_status_type rstat;
10341 const char *sym_name;
10343 size = (bfd_size_type) bfd_get_reloc_size (howto);
10344 buf = (bfd_byte *) bfd_zmalloc (size);
10345 if (buf == NULL && size != 0)
10347 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10354 case bfd_reloc_outofrange:
10357 case bfd_reloc_overflow:
10358 if (link_order->type == bfd_section_reloc_link_order)
10359 sym_name = bfd_section_name (output_bfd,
10360 link_order->u.reloc.p->u.section);
10362 sym_name = link_order->u.reloc.p->u.name;
10363 if (! ((*info->callbacks->reloc_overflow)
10364 (info, NULL, sym_name, howto->name, addend, NULL,
10365 NULL, (bfd_vma) 0)))
10372 ok = bfd_set_section_contents (output_bfd, output_section, buf,
10373 link_order->offset, size);
10379 /* The address of a reloc is relative to the section in a
10380 relocatable file, and is a virtual address in an executable
10382 offset = link_order->offset;
10383 if (! info->relocatable)
10384 offset += output_section->vma;
10386 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10388 irel[i].r_offset = offset;
10389 irel[i].r_info = 0;
10390 irel[i].r_addend = 0;
10392 if (bed->s->arch_size == 32)
10393 irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10395 irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10397 rel_hdr = reldata->hdr;
10398 erel = rel_hdr->contents;
10399 if (rel_hdr->sh_type == SHT_REL)
10401 erel += reldata->count * bed->s->sizeof_rel;
10402 (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10406 irel[0].r_addend = addend;
10407 erel += reldata->count * bed->s->sizeof_rela;
10408 (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10417 /* Get the output vma of the section pointed to by the sh_link field. */
10420 elf_get_linked_section_vma (struct bfd_link_order *p)
10422 Elf_Internal_Shdr **elf_shdrp;
10426 s = p->u.indirect.section;
10427 elf_shdrp = elf_elfsections (s->owner);
10428 elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10429 elfsec = elf_shdrp[elfsec]->sh_link;
10431 The Intel C compiler generates SHT_IA_64_UNWIND with
10432 SHF_LINK_ORDER. But it doesn't set the sh_link or
10433 sh_info fields. Hence we could get the situation
10434 where elfsec is 0. */
10437 const struct elf_backend_data *bed
10438 = get_elf_backend_data (s->owner);
10439 if (bed->link_order_error_handler)
10440 bed->link_order_error_handler
10441 (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10446 s = elf_shdrp[elfsec]->bfd_section;
10447 return s->output_section->vma + s->output_offset;
10452 /* Compare two sections based on the locations of the sections they are
10453 linked to. Used by elf_fixup_link_order. */
10456 compare_link_order (const void * a, const void * b)
10461 apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10462 bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10465 return apos > bpos;
10469 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
10470 order as their linked sections. Returns false if this could not be done
10471 because an output section includes both ordered and unordered
10472 sections. Ideally we'd do this in the linker proper. */
10475 elf_fixup_link_order (bfd *abfd, asection *o)
10477 int seen_linkorder;
10480 struct bfd_link_order *p;
10482 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10484 struct bfd_link_order **sections;
10485 asection *s, *other_sec, *linkorder_sec;
10489 linkorder_sec = NULL;
10491 seen_linkorder = 0;
10492 for (p = o->map_head.link_order; p != NULL; p = p->next)
10494 if (p->type == bfd_indirect_link_order)
10496 s = p->u.indirect.section;
10498 if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10499 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10500 && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10501 && elfsec < elf_numsections (sub)
10502 && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10503 && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10517 if (seen_other && seen_linkorder)
10519 if (other_sec && linkorder_sec)
10520 (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10522 linkorder_sec->owner, other_sec,
10525 (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10527 bfd_set_error (bfd_error_bad_value);
10532 if (!seen_linkorder)
10535 sections = (struct bfd_link_order **)
10536 bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10537 if (sections == NULL)
10539 seen_linkorder = 0;
10541 for (p = o->map_head.link_order; p != NULL; p = p->next)
10543 sections[seen_linkorder++] = p;
10545 /* Sort the input sections in the order of their linked section. */
10546 qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10547 compare_link_order);
10549 /* Change the offsets of the sections. */
10551 for (n = 0; n < seen_linkorder; n++)
10553 s = sections[n]->u.indirect.section;
10554 offset &= ~(bfd_vma) 0 << s->alignment_power;
10555 s->output_offset = offset;
10556 sections[n]->offset = offset;
10557 /* FIXME: octets_per_byte. */
10558 offset += sections[n]->size;
10566 elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
10570 if (flinfo->symstrtab != NULL)
10571 _bfd_stringtab_free (flinfo->symstrtab);
10572 if (flinfo->contents != NULL)
10573 free (flinfo->contents);
10574 if (flinfo->external_relocs != NULL)
10575 free (flinfo->external_relocs);
10576 if (flinfo->internal_relocs != NULL)
10577 free (flinfo->internal_relocs);
10578 if (flinfo->external_syms != NULL)
10579 free (flinfo->external_syms);
10580 if (flinfo->locsym_shndx != NULL)
10581 free (flinfo->locsym_shndx);
10582 if (flinfo->internal_syms != NULL)
10583 free (flinfo->internal_syms);
10584 if (flinfo->indices != NULL)
10585 free (flinfo->indices);
10586 if (flinfo->sections != NULL)
10587 free (flinfo->sections);
10588 if (flinfo->symbuf != NULL)
10589 free (flinfo->symbuf);
10590 if (flinfo->symshndxbuf != NULL)
10591 free (flinfo->symshndxbuf);
10592 for (o = obfd->sections; o != NULL; o = o->next)
10594 struct bfd_elf_section_data *esdo = elf_section_data (o);
10595 if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
10596 free (esdo->rel.hashes);
10597 if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
10598 free (esdo->rela.hashes);
10602 /* Do the final step of an ELF link. */
10605 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10607 bfd_boolean dynamic;
10608 bfd_boolean emit_relocs;
10610 struct elf_final_link_info flinfo;
10612 struct bfd_link_order *p;
10614 bfd_size_type max_contents_size;
10615 bfd_size_type max_external_reloc_size;
10616 bfd_size_type max_internal_reloc_count;
10617 bfd_size_type max_sym_count;
10618 bfd_size_type max_sym_shndx_count;
10619 Elf_Internal_Sym elfsym;
10621 Elf_Internal_Shdr *symtab_hdr;
10622 Elf_Internal_Shdr *symtab_shndx_hdr;
10623 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10624 struct elf_outext_info eoinfo;
10625 bfd_boolean merged;
10626 size_t relativecount = 0;
10627 asection *reldyn = 0;
10629 asection *attr_section = NULL;
10630 bfd_vma attr_size = 0;
10631 const char *std_attrs_section;
10633 if (! is_elf_hash_table (info->hash))
10637 abfd->flags |= DYNAMIC;
10639 dynamic = elf_hash_table (info)->dynamic_sections_created;
10640 dynobj = elf_hash_table (info)->dynobj;
10642 emit_relocs = (info->relocatable
10643 || info->emitrelocations);
10645 flinfo.info = info;
10646 flinfo.output_bfd = abfd;
10647 flinfo.symstrtab = _bfd_elf_stringtab_init ();
10648 if (flinfo.symstrtab == NULL)
10653 flinfo.dynsym_sec = NULL;
10654 flinfo.hash_sec = NULL;
10655 flinfo.symver_sec = NULL;
10659 flinfo.dynsym_sec = bfd_get_linker_section (dynobj, ".dynsym");
10660 flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
10661 /* Note that dynsym_sec can be NULL (on VMS). */
10662 flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
10663 /* Note that it is OK if symver_sec is NULL. */
10666 flinfo.contents = NULL;
10667 flinfo.external_relocs = NULL;
10668 flinfo.internal_relocs = NULL;
10669 flinfo.external_syms = NULL;
10670 flinfo.locsym_shndx = NULL;
10671 flinfo.internal_syms = NULL;
10672 flinfo.indices = NULL;
10673 flinfo.sections = NULL;
10674 flinfo.symbuf = NULL;
10675 flinfo.symshndxbuf = NULL;
10676 flinfo.symbuf_count = 0;
10677 flinfo.shndxbuf_size = 0;
10678 flinfo.filesym_count = 0;
10680 /* The object attributes have been merged. Remove the input
10681 sections from the link, and set the contents of the output
10683 std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10684 for (o = abfd->sections; o != NULL; o = o->next)
10686 if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10687 || strcmp (o->name, ".gnu.attributes") == 0)
10689 for (p = o->map_head.link_order; p != NULL; p = p->next)
10691 asection *input_section;
10693 if (p->type != bfd_indirect_link_order)
10695 input_section = p->u.indirect.section;
10696 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10697 elf_link_input_bfd ignores this section. */
10698 input_section->flags &= ~SEC_HAS_CONTENTS;
10701 attr_size = bfd_elf_obj_attr_size (abfd);
10704 bfd_set_section_size (abfd, o, attr_size);
10706 /* Skip this section later on. */
10707 o->map_head.link_order = NULL;
10710 o->flags |= SEC_EXCLUDE;
10714 /* Count up the number of relocations we will output for each output
10715 section, so that we know the sizes of the reloc sections. We
10716 also figure out some maximum sizes. */
10717 max_contents_size = 0;
10718 max_external_reloc_size = 0;
10719 max_internal_reloc_count = 0;
10721 max_sym_shndx_count = 0;
10723 for (o = abfd->sections; o != NULL; o = o->next)
10725 struct bfd_elf_section_data *esdo = elf_section_data (o);
10726 o->reloc_count = 0;
10728 for (p = o->map_head.link_order; p != NULL; p = p->next)
10730 unsigned int reloc_count = 0;
10731 struct bfd_elf_section_data *esdi = NULL;
10733 if (p->type == bfd_section_reloc_link_order
10734 || p->type == bfd_symbol_reloc_link_order)
10736 else if (p->type == bfd_indirect_link_order)
10740 sec = p->u.indirect.section;
10741 esdi = elf_section_data (sec);
10743 /* Mark all sections which are to be included in the
10744 link. This will normally be every section. We need
10745 to do this so that we can identify any sections which
10746 the linker has decided to not include. */
10747 sec->linker_mark = TRUE;
10749 if (sec->flags & SEC_MERGE)
10752 if (esdo->this_hdr.sh_type == SHT_REL
10753 || esdo->this_hdr.sh_type == SHT_RELA)
10754 /* Some backends use reloc_count in relocation sections
10755 to count particular types of relocs. Of course,
10756 reloc sections themselves can't have relocations. */
10758 else if (info->relocatable || info->emitrelocations)
10759 reloc_count = sec->reloc_count;
10760 else if (bed->elf_backend_count_relocs)
10761 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10763 if (sec->rawsize > max_contents_size)
10764 max_contents_size = sec->rawsize;
10765 if (sec->size > max_contents_size)
10766 max_contents_size = sec->size;
10768 /* We are interested in just local symbols, not all
10770 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10771 && (sec->owner->flags & DYNAMIC) == 0)
10775 if (elf_bad_symtab (sec->owner))
10776 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10777 / bed->s->sizeof_sym);
10779 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10781 if (sym_count > max_sym_count)
10782 max_sym_count = sym_count;
10784 if (sym_count > max_sym_shndx_count
10785 && elf_symtab_shndx (sec->owner) != 0)
10786 max_sym_shndx_count = sym_count;
10788 if ((sec->flags & SEC_RELOC) != 0)
10790 size_t ext_size = 0;
10792 if (esdi->rel.hdr != NULL)
10793 ext_size = esdi->rel.hdr->sh_size;
10794 if (esdi->rela.hdr != NULL)
10795 ext_size += esdi->rela.hdr->sh_size;
10797 if (ext_size > max_external_reloc_size)
10798 max_external_reloc_size = ext_size;
10799 if (sec->reloc_count > max_internal_reloc_count)
10800 max_internal_reloc_count = sec->reloc_count;
10805 if (reloc_count == 0)
10808 o->reloc_count += reloc_count;
10810 if (p->type == bfd_indirect_link_order
10811 && (info->relocatable || info->emitrelocations))
10814 esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
10815 if (esdi->rela.hdr)
10816 esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
10821 esdo->rela.count += reloc_count;
10823 esdo->rel.count += reloc_count;
10827 if (o->reloc_count > 0)
10828 o->flags |= SEC_RELOC;
10831 /* Explicitly clear the SEC_RELOC flag. The linker tends to
10832 set it (this is probably a bug) and if it is set
10833 assign_section_numbers will create a reloc section. */
10834 o->flags &=~ SEC_RELOC;
10837 /* If the SEC_ALLOC flag is not set, force the section VMA to
10838 zero. This is done in elf_fake_sections as well, but forcing
10839 the VMA to 0 here will ensure that relocs against these
10840 sections are handled correctly. */
10841 if ((o->flags & SEC_ALLOC) == 0
10842 && ! o->user_set_vma)
10846 if (! info->relocatable && merged)
10847 elf_link_hash_traverse (elf_hash_table (info),
10848 _bfd_elf_link_sec_merge_syms, abfd);
10850 /* Figure out the file positions for everything but the symbol table
10851 and the relocs. We set symcount to force assign_section_numbers
10852 to create a symbol table. */
10853 bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
10854 BFD_ASSERT (! abfd->output_has_begun);
10855 if (! _bfd_elf_compute_section_file_positions (abfd, info))
10858 /* Set sizes, and assign file positions for reloc sections. */
10859 for (o = abfd->sections; o != NULL; o = o->next)
10861 struct bfd_elf_section_data *esdo = elf_section_data (o);
10862 if ((o->flags & SEC_RELOC) != 0)
10865 && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
10869 && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
10873 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10874 to count upwards while actually outputting the relocations. */
10875 esdo->rel.count = 0;
10876 esdo->rela.count = 0;
10879 /* We have now assigned file positions for all the sections except
10880 .symtab, .strtab, and non-loaded reloc sections. We start the
10881 .symtab section at the current file position, and write directly
10882 to it. We build the .strtab section in memory. */
10883 bfd_get_symcount (abfd) = 0;
10884 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10885 /* sh_name is set in prep_headers. */
10886 symtab_hdr->sh_type = SHT_SYMTAB;
10887 /* sh_flags, sh_addr and sh_size all start off zero. */
10888 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10889 /* sh_link is set in assign_section_numbers. */
10890 /* sh_info is set below. */
10891 /* sh_offset is set just below. */
10892 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10894 /* Allocate a buffer to hold swapped out symbols. This is to avoid
10895 continuously seeking to the right position in the file. */
10896 if (! info->keep_memory || max_sym_count < 20)
10897 flinfo.symbuf_size = 20;
10899 flinfo.symbuf_size = max_sym_count;
10900 amt = flinfo.symbuf_size;
10901 amt *= bed->s->sizeof_sym;
10902 flinfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10903 if (flinfo.symbuf == NULL)
10905 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10907 /* Wild guess at number of output symbols. realloc'd as needed. */
10908 amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10909 flinfo.shndxbuf_size = amt;
10910 amt *= sizeof (Elf_External_Sym_Shndx);
10911 flinfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10912 if (flinfo.symshndxbuf == NULL)
10916 if (info->strip != strip_all || emit_relocs)
10918 file_ptr off = elf_next_file_pos (abfd);
10920 _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10922 /* Note that at this point elf_next_file_pos (abfd) is
10923 incorrect. We do not yet know the size of the .symtab section.
10924 We correct next_file_pos below, after we do know the size. */
10926 /* Start writing out the symbol table. The first symbol is always a
10928 elfsym.st_value = 0;
10929 elfsym.st_size = 0;
10930 elfsym.st_info = 0;
10931 elfsym.st_other = 0;
10932 elfsym.st_shndx = SHN_UNDEF;
10933 elfsym.st_target_internal = 0;
10934 if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
10938 /* Output a symbol for each section. We output these even if we are
10939 discarding local symbols, since they are used for relocs. These
10940 symbols have no names. We store the index of each one in the
10941 index field of the section, so that we can find it again when
10942 outputting relocs. */
10944 elfsym.st_size = 0;
10945 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10946 elfsym.st_other = 0;
10947 elfsym.st_value = 0;
10948 elfsym.st_target_internal = 0;
10949 for (i = 1; i < elf_numsections (abfd); i++)
10951 o = bfd_section_from_elf_index (abfd, i);
10954 o->target_index = bfd_get_symcount (abfd);
10955 elfsym.st_shndx = i;
10956 if (!info->relocatable)
10957 elfsym.st_value = o->vma;
10958 if (elf_link_output_sym (&flinfo, NULL, &elfsym, o, NULL) != 1)
10964 /* Allocate some memory to hold information read in from the input
10966 if (max_contents_size != 0)
10968 flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10969 if (flinfo.contents == NULL)
10973 if (max_external_reloc_size != 0)
10975 flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
10976 if (flinfo.external_relocs == NULL)
10980 if (max_internal_reloc_count != 0)
10982 amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10983 amt *= sizeof (Elf_Internal_Rela);
10984 flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10985 if (flinfo.internal_relocs == NULL)
10989 if (max_sym_count != 0)
10991 amt = max_sym_count * bed->s->sizeof_sym;
10992 flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10993 if (flinfo.external_syms == NULL)
10996 amt = max_sym_count * sizeof (Elf_Internal_Sym);
10997 flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
10998 if (flinfo.internal_syms == NULL)
11001 amt = max_sym_count * sizeof (long);
11002 flinfo.indices = (long int *) bfd_malloc (amt);
11003 if (flinfo.indices == NULL)
11006 amt = max_sym_count * sizeof (asection *);
11007 flinfo.sections = (asection **) bfd_malloc (amt);
11008 if (flinfo.sections == NULL)
11012 if (max_sym_shndx_count != 0)
11014 amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
11015 flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
11016 if (flinfo.locsym_shndx == NULL)
11020 if (elf_hash_table (info)->tls_sec)
11022 bfd_vma base, end = 0;
11025 for (sec = elf_hash_table (info)->tls_sec;
11026 sec && (sec->flags & SEC_THREAD_LOCAL);
11029 bfd_size_type size = sec->size;
11032 && (sec->flags & SEC_HAS_CONTENTS) == 0)
11034 struct bfd_link_order *ord = sec->map_tail.link_order;
11037 size = ord->offset + ord->size;
11039 end = sec->vma + size;
11041 base = elf_hash_table (info)->tls_sec->vma;
11042 /* Only align end of TLS section if static TLS doesn't have special
11043 alignment requirements. */
11044 if (bed->static_tls_alignment == 1)
11045 end = align_power (end,
11046 elf_hash_table (info)->tls_sec->alignment_power);
11047 elf_hash_table (info)->tls_size = end - base;
11050 /* Reorder SHF_LINK_ORDER sections. */
11051 for (o = abfd->sections; o != NULL; o = o->next)
11053 if (!elf_fixup_link_order (abfd, o))
11057 /* Since ELF permits relocations to be against local symbols, we
11058 must have the local symbols available when we do the relocations.
11059 Since we would rather only read the local symbols once, and we
11060 would rather not keep them in memory, we handle all the
11061 relocations for a single input file at the same time.
11063 Unfortunately, there is no way to know the total number of local
11064 symbols until we have seen all of them, and the local symbol
11065 indices precede the global symbol indices. This means that when
11066 we are generating relocatable output, and we see a reloc against
11067 a global symbol, we can not know the symbol index until we have
11068 finished examining all the local symbols to see which ones we are
11069 going to output. To deal with this, we keep the relocations in
11070 memory, and don't output them until the end of the link. This is
11071 an unfortunate waste of memory, but I don't see a good way around
11072 it. Fortunately, it only happens when performing a relocatable
11073 link, which is not the common case. FIXME: If keep_memory is set
11074 we could write the relocs out and then read them again; I don't
11075 know how bad the memory loss will be. */
11077 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11078 sub->output_has_begun = FALSE;
11079 for (o = abfd->sections; o != NULL; o = o->next)
11081 for (p = o->map_head.link_order; p != NULL; p = p->next)
11083 if (p->type == bfd_indirect_link_order
11084 && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
11085 == bfd_target_elf_flavour)
11086 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
11088 if (! sub->output_has_begun)
11090 if (! elf_link_input_bfd (&flinfo, sub))
11092 sub->output_has_begun = TRUE;
11095 else if (p->type == bfd_section_reloc_link_order
11096 || p->type == bfd_symbol_reloc_link_order)
11098 if (! elf_reloc_link_order (abfd, info, o, p))
11103 if (! _bfd_default_link_order (abfd, info, o, p))
11105 if (p->type == bfd_indirect_link_order
11106 && (bfd_get_flavour (sub)
11107 == bfd_target_elf_flavour)
11108 && (elf_elfheader (sub)->e_ident[EI_CLASS]
11109 != bed->s->elfclass))
11111 const char *iclass, *oclass;
11113 if (bed->s->elfclass == ELFCLASS64)
11115 iclass = "ELFCLASS32";
11116 oclass = "ELFCLASS64";
11120 iclass = "ELFCLASS64";
11121 oclass = "ELFCLASS32";
11124 bfd_set_error (bfd_error_wrong_format);
11125 (*_bfd_error_handler)
11126 (_("%B: file class %s incompatible with %s"),
11127 sub, iclass, oclass);
11136 /* Free symbol buffer if needed. */
11137 if (!info->reduce_memory_overheads)
11139 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11140 if (bfd_get_flavour (sub) == bfd_target_elf_flavour
11141 && elf_tdata (sub)->symbuf)
11143 free (elf_tdata (sub)->symbuf);
11144 elf_tdata (sub)->symbuf = NULL;
11148 /* Output any global symbols that got converted to local in a
11149 version script or due to symbol visibility. We do this in a
11150 separate step since ELF requires all local symbols to appear
11151 prior to any global symbols. FIXME: We should only do this if
11152 some global symbols were, in fact, converted to become local.
11153 FIXME: Will this work correctly with the Irix 5 linker? */
11154 eoinfo.failed = FALSE;
11155 eoinfo.flinfo = &flinfo;
11156 eoinfo.localsyms = TRUE;
11157 eoinfo.file_sym_done = FALSE;
11158 bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11162 /* If backend needs to output some local symbols not present in the hash
11163 table, do it now. */
11164 if (bed->elf_backend_output_arch_local_syms
11165 && (info->strip != strip_all || emit_relocs))
11167 typedef int (*out_sym_func)
11168 (void *, const char *, Elf_Internal_Sym *, asection *,
11169 struct elf_link_hash_entry *);
11171 if (! ((*bed->elf_backend_output_arch_local_syms)
11172 (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11176 /* That wrote out all the local symbols. Finish up the symbol table
11177 with the global symbols. Even if we want to strip everything we
11178 can, we still need to deal with those global symbols that got
11179 converted to local in a version script. */
11181 /* The sh_info field records the index of the first non local symbol. */
11182 symtab_hdr->sh_info = bfd_get_symcount (abfd);
11185 && flinfo.dynsym_sec != NULL
11186 && flinfo.dynsym_sec->output_section != bfd_abs_section_ptr)
11188 Elf_Internal_Sym sym;
11189 bfd_byte *dynsym = flinfo.dynsym_sec->contents;
11190 long last_local = 0;
11192 /* Write out the section symbols for the output sections. */
11193 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
11199 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11201 sym.st_target_internal = 0;
11203 for (s = abfd->sections; s != NULL; s = s->next)
11209 dynindx = elf_section_data (s)->dynindx;
11212 indx = elf_section_data (s)->this_idx;
11213 BFD_ASSERT (indx > 0);
11214 sym.st_shndx = indx;
11215 if (! check_dynsym (abfd, &sym))
11217 sym.st_value = s->vma;
11218 dest = dynsym + dynindx * bed->s->sizeof_sym;
11219 if (last_local < dynindx)
11220 last_local = dynindx;
11221 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11225 /* Write out the local dynsyms. */
11226 if (elf_hash_table (info)->dynlocal)
11228 struct elf_link_local_dynamic_entry *e;
11229 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
11234 /* Copy the internal symbol and turn off visibility.
11235 Note that we saved a word of storage and overwrote
11236 the original st_name with the dynstr_index. */
11238 sym.st_other &= ~ELF_ST_VISIBILITY (-1);
11240 s = bfd_section_from_elf_index (e->input_bfd,
11245 elf_section_data (s->output_section)->this_idx;
11246 if (! check_dynsym (abfd, &sym))
11248 sym.st_value = (s->output_section->vma
11250 + e->isym.st_value);
11253 if (last_local < e->dynindx)
11254 last_local = e->dynindx;
11256 dest = dynsym + e->dynindx * bed->s->sizeof_sym;
11257 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11261 elf_section_data (flinfo.dynsym_sec->output_section)->this_hdr.sh_info =
11265 /* We get the global symbols from the hash table. */
11266 eoinfo.failed = FALSE;
11267 eoinfo.localsyms = FALSE;
11268 eoinfo.flinfo = &flinfo;
11269 bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11273 /* If backend needs to output some symbols not present in the hash
11274 table, do it now. */
11275 if (bed->elf_backend_output_arch_syms
11276 && (info->strip != strip_all || emit_relocs))
11278 typedef int (*out_sym_func)
11279 (void *, const char *, Elf_Internal_Sym *, asection *,
11280 struct elf_link_hash_entry *);
11282 if (! ((*bed->elf_backend_output_arch_syms)
11283 (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11287 /* Flush all symbols to the file. */
11288 if (! elf_link_flush_output_syms (&flinfo, bed))
11291 /* Now we know the size of the symtab section. */
11292 if (bfd_get_symcount (abfd) > 0)
11294 /* Finish up and write out the symbol string table (.strtab)
11296 Elf_Internal_Shdr *symstrtab_hdr;
11297 file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
11299 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
11300 if (symtab_shndx_hdr->sh_name != 0)
11302 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
11303 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
11304 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
11305 amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
11306 symtab_shndx_hdr->sh_size = amt;
11308 off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
11311 if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
11312 || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
11316 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
11317 /* sh_name was set in prep_headers. */
11318 symstrtab_hdr->sh_type = SHT_STRTAB;
11319 symstrtab_hdr->sh_flags = 0;
11320 symstrtab_hdr->sh_addr = 0;
11321 symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
11322 symstrtab_hdr->sh_entsize = 0;
11323 symstrtab_hdr->sh_link = 0;
11324 symstrtab_hdr->sh_info = 0;
11325 /* sh_offset is set just below. */
11326 symstrtab_hdr->sh_addralign = 1;
11328 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
11330 elf_next_file_pos (abfd) = off;
11332 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
11333 || ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
11337 /* Adjust the relocs to have the correct symbol indices. */
11338 for (o = abfd->sections; o != NULL; o = o->next)
11340 struct bfd_elf_section_data *esdo = elf_section_data (o);
11342 if ((o->flags & SEC_RELOC) == 0)
11345 sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o);
11346 if (esdo->rel.hdr != NULL)
11347 elf_link_adjust_relocs (abfd, &esdo->rel, sort);
11348 if (esdo->rela.hdr != NULL)
11349 elf_link_adjust_relocs (abfd, &esdo->rela, sort);
11351 /* Set the reloc_count field to 0 to prevent write_relocs from
11352 trying to swap the relocs out itself. */
11353 o->reloc_count = 0;
11356 if (dynamic && info->combreloc && dynobj != NULL)
11357 relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
11359 /* If we are linking against a dynamic object, or generating a
11360 shared library, finish up the dynamic linking information. */
11363 bfd_byte *dyncon, *dynconend;
11365 /* Fix up .dynamic entries. */
11366 o = bfd_get_linker_section (dynobj, ".dynamic");
11367 BFD_ASSERT (o != NULL);
11369 dyncon = o->contents;
11370 dynconend = o->contents + o->size;
11371 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11373 Elf_Internal_Dyn dyn;
11377 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11384 if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11386 switch (elf_section_data (reldyn)->this_hdr.sh_type)
11388 case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11389 case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11392 dyn.d_un.d_val = relativecount;
11399 name = info->init_function;
11402 name = info->fini_function;
11405 struct elf_link_hash_entry *h;
11407 h = elf_link_hash_lookup (elf_hash_table (info), name,
11408 FALSE, FALSE, TRUE);
11410 && (h->root.type == bfd_link_hash_defined
11411 || h->root.type == bfd_link_hash_defweak))
11413 dyn.d_un.d_ptr = h->root.u.def.value;
11414 o = h->root.u.def.section;
11415 if (o->output_section != NULL)
11416 dyn.d_un.d_ptr += (o->output_section->vma
11417 + o->output_offset);
11420 /* The symbol is imported from another shared
11421 library and does not apply to this one. */
11422 dyn.d_un.d_ptr = 0;
11429 case DT_PREINIT_ARRAYSZ:
11430 name = ".preinit_array";
11432 case DT_INIT_ARRAYSZ:
11433 name = ".init_array";
11435 case DT_FINI_ARRAYSZ:
11436 name = ".fini_array";
11438 o = bfd_get_section_by_name (abfd, name);
11441 (*_bfd_error_handler)
11442 (_("%B: could not find output section %s"), abfd, name);
11446 (*_bfd_error_handler)
11447 (_("warning: %s section has zero size"), name);
11448 dyn.d_un.d_val = o->size;
11451 case DT_PREINIT_ARRAY:
11452 name = ".preinit_array";
11454 case DT_INIT_ARRAY:
11455 name = ".init_array";
11457 case DT_FINI_ARRAY:
11458 name = ".fini_array";
11465 name = ".gnu.hash";
11474 name = ".gnu.version_d";
11477 name = ".gnu.version_r";
11480 name = ".gnu.version";
11482 o = bfd_get_section_by_name (abfd, name);
11485 (*_bfd_error_handler)
11486 (_("%B: could not find output section %s"), abfd, name);
11489 if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11491 (*_bfd_error_handler)
11492 (_("warning: section '%s' is being made into a note"), name);
11493 bfd_set_error (bfd_error_nonrepresentable_section);
11496 dyn.d_un.d_ptr = o->vma;
11503 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11507 dyn.d_un.d_val = 0;
11508 dyn.d_un.d_ptr = 0;
11509 for (i = 1; i < elf_numsections (abfd); i++)
11511 Elf_Internal_Shdr *hdr;
11513 hdr = elf_elfsections (abfd)[i];
11514 if (hdr->sh_type == type
11515 && (hdr->sh_flags & SHF_ALLOC) != 0)
11517 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11518 dyn.d_un.d_val += hdr->sh_size;
11521 if (dyn.d_un.d_ptr == 0
11522 || hdr->sh_addr < dyn.d_un.d_ptr)
11523 dyn.d_un.d_ptr = hdr->sh_addr;
11529 bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11533 /* If we have created any dynamic sections, then output them. */
11534 if (dynobj != NULL)
11536 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11539 /* Check for DT_TEXTREL (late, in case the backend removes it). */
11540 if (((info->warn_shared_textrel && info->shared)
11541 || info->error_textrel)
11542 && (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
11544 bfd_byte *dyncon, *dynconend;
11546 dyncon = o->contents;
11547 dynconend = o->contents + o->size;
11548 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11550 Elf_Internal_Dyn dyn;
11552 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11554 if (dyn.d_tag == DT_TEXTREL)
11556 if (info->error_textrel)
11557 info->callbacks->einfo
11558 (_("%P%X: read-only segment has dynamic relocations.\n"));
11560 info->callbacks->einfo
11561 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11567 for (o = dynobj->sections; o != NULL; o = o->next)
11569 if ((o->flags & SEC_HAS_CONTENTS) == 0
11571 || o->output_section == bfd_abs_section_ptr)
11573 if ((o->flags & SEC_LINKER_CREATED) == 0)
11575 /* At this point, we are only interested in sections
11576 created by _bfd_elf_link_create_dynamic_sections. */
11579 if (elf_hash_table (info)->stab_info.stabstr == o)
11581 if (elf_hash_table (info)->eh_info.hdr_sec == o)
11583 if (strcmp (o->name, ".dynstr") != 0)
11585 /* FIXME: octets_per_byte. */
11586 if (! bfd_set_section_contents (abfd, o->output_section,
11588 (file_ptr) o->output_offset,
11594 /* The contents of the .dynstr section are actually in a
11598 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11599 if (bfd_seek (abfd, off, SEEK_SET) != 0
11600 || ! _bfd_elf_strtab_emit (abfd,
11601 elf_hash_table (info)->dynstr))
11607 if (info->relocatable)
11609 bfd_boolean failed = FALSE;
11611 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11616 /* If we have optimized stabs strings, output them. */
11617 if (elf_hash_table (info)->stab_info.stabstr != NULL)
11619 if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11623 if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11626 elf_final_link_free (abfd, &flinfo);
11628 elf_linker (abfd) = TRUE;
11632 bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11633 if (contents == NULL)
11634 return FALSE; /* Bail out and fail. */
11635 bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11636 bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11643 elf_final_link_free (abfd, &flinfo);
11647 /* Initialize COOKIE for input bfd ABFD. */
11650 init_reloc_cookie (struct elf_reloc_cookie *cookie,
11651 struct bfd_link_info *info, bfd *abfd)
11653 Elf_Internal_Shdr *symtab_hdr;
11654 const struct elf_backend_data *bed;
11656 bed = get_elf_backend_data (abfd);
11657 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11659 cookie->abfd = abfd;
11660 cookie->sym_hashes = elf_sym_hashes (abfd);
11661 cookie->bad_symtab = elf_bad_symtab (abfd);
11662 if (cookie->bad_symtab)
11664 cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11665 cookie->extsymoff = 0;
11669 cookie->locsymcount = symtab_hdr->sh_info;
11670 cookie->extsymoff = symtab_hdr->sh_info;
11673 if (bed->s->arch_size == 32)
11674 cookie->r_sym_shift = 8;
11676 cookie->r_sym_shift = 32;
11678 cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11679 if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11681 cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11682 cookie->locsymcount, 0,
11684 if (cookie->locsyms == NULL)
11686 info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11689 if (info->keep_memory)
11690 symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11695 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
11698 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11700 Elf_Internal_Shdr *symtab_hdr;
11702 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11703 if (cookie->locsyms != NULL
11704 && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11705 free (cookie->locsyms);
11708 /* Initialize the relocation information in COOKIE for input section SEC
11709 of input bfd ABFD. */
11712 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11713 struct bfd_link_info *info, bfd *abfd,
11716 const struct elf_backend_data *bed;
11718 if (sec->reloc_count == 0)
11720 cookie->rels = NULL;
11721 cookie->relend = NULL;
11725 bed = get_elf_backend_data (abfd);
11727 cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11728 info->keep_memory);
11729 if (cookie->rels == NULL)
11731 cookie->rel = cookie->rels;
11732 cookie->relend = (cookie->rels
11733 + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11735 cookie->rel = cookie->rels;
11739 /* Free the memory allocated by init_reloc_cookie_rels,
11743 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11746 if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11747 free (cookie->rels);
11750 /* Initialize the whole of COOKIE for input section SEC. */
11753 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11754 struct bfd_link_info *info,
11757 if (!init_reloc_cookie (cookie, info, sec->owner))
11759 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11764 fini_reloc_cookie (cookie, sec->owner);
11769 /* Free the memory allocated by init_reloc_cookie_for_section,
11773 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11776 fini_reloc_cookie_rels (cookie, sec);
11777 fini_reloc_cookie (cookie, sec->owner);
11780 /* Garbage collect unused sections. */
11782 /* Default gc_mark_hook. */
11785 _bfd_elf_gc_mark_hook (asection *sec,
11786 struct bfd_link_info *info ATTRIBUTE_UNUSED,
11787 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11788 struct elf_link_hash_entry *h,
11789 Elf_Internal_Sym *sym)
11791 const char *sec_name;
11795 switch (h->root.type)
11797 case bfd_link_hash_defined:
11798 case bfd_link_hash_defweak:
11799 return h->root.u.def.section;
11801 case bfd_link_hash_common:
11802 return h->root.u.c.p->section;
11804 case bfd_link_hash_undefined:
11805 case bfd_link_hash_undefweak:
11806 /* To work around a glibc bug, keep all XXX input sections
11807 when there is an as yet undefined reference to __start_XXX
11808 or __stop_XXX symbols. The linker will later define such
11809 symbols for orphan input sections that have a name
11810 representable as a C identifier. */
11811 if (strncmp (h->root.root.string, "__start_", 8) == 0)
11812 sec_name = h->root.root.string + 8;
11813 else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
11814 sec_name = h->root.root.string + 7;
11818 if (sec_name && *sec_name != '\0')
11822 for (i = info->input_bfds; i; i = i->link.next)
11824 sec = bfd_get_section_by_name (i, sec_name);
11826 sec->flags |= SEC_KEEP;
11836 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11841 /* COOKIE->rel describes a relocation against section SEC, which is
11842 a section we've decided to keep. Return the section that contains
11843 the relocation symbol, or NULL if no section contains it. */
11846 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11847 elf_gc_mark_hook_fn gc_mark_hook,
11848 struct elf_reloc_cookie *cookie)
11850 unsigned long r_symndx;
11851 struct elf_link_hash_entry *h;
11853 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11854 if (r_symndx == STN_UNDEF)
11857 if (r_symndx >= cookie->locsymcount
11858 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11860 h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11863 info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
11867 while (h->root.type == bfd_link_hash_indirect
11868 || h->root.type == bfd_link_hash_warning)
11869 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11871 /* If this symbol is weak and there is a non-weak definition, we
11872 keep the non-weak definition because many backends put
11873 dynamic reloc info on the non-weak definition for code
11874 handling copy relocs. */
11875 if (h->u.weakdef != NULL)
11876 h->u.weakdef->mark = 1;
11877 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11880 return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11881 &cookie->locsyms[r_symndx]);
11884 /* COOKIE->rel describes a relocation against section SEC, which is
11885 a section we've decided to keep. Mark the section that contains
11886 the relocation symbol. */
11889 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11891 elf_gc_mark_hook_fn gc_mark_hook,
11892 struct elf_reloc_cookie *cookie)
11896 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11897 if (rsec && !rsec->gc_mark)
11899 if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
11900 || (rsec->owner->flags & DYNAMIC) != 0)
11902 else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11908 /* The mark phase of garbage collection. For a given section, mark
11909 it and any sections in this section's group, and all the sections
11910 which define symbols to which it refers. */
11913 _bfd_elf_gc_mark (struct bfd_link_info *info,
11915 elf_gc_mark_hook_fn gc_mark_hook)
11918 asection *group_sec, *eh_frame;
11922 /* Mark all the sections in the group. */
11923 group_sec = elf_section_data (sec)->next_in_group;
11924 if (group_sec && !group_sec->gc_mark)
11925 if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11928 /* Look through the section relocs. */
11930 eh_frame = elf_eh_frame_section (sec->owner);
11931 if ((sec->flags & SEC_RELOC) != 0
11932 && sec->reloc_count > 0
11933 && sec != eh_frame)
11935 struct elf_reloc_cookie cookie;
11937 if (!init_reloc_cookie_for_section (&cookie, info, sec))
11941 for (; cookie.rel < cookie.relend; cookie.rel++)
11942 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11947 fini_reloc_cookie_for_section (&cookie, sec);
11951 if (ret && eh_frame && elf_fde_list (sec))
11953 struct elf_reloc_cookie cookie;
11955 if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11959 if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11960 gc_mark_hook, &cookie))
11962 fini_reloc_cookie_for_section (&cookie, eh_frame);
11969 /* Scan and mark sections in a special or debug section group. */
11972 _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
11974 /* Point to first section of section group. */
11976 /* Used to iterate the section group. */
11979 bfd_boolean is_special_grp = TRUE;
11980 bfd_boolean is_debug_grp = TRUE;
11982 /* First scan to see if group contains any section other than debug
11983 and special section. */
11984 ssec = msec = elf_next_in_group (grp);
11987 if ((msec->flags & SEC_DEBUGGING) == 0)
11988 is_debug_grp = FALSE;
11990 if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
11991 is_special_grp = FALSE;
11993 msec = elf_next_in_group (msec);
11995 while (msec != ssec);
11997 /* If this is a pure debug section group or pure special section group,
11998 keep all sections in this group. */
11999 if (is_debug_grp || is_special_grp)
12004 msec = elf_next_in_group (msec);
12006 while (msec != ssec);
12010 /* Keep debug and special sections. */
12013 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12014 elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
12018 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12021 bfd_boolean some_kept;
12022 bfd_boolean debug_frag_seen;
12024 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
12027 /* Ensure all linker created sections are kept,
12028 see if any other section is already marked,
12029 and note if we have any fragmented debug sections. */
12030 debug_frag_seen = some_kept = FALSE;
12031 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12033 if ((isec->flags & SEC_LINKER_CREATED) != 0)
12035 else if (isec->gc_mark)
12038 if (debug_frag_seen == FALSE
12039 && (isec->flags & SEC_DEBUGGING)
12040 && CONST_STRNEQ (isec->name, ".debug_line."))
12041 debug_frag_seen = TRUE;
12044 /* If no section in this file will be kept, then we can
12045 toss out the debug and special sections. */
12049 /* Keep debug and special sections like .comment when they are
12050 not part of a group. Also keep section groups that contain
12051 just debug sections or special sections. */
12052 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12054 if ((isec->flags & SEC_GROUP) != 0)
12055 _bfd_elf_gc_mark_debug_special_section_group (isec);
12056 else if (((isec->flags & SEC_DEBUGGING) != 0
12057 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
12058 && elf_next_in_group (isec) == NULL)
12062 if (! debug_frag_seen)
12065 /* Look for CODE sections which are going to be discarded,
12066 and find and discard any fragmented debug sections which
12067 are associated with that code section. */
12068 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12069 if ((isec->flags & SEC_CODE) != 0
12070 && isec->gc_mark == 0)
12075 ilen = strlen (isec->name);
12077 /* Association is determined by the name of the debug section
12078 containing the name of the code section as a suffix. For
12079 example .debug_line.text.foo is a debug section associated
12081 for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
12085 if (dsec->gc_mark == 0
12086 || (dsec->flags & SEC_DEBUGGING) == 0)
12089 dlen = strlen (dsec->name);
12092 && strncmp (dsec->name + (dlen - ilen),
12093 isec->name, ilen) == 0)
12104 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
12106 struct elf_gc_sweep_symbol_info
12108 struct bfd_link_info *info;
12109 void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
12114 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
12117 && (((h->root.type == bfd_link_hash_defined
12118 || h->root.type == bfd_link_hash_defweak)
12119 && !((h->def_regular || ELF_COMMON_DEF_P (h))
12120 && h->root.u.def.section->gc_mark))
12121 || h->root.type == bfd_link_hash_undefined
12122 || h->root.type == bfd_link_hash_undefweak))
12124 struct elf_gc_sweep_symbol_info *inf;
12126 inf = (struct elf_gc_sweep_symbol_info *) data;
12127 (*inf->hide_symbol) (inf->info, h, TRUE);
12128 h->def_regular = 0;
12129 h->ref_regular = 0;
12130 h->ref_regular_nonweak = 0;
12136 /* The sweep phase of garbage collection. Remove all garbage sections. */
12138 typedef bfd_boolean (*gc_sweep_hook_fn)
12139 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
12142 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
12145 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12146 gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
12147 unsigned long section_sym_count;
12148 struct elf_gc_sweep_symbol_info sweep_info;
12150 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12154 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12157 for (o = sub->sections; o != NULL; o = o->next)
12159 /* When any section in a section group is kept, we keep all
12160 sections in the section group. If the first member of
12161 the section group is excluded, we will also exclude the
12163 if (o->flags & SEC_GROUP)
12165 asection *first = elf_next_in_group (o);
12166 o->gc_mark = first->gc_mark;
12172 /* Skip sweeping sections already excluded. */
12173 if (o->flags & SEC_EXCLUDE)
12176 /* Since this is early in the link process, it is simple
12177 to remove a section from the output. */
12178 o->flags |= SEC_EXCLUDE;
12180 if (info->print_gc_sections && o->size != 0)
12181 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
12183 /* But we also have to update some of the relocation
12184 info we collected before. */
12186 && (o->flags & SEC_RELOC) != 0
12187 && o->reloc_count != 0
12188 && !((info->strip == strip_all || info->strip == strip_debugger)
12189 && (o->flags & SEC_DEBUGGING) != 0)
12190 && !bfd_is_abs_section (o->output_section))
12192 Elf_Internal_Rela *internal_relocs;
12196 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
12197 info->keep_memory);
12198 if (internal_relocs == NULL)
12201 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
12203 if (elf_section_data (o)->relocs != internal_relocs)
12204 free (internal_relocs);
12212 /* Remove the symbols that were in the swept sections from the dynamic
12213 symbol table. GCFIXME: Anyone know how to get them out of the
12214 static symbol table as well? */
12215 sweep_info.info = info;
12216 sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
12217 elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
12220 _bfd_elf_link_renumber_dynsyms (abfd, info, §ion_sym_count);
12224 /* Propagate collected vtable information. This is called through
12225 elf_link_hash_traverse. */
12228 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
12230 /* Those that are not vtables. */
12231 if (h->vtable == NULL || h->vtable->parent == NULL)
12234 /* Those vtables that do not have parents, we cannot merge. */
12235 if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
12238 /* If we've already been done, exit. */
12239 if (h->vtable->used && h->vtable->used[-1])
12242 /* Make sure the parent's table is up to date. */
12243 elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
12245 if (h->vtable->used == NULL)
12247 /* None of this table's entries were referenced. Re-use the
12249 h->vtable->used = h->vtable->parent->vtable->used;
12250 h->vtable->size = h->vtable->parent->vtable->size;
12255 bfd_boolean *cu, *pu;
12257 /* Or the parent's entries into ours. */
12258 cu = h->vtable->used;
12260 pu = h->vtable->parent->vtable->used;
12263 const struct elf_backend_data *bed;
12264 unsigned int log_file_align;
12266 bed = get_elf_backend_data (h->root.u.def.section->owner);
12267 log_file_align = bed->s->log_file_align;
12268 n = h->vtable->parent->vtable->size >> log_file_align;
12283 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
12286 bfd_vma hstart, hend;
12287 Elf_Internal_Rela *relstart, *relend, *rel;
12288 const struct elf_backend_data *bed;
12289 unsigned int log_file_align;
12291 /* Take care of both those symbols that do not describe vtables as
12292 well as those that are not loaded. */
12293 if (h->vtable == NULL || h->vtable->parent == NULL)
12296 BFD_ASSERT (h->root.type == bfd_link_hash_defined
12297 || h->root.type == bfd_link_hash_defweak);
12299 sec = h->root.u.def.section;
12300 hstart = h->root.u.def.value;
12301 hend = hstart + h->size;
12303 relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
12305 return *(bfd_boolean *) okp = FALSE;
12306 bed = get_elf_backend_data (sec->owner);
12307 log_file_align = bed->s->log_file_align;
12309 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
12311 for (rel = relstart; rel < relend; ++rel)
12312 if (rel->r_offset >= hstart && rel->r_offset < hend)
12314 /* If the entry is in use, do nothing. */
12315 if (h->vtable->used
12316 && (rel->r_offset - hstart) < h->vtable->size)
12318 bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
12319 if (h->vtable->used[entry])
12322 /* Otherwise, kill it. */
12323 rel->r_offset = rel->r_info = rel->r_addend = 0;
12329 /* Mark sections containing dynamically referenced symbols. When
12330 building shared libraries, we must assume that any visible symbol is
12334 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
12336 struct bfd_link_info *info = (struct bfd_link_info *) inf;
12337 struct bfd_elf_dynamic_list *d = info->dynamic_list;
12339 if ((h->root.type == bfd_link_hash_defined
12340 || h->root.type == bfd_link_hash_defweak)
12342 || ((h->def_regular || ELF_COMMON_DEF_P (h))
12343 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
12344 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
12345 && (!info->executable
12346 || info->export_dynamic
12349 && (*d->match) (&d->head, NULL, h->root.root.string)))
12350 && (strchr (h->root.root.string, ELF_VER_CHR) != NULL
12351 || !bfd_hide_sym_by_version (info->version_info,
12352 h->root.root.string)))))
12353 h->root.u.def.section->flags |= SEC_KEEP;
12358 /* Keep all sections containing symbols undefined on the command-line,
12359 and the section containing the entry symbol. */
12362 _bfd_elf_gc_keep (struct bfd_link_info *info)
12364 struct bfd_sym_chain *sym;
12366 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
12368 struct elf_link_hash_entry *h;
12370 h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
12371 FALSE, FALSE, FALSE);
12374 && (h->root.type == bfd_link_hash_defined
12375 || h->root.type == bfd_link_hash_defweak)
12376 && !bfd_is_abs_section (h->root.u.def.section))
12377 h->root.u.def.section->flags |= SEC_KEEP;
12381 /* Do mark and sweep of unused sections. */
12384 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
12386 bfd_boolean ok = TRUE;
12388 elf_gc_mark_hook_fn gc_mark_hook;
12389 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12390 struct elf_link_hash_table *htab;
12392 if (!bed->can_gc_sections
12393 || !is_elf_hash_table (info->hash))
12395 (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
12399 bed->gc_keep (info);
12400 htab = elf_hash_table (info);
12402 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
12403 at the .eh_frame section if we can mark the FDEs individually. */
12404 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12407 struct elf_reloc_cookie cookie;
12409 sec = bfd_get_section_by_name (sub, ".eh_frame");
12410 while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12412 _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12413 if (elf_section_data (sec)->sec_info
12414 && (sec->flags & SEC_LINKER_CREATED) == 0)
12415 elf_eh_frame_section (sub) = sec;
12416 fini_reloc_cookie_for_section (&cookie, sec);
12417 sec = bfd_get_next_section_by_name (sec);
12421 /* Apply transitive closure to the vtable entry usage info. */
12422 elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok);
12426 /* Kill the vtable relocations that were not used. */
12427 elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok);
12431 /* Mark dynamically referenced symbols. */
12432 if (htab->dynamic_sections_created)
12433 elf_link_hash_traverse (htab, bed->gc_mark_dynamic_ref, info);
12435 /* Grovel through relocs to find out who stays ... */
12436 gc_mark_hook = bed->gc_mark_hook;
12437 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12441 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12444 /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12445 Also treat note sections as a root, if the section is not part
12447 for (o = sub->sections; o != NULL; o = o->next)
12449 && (o->flags & SEC_EXCLUDE) == 0
12450 && ((o->flags & SEC_KEEP) != 0
12451 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12452 && elf_next_in_group (o) == NULL )))
12454 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12459 /* Allow the backend to mark additional target specific sections. */
12460 bed->gc_mark_extra_sections (info, gc_mark_hook);
12462 /* ... and mark SEC_EXCLUDE for those that go. */
12463 return elf_gc_sweep (abfd, info);
12466 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */
12469 bfd_elf_gc_record_vtinherit (bfd *abfd,
12471 struct elf_link_hash_entry *h,
12474 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12475 struct elf_link_hash_entry **search, *child;
12476 bfd_size_type extsymcount;
12477 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12479 /* The sh_info field of the symtab header tells us where the
12480 external symbols start. We don't care about the local symbols at
12482 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12483 if (!elf_bad_symtab (abfd))
12484 extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12486 sym_hashes = elf_sym_hashes (abfd);
12487 sym_hashes_end = sym_hashes + extsymcount;
12489 /* Hunt down the child symbol, which is in this section at the same
12490 offset as the relocation. */
12491 for (search = sym_hashes; search != sym_hashes_end; ++search)
12493 if ((child = *search) != NULL
12494 && (child->root.type == bfd_link_hash_defined
12495 || child->root.type == bfd_link_hash_defweak)
12496 && child->root.u.def.section == sec
12497 && child->root.u.def.value == offset)
12501 (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12502 abfd, sec, (unsigned long) offset);
12503 bfd_set_error (bfd_error_invalid_operation);
12507 if (!child->vtable)
12509 child->vtable = ((struct elf_link_virtual_table_entry *)
12510 bfd_zalloc (abfd, sizeof (*child->vtable)));
12511 if (!child->vtable)
12516 /* This *should* only be the absolute section. It could potentially
12517 be that someone has defined a non-global vtable though, which
12518 would be bad. It isn't worth paging in the local symbols to be
12519 sure though; that case should simply be handled by the assembler. */
12521 child->vtable->parent = (struct elf_link_hash_entry *) -1;
12524 child->vtable->parent = h;
12529 /* Called from check_relocs to record the existence of a VTENTRY reloc. */
12532 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12533 asection *sec ATTRIBUTE_UNUSED,
12534 struct elf_link_hash_entry *h,
12537 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12538 unsigned int log_file_align = bed->s->log_file_align;
12542 h->vtable = ((struct elf_link_virtual_table_entry *)
12543 bfd_zalloc (abfd, sizeof (*h->vtable)));
12548 if (addend >= h->vtable->size)
12550 size_t size, bytes, file_align;
12551 bfd_boolean *ptr = h->vtable->used;
12553 /* While the symbol is undefined, we have to be prepared to handle
12555 file_align = 1 << log_file_align;
12556 if (h->root.type == bfd_link_hash_undefined)
12557 size = addend + file_align;
12561 if (addend >= size)
12563 /* Oops! We've got a reference past the defined end of
12564 the table. This is probably a bug -- shall we warn? */
12565 size = addend + file_align;
12568 size = (size + file_align - 1) & -file_align;
12570 /* Allocate one extra entry for use as a "done" flag for the
12571 consolidation pass. */
12572 bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
12576 ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
12582 oldbytes = (((h->vtable->size >> log_file_align) + 1)
12583 * sizeof (bfd_boolean));
12584 memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
12588 ptr = (bfd_boolean *) bfd_zmalloc (bytes);
12593 /* And arrange for that done flag to be at index -1. */
12594 h->vtable->used = ptr + 1;
12595 h->vtable->size = size;
12598 h->vtable->used[addend >> log_file_align] = TRUE;
12603 /* Map an ELF section header flag to its corresponding string. */
12607 flagword flag_value;
12608 } elf_flags_to_name_table;
12610 static elf_flags_to_name_table elf_flags_to_names [] =
12612 { "SHF_WRITE", SHF_WRITE },
12613 { "SHF_ALLOC", SHF_ALLOC },
12614 { "SHF_EXECINSTR", SHF_EXECINSTR },
12615 { "SHF_MERGE", SHF_MERGE },
12616 { "SHF_STRINGS", SHF_STRINGS },
12617 { "SHF_INFO_LINK", SHF_INFO_LINK},
12618 { "SHF_LINK_ORDER", SHF_LINK_ORDER},
12619 { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
12620 { "SHF_GROUP", SHF_GROUP },
12621 { "SHF_TLS", SHF_TLS },
12622 { "SHF_MASKOS", SHF_MASKOS },
12623 { "SHF_EXCLUDE", SHF_EXCLUDE },
12626 /* Returns TRUE if the section is to be included, otherwise FALSE. */
12628 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
12629 struct flag_info *flaginfo,
12632 const bfd_vma sh_flags = elf_section_flags (section);
12634 if (!flaginfo->flags_initialized)
12636 bfd *obfd = info->output_bfd;
12637 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12638 struct flag_info_list *tf = flaginfo->flag_list;
12640 int without_hex = 0;
12642 for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
12645 flagword (*lookup) (char *);
12647 lookup = bed->elf_backend_lookup_section_flags_hook;
12648 if (lookup != NULL)
12650 flagword hexval = (*lookup) ((char *) tf->name);
12654 if (tf->with == with_flags)
12655 with_hex |= hexval;
12656 else if (tf->with == without_flags)
12657 without_hex |= hexval;
12662 for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
12664 if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
12666 if (tf->with == with_flags)
12667 with_hex |= elf_flags_to_names[i].flag_value;
12668 else if (tf->with == without_flags)
12669 without_hex |= elf_flags_to_names[i].flag_value;
12676 info->callbacks->einfo
12677 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
12681 flaginfo->flags_initialized = TRUE;
12682 flaginfo->only_with_flags |= with_hex;
12683 flaginfo->not_with_flags |= without_hex;
12686 if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
12689 if ((flaginfo->not_with_flags & sh_flags) != 0)
12695 struct alloc_got_off_arg {
12697 struct bfd_link_info *info;
12700 /* We need a special top-level link routine to convert got reference counts
12701 to real got offsets. */
12704 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
12706 struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
12707 bfd *obfd = gofarg->info->output_bfd;
12708 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12710 if (h->got.refcount > 0)
12712 h->got.offset = gofarg->gotoff;
12713 gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
12716 h->got.offset = (bfd_vma) -1;
12721 /* And an accompanying bit to work out final got entry offsets once
12722 we're done. Should be called from final_link. */
12725 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
12726 struct bfd_link_info *info)
12729 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12731 struct alloc_got_off_arg gofarg;
12733 BFD_ASSERT (abfd == info->output_bfd);
12735 if (! is_elf_hash_table (info->hash))
12738 /* The GOT offset is relative to the .got section, but the GOT header is
12739 put into the .got.plt section, if the backend uses it. */
12740 if (bed->want_got_plt)
12743 gotoff = bed->got_header_size;
12745 /* Do the local .got entries first. */
12746 for (i = info->input_bfds; i; i = i->link.next)
12748 bfd_signed_vma *local_got;
12749 bfd_size_type j, locsymcount;
12750 Elf_Internal_Shdr *symtab_hdr;
12752 if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12755 local_got = elf_local_got_refcounts (i);
12759 symtab_hdr = &elf_tdata (i)->symtab_hdr;
12760 if (elf_bad_symtab (i))
12761 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12763 locsymcount = symtab_hdr->sh_info;
12765 for (j = 0; j < locsymcount; ++j)
12767 if (local_got[j] > 0)
12769 local_got[j] = gotoff;
12770 gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12773 local_got[j] = (bfd_vma) -1;
12777 /* Then the global .got entries. .plt refcounts are handled by
12778 adjust_dynamic_symbol */
12779 gofarg.gotoff = gotoff;
12780 gofarg.info = info;
12781 elf_link_hash_traverse (elf_hash_table (info),
12782 elf_gc_allocate_got_offsets,
12787 /* Many folk need no more in the way of final link than this, once
12788 got entry reference counting is enabled. */
12791 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12793 if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12796 /* Invoke the regular ELF backend linker to do all the work. */
12797 return bfd_elf_final_link (abfd, info);
12801 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12803 struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12805 if (rcookie->bad_symtab)
12806 rcookie->rel = rcookie->rels;
12808 for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12810 unsigned long r_symndx;
12812 if (! rcookie->bad_symtab)
12813 if (rcookie->rel->r_offset > offset)
12815 if (rcookie->rel->r_offset != offset)
12818 r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12819 if (r_symndx == STN_UNDEF)
12822 if (r_symndx >= rcookie->locsymcount
12823 || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12825 struct elf_link_hash_entry *h;
12827 h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12829 while (h->root.type == bfd_link_hash_indirect
12830 || h->root.type == bfd_link_hash_warning)
12831 h = (struct elf_link_hash_entry *) h->root.u.i.link;
12833 if ((h->root.type == bfd_link_hash_defined
12834 || h->root.type == bfd_link_hash_defweak)
12835 && (h->root.u.def.section->owner != rcookie->abfd
12836 || h->root.u.def.section->kept_section != NULL
12837 || discarded_section (h->root.u.def.section)))
12842 /* It's not a relocation against a global symbol,
12843 but it could be a relocation against a local
12844 symbol for a discarded section. */
12846 Elf_Internal_Sym *isym;
12848 /* Need to: get the symbol; get the section. */
12849 isym = &rcookie->locsyms[r_symndx];
12850 isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12852 && (isec->kept_section != NULL
12853 || discarded_section (isec)))
12861 /* Discard unneeded references to discarded sections.
12862 Returns -1 on error, 1 if any section's size was changed, 0 if
12863 nothing changed. This function assumes that the relocations are in
12864 sorted order, which is true for all known assemblers. */
12867 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12869 struct elf_reloc_cookie cookie;
12874 if (info->traditional_format
12875 || !is_elf_hash_table (info->hash))
12878 o = bfd_get_section_by_name (output_bfd, ".stab");
12883 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12886 || i->reloc_count == 0
12887 || i->sec_info_type != SEC_INFO_TYPE_STABS)
12891 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12894 if (!init_reloc_cookie_for_section (&cookie, info, i))
12897 if (_bfd_discard_section_stabs (abfd, i,
12898 elf_section_data (i)->sec_info,
12899 bfd_elf_reloc_symbol_deleted_p,
12903 fini_reloc_cookie_for_section (&cookie, i);
12907 o = bfd_get_section_by_name (output_bfd, ".eh_frame");
12912 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12918 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12921 if (!init_reloc_cookie_for_section (&cookie, info, i))
12924 _bfd_elf_parse_eh_frame (abfd, info, i, &cookie);
12925 if (_bfd_elf_discard_section_eh_frame (abfd, info, i,
12926 bfd_elf_reloc_symbol_deleted_p,
12930 fini_reloc_cookie_for_section (&cookie, i);
12934 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
12936 const struct elf_backend_data *bed;
12938 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12941 bed = get_elf_backend_data (abfd);
12943 if (bed->elf_backend_discard_info != NULL)
12945 if (!init_reloc_cookie (&cookie, info, abfd))
12948 if ((*bed->elf_backend_discard_info) (abfd, &cookie, info))
12951 fini_reloc_cookie (&cookie, abfd);
12955 if (info->eh_frame_hdr
12956 && !info->relocatable
12957 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12964 _bfd_elf_section_already_linked (bfd *abfd,
12966 struct bfd_link_info *info)
12969 const char *name, *key;
12970 struct bfd_section_already_linked *l;
12971 struct bfd_section_already_linked_hash_entry *already_linked_list;
12973 if (sec->output_section == bfd_abs_section_ptr)
12976 flags = sec->flags;
12978 /* Return if it isn't a linkonce section. A comdat group section
12979 also has SEC_LINK_ONCE set. */
12980 if ((flags & SEC_LINK_ONCE) == 0)
12983 /* Don't put group member sections on our list of already linked
12984 sections. They are handled as a group via their group section. */
12985 if (elf_sec_group (sec) != NULL)
12988 /* For a SHT_GROUP section, use the group signature as the key. */
12990 if ((flags & SEC_GROUP) != 0
12991 && elf_next_in_group (sec) != NULL
12992 && elf_group_name (elf_next_in_group (sec)) != NULL)
12993 key = elf_group_name (elf_next_in_group (sec));
12996 /* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */
12997 if (CONST_STRNEQ (name, ".gnu.linkonce.")
12998 && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
13001 /* Must be a user linkonce section that doesn't follow gcc's
13002 naming convention. In this case we won't be matching
13003 single member groups. */
13007 already_linked_list = bfd_section_already_linked_table_lookup (key);
13009 for (l = already_linked_list->entry; l != NULL; l = l->next)
13011 /* We may have 2 different types of sections on the list: group
13012 sections with a signature of <key> (<key> is some string),
13013 and linkonce sections named .gnu.linkonce.<type>.<key>.
13014 Match like sections. LTO plugin sections are an exception.
13015 They are always named .gnu.linkonce.t.<key> and match either
13016 type of section. */
13017 if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
13018 && ((flags & SEC_GROUP) != 0
13019 || strcmp (name, l->sec->name) == 0))
13020 || (l->sec->owner->flags & BFD_PLUGIN) != 0)
13022 /* The section has already been linked. See if we should
13023 issue a warning. */
13024 if (!_bfd_handle_already_linked (sec, l, info))
13027 if (flags & SEC_GROUP)
13029 asection *first = elf_next_in_group (sec);
13030 asection *s = first;
13034 s->output_section = bfd_abs_section_ptr;
13035 /* Record which group discards it. */
13036 s->kept_section = l->sec;
13037 s = elf_next_in_group (s);
13038 /* These lists are circular. */
13048 /* A single member comdat group section may be discarded by a
13049 linkonce section and vice versa. */
13050 if ((flags & SEC_GROUP) != 0)
13052 asection *first = elf_next_in_group (sec);
13054 if (first != NULL && elf_next_in_group (first) == first)
13055 /* Check this single member group against linkonce sections. */
13056 for (l = already_linked_list->entry; l != NULL; l = l->next)
13057 if ((l->sec->flags & SEC_GROUP) == 0
13058 && bfd_elf_match_symbols_in_sections (l->sec, first, info))
13060 first->output_section = bfd_abs_section_ptr;
13061 first->kept_section = l->sec;
13062 sec->output_section = bfd_abs_section_ptr;
13067 /* Check this linkonce section against single member groups. */
13068 for (l = already_linked_list->entry; l != NULL; l = l->next)
13069 if (l->sec->flags & SEC_GROUP)
13071 asection *first = elf_next_in_group (l->sec);
13074 && elf_next_in_group (first) == first
13075 && bfd_elf_match_symbols_in_sections (first, sec, info))
13077 sec->output_section = bfd_abs_section_ptr;
13078 sec->kept_section = first;
13083 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
13084 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
13085 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
13086 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
13087 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
13088 but its `.gnu.linkonce.t.F' is discarded means we chose one-only
13089 `.gnu.linkonce.t.F' section from a different bfd not requiring any
13090 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
13091 The reverse order cannot happen as there is never a bfd with only the
13092 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not
13093 matter as here were are looking only for cross-bfd sections. */
13095 if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
13096 for (l = already_linked_list->entry; l != NULL; l = l->next)
13097 if ((l->sec->flags & SEC_GROUP) == 0
13098 && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
13100 if (abfd != l->sec->owner)
13101 sec->output_section = bfd_abs_section_ptr;
13105 /* This is the first section with this name. Record it. */
13106 if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
13107 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
13108 return sec->output_section == bfd_abs_section_ptr;
13112 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
13114 return sym->st_shndx == SHN_COMMON;
13118 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
13124 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
13126 return bfd_com_section_ptr;
13130 _bfd_elf_default_got_elt_size (bfd *abfd,
13131 struct bfd_link_info *info ATTRIBUTE_UNUSED,
13132 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
13133 bfd *ibfd ATTRIBUTE_UNUSED,
13134 unsigned long symndx ATTRIBUTE_UNUSED)
13136 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13137 return bed->s->arch_size / 8;
13140 /* Routines to support the creation of dynamic relocs. */
13142 /* Returns the name of the dynamic reloc section associated with SEC. */
13144 static const char *
13145 get_dynamic_reloc_section_name (bfd * abfd,
13147 bfd_boolean is_rela)
13150 const char *old_name = bfd_get_section_name (NULL, sec);
13151 const char *prefix = is_rela ? ".rela" : ".rel";
13153 if (old_name == NULL)
13156 name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
13157 sprintf (name, "%s%s", prefix, old_name);
13162 /* Returns the dynamic reloc section associated with SEC.
13163 If necessary compute the name of the dynamic reloc section based
13164 on SEC's name (looked up in ABFD's string table) and the setting
13168 _bfd_elf_get_dynamic_reloc_section (bfd * abfd,
13170 bfd_boolean is_rela)
13172 asection * reloc_sec = elf_section_data (sec)->sreloc;
13174 if (reloc_sec == NULL)
13176 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13180 reloc_sec = bfd_get_linker_section (abfd, name);
13182 if (reloc_sec != NULL)
13183 elf_section_data (sec)->sreloc = reloc_sec;
13190 /* Returns the dynamic reloc section associated with SEC. If the
13191 section does not exist it is created and attached to the DYNOBJ
13192 bfd and stored in the SRELOC field of SEC's elf_section_data
13195 ALIGNMENT is the alignment for the newly created section and
13196 IS_RELA defines whether the name should be .rela.<SEC's name>
13197 or .rel.<SEC's name>. The section name is looked up in the
13198 string table associated with ABFD. */
13201 _bfd_elf_make_dynamic_reloc_section (asection *sec,
13203 unsigned int alignment,
13205 bfd_boolean is_rela)
13207 asection * reloc_sec = elf_section_data (sec)->sreloc;
13209 if (reloc_sec == NULL)
13211 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13216 reloc_sec = bfd_get_linker_section (dynobj, name);
13218 if (reloc_sec == NULL)
13220 flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY
13221 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
13222 if ((sec->flags & SEC_ALLOC) != 0)
13223 flags |= SEC_ALLOC | SEC_LOAD;
13225 reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
13226 if (reloc_sec != NULL)
13228 /* _bfd_elf_get_sec_type_attr chooses a section type by
13229 name. Override as it may be wrong, eg. for a user
13230 section named "auto" we'll get ".relauto" which is
13231 seen to be a .rela section. */
13232 elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
13233 if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
13238 elf_section_data (sec)->sreloc = reloc_sec;
13244 /* Copy the ELF symbol type and other attributes for a linker script
13245 assignment from HSRC to HDEST. Generally this should be treated as
13246 if we found a strong non-dynamic definition for HDEST (except that
13247 ld ignores multiple definition errors). */
13249 _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
13250 struct bfd_link_hash_entry *hdest,
13251 struct bfd_link_hash_entry *hsrc)
13253 struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *) hdest;
13254 struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *) hsrc;
13255 Elf_Internal_Sym isym;
13257 ehdest->type = ehsrc->type;
13258 ehdest->target_internal = ehsrc->target_internal;
13260 isym.st_other = ehsrc->other;
13261 elf_merge_st_other (abfd, ehdest, &isym, TRUE, FALSE);
13264 /* Append a RELA relocation REL to section S in BFD. */
13267 elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13269 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13270 bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
13271 BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
13272 bed->s->swap_reloca_out (abfd, rel, loc);
13275 /* Append a REL relocation REL to section S in BFD. */
13278 elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13280 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13281 bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
13282 BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
13283 bed->s->swap_reloc_out (abfd, rel, loc);