2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* ELF linker code. */
23 /* This struct is used to pass information to routines called via
24 elf_link_hash_traverse which must return failure. */
26 struct elf_info_failed
29 struct bfd_link_info *info;
30 struct bfd_elf_version_tree *verdefs;
33 static boolean is_global_data_symbol_definition
34 PARAMS ((bfd *, Elf_Internal_Sym *));
35 static boolean elf_link_is_defined_archive_symbol
36 PARAMS ((bfd *, carsym *));
37 static boolean elf_link_add_object_symbols
38 PARAMS ((bfd *, struct bfd_link_info *));
39 static boolean elf_link_add_archive_symbols
40 PARAMS ((bfd *, struct bfd_link_info *));
41 static boolean elf_merge_symbol
42 PARAMS ((bfd *, struct bfd_link_info *, const char *,
43 Elf_Internal_Sym *, asection **, bfd_vma *,
44 struct elf_link_hash_entry **, boolean *, boolean *,
46 static boolean elf_add_default_symbol
47 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
48 const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
49 boolean *, boolean, boolean));
50 static boolean elf_export_symbol
51 PARAMS ((struct elf_link_hash_entry *, PTR));
52 static boolean elf_finalize_dynstr
53 PARAMS ((bfd *, struct bfd_link_info *));
54 static boolean elf_fix_symbol_flags
55 PARAMS ((struct elf_link_hash_entry *, struct elf_info_failed *));
56 static boolean elf_adjust_dynamic_symbol
57 PARAMS ((struct elf_link_hash_entry *, PTR));
58 static boolean elf_link_find_version_dependencies
59 PARAMS ((struct elf_link_hash_entry *, PTR));
60 static boolean elf_link_assign_sym_version
61 PARAMS ((struct elf_link_hash_entry *, PTR));
62 static boolean elf_collect_hash_codes
63 PARAMS ((struct elf_link_hash_entry *, PTR));
64 static boolean elf_link_read_relocs_from_section
65 PARAMS ((bfd *, Elf_Internal_Shdr *, PTR, Elf_Internal_Rela *));
66 static size_t compute_bucket_count
67 PARAMS ((struct bfd_link_info *));
68 static boolean elf_link_output_relocs
69 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *));
70 static boolean elf_link_size_reloc_section
71 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
72 static void elf_link_adjust_relocs
73 PARAMS ((bfd *, Elf_Internal_Shdr *, unsigned int,
74 struct elf_link_hash_entry **));
75 static int elf_link_sort_cmp1
76 PARAMS ((const void *, const void *));
77 static int elf_link_sort_cmp2
78 PARAMS ((const void *, const void *));
79 static size_t elf_link_sort_relocs
80 PARAMS ((bfd *, struct bfd_link_info *, asection **));
81 static boolean elf_section_ignore_discarded_relocs
82 PARAMS ((asection *));
84 /* Given an ELF BFD, add symbols to the global hash table as
88 elf_bfd_link_add_symbols (abfd, info)
90 struct bfd_link_info *info;
92 switch (bfd_get_format (abfd))
95 return elf_link_add_object_symbols (abfd, info);
97 return elf_link_add_archive_symbols (abfd, info);
99 bfd_set_error (bfd_error_wrong_format);
104 /* Return true iff this is a non-common, definition of a non-function symbol. */
106 is_global_data_symbol_definition (abfd, sym)
107 bfd * abfd ATTRIBUTE_UNUSED;
108 Elf_Internal_Sym * sym;
110 /* Local symbols do not count, but target specific ones might. */
111 if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
112 && ELF_ST_BIND (sym->st_info) < STB_LOOS)
115 /* Function symbols do not count. */
116 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
119 /* If the section is undefined, then so is the symbol. */
120 if (sym->st_shndx == SHN_UNDEF)
123 /* If the symbol is defined in the common section, then
124 it is a common definition and so does not count. */
125 if (sym->st_shndx == SHN_COMMON)
128 /* If the symbol is in a target specific section then we
129 must rely upon the backend to tell us what it is. */
130 if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
131 /* FIXME - this function is not coded yet:
133 return _bfd_is_global_symbol_definition (abfd, sym);
135 Instead for now assume that the definition is not global,
136 Even if this is wrong, at least the linker will behave
137 in the same way that it used to do. */
143 /* Search the symbol table of the archive element of the archive ABFD
144 whose archive map contains a mention of SYMDEF, and determine if
145 the symbol is defined in this element. */
147 elf_link_is_defined_archive_symbol (abfd, symdef)
151 Elf_Internal_Shdr * hdr;
152 bfd_size_type symcount;
153 bfd_size_type extsymcount;
154 bfd_size_type extsymoff;
155 Elf_Internal_Sym *isymbuf;
156 Elf_Internal_Sym *isym;
157 Elf_Internal_Sym *isymend;
160 abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
161 if (abfd == (bfd *) NULL)
164 if (! bfd_check_format (abfd, bfd_object))
167 /* If we have already included the element containing this symbol in the
168 link then we do not need to include it again. Just claim that any symbol
169 it contains is not a definition, so that our caller will not decide to
170 (re)include this element. */
171 if (abfd->archive_pass)
174 /* Select the appropriate symbol table. */
175 if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
176 hdr = &elf_tdata (abfd)->symtab_hdr;
178 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
180 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
182 /* The sh_info field of the symtab header tells us where the
183 external symbols start. We don't care about the local symbols. */
184 if (elf_bad_symtab (abfd))
186 extsymcount = symcount;
191 extsymcount = symcount - hdr->sh_info;
192 extsymoff = hdr->sh_info;
195 if (extsymcount == 0)
198 /* Read in the symbol table. */
199 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
204 /* Scan the symbol table looking for SYMDEF. */
206 for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
210 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
212 if (name == (const char *) NULL)
215 if (strcmp (name, symdef->name) == 0)
217 result = is_global_data_symbol_definition (abfd, isym);
227 /* Add symbols from an ELF archive file to the linker hash table. We
228 don't use _bfd_generic_link_add_archive_symbols because of a
229 problem which arises on UnixWare. The UnixWare libc.so is an
230 archive which includes an entry libc.so.1 which defines a bunch of
231 symbols. The libc.so archive also includes a number of other
232 object files, which also define symbols, some of which are the same
233 as those defined in libc.so.1. Correct linking requires that we
234 consider each object file in turn, and include it if it defines any
235 symbols we need. _bfd_generic_link_add_archive_symbols does not do
236 this; it looks through the list of undefined symbols, and includes
237 any object file which defines them. When this algorithm is used on
238 UnixWare, it winds up pulling in libc.so.1 early and defining a
239 bunch of symbols. This means that some of the other objects in the
240 archive are not included in the link, which is incorrect since they
241 precede libc.so.1 in the archive.
243 Fortunately, ELF archive handling is simpler than that done by
244 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
245 oddities. In ELF, if we find a symbol in the archive map, and the
246 symbol is currently undefined, we know that we must pull in that
249 Unfortunately, we do have to make multiple passes over the symbol
250 table until nothing further is resolved. */
253 elf_link_add_archive_symbols (abfd, info)
255 struct bfd_link_info *info;
258 boolean *defined = NULL;
259 boolean *included = NULL;
264 if (! bfd_has_map (abfd))
266 /* An empty archive is a special case. */
267 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
269 bfd_set_error (bfd_error_no_armap);
273 /* Keep track of all symbols we know to be already defined, and all
274 files we know to be already included. This is to speed up the
275 second and subsequent passes. */
276 c = bfd_ardata (abfd)->symdef_count;
280 amt *= sizeof (boolean);
281 defined = (boolean *) bfd_zmalloc (amt);
282 included = (boolean *) bfd_zmalloc (amt);
283 if (defined == (boolean *) NULL || included == (boolean *) NULL)
286 symdefs = bfd_ardata (abfd)->symdefs;
299 symdefend = symdef + c;
300 for (i = 0; symdef < symdefend; symdef++, i++)
302 struct elf_link_hash_entry *h;
304 struct bfd_link_hash_entry *undefs_tail;
307 if (defined[i] || included[i])
309 if (symdef->file_offset == last)
315 h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
316 false, false, false);
323 /* If this is a default version (the name contains @@),
324 look up the symbol again with only one `@' as well
325 as without the version. The effect is that references
326 to the symbol with and without the version will be
327 matched by the default symbol in the archive. */
329 p = strchr (symdef->name, ELF_VER_CHR);
330 if (p == NULL || p[1] != ELF_VER_CHR)
333 /* First check with only one `@'. */
334 len = strlen (symdef->name);
335 copy = bfd_alloc (abfd, (bfd_size_type) len);
338 first = p - symdef->name + 1;
339 memcpy (copy, symdef->name, first);
340 memcpy (copy + first, symdef->name + first + 1, len - first);
342 h = elf_link_hash_lookup (elf_hash_table (info), copy,
343 false, false, false);
347 /* We also need to check references to the symbol
348 without the version. */
350 copy[first - 1] = '\0';
351 h = elf_link_hash_lookup (elf_hash_table (info),
352 copy, false, false, false);
355 bfd_release (abfd, copy);
361 if (h->root.type == bfd_link_hash_common)
363 /* We currently have a common symbol. The archive map contains
364 a reference to this symbol, so we may want to include it. We
365 only want to include it however, if this archive element
366 contains a definition of the symbol, not just another common
369 Unfortunately some archivers (including GNU ar) will put
370 declarations of common symbols into their archive maps, as
371 well as real definitions, so we cannot just go by the archive
372 map alone. Instead we must read in the element's symbol
373 table and check that to see what kind of symbol definition
375 if (! elf_link_is_defined_archive_symbol (abfd, symdef))
378 else if (h->root.type != bfd_link_hash_undefined)
380 if (h->root.type != bfd_link_hash_undefweak)
385 /* We need to include this archive member. */
386 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
387 if (element == (bfd *) NULL)
390 if (! bfd_check_format (element, bfd_object))
393 /* Doublecheck that we have not included this object
394 already--it should be impossible, but there may be
395 something wrong with the archive. */
396 if (element->archive_pass != 0)
398 bfd_set_error (bfd_error_bad_value);
401 element->archive_pass = 1;
403 undefs_tail = info->hash->undefs_tail;
405 if (! (*info->callbacks->add_archive_element) (info, element,
408 if (! elf_link_add_object_symbols (element, info))
411 /* If there are any new undefined symbols, we need to make
412 another pass through the archive in order to see whether
413 they can be defined. FIXME: This isn't perfect, because
414 common symbols wind up on undefs_tail and because an
415 undefined symbol which is defined later on in this pass
416 does not require another pass. This isn't a bug, but it
417 does make the code less efficient than it could be. */
418 if (undefs_tail != info->hash->undefs_tail)
421 /* Look backward to mark all symbols from this object file
422 which we have already seen in this pass. */
426 included[mark] = true;
431 while (symdefs[mark].file_offset == symdef->file_offset);
433 /* We mark subsequent symbols from this object file as we go
434 on through the loop. */
435 last = symdef->file_offset;
446 if (defined != (boolean *) NULL)
448 if (included != (boolean *) NULL)
453 /* This function is called when we want to define a new symbol. It
454 handles the various cases which arise when we find a definition in
455 a dynamic object, or when there is already a definition in a
456 dynamic object. The new symbol is described by NAME, SYM, PSEC,
457 and PVALUE. We set SYM_HASH to the hash table entry. We set
458 OVERRIDE if the old symbol is overriding a new definition. We set
459 TYPE_CHANGE_OK if it is OK for the type to change. We set
460 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
461 change, we mean that we shouldn't warn if the type or size does
462 change. DT_NEEDED indicates if it comes from a DT_NEEDED entry of
466 elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash,
467 override, type_change_ok, size_change_ok, dt_needed)
469 struct bfd_link_info *info;
471 Elf_Internal_Sym *sym;
474 struct elf_link_hash_entry **sym_hash;
476 boolean *type_change_ok;
477 boolean *size_change_ok;
481 struct elf_link_hash_entry *h;
484 boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
489 bind = ELF_ST_BIND (sym->st_info);
491 if (! bfd_is_und_section (sec))
492 h = elf_link_hash_lookup (elf_hash_table (info), name, true, false, false);
494 h = ((struct elf_link_hash_entry *)
495 bfd_wrapped_link_hash_lookup (abfd, info, name, true, false, false));
500 /* This code is for coping with dynamic objects, and is only useful
501 if we are doing an ELF link. */
502 if (info->hash->creator != abfd->xvec)
505 /* For merging, we only care about real symbols. */
507 while (h->root.type == bfd_link_hash_indirect
508 || h->root.type == bfd_link_hash_warning)
509 h = (struct elf_link_hash_entry *) h->root.u.i.link;
511 /* If we just created the symbol, mark it as being an ELF symbol.
512 Other than that, there is nothing to do--there is no merge issue
513 with a newly defined symbol--so we just return. */
515 if (h->root.type == bfd_link_hash_new)
517 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
521 /* OLDBFD is a BFD associated with the existing symbol. */
523 switch (h->root.type)
529 case bfd_link_hash_undefined:
530 case bfd_link_hash_undefweak:
531 oldbfd = h->root.u.undef.abfd;
534 case bfd_link_hash_defined:
535 case bfd_link_hash_defweak:
536 oldbfd = h->root.u.def.section->owner;
539 case bfd_link_hash_common:
540 oldbfd = h->root.u.c.p->section->owner;
544 /* In cases involving weak versioned symbols, we may wind up trying
545 to merge a symbol with itself. Catch that here, to avoid the
546 confusion that results if we try to override a symbol with
547 itself. The additional tests catch cases like
548 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
549 dynamic object, which we do want to handle here. */
551 && ((abfd->flags & DYNAMIC) == 0
552 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0))
555 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
556 respectively, is from a dynamic object. */
558 if ((abfd->flags & DYNAMIC) != 0)
564 olddyn = (oldbfd->flags & DYNAMIC) != 0;
569 /* This code handles the special SHN_MIPS_{TEXT,DATA} section
570 indices used by MIPS ELF. */
571 switch (h->root.type)
577 case bfd_link_hash_defined:
578 case bfd_link_hash_defweak:
579 hsec = h->root.u.def.section;
582 case bfd_link_hash_common:
583 hsec = h->root.u.c.p->section;
590 olddyn = (hsec->symbol->flags & BSF_DYNAMIC) != 0;
593 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
594 respectively, appear to be a definition rather than reference. */
596 if (bfd_is_und_section (sec) || bfd_is_com_section (sec))
601 if (h->root.type == bfd_link_hash_undefined
602 || h->root.type == bfd_link_hash_undefweak
603 || h->root.type == bfd_link_hash_common)
608 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
609 symbol, respectively, appears to be a common symbol in a dynamic
610 object. If a symbol appears in an uninitialized section, and is
611 not weak, and is not a function, then it may be a common symbol
612 which was resolved when the dynamic object was created. We want
613 to treat such symbols specially, because they raise special
614 considerations when setting the symbol size: if the symbol
615 appears as a common symbol in a regular object, and the size in
616 the regular object is larger, we must make sure that we use the
617 larger size. This problematic case can always be avoided in C,
618 but it must be handled correctly when using Fortran shared
621 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
622 likewise for OLDDYNCOMMON and OLDDEF.
624 Note that this test is just a heuristic, and that it is quite
625 possible to have an uninitialized symbol in a shared object which
626 is really a definition, rather than a common symbol. This could
627 lead to some minor confusion when the symbol really is a common
628 symbol in some regular object. However, I think it will be
633 && (sec->flags & SEC_ALLOC) != 0
634 && (sec->flags & SEC_LOAD) == 0
637 && ELF_ST_TYPE (sym->st_info) != STT_FUNC)
640 newdyncommon = false;
644 && h->root.type == bfd_link_hash_defined
645 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
646 && (h->root.u.def.section->flags & SEC_ALLOC) != 0
647 && (h->root.u.def.section->flags & SEC_LOAD) == 0
649 && h->type != STT_FUNC)
652 olddyncommon = false;
654 /* It's OK to change the type if either the existing symbol or the
655 new symbol is weak unless it comes from a DT_NEEDED entry of
656 a shared object, in which case, the DT_NEEDED entry may not be
657 required at the run time. */
659 if ((! dt_needed && h->root.type == bfd_link_hash_defweak)
660 || h->root.type == bfd_link_hash_undefweak
662 *type_change_ok = true;
664 /* It's OK to change the size if either the existing symbol or the
665 new symbol is weak, or if the old symbol is undefined. */
668 || h->root.type == bfd_link_hash_undefined)
669 *size_change_ok = true;
671 /* If both the old and the new symbols look like common symbols in a
672 dynamic object, set the size of the symbol to the larger of the
677 && sym->st_size != h->size)
679 /* Since we think we have two common symbols, issue a multiple
680 common warning if desired. Note that we only warn if the
681 size is different. If the size is the same, we simply let
682 the old symbol override the new one as normally happens with
683 symbols defined in dynamic objects. */
685 if (! ((*info->callbacks->multiple_common)
686 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
687 h->size, abfd, bfd_link_hash_common, sym->st_size)))
690 if (sym->st_size > h->size)
691 h->size = sym->st_size;
693 *size_change_ok = true;
696 /* If we are looking at a dynamic object, and we have found a
697 definition, we need to see if the symbol was already defined by
698 some other object. If so, we want to use the existing
699 definition, and we do not want to report a multiple symbol
700 definition error; we do this by clobbering *PSEC to be
703 We treat a common symbol as a definition if the symbol in the
704 shared library is a function, since common symbols always
705 represent variables; this can cause confusion in principle, but
706 any such confusion would seem to indicate an erroneous program or
707 shared library. We also permit a common symbol in a regular
708 object to override a weak symbol in a shared object.
710 We prefer a non-weak definition in a shared library to a weak
711 definition in the executable unless it comes from a DT_NEEDED
712 entry of a shared object, in which case, the DT_NEEDED entry
713 may not be required at the run time. */
718 || (h->root.type == bfd_link_hash_common
720 || ELF_ST_TYPE (sym->st_info) == STT_FUNC)))
721 && (h->root.type != bfd_link_hash_defweak
723 || bind == STB_WEAK))
727 newdyncommon = false;
729 *psec = sec = bfd_und_section_ptr;
730 *size_change_ok = true;
732 /* If we get here when the old symbol is a common symbol, then
733 we are explicitly letting it override a weak symbol or
734 function in a dynamic object, and we don't want to warn about
735 a type change. If the old symbol is a defined symbol, a type
736 change warning may still be appropriate. */
738 if (h->root.type == bfd_link_hash_common)
739 *type_change_ok = true;
742 /* Handle the special case of an old common symbol merging with a
743 new symbol which looks like a common symbol in a shared object.
744 We change *PSEC and *PVALUE to make the new symbol look like a
745 common symbol, and let _bfd_generic_link_add_one_symbol will do
749 && h->root.type == bfd_link_hash_common)
753 newdyncommon = false;
754 *pvalue = sym->st_size;
755 *psec = sec = bfd_com_section_ptr;
756 *size_change_ok = true;
759 /* If the old symbol is from a dynamic object, and the new symbol is
760 a definition which is not from a dynamic object, then the new
761 symbol overrides the old symbol. Symbols from regular files
762 always take precedence over symbols from dynamic objects, even if
763 they are defined after the dynamic object in the link.
765 As above, we again permit a common symbol in a regular object to
766 override a definition in a shared object if the shared object
767 symbol is a function or is weak.
769 As above, we permit a non-weak definition in a shared object to
770 override a weak definition in a regular object. */
774 || (bfd_is_com_section (sec)
775 && (h->root.type == bfd_link_hash_defweak
776 || h->type == STT_FUNC)))
779 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
781 || h->root.type == bfd_link_hash_defweak))
783 /* Change the hash table entry to undefined, and let
784 _bfd_generic_link_add_one_symbol do the right thing with the
787 h->root.type = bfd_link_hash_undefined;
788 h->root.u.undef.abfd = h->root.u.def.section->owner;
789 *size_change_ok = true;
792 olddyncommon = false;
794 /* We again permit a type change when a common symbol may be
795 overriding a function. */
797 if (bfd_is_com_section (sec))
798 *type_change_ok = true;
800 /* This union may have been set to be non-NULL when this symbol
801 was seen in a dynamic object. We must force the union to be
802 NULL, so that it is correct for a regular symbol. */
804 h->verinfo.vertree = NULL;
806 /* In this special case, if H is the target of an indirection,
807 we want the caller to frob with H rather than with the
808 indirect symbol. That will permit the caller to redefine the
809 target of the indirection, rather than the indirect symbol
810 itself. FIXME: This will break the -y option if we store a
811 symbol with a different name. */
815 /* Handle the special case of a new common symbol merging with an
816 old symbol that looks like it might be a common symbol defined in
817 a shared object. Note that we have already handled the case in
818 which a new common symbol should simply override the definition
819 in the shared library. */
822 && bfd_is_com_section (sec)
825 /* It would be best if we could set the hash table entry to a
826 common symbol, but we don't know what to use for the section
828 if (! ((*info->callbacks->multiple_common)
829 (info, h->root.root.string, oldbfd, bfd_link_hash_common,
830 h->size, abfd, bfd_link_hash_common, sym->st_size)))
833 /* If the predumed common symbol in the dynamic object is
834 larger, pretend that the new symbol has its size. */
836 if (h->size > *pvalue)
839 /* FIXME: We no longer know the alignment required by the symbol
840 in the dynamic object, so we just wind up using the one from
841 the regular object. */
844 olddyncommon = false;
846 h->root.type = bfd_link_hash_undefined;
847 h->root.u.undef.abfd = h->root.u.def.section->owner;
849 *size_change_ok = true;
850 *type_change_ok = true;
852 h->verinfo.vertree = NULL;
855 /* Handle the special case of a weak definition in a regular object
856 followed by a non-weak definition in a shared object. In this
857 case, we prefer the definition in the shared object unless it
858 comes from a DT_NEEDED entry of a shared object, in which case,
859 the DT_NEEDED entry may not be required at the run time. */
862 && h->root.type == bfd_link_hash_defweak
867 /* To make this work we have to frob the flags so that the rest
868 of the code does not think we are using the regular
870 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
871 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
872 else if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
873 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
874 h->elf_link_hash_flags &= ~ (ELF_LINK_HASH_DEF_REGULAR
875 | ELF_LINK_HASH_DEF_DYNAMIC);
877 /* If H is the target of an indirection, we want the caller to
878 use H rather than the indirect symbol. Otherwise if we are
879 defining a new indirect symbol we will wind up attaching it
880 to the entry we are overriding. */
884 /* Handle the special case of a non-weak definition in a shared
885 object followed by a weak definition in a regular object. In
886 this case we prefer to definition in the shared object. To make
887 this work we have to tell the caller to not treat the new symbol
891 && h->root.type != bfd_link_hash_defweak
900 /* This function is called to create an indirect symbol from the
901 default for the symbol with the default version if needed. The
902 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We
903 set DYNSYM if the new indirect symbol is dynamic. DT_NEEDED
904 indicates if it comes from a DT_NEEDED entry of a shared object. */
907 elf_add_default_symbol (abfd, info, h, name, sym, psec, value,
908 dynsym, override, dt_needed)
910 struct bfd_link_info *info;
911 struct elf_link_hash_entry *h;
913 Elf_Internal_Sym *sym;
920 boolean type_change_ok;
921 boolean size_change_ok;
923 struct elf_link_hash_entry *hi;
924 struct bfd_link_hash_entry *bh;
925 struct elf_backend_data *bed;
929 size_t len, shortlen;
932 /* If this symbol has a version, and it is the default version, we
933 create an indirect symbol from the default name to the fully
934 decorated name. This will cause external references which do not
935 specify a version to be bound to this version of the symbol. */
936 p = strchr (name, ELF_VER_CHR);
937 if (p == NULL || p[1] != ELF_VER_CHR)
942 /* We are overridden by an old defition. We need to check if we
943 need to create the indirect symbol from the default name. */
944 hi = elf_link_hash_lookup (elf_hash_table (info), name, true,
946 BFD_ASSERT (hi != NULL);
949 while (hi->root.type == bfd_link_hash_indirect
950 || hi->root.type == bfd_link_hash_warning)
952 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
958 bed = get_elf_backend_data (abfd);
959 collect = bed->collect;
960 dynamic = (abfd->flags & DYNAMIC) != 0;
963 shortname = bfd_hash_allocate (&info->hash->table, shortlen + 1);
964 if (shortname == NULL)
966 memcpy (shortname, name, shortlen);
967 shortname[shortlen] = '\0';
969 /* We are going to create a new symbol. Merge it with any existing
970 symbol with this name. For the purposes of the merge, act as
971 though we were defining the symbol we just defined, although we
972 actually going to define an indirect symbol. */
973 type_change_ok = false;
974 size_change_ok = false;
976 if (! elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
977 &hi, &override, &type_change_ok,
978 &size_change_ok, dt_needed))
984 if (! (_bfd_generic_link_add_one_symbol
985 (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
986 (bfd_vma) 0, name, false, collect, &bh)))
988 hi = (struct elf_link_hash_entry *) bh;
992 /* In this case the symbol named SHORTNAME is overriding the
993 indirect symbol we want to add. We were planning on making
994 SHORTNAME an indirect symbol referring to NAME. SHORTNAME
995 is the name without a version. NAME is the fully versioned
996 name, and it is the default version.
998 Overriding means that we already saw a definition for the
999 symbol SHORTNAME in a regular object, and it is overriding
1000 the symbol defined in the dynamic object.
1002 When this happens, we actually want to change NAME, the
1003 symbol we just added, to refer to SHORTNAME. This will cause
1004 references to NAME in the shared object to become references
1005 to SHORTNAME in the regular object. This is what we expect
1006 when we override a function in a shared object: that the
1007 references in the shared object will be mapped to the
1008 definition in the regular object. */
1010 while (hi->root.type == bfd_link_hash_indirect
1011 || hi->root.type == bfd_link_hash_warning)
1012 hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1014 h->root.type = bfd_link_hash_indirect;
1015 h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1016 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
1018 h->elf_link_hash_flags &=~ ELF_LINK_HASH_DEF_DYNAMIC;
1019 hi->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
1020 if (hi->elf_link_hash_flags
1021 & (ELF_LINK_HASH_REF_REGULAR
1022 | ELF_LINK_HASH_DEF_REGULAR))
1024 if (! _bfd_elf_link_record_dynamic_symbol (info, hi))
1029 /* Now set HI to H, so that the following code will set the
1030 other fields correctly. */
1034 /* If there is a duplicate definition somewhere, then HI may not
1035 point to an indirect symbol. We will have reported an error to
1036 the user in that case. */
1038 if (hi->root.type == bfd_link_hash_indirect)
1040 struct elf_link_hash_entry *ht;
1042 /* If the symbol became indirect, then we assume that we have
1043 not seen a definition before. */
1044 BFD_ASSERT ((hi->elf_link_hash_flags
1045 & (ELF_LINK_HASH_DEF_DYNAMIC
1046 | ELF_LINK_HASH_DEF_REGULAR)) == 0);
1048 ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1049 (*bed->elf_backend_copy_indirect_symbol) (bed, ht, hi);
1051 /* See if the new flags lead us to realize that the symbol must
1058 || ((hi->elf_link_hash_flags
1059 & ELF_LINK_HASH_REF_DYNAMIC) != 0))
1064 if ((hi->elf_link_hash_flags
1065 & ELF_LINK_HASH_REF_REGULAR) != 0)
1071 /* We also need to define an indirection from the nondefault version
1074 len = strlen (name);
1075 shortname = bfd_hash_allocate (&info->hash->table, len);
1076 if (shortname == NULL)
1078 memcpy (shortname, name, shortlen);
1079 memcpy (shortname + shortlen, p + 1, len - shortlen);
1081 /* Once again, merge with any existing symbol. */
1082 type_change_ok = false;
1083 size_change_ok = false;
1085 if (! elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1086 &hi, &override, &type_change_ok,
1087 &size_change_ok, dt_needed))
1092 /* Here SHORTNAME is a versioned name, so we don't expect to see
1093 the type of override we do in the case above unless it is
1094 overridden by a versioned definiton. */
1095 if (hi->root.type != bfd_link_hash_defined
1096 && hi->root.type != bfd_link_hash_defweak)
1097 (*_bfd_error_handler)
1098 (_("%s: warning: unexpected redefinition of indirect versioned symbol `%s'"),
1099 bfd_archive_filename (abfd), shortname);
1104 if (! (_bfd_generic_link_add_one_symbol
1105 (info, abfd, shortname, BSF_INDIRECT,
1106 bfd_ind_section_ptr, (bfd_vma) 0, name, false, collect, &bh)))
1108 hi = (struct elf_link_hash_entry *) bh;
1110 /* If there is a duplicate definition somewhere, then HI may not
1111 point to an indirect symbol. We will have reported an error
1112 to the user in that case. */
1114 if (hi->root.type == bfd_link_hash_indirect)
1116 /* If the symbol became indirect, then we assume that we have
1117 not seen a definition before. */
1118 BFD_ASSERT ((hi->elf_link_hash_flags
1119 & (ELF_LINK_HASH_DEF_DYNAMIC
1120 | ELF_LINK_HASH_DEF_REGULAR)) == 0);
1122 (*bed->elf_backend_copy_indirect_symbol) (bed, h, hi);
1124 /* See if the new flags lead us to realize that the symbol
1131 || ((hi->elf_link_hash_flags
1132 & ELF_LINK_HASH_REF_DYNAMIC) != 0))
1137 if ((hi->elf_link_hash_flags
1138 & ELF_LINK_HASH_REF_REGULAR) != 0)
1148 /* Add symbols from an ELF object file to the linker hash table. */
1151 elf_link_add_object_symbols (abfd, info)
1153 struct bfd_link_info *info;
1155 boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
1156 const Elf_Internal_Sym *,
1157 const char **, flagword *,
1158 asection **, bfd_vma *));
1159 boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
1160 asection *, const Elf_Internal_Rela *));
1162 Elf_Internal_Shdr *hdr;
1163 bfd_size_type symcount;
1164 bfd_size_type extsymcount;
1165 bfd_size_type extsymoff;
1166 struct elf_link_hash_entry **sym_hash;
1168 Elf_External_Versym *extversym = NULL;
1169 Elf_External_Versym *ever;
1170 struct elf_link_hash_entry *weaks;
1171 Elf_Internal_Sym *isymbuf = NULL;
1172 Elf_Internal_Sym *isym;
1173 Elf_Internal_Sym *isymend;
1174 struct elf_backend_data *bed;
1176 struct elf_link_hash_table * hash_table;
1179 hash_table = elf_hash_table (info);
1181 bed = get_elf_backend_data (abfd);
1182 add_symbol_hook = bed->elf_add_symbol_hook;
1183 collect = bed->collect;
1185 if ((abfd->flags & DYNAMIC) == 0)
1191 /* You can't use -r against a dynamic object. Also, there's no
1192 hope of using a dynamic object which does not exactly match
1193 the format of the output file. */
1194 if (info->relocateable || info->hash->creator != abfd->xvec)
1196 bfd_set_error (bfd_error_invalid_operation);
1201 /* As a GNU extension, any input sections which are named
1202 .gnu.warning.SYMBOL are treated as warning symbols for the given
1203 symbol. This differs from .gnu.warning sections, which generate
1204 warnings when they are included in an output file. */
1209 for (s = abfd->sections; s != NULL; s = s->next)
1213 name = bfd_get_section_name (abfd, s);
1214 if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
1219 name += sizeof ".gnu.warning." - 1;
1221 /* If this is a shared object, then look up the symbol
1222 in the hash table. If it is there, and it is already
1223 been defined, then we will not be using the entry
1224 from this shared object, so we don't need to warn.
1225 FIXME: If we see the definition in a regular object
1226 later on, we will warn, but we shouldn't. The only
1227 fix is to keep track of what warnings we are supposed
1228 to emit, and then handle them all at the end of the
1230 if (dynamic && abfd->xvec == info->hash->creator)
1232 struct elf_link_hash_entry *h;
1234 h = elf_link_hash_lookup (hash_table, name,
1235 false, false, true);
1237 /* FIXME: What about bfd_link_hash_common? */
1239 && (h->root.type == bfd_link_hash_defined
1240 || h->root.type == bfd_link_hash_defweak))
1242 /* We don't want to issue this warning. Clobber
1243 the section size so that the warning does not
1244 get copied into the output file. */
1250 sz = bfd_section_size (abfd, s);
1251 msg = (char *) bfd_alloc (abfd, sz + 1);
1255 if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
1260 if (! (_bfd_generic_link_add_one_symbol
1261 (info, abfd, name, BSF_WARNING, s, (bfd_vma) 0, msg,
1262 false, collect, (struct bfd_link_hash_entry **) NULL)))
1265 if (! info->relocateable)
1267 /* Clobber the section size so that the warning does
1268 not get copied into the output file. */
1278 /* If we are creating a shared library, create all the dynamic
1279 sections immediately. We need to attach them to something,
1280 so we attach them to this BFD, provided it is the right
1281 format. FIXME: If there are no input BFD's of the same
1282 format as the output, we can't make a shared library. */
1284 && is_elf_hash_table (info)
1285 && ! hash_table->dynamic_sections_created
1286 && abfd->xvec == info->hash->creator)
1288 if (! elf_link_create_dynamic_sections (abfd, info))
1292 else if (! is_elf_hash_table (info))
1299 bfd_size_type oldsize;
1300 bfd_size_type strindex;
1301 struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
1303 /* ld --just-symbols and dynamic objects don't mix very well.
1304 Test for --just-symbols by looking at info set up by
1305 _bfd_elf_link_just_syms. */
1306 if ((s = abfd->sections) != NULL
1307 && elf_section_data (s)->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
1310 /* Find the name to use in a DT_NEEDED entry that refers to this
1311 object. If the object has a DT_SONAME entry, we use it.
1312 Otherwise, if the generic linker stuck something in
1313 elf_dt_name, we use that. Otherwise, we just use the file
1314 name. If the generic linker put a null string into
1315 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
1316 there is a DT_SONAME entry. */
1318 name = bfd_get_filename (abfd);
1319 if (elf_dt_name (abfd) != NULL)
1321 name = elf_dt_name (abfd);
1324 if (elf_dt_soname (abfd) != NULL)
1330 s = bfd_get_section_by_name (abfd, ".dynamic");
1333 Elf_External_Dyn *dynbuf = NULL;
1334 Elf_External_Dyn *extdyn;
1335 Elf_External_Dyn *extdynend;
1337 unsigned long shlink;
1339 dynbuf = (Elf_External_Dyn *) bfd_malloc (s->_raw_size);
1343 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
1344 (file_ptr) 0, s->_raw_size))
1345 goto error_free_dyn;
1347 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1349 goto error_free_dyn;
1350 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1353 extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
1354 for (; extdyn < extdynend; extdyn++)
1356 Elf_Internal_Dyn dyn;
1358 elf_swap_dyn_in (abfd, extdyn, &dyn);
1359 if (dyn.d_tag == DT_SONAME)
1361 unsigned int tagv = dyn.d_un.d_val;
1362 name = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1364 goto error_free_dyn;
1366 if (dyn.d_tag == DT_NEEDED)
1368 struct bfd_link_needed_list *n, **pn;
1370 unsigned int tagv = dyn.d_un.d_val;
1372 amt = sizeof (struct bfd_link_needed_list);
1373 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1374 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1375 if (n == NULL || fnm == NULL)
1376 goto error_free_dyn;
1377 amt = strlen (fnm) + 1;
1378 anm = bfd_alloc (abfd, amt);
1380 goto error_free_dyn;
1381 memcpy (anm, fnm, (size_t) amt);
1385 for (pn = & hash_table->needed;
1391 if (dyn.d_tag == DT_RUNPATH)
1393 struct bfd_link_needed_list *n, **pn;
1395 unsigned int tagv = dyn.d_un.d_val;
1397 amt = sizeof (struct bfd_link_needed_list);
1398 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1399 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1400 if (n == NULL || fnm == NULL)
1401 goto error_free_dyn;
1402 amt = strlen (fnm) + 1;
1403 anm = bfd_alloc (abfd, amt);
1405 goto error_free_dyn;
1406 memcpy (anm, fnm, (size_t) amt);
1410 for (pn = & runpath;
1416 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
1417 if (!runpath && dyn.d_tag == DT_RPATH)
1419 struct bfd_link_needed_list *n, **pn;
1421 unsigned int tagv = dyn.d_un.d_val;
1423 amt = sizeof (struct bfd_link_needed_list);
1424 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1425 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1426 if (n == NULL || fnm == NULL)
1427 goto error_free_dyn;
1428 amt = strlen (fnm) + 1;
1429 anm = bfd_alloc (abfd, amt);
1436 memcpy (anm, fnm, (size_t) amt);
1451 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
1452 frees all more recently bfd_alloc'd blocks as well. */
1458 struct bfd_link_needed_list **pn;
1459 for (pn = & hash_table->runpath;
1466 /* We do not want to include any of the sections in a dynamic
1467 object in the output file. We hack by simply clobbering the
1468 list of sections in the BFD. This could be handled more
1469 cleanly by, say, a new section flag; the existing
1470 SEC_NEVER_LOAD flag is not the one we want, because that one
1471 still implies that the section takes up space in the output
1473 bfd_section_list_clear (abfd);
1475 /* If this is the first dynamic object found in the link, create
1476 the special sections required for dynamic linking. */
1477 if (! hash_table->dynamic_sections_created)
1478 if (! elf_link_create_dynamic_sections (abfd, info))
1483 /* Add a DT_NEEDED entry for this dynamic object. */
1484 oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
1485 strindex = _bfd_elf_strtab_add (hash_table->dynstr, name, false);
1486 if (strindex == (bfd_size_type) -1)
1489 if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
1492 Elf_External_Dyn *dyncon, *dynconend;
1494 /* The hash table size did not change, which means that
1495 the dynamic object name was already entered. If we
1496 have already included this dynamic object in the
1497 link, just ignore it. There is no reason to include
1498 a particular dynamic object more than once. */
1499 sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
1500 BFD_ASSERT (sdyn != NULL);
1502 dyncon = (Elf_External_Dyn *) sdyn->contents;
1503 dynconend = (Elf_External_Dyn *) (sdyn->contents +
1505 for (; dyncon < dynconend; dyncon++)
1507 Elf_Internal_Dyn dyn;
1509 elf_swap_dyn_in (hash_table->dynobj, dyncon, & dyn);
1510 if (dyn.d_tag == DT_NEEDED
1511 && dyn.d_un.d_val == strindex)
1513 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
1519 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
1523 /* Save the SONAME, if there is one, because sometimes the
1524 linker emulation code will need to know it. */
1526 name = basename (bfd_get_filename (abfd));
1527 elf_dt_name (abfd) = name;
1530 /* If this is a dynamic object, we always link against the .dynsym
1531 symbol table, not the .symtab symbol table. The dynamic linker
1532 will only see the .dynsym symbol table, so there is no reason to
1533 look at .symtab for a dynamic object. */
1535 if (! dynamic || elf_dynsymtab (abfd) == 0)
1536 hdr = &elf_tdata (abfd)->symtab_hdr;
1538 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1540 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1542 /* The sh_info field of the symtab header tells us where the
1543 external symbols start. We don't care about the local symbols at
1545 if (elf_bad_symtab (abfd))
1547 extsymcount = symcount;
1552 extsymcount = symcount - hdr->sh_info;
1553 extsymoff = hdr->sh_info;
1557 if (extsymcount != 0)
1559 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
1561 if (isymbuf == NULL)
1564 /* We store a pointer to the hash table entry for each external
1566 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
1567 sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
1568 if (sym_hash == NULL)
1569 goto error_free_sym;
1570 elf_sym_hashes (abfd) = sym_hash;
1575 /* Read in any version definitions. */
1576 if (! _bfd_elf_slurp_version_tables (abfd))
1577 goto error_free_sym;
1579 /* Read in the symbol versions, but don't bother to convert them
1580 to internal format. */
1581 if (elf_dynversym (abfd) != 0)
1583 Elf_Internal_Shdr *versymhdr;
1585 versymhdr = &elf_tdata (abfd)->dynversym_hdr;
1586 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
1587 if (extversym == NULL)
1588 goto error_free_sym;
1589 amt = versymhdr->sh_size;
1590 if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
1591 || bfd_bread ((PTR) extversym, amt, abfd) != amt)
1592 goto error_free_vers;
1598 ever = extversym != NULL ? extversym + extsymoff : NULL;
1599 for (isym = isymbuf, isymend = isymbuf + extsymcount;
1601 isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
1608 struct elf_link_hash_entry *h;
1610 boolean size_change_ok, type_change_ok;
1611 boolean new_weakdef;
1612 unsigned int old_alignment;
1617 flags = BSF_NO_FLAGS;
1619 value = isym->st_value;
1622 bind = ELF_ST_BIND (isym->st_info);
1623 if (bind == STB_LOCAL)
1625 /* This should be impossible, since ELF requires that all
1626 global symbols follow all local symbols, and that sh_info
1627 point to the first global symbol. Unfortunatealy, Irix 5
1631 else if (bind == STB_GLOBAL)
1633 if (isym->st_shndx != SHN_UNDEF
1634 && isym->st_shndx != SHN_COMMON)
1637 else if (bind == STB_WEAK)
1641 /* Leave it up to the processor backend. */
1644 if (isym->st_shndx == SHN_UNDEF)
1645 sec = bfd_und_section_ptr;
1646 else if (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
1648 sec = section_from_elf_index (abfd, isym->st_shndx);
1650 sec = bfd_abs_section_ptr;
1651 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1654 else if (isym->st_shndx == SHN_ABS)
1655 sec = bfd_abs_section_ptr;
1656 else if (isym->st_shndx == SHN_COMMON)
1658 sec = bfd_com_section_ptr;
1659 /* What ELF calls the size we call the value. What ELF
1660 calls the value we call the alignment. */
1661 value = isym->st_size;
1665 /* Leave it up to the processor backend. */
1668 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
1670 if (name == (const char *) NULL)
1671 goto error_free_vers;
1673 if (isym->st_shndx == SHN_COMMON
1674 && ELF_ST_TYPE (isym->st_info) == STT_TLS)
1676 asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
1680 tcomm = bfd_make_section (abfd, ".tcommon");
1682 || !bfd_set_section_flags (abfd, tcomm, (SEC_ALLOC
1684 | SEC_LINKER_CREATED
1685 | SEC_THREAD_LOCAL)))
1686 goto error_free_vers;
1690 else if (add_symbol_hook)
1692 if (! (*add_symbol_hook) (abfd, info, isym, &name, &flags, &sec,
1694 goto error_free_vers;
1696 /* The hook function sets the name to NULL if this symbol
1697 should be skipped for some reason. */
1698 if (name == (const char *) NULL)
1702 /* Sanity check that all possibilities were handled. */
1703 if (sec == (asection *) NULL)
1705 bfd_set_error (bfd_error_bad_value);
1706 goto error_free_vers;
1709 if (bfd_is_und_section (sec)
1710 || bfd_is_com_section (sec))
1715 size_change_ok = false;
1716 type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
1718 if (info->hash->creator->flavour == bfd_target_elf_flavour)
1720 Elf_Internal_Versym iver;
1721 unsigned int vernum = 0;
1725 _bfd_elf_swap_versym_in (abfd, ever, &iver);
1726 vernum = iver.vs_vers & VERSYM_VERSION;
1728 /* If this is a hidden symbol, or if it is not version
1729 1, we append the version name to the symbol name.
1730 However, we do not modify a non-hidden absolute
1731 symbol, because it might be the version symbol
1732 itself. FIXME: What if it isn't? */
1733 if ((iver.vs_vers & VERSYM_HIDDEN) != 0
1734 || (vernum > 1 && ! bfd_is_abs_section (sec)))
1737 size_t namelen, verlen, newlen;
1740 if (isym->st_shndx != SHN_UNDEF)
1742 if (vernum > elf_tdata (abfd)->dynverdef_hdr.sh_info)
1744 (*_bfd_error_handler)
1745 (_("%s: %s: invalid version %u (max %d)"),
1746 bfd_archive_filename (abfd), name, vernum,
1747 elf_tdata (abfd)->dynverdef_hdr.sh_info);
1748 bfd_set_error (bfd_error_bad_value);
1749 goto error_free_vers;
1751 else if (vernum > 1)
1753 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1759 /* We cannot simply test for the number of
1760 entries in the VERNEED section since the
1761 numbers for the needed versions do not start
1763 Elf_Internal_Verneed *t;
1766 for (t = elf_tdata (abfd)->verref;
1770 Elf_Internal_Vernaux *a;
1772 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1774 if (a->vna_other == vernum)
1776 verstr = a->vna_nodename;
1785 (*_bfd_error_handler)
1786 (_("%s: %s: invalid needed version %d"),
1787 bfd_archive_filename (abfd), name, vernum);
1788 bfd_set_error (bfd_error_bad_value);
1789 goto error_free_vers;
1793 namelen = strlen (name);
1794 verlen = strlen (verstr);
1795 newlen = namelen + verlen + 2;
1796 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
1797 && isym->st_shndx != SHN_UNDEF)
1800 newname = (char *) bfd_alloc (abfd, (bfd_size_type) newlen);
1801 if (newname == NULL)
1802 goto error_free_vers;
1803 memcpy (newname, name, namelen);
1804 p = newname + namelen;
1806 /* If this is a defined non-hidden version symbol,
1807 we add another @ to the name. This indicates the
1808 default version of the symbol. */
1809 if ((iver.vs_vers & VERSYM_HIDDEN) == 0
1810 && isym->st_shndx != SHN_UNDEF)
1812 memcpy (p, verstr, verlen + 1);
1818 if (! elf_merge_symbol (abfd, info, name, isym, &sec, &value,
1819 sym_hash, &override, &type_change_ok,
1820 &size_change_ok, dt_needed))
1821 goto error_free_vers;
1827 while (h->root.type == bfd_link_hash_indirect
1828 || h->root.type == bfd_link_hash_warning)
1829 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1831 /* Remember the old alignment if this is a common symbol, so
1832 that we don't reduce the alignment later on. We can't
1833 check later, because _bfd_generic_link_add_one_symbol
1834 will set a default for the alignment which we want to
1836 if (h->root.type == bfd_link_hash_common)
1837 old_alignment = h->root.u.c.p->alignment_power;
1839 if (elf_tdata (abfd)->verdef != NULL
1843 h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
1846 if (! (_bfd_generic_link_add_one_symbol
1847 (info, abfd, name, flags, sec, value, (const char *) NULL,
1848 false, collect, (struct bfd_link_hash_entry **) sym_hash)))
1849 goto error_free_vers;
1852 while (h->root.type == bfd_link_hash_indirect
1853 || h->root.type == bfd_link_hash_warning)
1854 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1857 new_weakdef = false;
1860 && (flags & BSF_WEAK) != 0
1861 && ELF_ST_TYPE (isym->st_info) != STT_FUNC
1862 && info->hash->creator->flavour == bfd_target_elf_flavour
1863 && h->weakdef == NULL)
1865 /* Keep a list of all weak defined non function symbols from
1866 a dynamic object, using the weakdef field. Later in this
1867 function we will set the weakdef field to the correct
1868 value. We only put non-function symbols from dynamic
1869 objects on this list, because that happens to be the only
1870 time we need to know the normal symbol corresponding to a
1871 weak symbol, and the information is time consuming to
1872 figure out. If the weakdef field is not already NULL,
1873 then this symbol was already defined by some previous
1874 dynamic object, and we will be using that previous
1875 definition anyhow. */
1882 /* Set the alignment of a common symbol. */
1883 if (isym->st_shndx == SHN_COMMON
1884 && h->root.type == bfd_link_hash_common)
1888 align = bfd_log2 (isym->st_value);
1889 if (align > old_alignment
1890 /* Permit an alignment power of zero if an alignment of one
1891 is specified and no other alignments have been specified. */
1892 || (isym->st_value == 1 && old_alignment == 0))
1893 h->root.u.c.p->alignment_power = align;
1896 if (info->hash->creator->flavour == bfd_target_elf_flavour)
1902 /* Remember the symbol size and type. */
1903 if (isym->st_size != 0
1904 && (definition || h->size == 0))
1906 if (h->size != 0 && h->size != isym->st_size && ! size_change_ok)
1907 (*_bfd_error_handler)
1908 (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
1909 name, (unsigned long) h->size,
1910 (unsigned long) isym->st_size, bfd_archive_filename (abfd));
1912 h->size = isym->st_size;
1915 /* If this is a common symbol, then we always want H->SIZE
1916 to be the size of the common symbol. The code just above
1917 won't fix the size if a common symbol becomes larger. We
1918 don't warn about a size change here, because that is
1919 covered by --warn-common. */
1920 if (h->root.type == bfd_link_hash_common)
1921 h->size = h->root.u.c.size;
1923 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
1924 && (definition || h->type == STT_NOTYPE))
1926 if (h->type != STT_NOTYPE
1927 && h->type != ELF_ST_TYPE (isym->st_info)
1928 && ! type_change_ok)
1929 (*_bfd_error_handler)
1930 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
1931 name, h->type, ELF_ST_TYPE (isym->st_info),
1932 bfd_archive_filename (abfd));
1934 h->type = ELF_ST_TYPE (isym->st_info);
1937 /* If st_other has a processor-specific meaning, specific code
1938 might be needed here. */
1939 if (isym->st_other != 0)
1941 unsigned char hvis, symvis, other;
1943 /* Take the balance of OTHER from the definition. */
1944 other = (definition ? isym->st_other : h->other);
1945 other &= ~ ELF_ST_VISIBILITY (-1);
1947 /* Combine visibilities, using the most constraining one. */
1948 hvis = ELF_ST_VISIBILITY (h->other);
1949 symvis = ELF_ST_VISIBILITY (isym->st_other);
1951 h->other = other | (hvis > symvis ? hvis : symvis);
1954 /* Set a flag in the hash table entry indicating the type of
1955 reference or definition we just found. Keep a count of
1956 the number of dynamic symbols we find. A dynamic symbol
1957 is one which is referenced or defined by both a regular
1958 object and a shared object. */
1959 old_flags = h->elf_link_hash_flags;
1965 new_flag = ELF_LINK_HASH_REF_REGULAR;
1966 if (bind != STB_WEAK)
1967 new_flag |= ELF_LINK_HASH_REF_REGULAR_NONWEAK;
1970 new_flag = ELF_LINK_HASH_DEF_REGULAR;
1972 || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1973 | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
1979 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
1981 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
1982 if ((old_flags & (ELF_LINK_HASH_DEF_REGULAR
1983 | ELF_LINK_HASH_REF_REGULAR)) != 0
1984 || (h->weakdef != NULL
1986 && h->weakdef->dynindx != -1))
1990 h->elf_link_hash_flags |= new_flag;
1992 /* Check to see if we need to add an indirect symbol for
1993 the default name. */
1994 if (definition || h->root.type == bfd_link_hash_common)
1995 if (! elf_add_default_symbol (abfd, info, h, name, isym,
1996 &sec, &value, &dynsym,
1997 override, dt_needed))
1998 goto error_free_vers;
2000 if (dynsym && h->dynindx == -1)
2002 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2003 goto error_free_vers;
2004 if (h->weakdef != NULL
2006 && h->weakdef->dynindx == -1)
2008 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
2009 goto error_free_vers;
2012 else if (dynsym && h->dynindx != -1)
2013 /* If the symbol already has a dynamic index, but
2014 visibility says it should not be visible, turn it into
2016 switch (ELF_ST_VISIBILITY (h->other))
2020 (*bed->elf_backend_hide_symbol) (info, h, true);
2024 if (dt_needed && definition
2025 && (h->elf_link_hash_flags
2026 & ELF_LINK_HASH_REF_REGULAR) != 0)
2028 bfd_size_type oldsize;
2029 bfd_size_type strindex;
2031 if (! is_elf_hash_table (info))
2032 goto error_free_vers;
2034 /* The symbol from a DT_NEEDED object is referenced from
2035 the regular object to create a dynamic executable. We
2036 have to make sure there is a DT_NEEDED entry for it. */
2039 oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
2040 strindex = _bfd_elf_strtab_add (hash_table->dynstr,
2041 elf_dt_soname (abfd), false);
2042 if (strindex == (bfd_size_type) -1)
2043 goto error_free_vers;
2045 if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
2048 Elf_External_Dyn *dyncon, *dynconend;
2050 sdyn = bfd_get_section_by_name (hash_table->dynobj,
2052 BFD_ASSERT (sdyn != NULL);
2054 dyncon = (Elf_External_Dyn *) sdyn->contents;
2055 dynconend = (Elf_External_Dyn *) (sdyn->contents +
2057 for (; dyncon < dynconend; dyncon++)
2059 Elf_Internal_Dyn dyn;
2061 elf_swap_dyn_in (hash_table->dynobj,
2063 BFD_ASSERT (dyn.d_tag != DT_NEEDED ||
2064 dyn.d_un.d_val != strindex);
2068 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
2069 goto error_free_vers;
2074 if (extversym != NULL)
2080 if (isymbuf != NULL)
2084 /* Now set the weakdefs field correctly for all the weak defined
2085 symbols we found. The only way to do this is to search all the
2086 symbols. Since we only need the information for non functions in
2087 dynamic objects, that's the only time we actually put anything on
2088 the list WEAKS. We need this information so that if a regular
2089 object refers to a symbol defined weakly in a dynamic object, the
2090 real symbol in the dynamic object is also put in the dynamic
2091 symbols; we also must arrange for both symbols to point to the
2092 same memory location. We could handle the general case of symbol
2093 aliasing, but a general symbol alias can only be generated in
2094 assembler code, handling it correctly would be very time
2095 consuming, and other ELF linkers don't handle general aliasing
2097 while (weaks != NULL)
2099 struct elf_link_hash_entry *hlook;
2102 struct elf_link_hash_entry **hpp;
2103 struct elf_link_hash_entry **hppend;
2106 weaks = hlook->weakdef;
2107 hlook->weakdef = NULL;
2109 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
2110 || hlook->root.type == bfd_link_hash_defweak
2111 || hlook->root.type == bfd_link_hash_common
2112 || hlook->root.type == bfd_link_hash_indirect);
2113 slook = hlook->root.u.def.section;
2114 vlook = hlook->root.u.def.value;
2116 hpp = elf_sym_hashes (abfd);
2117 hppend = hpp + extsymcount;
2118 for (; hpp < hppend; hpp++)
2120 struct elf_link_hash_entry *h;
2123 if (h != NULL && h != hlook
2124 && h->root.type == bfd_link_hash_defined
2125 && h->root.u.def.section == slook
2126 && h->root.u.def.value == vlook)
2130 /* If the weak definition is in the list of dynamic
2131 symbols, make sure the real definition is put there
2133 if (hlook->dynindx != -1
2134 && h->dynindx == -1)
2136 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2140 /* If the real definition is in the list of dynamic
2141 symbols, make sure the weak definition is put there
2142 as well. If we don't do this, then the dynamic
2143 loader might not merge the entries for the real
2144 definition and the weak definition. */
2145 if (h->dynindx != -1
2146 && hlook->dynindx == -1)
2148 if (! _bfd_elf_link_record_dynamic_symbol (info, hlook))
2156 /* If this object is the same format as the output object, and it is
2157 not a shared library, then let the backend look through the
2160 This is required to build global offset table entries and to
2161 arrange for dynamic relocs. It is not required for the
2162 particular common case of linking non PIC code, even when linking
2163 against shared libraries, but unfortunately there is no way of
2164 knowing whether an object file has been compiled PIC or not.
2165 Looking through the relocs is not particularly time consuming.
2166 The problem is that we must either (1) keep the relocs in memory,
2167 which causes the linker to require additional runtime memory or
2168 (2) read the relocs twice from the input file, which wastes time.
2169 This would be a good case for using mmap.
2171 I have no idea how to handle linking PIC code into a file of a
2172 different format. It probably can't be done. */
2173 check_relocs = get_elf_backend_data (abfd)->check_relocs;
2175 && abfd->xvec == info->hash->creator
2176 && check_relocs != NULL)
2180 for (o = abfd->sections; o != NULL; o = o->next)
2182 Elf_Internal_Rela *internal_relocs;
2185 if ((o->flags & SEC_RELOC) == 0
2186 || o->reloc_count == 0
2187 || ((info->strip == strip_all || info->strip == strip_debugger)
2188 && (o->flags & SEC_DEBUGGING) != 0)
2189 || bfd_is_abs_section (o->output_section))
2192 internal_relocs = (NAME(_bfd_elf,link_read_relocs)
2193 (abfd, o, (PTR) NULL,
2194 (Elf_Internal_Rela *) NULL,
2195 info->keep_memory));
2196 if (internal_relocs == NULL)
2199 ok = (*check_relocs) (abfd, info, o, internal_relocs);
2201 if (elf_section_data (o)->relocs != internal_relocs)
2202 free (internal_relocs);
2209 /* If this is a non-traditional, non-relocateable link, try to
2210 optimize the handling of the .stab/.stabstr sections. */
2212 && ! info->relocateable
2213 && ! info->traditional_format
2214 && info->hash->creator->flavour == bfd_target_elf_flavour
2215 && is_elf_hash_table (info)
2216 && (info->strip != strip_all && info->strip != strip_debugger))
2218 asection *stab, *stabstr;
2220 stab = bfd_get_section_by_name (abfd, ".stab");
2222 && (stab->flags & SEC_MERGE) == 0
2223 && !bfd_is_abs_section (stab->output_section))
2225 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
2227 if (stabstr != NULL)
2229 struct bfd_elf_section_data *secdata;
2231 secdata = elf_section_data (stab);
2232 if (! _bfd_link_section_stabs (abfd,
2233 & hash_table->stab_info,
2235 &secdata->sec_info))
2237 if (secdata->sec_info)
2238 secdata->sec_info_type = ELF_INFO_TYPE_STABS;
2243 if (! info->relocateable && ! dynamic
2244 && is_elf_hash_table (info))
2248 for (s = abfd->sections; s != NULL; s = s->next)
2249 if ((s->flags & SEC_MERGE) != 0
2250 && !bfd_is_abs_section (s->output_section))
2252 struct bfd_elf_section_data *secdata;
2254 secdata = elf_section_data (s);
2255 if (! _bfd_merge_section (abfd,
2256 & hash_table->merge_info,
2257 s, &secdata->sec_info))
2259 else if (secdata->sec_info)
2260 secdata->sec_info_type = ELF_INFO_TYPE_MERGE;
2264 if (is_elf_hash_table (info))
2266 /* Add this bfd to the loaded list. */
2267 struct elf_link_loaded_list *n;
2269 n = ((struct elf_link_loaded_list *)
2270 bfd_alloc (abfd, sizeof (struct elf_link_loaded_list)));
2274 n->next = hash_table->loaded;
2275 hash_table->loaded = n;
2281 if (extversym != NULL)
2284 if (isymbuf != NULL)
2290 /* Create some sections which will be filled in with dynamic linking
2291 information. ABFD is an input file which requires dynamic sections
2292 to be created. The dynamic sections take up virtual memory space
2293 when the final executable is run, so we need to create them before
2294 addresses are assigned to the output sections. We work out the
2295 actual contents and size of these sections later. */
2298 elf_link_create_dynamic_sections (abfd, info)
2300 struct bfd_link_info *info;
2303 register asection *s;
2304 struct elf_link_hash_entry *h;
2305 struct bfd_link_hash_entry *bh;
2306 struct elf_backend_data *bed;
2308 if (! is_elf_hash_table (info))
2311 if (elf_hash_table (info)->dynamic_sections_created)
2314 /* Make sure that all dynamic sections use the same input BFD. */
2315 if (elf_hash_table (info)->dynobj == NULL)
2316 elf_hash_table (info)->dynobj = abfd;
2318 abfd = elf_hash_table (info)->dynobj;
2320 /* Note that we set the SEC_IN_MEMORY flag for all of these
2322 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2323 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2325 /* A dynamically linked executable has a .interp section, but a
2326 shared library does not. */
2329 s = bfd_make_section (abfd, ".interp");
2331 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
2335 if (! info->traditional_format
2336 && info->hash->creator->flavour == bfd_target_elf_flavour)
2338 s = bfd_make_section (abfd, ".eh_frame_hdr");
2340 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2341 || ! bfd_set_section_alignment (abfd, s, 2))
2345 /* Create sections to hold version informations. These are removed
2346 if they are not needed. */
2347 s = bfd_make_section (abfd, ".gnu.version_d");
2349 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2350 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2353 s = bfd_make_section (abfd, ".gnu.version");
2355 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2356 || ! bfd_set_section_alignment (abfd, s, 1))
2359 s = bfd_make_section (abfd, ".gnu.version_r");
2361 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2362 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2365 s = bfd_make_section (abfd, ".dynsym");
2367 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2368 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2371 s = bfd_make_section (abfd, ".dynstr");
2373 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
2376 /* Create a strtab to hold the dynamic symbol names. */
2377 if (elf_hash_table (info)->dynstr == NULL)
2379 elf_hash_table (info)->dynstr = _bfd_elf_strtab_init ();
2380 if (elf_hash_table (info)->dynstr == NULL)
2384 s = bfd_make_section (abfd, ".dynamic");
2386 || ! bfd_set_section_flags (abfd, s, flags)
2387 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2390 /* The special symbol _DYNAMIC is always set to the start of the
2391 .dynamic section. This call occurs before we have processed the
2392 symbols for any dynamic object, so we don't have to worry about
2393 overriding a dynamic definition. We could set _DYNAMIC in a
2394 linker script, but we only want to define it if we are, in fact,
2395 creating a .dynamic section. We don't want to define it if there
2396 is no .dynamic section, since on some ELF platforms the start up
2397 code examines it to decide how to initialize the process. */
2399 if (! (_bfd_generic_link_add_one_symbol
2400 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
2401 (const char *) 0, false, get_elf_backend_data (abfd)->collect, &bh)))
2403 h = (struct elf_link_hash_entry *) bh;
2404 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2405 h->type = STT_OBJECT;
2408 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2411 bed = get_elf_backend_data (abfd);
2413 s = bfd_make_section (abfd, ".hash");
2415 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2416 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2418 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
2420 /* Let the backend create the rest of the sections. This lets the
2421 backend set the right flags. The backend will normally create
2422 the .got and .plt sections. */
2423 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
2426 elf_hash_table (info)->dynamic_sections_created = true;
2431 /* Add an entry to the .dynamic table. */
2434 elf_add_dynamic_entry (info, tag, val)
2435 struct bfd_link_info *info;
2439 Elf_Internal_Dyn dyn;
2442 bfd_size_type newsize;
2443 bfd_byte *newcontents;
2445 if (! is_elf_hash_table (info))
2448 dynobj = elf_hash_table (info)->dynobj;
2450 s = bfd_get_section_by_name (dynobj, ".dynamic");
2451 BFD_ASSERT (s != NULL);
2453 newsize = s->_raw_size + sizeof (Elf_External_Dyn);
2454 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
2455 if (newcontents == NULL)
2459 dyn.d_un.d_val = val;
2460 elf_swap_dyn_out (dynobj, &dyn,
2461 (Elf_External_Dyn *) (newcontents + s->_raw_size));
2463 s->_raw_size = newsize;
2464 s->contents = newcontents;
2469 /* Read and swap the relocs from the section indicated by SHDR. This
2470 may be either a REL or a RELA section. The relocations are
2471 translated into RELA relocations and stored in INTERNAL_RELOCS,
2472 which should have already been allocated to contain enough space.
2473 The EXTERNAL_RELOCS are a buffer where the external form of the
2474 relocations should be stored.
2476 Returns false if something goes wrong. */
2479 elf_link_read_relocs_from_section (abfd, shdr, external_relocs,
2482 Elf_Internal_Shdr *shdr;
2483 PTR external_relocs;
2484 Elf_Internal_Rela *internal_relocs;
2486 struct elf_backend_data *bed;
2489 /* If there aren't any relocations, that's OK. */
2493 /* Position ourselves at the start of the section. */
2494 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2497 /* Read the relocations. */
2498 if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2501 bed = get_elf_backend_data (abfd);
2503 /* Convert the external relocations to the internal format. */
2504 if (shdr->sh_entsize == sizeof (Elf_External_Rel))
2506 Elf_External_Rel *erel;
2507 Elf_External_Rel *erelend;
2508 Elf_Internal_Rela *irela;
2509 Elf_Internal_Rel *irel;
2511 erel = (Elf_External_Rel *) external_relocs;
2512 erelend = erel + NUM_SHDR_ENTRIES (shdr);
2513 irela = internal_relocs;
2514 amt = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rel);
2515 irel = bfd_alloc (abfd, amt);
2516 for (; erel < erelend; erel++, irela += bed->s->int_rels_per_ext_rel)
2520 if (bed->s->swap_reloc_in)
2521 (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, irel);
2523 elf_swap_reloc_in (abfd, erel, irel);
2525 for (i = 0; i < bed->s->int_rels_per_ext_rel; ++i)
2527 irela[i].r_offset = irel[i].r_offset;
2528 irela[i].r_info = irel[i].r_info;
2529 irela[i].r_addend = 0;
2535 Elf_External_Rela *erela;
2536 Elf_External_Rela *erelaend;
2537 Elf_Internal_Rela *irela;
2539 BFD_ASSERT (shdr->sh_entsize == sizeof (Elf_External_Rela));
2541 erela = (Elf_External_Rela *) external_relocs;
2542 erelaend = erela + NUM_SHDR_ENTRIES (shdr);
2543 irela = internal_relocs;
2544 for (; erela < erelaend; erela++, irela += bed->s->int_rels_per_ext_rel)
2546 if (bed->s->swap_reloca_in)
2547 (*bed->s->swap_reloca_in) (abfd, (bfd_byte *) erela, irela);
2549 elf_swap_reloca_in (abfd, erela, irela);
2556 /* Read and swap the relocs for a section O. They may have been
2557 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2558 not NULL, they are used as buffers to read into. They are known to
2559 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2560 the return value is allocated using either malloc or bfd_alloc,
2561 according to the KEEP_MEMORY argument. If O has two relocation
2562 sections (both REL and RELA relocations), then the REL_HDR
2563 relocations will appear first in INTERNAL_RELOCS, followed by the
2564 REL_HDR2 relocations. */
2567 NAME(_bfd_elf,link_read_relocs) (abfd, o, external_relocs, internal_relocs,
2571 PTR external_relocs;
2572 Elf_Internal_Rela *internal_relocs;
2573 boolean keep_memory;
2575 Elf_Internal_Shdr *rel_hdr;
2577 Elf_Internal_Rela *alloc2 = NULL;
2578 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2580 if (elf_section_data (o)->relocs != NULL)
2581 return elf_section_data (o)->relocs;
2583 if (o->reloc_count == 0)
2586 rel_hdr = &elf_section_data (o)->rel_hdr;
2588 if (internal_relocs == NULL)
2592 size = o->reloc_count;
2593 size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2595 internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2597 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2598 if (internal_relocs == NULL)
2602 if (external_relocs == NULL)
2604 bfd_size_type size = rel_hdr->sh_size;
2606 if (elf_section_data (o)->rel_hdr2)
2607 size += elf_section_data (o)->rel_hdr2->sh_size;
2608 alloc1 = (PTR) bfd_malloc (size);
2611 external_relocs = alloc1;
2614 if (!elf_link_read_relocs_from_section (abfd, rel_hdr,
2618 if (!elf_link_read_relocs_from_section
2620 elf_section_data (o)->rel_hdr2,
2621 ((bfd_byte *) external_relocs) + rel_hdr->sh_size,
2622 internal_relocs + (NUM_SHDR_ENTRIES (rel_hdr)
2623 * bed->s->int_rels_per_ext_rel)))
2626 /* Cache the results for next time, if we can. */
2628 elf_section_data (o)->relocs = internal_relocs;
2633 /* Don't free alloc2, since if it was allocated we are passing it
2634 back (under the name of internal_relocs). */
2636 return internal_relocs;
2646 /* Record an assignment to a symbol made by a linker script. We need
2647 this in case some dynamic object refers to this symbol. */
2650 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
2651 bfd *output_bfd ATTRIBUTE_UNUSED;
2652 struct bfd_link_info *info;
2656 struct elf_link_hash_entry *h;
2658 if (info->hash->creator->flavour != bfd_target_elf_flavour)
2661 h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
2665 if (h->root.type == bfd_link_hash_new)
2666 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
2668 /* If this symbol is being provided by the linker script, and it is
2669 currently defined by a dynamic object, but not by a regular
2670 object, then mark it as undefined so that the generic linker will
2671 force the correct value. */
2673 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2674 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2675 h->root.type = bfd_link_hash_undefined;
2677 /* If this symbol is not being provided by the linker script, and it is
2678 currently defined by a dynamic object, but not by a regular object,
2679 then clear out any version information because the symbol will not be
2680 associated with the dynamic object any more. */
2682 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2683 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2684 h->verinfo.verdef = NULL;
2686 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2688 if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
2689 | ELF_LINK_HASH_REF_DYNAMIC)) != 0
2691 && h->dynindx == -1)
2693 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2696 /* If this is a weak defined symbol, and we know a corresponding
2697 real symbol from the same dynamic object, make sure the real
2698 symbol is also made into a dynamic symbol. */
2699 if (h->weakdef != NULL
2700 && h->weakdef->dynindx == -1)
2702 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
2710 /* This structure is used to pass information to
2711 elf_link_assign_sym_version. */
2713 struct elf_assign_sym_version_info
2717 /* General link information. */
2718 struct bfd_link_info *info;
2720 struct bfd_elf_version_tree *verdefs;
2721 /* Whether we had a failure. */
2725 /* This structure is used to pass information to
2726 elf_link_find_version_dependencies. */
2728 struct elf_find_verdep_info
2732 /* General link information. */
2733 struct bfd_link_info *info;
2734 /* The number of dependencies. */
2736 /* Whether we had a failure. */
2740 /* Array used to determine the number of hash table buckets to use
2741 based on the number of symbols there are. If there are fewer than
2742 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
2743 fewer than 37 we use 17 buckets, and so forth. We never use more
2744 than 32771 buckets. */
2746 static const size_t elf_buckets[] =
2748 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
2752 /* Compute bucket count for hashing table. We do not use a static set
2753 of possible tables sizes anymore. Instead we determine for all
2754 possible reasonable sizes of the table the outcome (i.e., the
2755 number of collisions etc) and choose the best solution. The
2756 weighting functions are not too simple to allow the table to grow
2757 without bounds. Instead one of the weighting factors is the size.
2758 Therefore the result is always a good payoff between few collisions
2759 (= short chain lengths) and table size. */
2761 compute_bucket_count (info)
2762 struct bfd_link_info *info;
2764 size_t dynsymcount = elf_hash_table (info)->dynsymcount;
2765 size_t best_size = 0;
2766 unsigned long int *hashcodes;
2767 unsigned long int *hashcodesp;
2768 unsigned long int i;
2771 /* Compute the hash values for all exported symbols. At the same
2772 time store the values in an array so that we could use them for
2775 amt *= sizeof (unsigned long int);
2776 hashcodes = (unsigned long int *) bfd_malloc (amt);
2777 if (hashcodes == NULL)
2779 hashcodesp = hashcodes;
2781 /* Put all hash values in HASHCODES. */
2782 elf_link_hash_traverse (elf_hash_table (info),
2783 elf_collect_hash_codes, &hashcodesp);
2785 /* We have a problem here. The following code to optimize the table
2786 size requires an integer type with more the 32 bits. If
2787 BFD_HOST_U_64_BIT is set we know about such a type. */
2788 #ifdef BFD_HOST_U_64_BIT
2791 unsigned long int nsyms = hashcodesp - hashcodes;
2794 BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
2795 unsigned long int *counts ;
2797 /* Possible optimization parameters: if we have NSYMS symbols we say
2798 that the hashing table must at least have NSYMS/4 and at most
2800 minsize = nsyms / 4;
2803 best_size = maxsize = nsyms * 2;
2805 /* Create array where we count the collisions in. We must use bfd_malloc
2806 since the size could be large. */
2808 amt *= sizeof (unsigned long int);
2809 counts = (unsigned long int *) bfd_malloc (amt);
2816 /* Compute the "optimal" size for the hash table. The criteria is a
2817 minimal chain length. The minor criteria is (of course) the size
2819 for (i = minsize; i < maxsize; ++i)
2821 /* Walk through the array of hashcodes and count the collisions. */
2822 BFD_HOST_U_64_BIT max;
2823 unsigned long int j;
2824 unsigned long int fact;
2826 memset (counts, '\0', i * sizeof (unsigned long int));
2828 /* Determine how often each hash bucket is used. */
2829 for (j = 0; j < nsyms; ++j)
2830 ++counts[hashcodes[j] % i];
2832 /* For the weight function we need some information about the
2833 pagesize on the target. This is information need not be 100%
2834 accurate. Since this information is not available (so far) we
2835 define it here to a reasonable default value. If it is crucial
2836 to have a better value some day simply define this value. */
2837 # ifndef BFD_TARGET_PAGESIZE
2838 # define BFD_TARGET_PAGESIZE (4096)
2841 /* We in any case need 2 + NSYMS entries for the size values and
2843 max = (2 + nsyms) * (ARCH_SIZE / 8);
2846 /* Variant 1: optimize for short chains. We add the squares
2847 of all the chain lengths (which favous many small chain
2848 over a few long chains). */
2849 for (j = 0; j < i; ++j)
2850 max += counts[j] * counts[j];
2852 /* This adds penalties for the overall size of the table. */
2853 fact = i / (BFD_TARGET_PAGESIZE / (ARCH_SIZE / 8)) + 1;
2856 /* Variant 2: Optimize a lot more for small table. Here we
2857 also add squares of the size but we also add penalties for
2858 empty slots (the +1 term). */
2859 for (j = 0; j < i; ++j)
2860 max += (1 + counts[j]) * (1 + counts[j]);
2862 /* The overall size of the table is considered, but not as
2863 strong as in variant 1, where it is squared. */
2864 fact = i / (BFD_TARGET_PAGESIZE / (ARCH_SIZE / 8)) + 1;
2868 /* Compare with current best results. */
2869 if (max < best_chlen)
2879 #endif /* defined (BFD_HOST_U_64_BIT) */
2881 /* This is the fallback solution if no 64bit type is available or if we
2882 are not supposed to spend much time on optimizations. We select the
2883 bucket count using a fixed set of numbers. */
2884 for (i = 0; elf_buckets[i] != 0; i++)
2886 best_size = elf_buckets[i];
2887 if (dynsymcount < elf_buckets[i + 1])
2892 /* Free the arrays we needed. */
2898 /* Set up the sizes and contents of the ELF dynamic sections. This is
2899 called by the ELF linker emulation before_allocation routine. We
2900 must set the sizes of the sections before the linker sets the
2901 addresses of the various sections. */
2904 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
2906 auxiliary_filters, info, sinterpptr,
2911 const char *filter_shlib;
2912 const char * const *auxiliary_filters;
2913 struct bfd_link_info *info;
2914 asection **sinterpptr;
2915 struct bfd_elf_version_tree *verdefs;
2917 bfd_size_type soname_indx;
2919 struct elf_backend_data *bed;
2920 struct elf_assign_sym_version_info asvinfo;
2924 soname_indx = (bfd_size_type) -1;
2926 if (info->hash->creator->flavour != bfd_target_elf_flavour)
2929 if (! is_elf_hash_table (info))
2932 /* Any syms created from now on start with -1 in
2933 got.refcount/offset and plt.refcount/offset. */
2934 elf_hash_table (info)->init_refcount = -1;
2936 /* The backend may have to create some sections regardless of whether
2937 we're dynamic or not. */
2938 bed = get_elf_backend_data (output_bfd);
2939 if (bed->elf_backend_always_size_sections
2940 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
2943 dynobj = elf_hash_table (info)->dynobj;
2945 /* If there were no dynamic objects in the link, there is nothing to
2950 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
2953 if (elf_hash_table (info)->dynamic_sections_created)
2955 struct elf_info_failed eif;
2956 struct elf_link_hash_entry *h;
2958 struct bfd_elf_version_tree *t;
2959 struct bfd_elf_version_expr *d;
2960 boolean all_defined;
2962 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
2963 BFD_ASSERT (*sinterpptr != NULL || info->shared);
2967 soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
2969 if (soname_indx == (bfd_size_type) -1
2970 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SONAME,
2977 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMBOLIC,
2980 info->flags |= DF_SYMBOLIC;
2987 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
2989 if (info->new_dtags)
2990 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
2991 if (indx == (bfd_size_type) -1
2992 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_RPATH, indx)
2994 && ! elf_add_dynamic_entry (info, (bfd_vma) DT_RUNPATH,
2999 if (filter_shlib != NULL)
3003 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3004 filter_shlib, true);
3005 if (indx == (bfd_size_type) -1
3006 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_FILTER, indx))
3010 if (auxiliary_filters != NULL)
3012 const char * const *p;
3014 for (p = auxiliary_filters; *p != NULL; p++)
3018 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3020 if (indx == (bfd_size_type) -1
3021 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_AUXILIARY,
3028 eif.verdefs = verdefs;
3031 /* If we are supposed to export all symbols into the dynamic symbol
3032 table (this is not the normal case), then do so. */
3033 if (info->export_dynamic)
3035 elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
3041 /* Make all global versions with definiton. */
3042 for (t = verdefs; t != NULL; t = t->next)
3043 for (d = t->globals; d != NULL; d = d->next)
3044 if (!d->symver && strchr (d->pattern, '*') == NULL)
3046 const char *verstr, *name;
3047 size_t namelen, verlen, newlen;
3049 struct elf_link_hash_entry *newh;
3052 namelen = strlen (name);
3054 verlen = strlen (verstr);
3055 newlen = namelen + verlen + 3;
3057 newname = (char *) bfd_malloc ((bfd_size_type) newlen);
3058 if (newname == NULL)
3060 memcpy (newname, name, namelen);
3062 /* Check the hidden versioned definition. */
3063 p = newname + namelen;
3065 memcpy (p, verstr, verlen + 1);
3066 newh = elf_link_hash_lookup (elf_hash_table (info),
3067 newname, false, false,
3070 || (newh->root.type != bfd_link_hash_defined
3071 && newh->root.type != bfd_link_hash_defweak))
3073 /* Check the default versioned definition. */
3075 memcpy (p, verstr, verlen + 1);
3076 newh = elf_link_hash_lookup (elf_hash_table (info),
3077 newname, false, false,
3082 /* Mark this version if there is a definition and it is
3083 not defined in a shared object. */
3085 && ((newh->elf_link_hash_flags
3086 & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
3087 && (newh->root.type == bfd_link_hash_defined
3088 || newh->root.type == bfd_link_hash_defweak))
3092 /* Attach all the symbols to their version information. */
3093 asvinfo.output_bfd = output_bfd;
3094 asvinfo.info = info;
3095 asvinfo.verdefs = verdefs;
3096 asvinfo.failed = false;
3098 elf_link_hash_traverse (elf_hash_table (info),
3099 elf_link_assign_sym_version,
3104 if (!info->allow_undefined_version)
3106 /* Check if all global versions have a definiton. */
3108 for (t = verdefs; t != NULL; t = t->next)
3109 for (d = t->globals; d != NULL; d = d->next)
3110 if (!d->symver && !d->script
3111 && strchr (d->pattern, '*') == NULL)
3113 (*_bfd_error_handler)
3114 (_("%s: undefined version: %s"),
3115 d->pattern, t->name);
3116 all_defined = false;
3121 bfd_set_error (bfd_error_bad_value);
3126 /* Find all symbols which were defined in a dynamic object and make
3127 the backend pick a reasonable value for them. */
3128 elf_link_hash_traverse (elf_hash_table (info),
3129 elf_adjust_dynamic_symbol,
3134 /* Add some entries to the .dynamic section. We fill in some of the
3135 values later, in elf_bfd_final_link, but we must add the entries
3136 now so that we know the final size of the .dynamic section. */
3138 /* If there are initialization and/or finalization functions to
3139 call then add the corresponding DT_INIT/DT_FINI entries. */
3140 h = (info->init_function
3141 ? elf_link_hash_lookup (elf_hash_table (info),
3142 info->init_function, false,
3146 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3147 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3149 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_INIT, (bfd_vma) 0))
3152 h = (info->fini_function
3153 ? elf_link_hash_lookup (elf_hash_table (info),
3154 info->fini_function, false,
3158 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
3159 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
3161 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FINI, (bfd_vma) 0))
3165 if (bfd_get_section_by_name (output_bfd, ".preinit_array") != NULL)
3167 /* DT_PREINIT_ARRAY is not allowed in shared library. */
3173 for (sub = info->input_bfds; sub != NULL;
3174 sub = sub->link_next)
3175 for (o = sub->sections; o != NULL; o = o->next)
3176 if (elf_section_data (o)->this_hdr.sh_type
3177 == SHT_PREINIT_ARRAY)
3179 (*_bfd_error_handler)
3180 (_("%s: .preinit_array section is not allowed in DSO"),
3181 bfd_archive_filename (sub));
3185 bfd_set_error (bfd_error_nonrepresentable_section);
3189 if (!elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAY,
3191 || !elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAYSZ,
3195 if (bfd_get_section_by_name (output_bfd, ".init_array") != NULL)
3197 if (!elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAY,
3199 || !elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAYSZ,
3203 if (bfd_get_section_by_name (output_bfd, ".fini_array") != NULL)
3205 if (!elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAY,
3207 || !elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAYSZ,
3212 dynstr = bfd_get_section_by_name (dynobj, ".dynstr");
3213 /* If .dynstr is excluded from the link, we don't want any of
3214 these tags. Strictly, we should be checking each section
3215 individually; This quick check covers for the case where
3216 someone does a /DISCARD/ : { *(*) }. */
3217 if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
3219 bfd_size_type strsize;
3221 strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
3222 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_HASH, (bfd_vma) 0)
3223 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRTAB, (bfd_vma) 0)
3224 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMTAB, (bfd_vma) 0)
3225 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRSZ, strsize)
3226 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMENT,
3227 (bfd_vma) sizeof (Elf_External_Sym)))
3232 /* The backend must work out the sizes of all the other dynamic
3234 if (bed->elf_backend_size_dynamic_sections
3235 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
3238 if (elf_hash_table (info)->dynamic_sections_created)
3240 bfd_size_type dynsymcount;
3242 size_t bucketcount = 0;
3243 size_t hash_entry_size;
3244 unsigned int dtagcount;
3246 /* Set up the version definition section. */
3247 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3248 BFD_ASSERT (s != NULL);
3250 /* We may have created additional version definitions if we are
3251 just linking a regular application. */
3252 verdefs = asvinfo.verdefs;
3254 /* Skip anonymous version tag. */
3255 if (verdefs != NULL && verdefs->vernum == 0)
3256 verdefs = verdefs->next;
3258 if (verdefs == NULL)
3259 _bfd_strip_section_from_output (info, s);
3264 struct bfd_elf_version_tree *t;
3266 Elf_Internal_Verdef def;
3267 Elf_Internal_Verdaux defaux;
3272 /* Make space for the base version. */
3273 size += sizeof (Elf_External_Verdef);
3274 size += sizeof (Elf_External_Verdaux);
3277 for (t = verdefs; t != NULL; t = t->next)
3279 struct bfd_elf_version_deps *n;
3281 size += sizeof (Elf_External_Verdef);
3282 size += sizeof (Elf_External_Verdaux);
3285 for (n = t->deps; n != NULL; n = n->next)
3286 size += sizeof (Elf_External_Verdaux);
3289 s->_raw_size = size;
3290 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
3291 if (s->contents == NULL && s->_raw_size != 0)
3294 /* Fill in the version definition section. */
3298 def.vd_version = VER_DEF_CURRENT;
3299 def.vd_flags = VER_FLG_BASE;
3302 def.vd_aux = sizeof (Elf_External_Verdef);
3303 def.vd_next = (sizeof (Elf_External_Verdef)
3304 + sizeof (Elf_External_Verdaux));
3306 if (soname_indx != (bfd_size_type) -1)
3308 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
3310 def.vd_hash = bfd_elf_hash (soname);
3311 defaux.vda_name = soname_indx;
3318 name = basename (output_bfd->filename);
3319 def.vd_hash = bfd_elf_hash (name);
3320 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3322 if (indx == (bfd_size_type) -1)
3324 defaux.vda_name = indx;
3326 defaux.vda_next = 0;
3328 _bfd_elf_swap_verdef_out (output_bfd, &def,
3329 (Elf_External_Verdef *) p);
3330 p += sizeof (Elf_External_Verdef);
3331 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3332 (Elf_External_Verdaux *) p);
3333 p += sizeof (Elf_External_Verdaux);
3335 for (t = verdefs; t != NULL; t = t->next)
3338 struct bfd_elf_version_deps *n;
3339 struct elf_link_hash_entry *h;
3340 struct bfd_link_hash_entry *bh;
3343 for (n = t->deps; n != NULL; n = n->next)
3346 /* Add a symbol representing this version. */
3348 if (! (_bfd_generic_link_add_one_symbol
3349 (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
3350 (bfd_vma) 0, (const char *) NULL, false,
3351 get_elf_backend_data (dynobj)->collect, &bh)))
3353 h = (struct elf_link_hash_entry *) bh;
3354 h->elf_link_hash_flags &= ~ ELF_LINK_NON_ELF;
3355 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3356 h->type = STT_OBJECT;
3357 h->verinfo.vertree = t;
3359 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
3362 def.vd_version = VER_DEF_CURRENT;
3364 if (t->globals == NULL && t->locals == NULL && ! t->used)
3365 def.vd_flags |= VER_FLG_WEAK;
3366 def.vd_ndx = t->vernum + 1;
3367 def.vd_cnt = cdeps + 1;
3368 def.vd_hash = bfd_elf_hash (t->name);
3369 def.vd_aux = sizeof (Elf_External_Verdef);
3370 if (t->next != NULL)
3371 def.vd_next = (sizeof (Elf_External_Verdef)
3372 + (cdeps + 1) * sizeof (Elf_External_Verdaux));
3376 _bfd_elf_swap_verdef_out (output_bfd, &def,
3377 (Elf_External_Verdef *) p);
3378 p += sizeof (Elf_External_Verdef);
3380 defaux.vda_name = h->dynstr_index;
3381 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
3383 if (t->deps == NULL)
3384 defaux.vda_next = 0;
3386 defaux.vda_next = sizeof (Elf_External_Verdaux);
3387 t->name_indx = defaux.vda_name;
3389 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3390 (Elf_External_Verdaux *) p);
3391 p += sizeof (Elf_External_Verdaux);
3393 for (n = t->deps; n != NULL; n = n->next)
3395 if (n->version_needed == NULL)
3397 /* This can happen if there was an error in the
3399 defaux.vda_name = 0;
3403 defaux.vda_name = n->version_needed->name_indx;
3404 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
3407 if (n->next == NULL)
3408 defaux.vda_next = 0;
3410 defaux.vda_next = sizeof (Elf_External_Verdaux);
3412 _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3413 (Elf_External_Verdaux *) p);
3414 p += sizeof (Elf_External_Verdaux);
3418 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEF, (bfd_vma) 0)
3419 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEFNUM,
3423 elf_tdata (output_bfd)->cverdefs = cdefs;
3426 if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
3428 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS, info->flags))
3435 info->flags_1 &= ~ (DF_1_INITFIRST
3438 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS_1,
3443 /* Work out the size of the version reference section. */
3445 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3446 BFD_ASSERT (s != NULL);
3448 struct elf_find_verdep_info sinfo;
3450 sinfo.output_bfd = output_bfd;
3452 sinfo.vers = elf_tdata (output_bfd)->cverdefs;
3453 if (sinfo.vers == 0)
3455 sinfo.failed = false;
3457 elf_link_hash_traverse (elf_hash_table (info),
3458 elf_link_find_version_dependencies,
3461 if (elf_tdata (output_bfd)->verref == NULL)
3462 _bfd_strip_section_from_output (info, s);
3465 Elf_Internal_Verneed *t;
3470 /* Build the version definition section. */
3473 for (t = elf_tdata (output_bfd)->verref;
3477 Elf_Internal_Vernaux *a;
3479 size += sizeof (Elf_External_Verneed);
3481 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3482 size += sizeof (Elf_External_Vernaux);
3485 s->_raw_size = size;
3486 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
3487 if (s->contents == NULL)
3491 for (t = elf_tdata (output_bfd)->verref;
3496 Elf_Internal_Vernaux *a;
3500 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3503 t->vn_version = VER_NEED_CURRENT;
3505 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3506 elf_dt_name (t->vn_bfd) != NULL
3507 ? elf_dt_name (t->vn_bfd)
3508 : basename (t->vn_bfd->filename),
3510 if (indx == (bfd_size_type) -1)
3513 t->vn_aux = sizeof (Elf_External_Verneed);
3514 if (t->vn_nextref == NULL)
3517 t->vn_next = (sizeof (Elf_External_Verneed)
3518 + caux * sizeof (Elf_External_Vernaux));
3520 _bfd_elf_swap_verneed_out (output_bfd, t,
3521 (Elf_External_Verneed *) p);
3522 p += sizeof (Elf_External_Verneed);
3524 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3526 a->vna_hash = bfd_elf_hash (a->vna_nodename);
3527 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
3528 a->vna_nodename, false);
3529 if (indx == (bfd_size_type) -1)
3532 if (a->vna_nextptr == NULL)
3535 a->vna_next = sizeof (Elf_External_Vernaux);
3537 _bfd_elf_swap_vernaux_out (output_bfd, a,
3538 (Elf_External_Vernaux *) p);
3539 p += sizeof (Elf_External_Vernaux);
3543 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEED,
3545 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEEDNUM,
3549 elf_tdata (output_bfd)->cverrefs = crefs;
3553 /* Assign dynsym indicies. In a shared library we generate a
3554 section symbol for each output section, which come first.
3555 Next come all of the back-end allocated local dynamic syms,
3556 followed by the rest of the global symbols. */
3558 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info);
3560 /* Work out the size of the symbol version section. */
3561 s = bfd_get_section_by_name (dynobj, ".gnu.version");
3562 BFD_ASSERT (s != NULL);
3563 if (dynsymcount == 0
3564 || (verdefs == NULL && elf_tdata (output_bfd)->verref == NULL))
3566 _bfd_strip_section_from_output (info, s);
3567 /* The DYNSYMCOUNT might have changed if we were going to
3568 output a dynamic symbol table entry for S. */
3569 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info);
3573 s->_raw_size = dynsymcount * sizeof (Elf_External_Versym);
3574 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
3575 if (s->contents == NULL)
3578 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERSYM, (bfd_vma) 0))
3582 /* Set the size of the .dynsym and .hash sections. We counted
3583 the number of dynamic symbols in elf_link_add_object_symbols.
3584 We will build the contents of .dynsym and .hash when we build
3585 the final symbol table, because until then we do not know the
3586 correct value to give the symbols. We built the .dynstr
3587 section as we went along in elf_link_add_object_symbols. */
3588 s = bfd_get_section_by_name (dynobj, ".dynsym");
3589 BFD_ASSERT (s != NULL);
3590 s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
3591 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
3592 if (s->contents == NULL && s->_raw_size != 0)
3595 if (dynsymcount != 0)
3597 Elf_Internal_Sym isym;
3599 /* The first entry in .dynsym is a dummy symbol. */
3606 elf_swap_symbol_out (output_bfd, &isym, (PTR) s->contents, (PTR) 0);
3609 /* Compute the size of the hashing table. As a side effect this
3610 computes the hash values for all the names we export. */
3611 bucketcount = compute_bucket_count (info);
3613 s = bfd_get_section_by_name (dynobj, ".hash");
3614 BFD_ASSERT (s != NULL);
3615 hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
3616 s->_raw_size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
3617 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
3618 if (s->contents == NULL)
3621 bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) bucketcount,
3623 bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) dynsymcount,
3624 s->contents + hash_entry_size);
3626 elf_hash_table (info)->bucketcount = bucketcount;
3628 s = bfd_get_section_by_name (dynobj, ".dynstr");
3629 BFD_ASSERT (s != NULL);
3631 elf_finalize_dynstr (output_bfd, info);
3633 s->_raw_size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
3635 for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
3636 if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NULL, (bfd_vma) 0))
3643 /* This function is used to adjust offsets into .dynstr for
3644 dynamic symbols. This is called via elf_link_hash_traverse. */
3646 static boolean elf_adjust_dynstr_offsets
3647 PARAMS ((struct elf_link_hash_entry *, PTR));
3650 elf_adjust_dynstr_offsets (h, data)
3651 struct elf_link_hash_entry *h;
3654 struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3656 if (h->root.type == bfd_link_hash_warning)
3657 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3659 if (h->dynindx != -1)
3660 h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3664 /* Assign string offsets in .dynstr, update all structures referencing
3668 elf_finalize_dynstr (output_bfd, info)
3670 struct bfd_link_info *info;
3672 struct elf_link_local_dynamic_entry *entry;
3673 struct elf_strtab_hash *dynstr = elf_hash_table (info)->dynstr;
3674 bfd *dynobj = elf_hash_table (info)->dynobj;
3677 Elf_External_Dyn *dyncon, *dynconend;
3679 _bfd_elf_strtab_finalize (dynstr);
3680 size = _bfd_elf_strtab_size (dynstr);
3682 /* Update all .dynamic entries referencing .dynstr strings. */
3683 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3684 BFD_ASSERT (sdyn != NULL);
3686 dyncon = (Elf_External_Dyn *) sdyn->contents;
3687 dynconend = (Elf_External_Dyn *) (sdyn->contents +
3689 for (; dyncon < dynconend; dyncon++)
3691 Elf_Internal_Dyn dyn;
3693 elf_swap_dyn_in (dynobj, dyncon, & dyn);
3697 dyn.d_un.d_val = size;
3698 elf_swap_dyn_out (dynobj, & dyn, dyncon);
3706 dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3707 elf_swap_dyn_out (dynobj, & dyn, dyncon);
3714 /* Now update local dynamic symbols. */
3715 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
3716 entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3717 entry->isym.st_name);
3719 /* And the rest of dynamic symbols. */
3720 elf_link_hash_traverse (elf_hash_table (info),
3721 elf_adjust_dynstr_offsets, dynstr);
3723 /* Adjust version definitions. */
3724 if (elf_tdata (output_bfd)->cverdefs)
3729 Elf_Internal_Verdef def;
3730 Elf_Internal_Verdaux defaux;
3732 s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3733 p = (bfd_byte *) s->contents;
3736 _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3738 p += sizeof (Elf_External_Verdef);
3739 for (i = 0; i < def.vd_cnt; ++i)
3741 _bfd_elf_swap_verdaux_in (output_bfd,
3742 (Elf_External_Verdaux *) p, &defaux);
3743 defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3745 _bfd_elf_swap_verdaux_out (output_bfd,
3746 &defaux, (Elf_External_Verdaux *) p);
3747 p += sizeof (Elf_External_Verdaux);
3750 while (def.vd_next);
3753 /* Adjust version references. */
3754 if (elf_tdata (output_bfd)->verref)
3759 Elf_Internal_Verneed need;
3760 Elf_Internal_Vernaux needaux;
3762 s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3763 p = (bfd_byte *) s->contents;
3766 _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3768 need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3769 _bfd_elf_swap_verneed_out (output_bfd, &need,
3770 (Elf_External_Verneed *) p);
3771 p += sizeof (Elf_External_Verneed);
3772 for (i = 0; i < need.vn_cnt; ++i)
3774 _bfd_elf_swap_vernaux_in (output_bfd,
3775 (Elf_External_Vernaux *) p, &needaux);
3776 needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3778 _bfd_elf_swap_vernaux_out (output_bfd,
3780 (Elf_External_Vernaux *) p);
3781 p += sizeof (Elf_External_Vernaux);
3784 while (need.vn_next);
3790 /* Fix up the flags for a symbol. This handles various cases which
3791 can only be fixed after all the input files are seen. This is
3792 currently called by both adjust_dynamic_symbol and
3793 assign_sym_version, which is unnecessary but perhaps more robust in
3794 the face of future changes. */
3797 elf_fix_symbol_flags (h, eif)
3798 struct elf_link_hash_entry *h;
3799 struct elf_info_failed *eif;
3801 /* If this symbol was mentioned in a non-ELF file, try to set
3802 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
3803 permit a non-ELF file to correctly refer to a symbol defined in
3804 an ELF dynamic object. */
3805 if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) != 0)
3807 while (h->root.type == bfd_link_hash_indirect)
3808 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3810 if (h->root.type != bfd_link_hash_defined
3811 && h->root.type != bfd_link_hash_defweak)
3812 h->elf_link_hash_flags |= (ELF_LINK_HASH_REF_REGULAR
3813 | ELF_LINK_HASH_REF_REGULAR_NONWEAK);
3816 if (h->root.u.def.section->owner != NULL
3817 && (bfd_get_flavour (h->root.u.def.section->owner)
3818 == bfd_target_elf_flavour))
3819 h->elf_link_hash_flags |= (ELF_LINK_HASH_REF_REGULAR
3820 | ELF_LINK_HASH_REF_REGULAR_NONWEAK);
3822 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3825 if (h->dynindx == -1
3826 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3827 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0))
3829 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
3838 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
3839 was first seen in a non-ELF file. Fortunately, if the symbol
3840 was first seen in an ELF file, we're probably OK unless the
3841 symbol was defined in a non-ELF file. Catch that case here.
3842 FIXME: We're still in trouble if the symbol was first seen in
3843 a dynamic object, and then later in a non-ELF regular object. */
3844 if ((h->root.type == bfd_link_hash_defined
3845 || h->root.type == bfd_link_hash_defweak)
3846 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
3847 && (h->root.u.def.section->owner != NULL
3848 ? (bfd_get_flavour (h->root.u.def.section->owner)
3849 != bfd_target_elf_flavour)
3850 : (bfd_is_abs_section (h->root.u.def.section)
3851 && (h->elf_link_hash_flags
3852 & ELF_LINK_HASH_DEF_DYNAMIC) == 0)))
3853 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3856 /* If this is a final link, and the symbol was defined as a common
3857 symbol in a regular object file, and there was no definition in
3858 any dynamic object, then the linker will have allocated space for
3859 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
3860 flag will not have been set. */
3861 if (h->root.type == bfd_link_hash_defined
3862 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
3863 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
3864 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3865 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
3866 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3868 /* If -Bsymbolic was used (which means to bind references to global
3869 symbols to the definition within the shared object), and this
3870 symbol was defined in a regular object, then it actually doesn't
3871 need a PLT entry, and we can accomplish that by forcing it local.
3872 Likewise, if the symbol has hidden or internal visibility.
3873 FIXME: It might be that we also do not need a PLT for other
3874 non-hidden visibilities, but we would have to tell that to the
3875 backend specifically; we can't just clear PLT-related data here. */
3876 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
3877 && eif->info->shared
3878 && is_elf_hash_table (eif->info)
3879 && (eif->info->symbolic
3880 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3881 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3882 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
3884 struct elf_backend_data *bed;
3885 boolean force_local;
3887 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
3889 force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3890 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
3891 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
3894 /* If this is a weak defined symbol in a dynamic object, and we know
3895 the real definition in the dynamic object, copy interesting flags
3896 over to the real definition. */
3897 if (h->weakdef != NULL)
3899 struct elf_link_hash_entry *weakdef;
3901 weakdef = h->weakdef;
3902 if (h->root.type == bfd_link_hash_indirect)
3903 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3905 BFD_ASSERT (h->root.type == bfd_link_hash_defined
3906 || h->root.type == bfd_link_hash_defweak);
3907 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
3908 || weakdef->root.type == bfd_link_hash_defweak);
3909 BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
3911 /* If the real definition is defined by a regular object file,
3912 don't do anything special. See the longer description in
3913 elf_adjust_dynamic_symbol, below. */
3914 if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
3918 struct elf_backend_data *bed;
3920 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
3921 (*bed->elf_backend_copy_indirect_symbol) (bed, weakdef, h);
3928 /* Make the backend pick a good value for a dynamic symbol. This is
3929 called via elf_link_hash_traverse, and also calls itself
3933 elf_adjust_dynamic_symbol (h, data)
3934 struct elf_link_hash_entry *h;
3937 struct elf_info_failed *eif = (struct elf_info_failed *) data;
3939 struct elf_backend_data *bed;
3941 if (h->root.type == bfd_link_hash_warning)
3943 h->plt.offset = (bfd_vma) -1;
3944 h->got.offset = (bfd_vma) -1;
3946 /* When warning symbols are created, they **replace** the "real"
3947 entry in the hash table, thus we never get to see the real
3948 symbol in a hash traversal. So look at it now. */
3949 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3952 /* Ignore indirect symbols. These are added by the versioning code. */
3953 if (h->root.type == bfd_link_hash_indirect)
3956 if (! is_elf_hash_table (eif->info))
3959 /* Fix the symbol flags. */
3960 if (! elf_fix_symbol_flags (h, eif))
3963 /* If this symbol does not require a PLT entry, and it is not
3964 defined by a dynamic object, or is not referenced by a regular
3965 object, ignore it. We do have to handle a weak defined symbol,
3966 even if no regular object refers to it, if we decided to add it
3967 to the dynamic symbol table. FIXME: Do we normally need to worry
3968 about symbols which are defined by one dynamic object and
3969 referenced by another one? */
3970 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
3971 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
3972 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3973 || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
3974 && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
3976 h->plt.offset = (bfd_vma) -1;
3980 /* If we've already adjusted this symbol, don't do it again. This
3981 can happen via a recursive call. */
3982 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
3985 /* Don't look at this symbol again. Note that we must set this
3986 after checking the above conditions, because we may look at a
3987 symbol once, decide not to do anything, and then get called
3988 recursively later after REF_REGULAR is set below. */
3989 h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
3991 /* If this is a weak definition, and we know a real definition, and
3992 the real symbol is not itself defined by a regular object file,
3993 then get a good value for the real definition. We handle the
3994 real symbol first, for the convenience of the backend routine.
3996 Note that there is a confusing case here. If the real definition
3997 is defined by a regular object file, we don't get the real symbol
3998 from the dynamic object, but we do get the weak symbol. If the
3999 processor backend uses a COPY reloc, then if some routine in the
4000 dynamic object changes the real symbol, we will not see that
4001 change in the corresponding weak symbol. This is the way other
4002 ELF linkers work as well, and seems to be a result of the shared
4005 I will clarify this issue. Most SVR4 shared libraries define the
4006 variable _timezone and define timezone as a weak synonym. The
4007 tzset call changes _timezone. If you write
4008 extern int timezone;
4010 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
4011 you might expect that, since timezone is a synonym for _timezone,
4012 the same number will print both times. However, if the processor
4013 backend uses a COPY reloc, then actually timezone will be copied
4014 into your process image, and, since you define _timezone
4015 yourself, _timezone will not. Thus timezone and _timezone will
4016 wind up at different memory locations. The tzset call will set
4017 _timezone, leaving timezone unchanged. */
4019 if (h->weakdef != NULL)
4021 /* If we get to this point, we know there is an implicit
4022 reference by a regular object file via the weak symbol H.
4023 FIXME: Is this really true? What if the traversal finds
4024 H->WEAKDEF before it finds H? */
4025 h->weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
4027 if (! elf_adjust_dynamic_symbol (h->weakdef, (PTR) eif))
4031 /* If a symbol has no type and no size and does not require a PLT
4032 entry, then we are probably about to do the wrong thing here: we
4033 are probably going to create a COPY reloc for an empty object.
4034 This case can arise when a shared object is built with assembly
4035 code, and the assembly code fails to set the symbol type. */
4037 && h->type == STT_NOTYPE
4038 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
4039 (*_bfd_error_handler)
4040 (_("warning: type and size of dynamic symbol `%s' are not defined"),
4041 h->root.root.string);
4043 dynobj = elf_hash_table (eif->info)->dynobj;
4044 bed = get_elf_backend_data (dynobj);
4045 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
4054 /* This routine is used to export all defined symbols into the dynamic
4055 symbol table. It is called via elf_link_hash_traverse. */
4058 elf_export_symbol (h, data)
4059 struct elf_link_hash_entry *h;
4062 struct elf_info_failed *eif = (struct elf_info_failed *) data;
4064 /* Ignore indirect symbols. These are added by the versioning code. */
4065 if (h->root.type == bfd_link_hash_indirect)
4068 if (h->root.type == bfd_link_hash_warning)
4069 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4071 if (h->dynindx == -1
4072 && (h->elf_link_hash_flags
4073 & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
4075 struct bfd_elf_version_tree *t;
4076 struct bfd_elf_version_expr *d;
4078 for (t = eif->verdefs; t != NULL; t = t->next)
4080 if (t->globals != NULL)
4082 for (d = t->globals; d != NULL; d = d->next)
4084 if ((*d->match) (d, h->root.root.string))
4089 if (t->locals != NULL)
4091 for (d = t->locals ; d != NULL; d = d->next)
4093 if ((*d->match) (d, h->root.root.string))
4102 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
4113 /* Look through the symbols which are defined in other shared
4114 libraries and referenced here. Update the list of version
4115 dependencies. This will be put into the .gnu.version_r section.
4116 This function is called via elf_link_hash_traverse. */
4119 elf_link_find_version_dependencies (h, data)
4120 struct elf_link_hash_entry *h;
4123 struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
4124 Elf_Internal_Verneed *t;
4125 Elf_Internal_Vernaux *a;
4128 if (h->root.type == bfd_link_hash_warning)
4129 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4131 /* We only care about symbols defined in shared objects with version
4133 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
4134 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
4136 || h->verinfo.verdef == NULL)
4139 /* See if we already know about this version. */
4140 for (t = elf_tdata (rinfo->output_bfd)->verref; t != NULL; t = t->vn_nextref)
4142 if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
4145 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4146 if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
4152 /* This is a new version. Add it to tree we are building. */
4157 t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->output_bfd, amt);
4160 rinfo->failed = true;
4164 t->vn_bfd = h->verinfo.verdef->vd_bfd;
4165 t->vn_nextref = elf_tdata (rinfo->output_bfd)->verref;
4166 elf_tdata (rinfo->output_bfd)->verref = t;
4170 a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->output_bfd, amt);
4172 /* Note that we are copying a string pointer here, and testing it
4173 above. If bfd_elf_string_from_elf_section is ever changed to
4174 discard the string data when low in memory, this will have to be
4176 a->vna_nodename = h->verinfo.verdef->vd_nodename;
4178 a->vna_flags = h->verinfo.verdef->vd_flags;
4179 a->vna_nextptr = t->vn_auxptr;
4181 h->verinfo.verdef->vd_exp_refno = rinfo->vers;
4184 a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
4191 /* Figure out appropriate versions for all the symbols. We may not
4192 have the version number script until we have read all of the input
4193 files, so until that point we don't know which symbols should be
4194 local. This function is called via elf_link_hash_traverse. */
4197 elf_link_assign_sym_version (h, data)
4198 struct elf_link_hash_entry *h;
4201 struct elf_assign_sym_version_info *sinfo;
4202 struct bfd_link_info *info;
4203 struct elf_backend_data *bed;
4204 struct elf_info_failed eif;
4208 sinfo = (struct elf_assign_sym_version_info *) data;
4211 if (h->root.type == bfd_link_hash_warning)
4212 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4214 /* Fix the symbol flags. */
4217 if (! elf_fix_symbol_flags (h, &eif))
4220 sinfo->failed = true;
4224 /* We only need version numbers for symbols defined in regular
4226 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4229 bed = get_elf_backend_data (sinfo->output_bfd);
4230 p = strchr (h->root.root.string, ELF_VER_CHR);
4231 if (p != NULL && h->verinfo.vertree == NULL)
4233 struct bfd_elf_version_tree *t;
4238 /* There are two consecutive ELF_VER_CHR characters if this is
4239 not a hidden symbol. */
4241 if (*p == ELF_VER_CHR)
4247 /* If there is no version string, we can just return out. */
4251 h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
4255 /* Look for the version. If we find it, it is no longer weak. */
4256 for (t = sinfo->verdefs; t != NULL; t = t->next)
4258 if (strcmp (t->name, p) == 0)
4262 struct bfd_elf_version_expr *d;
4264 len = p - h->root.root.string;
4265 alc = bfd_malloc ((bfd_size_type) len);
4268 memcpy (alc, h->root.root.string, len - 1);
4269 alc[len - 1] = '\0';
4270 if (alc[len - 2] == ELF_VER_CHR)
4271 alc[len - 2] = '\0';
4273 h->verinfo.vertree = t;
4277 if (t->globals != NULL)
4279 for (d = t->globals; d != NULL; d = d->next)
4280 if ((*d->match) (d, alc))
4284 /* See if there is anything to force this symbol to
4286 if (d == NULL && t->locals != NULL)
4288 for (d = t->locals; d != NULL; d = d->next)
4290 if ((*d->match) (d, alc))
4292 if (h->dynindx != -1
4294 && ! info->export_dynamic)
4296 (*bed->elf_backend_hide_symbol) (info, h, true);
4309 /* If we are building an application, we need to create a
4310 version node for this version. */
4311 if (t == NULL && ! info->shared)
4313 struct bfd_elf_version_tree **pp;
4316 /* If we aren't going to export this symbol, we don't need
4317 to worry about it. */
4318 if (h->dynindx == -1)
4322 t = ((struct bfd_elf_version_tree *)
4323 bfd_alloc (sinfo->output_bfd, amt));
4326 sinfo->failed = true;
4335 t->name_indx = (unsigned int) -1;
4339 /* Don't count anonymous version tag. */
4340 if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0)
4342 for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
4344 t->vernum = version_index;
4348 h->verinfo.vertree = t;
4352 /* We could not find the version for a symbol when
4353 generating a shared archive. Return an error. */
4354 (*_bfd_error_handler)
4355 (_("%s: undefined versioned symbol name %s"),
4356 bfd_get_filename (sinfo->output_bfd), h->root.root.string);
4357 bfd_set_error (bfd_error_bad_value);
4358 sinfo->failed = true;
4363 h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
4366 /* If we don't have a version for this symbol, see if we can find
4368 if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
4370 struct bfd_elf_version_tree *t;
4371 struct bfd_elf_version_tree *local_ver;
4372 struct bfd_elf_version_expr *d;
4374 /* See if can find what version this symbol is in. If the
4375 symbol is supposed to be local, then don't actually register
4378 for (t = sinfo->verdefs; t != NULL; t = t->next)
4380 if (t->globals != NULL)
4385 for (d = t->globals; d != NULL; d = d->next)
4387 if ((*d->match) (d, h->root.root.string))
4393 /* There is a version without definition. Make
4394 the symbol the default definition for this
4396 h->verinfo.vertree = t;
4407 /* There is no undefined version for this symbol. Hide the
4409 (*bed->elf_backend_hide_symbol) (info, h, true);
4412 if (t->locals != NULL)
4414 for (d = t->locals; d != NULL; d = d->next)
4416 /* If the match is "*", keep looking for a more
4417 explicit, perhaps even global, match. */
4418 if (d->pattern[0] == '*' && d->pattern[1] == '\0')
4420 else if ((*d->match) (d, h->root.root.string))
4432 if (local_ver != NULL)
4434 h->verinfo.vertree = local_ver;
4435 if (h->dynindx != -1
4437 && ! info->export_dynamic)
4439 (*bed->elf_backend_hide_symbol) (info, h, true);
4447 /* Final phase of ELF linker. */
4449 /* A structure we use to avoid passing large numbers of arguments. */
4451 struct elf_final_link_info
4453 /* General link information. */
4454 struct bfd_link_info *info;
4457 /* Symbol string table. */
4458 struct bfd_strtab_hash *symstrtab;
4459 /* .dynsym section. */
4460 asection *dynsym_sec;
4461 /* .hash section. */
4463 /* symbol version section (.gnu.version). */
4464 asection *symver_sec;
4465 /* first SHF_TLS section (if any). */
4466 asection *first_tls_sec;
4467 /* Buffer large enough to hold contents of any section. */
4469 /* Buffer large enough to hold external relocs of any section. */
4470 PTR external_relocs;
4471 /* Buffer large enough to hold internal relocs of any section. */
4472 Elf_Internal_Rela *internal_relocs;
4473 /* Buffer large enough to hold external local symbols of any input
4475 Elf_External_Sym *external_syms;
4476 /* And a buffer for symbol section indices. */
4477 Elf_External_Sym_Shndx *locsym_shndx;
4478 /* Buffer large enough to hold internal local symbols of any input
4480 Elf_Internal_Sym *internal_syms;
4481 /* Array large enough to hold a symbol index for each local symbol
4482 of any input BFD. */
4484 /* Array large enough to hold a section pointer for each local
4485 symbol of any input BFD. */
4486 asection **sections;
4487 /* Buffer to hold swapped out symbols. */
4488 Elf_External_Sym *symbuf;
4489 /* And one for symbol section indices. */
4490 Elf_External_Sym_Shndx *symshndxbuf;
4491 /* Number of swapped out symbols in buffer. */
4492 size_t symbuf_count;
4493 /* Number of symbols which fit in symbuf. */
4497 static boolean elf_link_output_sym
4498 PARAMS ((struct elf_final_link_info *, const char *,
4499 Elf_Internal_Sym *, asection *));
4500 static boolean elf_link_flush_output_syms
4501 PARAMS ((struct elf_final_link_info *));
4502 static boolean elf_link_output_extsym
4503 PARAMS ((struct elf_link_hash_entry *, PTR));
4504 static boolean elf_link_sec_merge_syms
4505 PARAMS ((struct elf_link_hash_entry *, PTR));
4506 static boolean elf_link_check_versioned_symbol
4507 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
4508 static boolean elf_link_input_bfd
4509 PARAMS ((struct elf_final_link_info *, bfd *));
4510 static boolean elf_reloc_link_order
4511 PARAMS ((bfd *, struct bfd_link_info *, asection *,
4512 struct bfd_link_order *));
4514 /* This struct is used to pass information to elf_link_output_extsym. */
4516 struct elf_outext_info
4520 struct elf_final_link_info *finfo;
4523 /* Compute the size of, and allocate space for, REL_HDR which is the
4524 section header for a section containing relocations for O. */
4527 elf_link_size_reloc_section (abfd, rel_hdr, o)
4529 Elf_Internal_Shdr *rel_hdr;
4532 bfd_size_type reloc_count;
4533 bfd_size_type num_rel_hashes;
4535 /* Figure out how many relocations there will be. */
4536 if (rel_hdr == &elf_section_data (o)->rel_hdr)
4537 reloc_count = elf_section_data (o)->rel_count;
4539 reloc_count = elf_section_data (o)->rel_count2;
4541 num_rel_hashes = o->reloc_count;
4542 if (num_rel_hashes < reloc_count)
4543 num_rel_hashes = reloc_count;
4545 /* That allows us to calculate the size of the section. */
4546 rel_hdr->sh_size = rel_hdr->sh_entsize * reloc_count;
4548 /* The contents field must last into write_object_contents, so we
4549 allocate it with bfd_alloc rather than malloc. Also since we
4550 cannot be sure that the contents will actually be filled in,
4551 we zero the allocated space. */
4552 rel_hdr->contents = (PTR) bfd_zalloc (abfd, rel_hdr->sh_size);
4553 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
4556 /* We only allocate one set of hash entries, so we only do it the
4557 first time we are called. */
4558 if (elf_section_data (o)->rel_hashes == NULL
4561 struct elf_link_hash_entry **p;
4563 p = ((struct elf_link_hash_entry **)
4564 bfd_zmalloc (num_rel_hashes
4565 * sizeof (struct elf_link_hash_entry *)));
4569 elf_section_data (o)->rel_hashes = p;
4575 /* When performing a relocateable link, the input relocations are
4576 preserved. But, if they reference global symbols, the indices
4577 referenced must be updated. Update all the relocations in
4578 REL_HDR (there are COUNT of them), using the data in REL_HASH. */
4581 elf_link_adjust_relocs (abfd, rel_hdr, count, rel_hash)
4583 Elf_Internal_Shdr *rel_hdr;
4585 struct elf_link_hash_entry **rel_hash;
4588 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4589 Elf_Internal_Rel *irel;
4590 Elf_Internal_Rela *irela;
4591 bfd_size_type amt = sizeof (Elf_Internal_Rel) * bed->s->int_rels_per_ext_rel;
4593 irel = (Elf_Internal_Rel *) bfd_zmalloc (amt);
4596 (*_bfd_error_handler) (_("Error: out of memory"));
4600 amt = sizeof (Elf_Internal_Rela) * bed->s->int_rels_per_ext_rel;
4601 irela = (Elf_Internal_Rela *) bfd_zmalloc (amt);
4604 (*_bfd_error_handler) (_("Error: out of memory"));
4608 for (i = 0; i < count; i++, rel_hash++)
4610 if (*rel_hash == NULL)
4613 BFD_ASSERT ((*rel_hash)->indx >= 0);
4615 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
4617 Elf_External_Rel *erel;
4620 erel = (Elf_External_Rel *) rel_hdr->contents + i;
4621 if (bed->s->swap_reloc_in)
4622 (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, irel);
4624 elf_swap_reloc_in (abfd, erel, irel);
4626 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
4627 irel[j].r_info = ELF_R_INFO ((*rel_hash)->indx,
4628 ELF_R_TYPE (irel[j].r_info));
4630 if (bed->s->swap_reloc_out)
4631 (*bed->s->swap_reloc_out) (abfd, irel, (bfd_byte *) erel);
4633 elf_swap_reloc_out (abfd, irel, erel);
4637 Elf_External_Rela *erela;
4640 BFD_ASSERT (rel_hdr->sh_entsize
4641 == sizeof (Elf_External_Rela));
4643 erela = (Elf_External_Rela *) rel_hdr->contents + i;
4644 if (bed->s->swap_reloca_in)
4645 (*bed->s->swap_reloca_in) (abfd, (bfd_byte *) erela, irela);
4647 elf_swap_reloca_in (abfd, erela, irela);
4649 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
4650 irela[j].r_info = ELF_R_INFO ((*rel_hash)->indx,
4651 ELF_R_TYPE (irela[j].r_info));
4653 if (bed->s->swap_reloca_out)
4654 (*bed->s->swap_reloca_out) (abfd, irela, (bfd_byte *) erela);
4656 elf_swap_reloca_out (abfd, irela, erela);
4664 struct elf_link_sort_rela
4667 enum elf_reloc_type_class type;
4670 Elf_Internal_Rel rel;
4671 Elf_Internal_Rela rela;
4676 elf_link_sort_cmp1 (A, B)
4680 struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
4681 struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
4682 int relativea, relativeb;
4684 relativea = a->type == reloc_class_relative;
4685 relativeb = b->type == reloc_class_relative;
4687 if (relativea < relativeb)
4689 if (relativea > relativeb)
4691 if (ELF_R_SYM (a->u.rel.r_info) < ELF_R_SYM (b->u.rel.r_info))
4693 if (ELF_R_SYM (a->u.rel.r_info) > ELF_R_SYM (b->u.rel.r_info))
4695 if (a->u.rel.r_offset < b->u.rel.r_offset)
4697 if (a->u.rel.r_offset > b->u.rel.r_offset)
4703 elf_link_sort_cmp2 (A, B)
4707 struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
4708 struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
4711 if (a->offset < b->offset)
4713 if (a->offset > b->offset)
4715 copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt);
4716 copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt);
4721 if (a->u.rel.r_offset < b->u.rel.r_offset)
4723 if (a->u.rel.r_offset > b->u.rel.r_offset)
4729 elf_link_sort_relocs (abfd, info, psec)
4731 struct bfd_link_info *info;
4734 bfd *dynobj = elf_hash_table (info)->dynobj;
4735 asection *reldyn, *o;
4736 boolean rel = false;
4737 bfd_size_type count, size;
4739 struct elf_link_sort_rela *rela;
4740 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4742 reldyn = bfd_get_section_by_name (abfd, ".rela.dyn");
4743 if (reldyn == NULL || reldyn->_raw_size == 0)
4745 reldyn = bfd_get_section_by_name (abfd, ".rel.dyn");
4746 if (reldyn == NULL || reldyn->_raw_size == 0)
4749 count = reldyn->_raw_size / sizeof (Elf_External_Rel);
4752 count = reldyn->_raw_size / sizeof (Elf_External_Rela);
4755 for (o = dynobj->sections; o != NULL; o = o->next)
4756 if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
4757 == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
4758 && o->output_section == reldyn)
4759 size += o->_raw_size;
4761 if (size != reldyn->_raw_size)
4764 rela = (struct elf_link_sort_rela *) bfd_zmalloc (sizeof (*rela) * count);
4767 (*info->callbacks->warning)
4768 (info, _("Not enough memory to sort relocations"), 0, abfd, 0,
4773 for (o = dynobj->sections; o != NULL; o = o->next)
4774 if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
4775 == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
4776 && o->output_section == reldyn)
4780 Elf_External_Rel *erel, *erelend;
4781 struct elf_link_sort_rela *s;
4783 erel = (Elf_External_Rel *) o->contents;
4784 erelend = (Elf_External_Rel *) (o->contents + o->_raw_size);
4785 s = rela + o->output_offset / sizeof (Elf_External_Rel);
4786 for (; erel < erelend; erel++, s++)
4788 if (bed->s->swap_reloc_in)
4789 (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, &s->u.rel);
4791 elf_swap_reloc_in (abfd, erel, &s->u.rel);
4793 s->type = (*bed->elf_backend_reloc_type_class) (&s->u.rela);
4798 Elf_External_Rela *erela, *erelaend;
4799 struct elf_link_sort_rela *s;
4801 erela = (Elf_External_Rela *) o->contents;
4802 erelaend = (Elf_External_Rela *) (o->contents + o->_raw_size);
4803 s = rela + o->output_offset / sizeof (Elf_External_Rela);
4804 for (; erela < erelaend; erela++, s++)
4806 if (bed->s->swap_reloca_in)
4807 (*bed->s->swap_reloca_in) (dynobj, (bfd_byte *) erela,
4810 elf_swap_reloca_in (dynobj, erela, &s->u.rela);
4812 s->type = (*bed->elf_backend_reloc_type_class) (&s->u.rela);
4817 qsort (rela, (size_t) count, sizeof (*rela), elf_link_sort_cmp1);
4818 for (ret = 0; ret < count && rela[ret].type == reloc_class_relative; ret++)
4820 for (i = ret, j = ret; i < count; i++)
4822 if (ELF_R_SYM (rela[i].u.rel.r_info) != ELF_R_SYM (rela[j].u.rel.r_info))
4824 rela[i].offset = rela[j].u.rel.r_offset;
4826 qsort (rela + ret, (size_t) count - ret, sizeof (*rela), elf_link_sort_cmp2);
4828 for (o = dynobj->sections; o != NULL; o = o->next)
4829 if ((o->flags & (SEC_HAS_CONTENTS|SEC_LINKER_CREATED))
4830 == (SEC_HAS_CONTENTS|SEC_LINKER_CREATED)
4831 && o->output_section == reldyn)
4835 Elf_External_Rel *erel, *erelend;
4836 struct elf_link_sort_rela *s;
4838 erel = (Elf_External_Rel *) o->contents;
4839 erelend = (Elf_External_Rel *) (o->contents + o->_raw_size);
4840 s = rela + o->output_offset / sizeof (Elf_External_Rel);
4841 for (; erel < erelend; erel++, s++)
4843 if (bed->s->swap_reloc_out)
4844 (*bed->s->swap_reloc_out) (abfd, &s->u.rel,
4847 elf_swap_reloc_out (abfd, &s->u.rel, erel);
4852 Elf_External_Rela *erela, *erelaend;
4853 struct elf_link_sort_rela *s;
4855 erela = (Elf_External_Rela *) o->contents;
4856 erelaend = (Elf_External_Rela *) (o->contents + o->_raw_size);
4857 s = rela + o->output_offset / sizeof (Elf_External_Rela);
4858 for (; erela < erelaend; erela++, s++)
4860 if (bed->s->swap_reloca_out)
4861 (*bed->s->swap_reloca_out) (dynobj, &s->u.rela,
4862 (bfd_byte *) erela);
4864 elf_swap_reloca_out (dynobj, &s->u.rela, erela);
4874 /* Do the final step of an ELF link. */
4877 elf_bfd_final_link (abfd, info)
4879 struct bfd_link_info *info;
4882 boolean emit_relocs;
4884 struct elf_final_link_info finfo;
4885 register asection *o;
4886 register struct bfd_link_order *p;
4888 bfd_size_type max_contents_size;
4889 bfd_size_type max_external_reloc_size;
4890 bfd_size_type max_internal_reloc_count;
4891 bfd_size_type max_sym_count;
4892 bfd_size_type max_sym_shndx_count;
4894 Elf_Internal_Sym elfsym;
4896 Elf_Internal_Shdr *symtab_hdr;
4897 Elf_Internal_Shdr *symstrtab_hdr;
4898 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4899 struct elf_outext_info eoinfo;
4901 size_t relativecount = 0;
4902 asection *reldyn = 0;
4905 if (! is_elf_hash_table (info))
4909 abfd->flags |= DYNAMIC;
4911 dynamic = elf_hash_table (info)->dynamic_sections_created;
4912 dynobj = elf_hash_table (info)->dynobj;
4914 emit_relocs = (info->relocateable
4915 || info->emitrelocations
4916 || bed->elf_backend_emit_relocs);
4919 finfo.output_bfd = abfd;
4920 finfo.symstrtab = elf_stringtab_init ();
4921 if (finfo.symstrtab == NULL)
4926 finfo.dynsym_sec = NULL;
4927 finfo.hash_sec = NULL;
4928 finfo.symver_sec = NULL;
4932 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
4933 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
4934 BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
4935 finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
4936 /* Note that it is OK if symver_sec is NULL. */
4939 finfo.contents = NULL;
4940 finfo.external_relocs = NULL;
4941 finfo.internal_relocs = NULL;
4942 finfo.external_syms = NULL;
4943 finfo.locsym_shndx = NULL;
4944 finfo.internal_syms = NULL;
4945 finfo.indices = NULL;
4946 finfo.sections = NULL;
4947 finfo.symbuf = NULL;
4948 finfo.symshndxbuf = NULL;
4949 finfo.symbuf_count = 0;
4950 finfo.first_tls_sec = NULL;
4951 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4952 if ((o->flags & SEC_THREAD_LOCAL) != 0
4953 && (o->flags & SEC_LOAD) != 0)
4955 finfo.first_tls_sec = o;
4959 /* Count up the number of relocations we will output for each output
4960 section, so that we know the sizes of the reloc sections. We
4961 also figure out some maximum sizes. */
4962 max_contents_size = 0;
4963 max_external_reloc_size = 0;
4964 max_internal_reloc_count = 0;
4966 max_sym_shndx_count = 0;
4968 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4972 for (p = o->link_order_head; p != NULL; p = p->next)
4974 if (p->type == bfd_section_reloc_link_order
4975 || p->type == bfd_symbol_reloc_link_order)
4977 else if (p->type == bfd_indirect_link_order)
4981 sec = p->u.indirect.section;
4983 /* Mark all sections which are to be included in the
4984 link. This will normally be every section. We need
4985 to do this so that we can identify any sections which
4986 the linker has decided to not include. */
4987 sec->linker_mark = true;
4989 if (sec->flags & SEC_MERGE)
4992 if (info->relocateable || info->emitrelocations)
4993 o->reloc_count += sec->reloc_count;
4994 else if (bed->elf_backend_count_relocs)
4996 Elf_Internal_Rela * relocs;
4998 relocs = (NAME(_bfd_elf,link_read_relocs)
4999 (abfd, sec, (PTR) NULL,
5000 (Elf_Internal_Rela *) NULL, info->keep_memory));
5003 += (*bed->elf_backend_count_relocs) (sec, relocs);
5005 if (elf_section_data (o)->relocs != relocs)
5009 if (sec->_raw_size > max_contents_size)
5010 max_contents_size = sec->_raw_size;
5011 if (sec->_cooked_size > max_contents_size)
5012 max_contents_size = sec->_cooked_size;
5014 /* We are interested in just local symbols, not all
5016 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
5017 && (sec->owner->flags & DYNAMIC) == 0)
5021 if (elf_bad_symtab (sec->owner))
5022 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
5023 / sizeof (Elf_External_Sym));
5025 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
5027 if (sym_count > max_sym_count)
5028 max_sym_count = sym_count;
5030 if (sym_count > max_sym_shndx_count
5031 && elf_symtab_shndx (sec->owner) != 0)
5032 max_sym_shndx_count = sym_count;
5034 if ((sec->flags & SEC_RELOC) != 0)
5038 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
5039 if (ext_size > max_external_reloc_size)
5040 max_external_reloc_size = ext_size;
5041 if (sec->reloc_count > max_internal_reloc_count)
5042 max_internal_reloc_count = sec->reloc_count;
5048 if (o->reloc_count > 0)
5049 o->flags |= SEC_RELOC;
5052 /* Explicitly clear the SEC_RELOC flag. The linker tends to
5053 set it (this is probably a bug) and if it is set
5054 assign_section_numbers will create a reloc section. */
5055 o->flags &=~ SEC_RELOC;
5058 /* If the SEC_ALLOC flag is not set, force the section VMA to
5059 zero. This is done in elf_fake_sections as well, but forcing
5060 the VMA to 0 here will ensure that relocs against these
5061 sections are handled correctly. */
5062 if ((o->flags & SEC_ALLOC) == 0
5063 && ! o->user_set_vma)
5067 if (! info->relocateable && merged)
5068 elf_link_hash_traverse (elf_hash_table (info),
5069 elf_link_sec_merge_syms, (PTR) abfd);
5071 /* Figure out the file positions for everything but the symbol table
5072 and the relocs. We set symcount to force assign_section_numbers
5073 to create a symbol table. */
5074 bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
5075 BFD_ASSERT (! abfd->output_has_begun);
5076 if (! _bfd_elf_compute_section_file_positions (abfd, info))
5079 /* Figure out how many relocations we will have in each section.
5080 Just using RELOC_COUNT isn't good enough since that doesn't
5081 maintain a separate value for REL vs. RELA relocations. */
5083 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5084 for (o = sub->sections; o != NULL; o = o->next)
5086 asection *output_section;
5088 if (! o->linker_mark)
5090 /* This section was omitted from the link. */
5094 output_section = o->output_section;
5096 if (output_section != NULL
5097 && (o->flags & SEC_RELOC) != 0)
5099 struct bfd_elf_section_data *esdi
5100 = elf_section_data (o);
5101 struct bfd_elf_section_data *esdo
5102 = elf_section_data (output_section);
5103 unsigned int *rel_count;
5104 unsigned int *rel_count2;
5105 bfd_size_type entsize;
5106 bfd_size_type entsize2;
5108 /* We must be careful to add the relocations from the
5109 input section to the right output count. */
5110 entsize = esdi->rel_hdr.sh_entsize;
5111 entsize2 = esdi->rel_hdr2 ? esdi->rel_hdr2->sh_entsize : 0;
5112 BFD_ASSERT ((entsize == sizeof (Elf_External_Rel)
5113 || entsize == sizeof (Elf_External_Rela))
5114 && entsize2 != entsize
5116 || entsize2 == sizeof (Elf_External_Rel)
5117 || entsize2 == sizeof (Elf_External_Rela)));
5118 if (entsize == esdo->rel_hdr.sh_entsize)
5120 rel_count = &esdo->rel_count;
5121 rel_count2 = &esdo->rel_count2;
5125 rel_count = &esdo->rel_count2;
5126 rel_count2 = &esdo->rel_count;
5129 *rel_count += NUM_SHDR_ENTRIES (& esdi->rel_hdr);
5131 *rel_count2 += NUM_SHDR_ENTRIES (esdi->rel_hdr2);
5132 output_section->flags |= SEC_RELOC;
5136 /* That created the reloc sections. Set their sizes, and assign
5137 them file positions, and allocate some buffers. */
5138 for (o = abfd->sections; o != NULL; o = o->next)
5140 if ((o->flags & SEC_RELOC) != 0)
5142 if (!elf_link_size_reloc_section (abfd,
5143 &elf_section_data (o)->rel_hdr,
5147 if (elf_section_data (o)->rel_hdr2
5148 && !elf_link_size_reloc_section (abfd,
5149 elf_section_data (o)->rel_hdr2,
5154 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
5155 to count upwards while actually outputting the relocations. */
5156 elf_section_data (o)->rel_count = 0;
5157 elf_section_data (o)->rel_count2 = 0;
5160 _bfd_elf_assign_file_positions_for_relocs (abfd);
5162 /* We have now assigned file positions for all the sections except
5163 .symtab and .strtab. We start the .symtab section at the current
5164 file position, and write directly to it. We build the .strtab
5165 section in memory. */
5166 bfd_get_symcount (abfd) = 0;
5167 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5168 /* sh_name is set in prep_headers. */
5169 symtab_hdr->sh_type = SHT_SYMTAB;
5170 symtab_hdr->sh_flags = 0;
5171 symtab_hdr->sh_addr = 0;
5172 symtab_hdr->sh_size = 0;
5173 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
5174 /* sh_link is set in assign_section_numbers. */
5175 /* sh_info is set below. */
5176 /* sh_offset is set just below. */
5177 symtab_hdr->sh_addralign = bed->s->file_align;
5179 off = elf_tdata (abfd)->next_file_pos;
5180 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
5182 /* Note that at this point elf_tdata (abfd)->next_file_pos is
5183 incorrect. We do not yet know the size of the .symtab section.
5184 We correct next_file_pos below, after we do know the size. */
5186 /* Allocate a buffer to hold swapped out symbols. This is to avoid
5187 continuously seeking to the right position in the file. */
5188 if (! info->keep_memory || max_sym_count < 20)
5189 finfo.symbuf_size = 20;
5191 finfo.symbuf_size = max_sym_count;
5192 amt = finfo.symbuf_size;
5193 amt *= sizeof (Elf_External_Sym);
5194 finfo.symbuf = (Elf_External_Sym *) bfd_malloc (amt);
5195 if (finfo.symbuf == NULL)
5197 if (elf_numsections (abfd) > SHN_LORESERVE)
5199 amt = finfo.symbuf_size;
5200 amt *= sizeof (Elf_External_Sym_Shndx);
5201 finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
5202 if (finfo.symshndxbuf == NULL)
5206 /* Start writing out the symbol table. The first symbol is always a
5208 if (info->strip != strip_all
5211 elfsym.st_value = 0;
5214 elfsym.st_other = 0;
5215 elfsym.st_shndx = SHN_UNDEF;
5216 if (! elf_link_output_sym (&finfo, (const char *) NULL,
5217 &elfsym, bfd_und_section_ptr))
5222 /* Some standard ELF linkers do this, but we don't because it causes
5223 bootstrap comparison failures. */
5224 /* Output a file symbol for the output file as the second symbol.
5225 We output this even if we are discarding local symbols, although
5226 I'm not sure if this is correct. */
5227 elfsym.st_value = 0;
5229 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5230 elfsym.st_other = 0;
5231 elfsym.st_shndx = SHN_ABS;
5232 if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
5233 &elfsym, bfd_abs_section_ptr))
5237 /* Output a symbol for each section. We output these even if we are
5238 discarding local symbols, since they are used for relocs. These
5239 symbols have no names. We store the index of each one in the
5240 index field of the section, so that we can find it again when
5241 outputting relocs. */
5242 if (info->strip != strip_all
5246 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5247 elfsym.st_other = 0;
5248 for (i = 1; i < elf_numsections (abfd); i++)
5250 o = section_from_elf_index (abfd, i);
5252 o->target_index = bfd_get_symcount (abfd);
5253 elfsym.st_shndx = i;
5254 if (info->relocateable || o == NULL)
5255 elfsym.st_value = 0;
5257 elfsym.st_value = o->vma;
5258 if (! elf_link_output_sym (&finfo, (const char *) NULL,
5261 if (i == SHN_LORESERVE)
5262 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
5266 /* Allocate some memory to hold information read in from the input
5268 if (max_contents_size != 0)
5270 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
5271 if (finfo.contents == NULL)
5275 if (max_external_reloc_size != 0)
5277 finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
5278 if (finfo.external_relocs == NULL)
5282 if (max_internal_reloc_count != 0)
5284 amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
5285 amt *= sizeof (Elf_Internal_Rela);
5286 finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
5287 if (finfo.internal_relocs == NULL)
5291 if (max_sym_count != 0)
5293 amt = max_sym_count * sizeof (Elf_External_Sym);
5294 finfo.external_syms = (Elf_External_Sym *) bfd_malloc (amt);
5295 if (finfo.external_syms == NULL)
5298 amt = max_sym_count * sizeof (Elf_Internal_Sym);
5299 finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
5300 if (finfo.internal_syms == NULL)
5303 amt = max_sym_count * sizeof (long);
5304 finfo.indices = (long *) bfd_malloc (amt);
5305 if (finfo.indices == NULL)
5308 amt = max_sym_count * sizeof (asection *);
5309 finfo.sections = (asection **) bfd_malloc (amt);
5310 if (finfo.sections == NULL)
5314 if (max_sym_shndx_count != 0)
5316 amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
5317 finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
5318 if (finfo.locsym_shndx == NULL)
5322 if (finfo.first_tls_sec)
5324 unsigned int align = 0;
5325 bfd_vma base = finfo.first_tls_sec->vma, end = 0;
5328 for (sec = finfo.first_tls_sec;
5329 sec && (sec->flags & SEC_THREAD_LOCAL);
5332 bfd_vma size = sec->_raw_size;
5334 if (bfd_get_section_alignment (abfd, sec) > align)
5335 align = bfd_get_section_alignment (abfd, sec);
5336 if (sec->_raw_size == 0 && (sec->flags & SEC_HAS_CONTENTS) == 0)
5338 struct bfd_link_order *o;
5341 for (o = sec->link_order_head; o != NULL; o = o->next)
5342 if (size < o->offset + o->size)
5343 size = o->offset + o->size;
5345 end = sec->vma + size;
5347 elf_hash_table (info)->tls_segment
5348 = bfd_zalloc (abfd, sizeof (struct elf_link_tls_segment));
5349 if (elf_hash_table (info)->tls_segment == NULL)
5351 elf_hash_table (info)->tls_segment->start = base;
5352 elf_hash_table (info)->tls_segment->size = end - base;
5353 elf_hash_table (info)->tls_segment->align = align;
5356 /* Since ELF permits relocations to be against local symbols, we
5357 must have the local symbols available when we do the relocations.
5358 Since we would rather only read the local symbols once, and we
5359 would rather not keep them in memory, we handle all the
5360 relocations for a single input file at the same time.
5362 Unfortunately, there is no way to know the total number of local
5363 symbols until we have seen all of them, and the local symbol
5364 indices precede the global symbol indices. This means that when
5365 we are generating relocateable output, and we see a reloc against
5366 a global symbol, we can not know the symbol index until we have
5367 finished examining all the local symbols to see which ones we are
5368 going to output. To deal with this, we keep the relocations in
5369 memory, and don't output them until the end of the link. This is
5370 an unfortunate waste of memory, but I don't see a good way around
5371 it. Fortunately, it only happens when performing a relocateable
5372 link, which is not the common case. FIXME: If keep_memory is set
5373 we could write the relocs out and then read them again; I don't
5374 know how bad the memory loss will be. */
5376 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5377 sub->output_has_begun = false;
5378 for (o = abfd->sections; o != NULL; o = o->next)
5380 for (p = o->link_order_head; p != NULL; p = p->next)
5382 if (p->type == bfd_indirect_link_order
5383 && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
5384 == bfd_target_elf_flavour)
5385 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
5387 if (! sub->output_has_begun)
5389 if (! elf_link_input_bfd (&finfo, sub))
5391 sub->output_has_begun = true;
5394 else if (p->type == bfd_section_reloc_link_order
5395 || p->type == bfd_symbol_reloc_link_order)
5397 if (! elf_reloc_link_order (abfd, info, o, p))
5402 if (! _bfd_default_link_order (abfd, info, o, p))
5408 /* Output any global symbols that got converted to local in a
5409 version script or due to symbol visibility. We do this in a
5410 separate step since ELF requires all local symbols to appear
5411 prior to any global symbols. FIXME: We should only do this if
5412 some global symbols were, in fact, converted to become local.
5413 FIXME: Will this work correctly with the Irix 5 linker? */
5414 eoinfo.failed = false;
5415 eoinfo.finfo = &finfo;
5416 eoinfo.localsyms = true;
5417 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
5422 /* That wrote out all the local symbols. Finish up the symbol table
5423 with the global symbols. Even if we want to strip everything we
5424 can, we still need to deal with those global symbols that got
5425 converted to local in a version script. */
5427 /* The sh_info field records the index of the first non local symbol. */
5428 symtab_hdr->sh_info = bfd_get_symcount (abfd);
5431 && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
5433 Elf_Internal_Sym sym;
5434 Elf_External_Sym *dynsym =
5435 (Elf_External_Sym *) finfo.dynsym_sec->contents;
5436 long last_local = 0;
5438 /* Write out the section symbols for the output sections. */
5445 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5448 for (s = abfd->sections; s != NULL; s = s->next)
5451 Elf_External_Sym *dest;
5453 indx = elf_section_data (s)->this_idx;
5454 BFD_ASSERT (indx > 0);
5455 sym.st_shndx = indx;
5456 sym.st_value = s->vma;
5457 dest = dynsym + elf_section_data (s)->dynindx;
5458 elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
5461 last_local = bfd_count_sections (abfd);
5464 /* Write out the local dynsyms. */
5465 if (elf_hash_table (info)->dynlocal)
5467 struct elf_link_local_dynamic_entry *e;
5468 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
5471 Elf_External_Sym *dest;
5473 sym.st_size = e->isym.st_size;
5474 sym.st_other = e->isym.st_other;
5476 /* Copy the internal symbol as is.
5477 Note that we saved a word of storage and overwrote
5478 the original st_name with the dynstr_index. */
5481 if (e->isym.st_shndx != SHN_UNDEF
5482 && (e->isym.st_shndx < SHN_LORESERVE
5483 || e->isym.st_shndx > SHN_HIRESERVE))
5485 s = bfd_section_from_elf_index (e->input_bfd,
5489 elf_section_data (s->output_section)->this_idx;
5490 sym.st_value = (s->output_section->vma
5492 + e->isym.st_value);
5495 if (last_local < e->dynindx)
5496 last_local = e->dynindx;
5498 dest = dynsym + e->dynindx;
5499 elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
5503 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
5507 /* We get the global symbols from the hash table. */
5508 eoinfo.failed = false;
5509 eoinfo.localsyms = false;
5510 eoinfo.finfo = &finfo;
5511 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
5516 /* If backend needs to output some symbols not present in the hash
5517 table, do it now. */
5518 if (bed->elf_backend_output_arch_syms)
5520 typedef boolean (*out_sym_func) PARAMS ((PTR, const char *,
5524 if (! ((*bed->elf_backend_output_arch_syms)
5525 (abfd, info, (PTR) &finfo, (out_sym_func) elf_link_output_sym)))
5529 /* Flush all symbols to the file. */
5530 if (! elf_link_flush_output_syms (&finfo))
5533 /* Now we know the size of the symtab section. */
5534 off += symtab_hdr->sh_size;
5536 /* Finish up and write out the symbol string table (.strtab)
5538 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5539 /* sh_name was set in prep_headers. */
5540 symstrtab_hdr->sh_type = SHT_STRTAB;
5541 symstrtab_hdr->sh_flags = 0;
5542 symstrtab_hdr->sh_addr = 0;
5543 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
5544 symstrtab_hdr->sh_entsize = 0;
5545 symstrtab_hdr->sh_link = 0;
5546 symstrtab_hdr->sh_info = 0;
5547 /* sh_offset is set just below. */
5548 symstrtab_hdr->sh_addralign = 1;
5550 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
5551 elf_tdata (abfd)->next_file_pos = off;
5553 if (bfd_get_symcount (abfd) > 0)
5555 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
5556 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
5560 /* Adjust the relocs to have the correct symbol indices. */
5561 for (o = abfd->sections; o != NULL; o = o->next)
5563 if ((o->flags & SEC_RELOC) == 0)
5566 elf_link_adjust_relocs (abfd, &elf_section_data (o)->rel_hdr,
5567 elf_section_data (o)->rel_count,
5568 elf_section_data (o)->rel_hashes);
5569 if (elf_section_data (o)->rel_hdr2 != NULL)
5570 elf_link_adjust_relocs (abfd, elf_section_data (o)->rel_hdr2,
5571 elf_section_data (o)->rel_count2,
5572 (elf_section_data (o)->rel_hashes
5573 + elf_section_data (o)->rel_count));
5575 /* Set the reloc_count field to 0 to prevent write_relocs from
5576 trying to swap the relocs out itself. */
5580 if (dynamic && info->combreloc && dynobj != NULL)
5581 relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
5583 /* If we are linking against a dynamic object, or generating a
5584 shared library, finish up the dynamic linking information. */
5587 Elf_External_Dyn *dyncon, *dynconend;
5589 /* Fix up .dynamic entries. */
5590 o = bfd_get_section_by_name (dynobj, ".dynamic");
5591 BFD_ASSERT (o != NULL);
5593 dyncon = (Elf_External_Dyn *) o->contents;
5594 dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
5595 for (; dyncon < dynconend; dyncon++)
5597 Elf_Internal_Dyn dyn;
5601 elf_swap_dyn_in (dynobj, dyncon, &dyn);
5608 if (relativecount > 0 && dyncon + 1 < dynconend)
5610 switch (elf_section_data (reldyn)->this_hdr.sh_type)
5612 case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
5613 case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
5616 if (dyn.d_tag != DT_NULL)
5618 dyn.d_un.d_val = relativecount;
5619 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5625 name = info->init_function;
5628 name = info->fini_function;
5631 struct elf_link_hash_entry *h;
5633 h = elf_link_hash_lookup (elf_hash_table (info), name,
5634 false, false, true);
5636 && (h->root.type == bfd_link_hash_defined
5637 || h->root.type == bfd_link_hash_defweak))
5639 dyn.d_un.d_val = h->root.u.def.value;
5640 o = h->root.u.def.section;
5641 if (o->output_section != NULL)
5642 dyn.d_un.d_val += (o->output_section->vma
5643 + o->output_offset);
5646 /* The symbol is imported from another shared
5647 library and does not apply to this one. */
5651 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5656 case DT_PREINIT_ARRAYSZ:
5657 name = ".preinit_array";
5659 case DT_INIT_ARRAYSZ:
5660 name = ".init_array";
5662 case DT_FINI_ARRAYSZ:
5663 name = ".fini_array";
5665 o = bfd_get_section_by_name (abfd, name);
5668 (*_bfd_error_handler)
5669 (_("%s: could not find output section %s"),
5670 bfd_get_filename (abfd), name);
5673 if (o->_raw_size == 0)
5674 (*_bfd_error_handler)
5675 (_("warning: %s section has zero size"), name);
5676 dyn.d_un.d_val = o->_raw_size;
5677 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5680 case DT_PREINIT_ARRAY:
5681 name = ".preinit_array";
5684 name = ".init_array";
5687 name = ".fini_array";
5700 name = ".gnu.version_d";
5703 name = ".gnu.version_r";
5706 name = ".gnu.version";
5708 o = bfd_get_section_by_name (abfd, name);
5711 (*_bfd_error_handler)
5712 (_("%s: could not find output section %s"),
5713 bfd_get_filename (abfd), name);
5716 dyn.d_un.d_ptr = o->vma;
5717 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5724 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
5729 for (i = 1; i < elf_numsections (abfd); i++)
5731 Elf_Internal_Shdr *hdr;
5733 hdr = elf_elfsections (abfd)[i];
5734 if (hdr->sh_type == type
5735 && (hdr->sh_flags & SHF_ALLOC) != 0)
5737 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
5738 dyn.d_un.d_val += hdr->sh_size;
5741 if (dyn.d_un.d_val == 0
5742 || hdr->sh_addr < dyn.d_un.d_val)
5743 dyn.d_un.d_val = hdr->sh_addr;
5747 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5753 /* If we have created any dynamic sections, then output them. */
5756 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
5759 for (o = dynobj->sections; o != NULL; o = o->next)
5761 if ((o->flags & SEC_HAS_CONTENTS) == 0
5762 || o->_raw_size == 0
5763 || o->output_section == bfd_abs_section_ptr)
5765 if ((o->flags & SEC_LINKER_CREATED) == 0)
5767 /* At this point, we are only interested in sections
5768 created by elf_link_create_dynamic_sections. */
5771 if ((elf_section_data (o->output_section)->this_hdr.sh_type
5773 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
5775 if (! bfd_set_section_contents (abfd, o->output_section,
5777 (file_ptr) o->output_offset,
5783 /* The contents of the .dynstr section are actually in a
5785 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
5786 if (bfd_seek (abfd, off, SEEK_SET) != 0
5787 || ! _bfd_elf_strtab_emit (abfd,
5788 elf_hash_table (info)->dynstr))
5794 if (info->relocateable)
5796 boolean failed = false;
5798 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
5803 /* If we have optimized stabs strings, output them. */
5804 if (elf_hash_table (info)->stab_info != NULL)
5806 if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
5810 if (info->eh_frame_hdr && elf_hash_table (info)->dynobj)
5812 o = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
5815 && (elf_section_data (o)->sec_info_type
5816 == ELF_INFO_TYPE_EH_FRAME_HDR))
5818 if (! _bfd_elf_write_section_eh_frame_hdr (abfd, o))
5823 if (finfo.symstrtab != NULL)
5824 _bfd_stringtab_free (finfo.symstrtab);
5825 if (finfo.contents != NULL)
5826 free (finfo.contents);
5827 if (finfo.external_relocs != NULL)
5828 free (finfo.external_relocs);
5829 if (finfo.internal_relocs != NULL)
5830 free (finfo.internal_relocs);
5831 if (finfo.external_syms != NULL)
5832 free (finfo.external_syms);
5833 if (finfo.locsym_shndx != NULL)
5834 free (finfo.locsym_shndx);
5835 if (finfo.internal_syms != NULL)
5836 free (finfo.internal_syms);
5837 if (finfo.indices != NULL)
5838 free (finfo.indices);
5839 if (finfo.sections != NULL)
5840 free (finfo.sections);
5841 if (finfo.symbuf != NULL)
5842 free (finfo.symbuf);
5843 if (finfo.symshndxbuf != NULL)
5844 free (finfo.symbuf);
5845 for (o = abfd->sections; o != NULL; o = o->next)
5847 if ((o->flags & SEC_RELOC) != 0
5848 && elf_section_data (o)->rel_hashes != NULL)
5849 free (elf_section_data (o)->rel_hashes);
5852 elf_tdata (abfd)->linker = true;
5857 if (finfo.symstrtab != NULL)
5858 _bfd_stringtab_free (finfo.symstrtab);
5859 if (finfo.contents != NULL)
5860 free (finfo.contents);
5861 if (finfo.external_relocs != NULL)
5862 free (finfo.external_relocs);
5863 if (finfo.internal_relocs != NULL)
5864 free (finfo.internal_relocs);
5865 if (finfo.external_syms != NULL)
5866 free (finfo.external_syms);
5867 if (finfo.locsym_shndx != NULL)
5868 free (finfo.locsym_shndx);
5869 if (finfo.internal_syms != NULL)
5870 free (finfo.internal_syms);
5871 if (finfo.indices != NULL)
5872 free (finfo.indices);
5873 if (finfo.sections != NULL)
5874 free (finfo.sections);
5875 if (finfo.symbuf != NULL)
5876 free (finfo.symbuf);
5877 if (finfo.symshndxbuf != NULL)
5878 free (finfo.symbuf);
5879 for (o = abfd->sections; o != NULL; o = o->next)
5881 if ((o->flags & SEC_RELOC) != 0
5882 && elf_section_data (o)->rel_hashes != NULL)
5883 free (elf_section_data (o)->rel_hashes);
5889 /* Add a symbol to the output symbol table. */
5892 elf_link_output_sym (finfo, name, elfsym, input_sec)
5893 struct elf_final_link_info *finfo;
5895 Elf_Internal_Sym *elfsym;
5896 asection *input_sec;
5898 Elf_External_Sym *dest;
5899 Elf_External_Sym_Shndx *destshndx;
5901 boolean (*output_symbol_hook) PARAMS ((bfd *,
5902 struct bfd_link_info *info,
5907 output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
5908 elf_backend_link_output_symbol_hook;
5909 if (output_symbol_hook != NULL)
5911 if (! ((*output_symbol_hook)
5912 (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
5916 if (name == (const char *) NULL || *name == '\0')
5917 elfsym->st_name = 0;
5918 else if (input_sec->flags & SEC_EXCLUDE)
5919 elfsym->st_name = 0;
5922 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
5924 if (elfsym->st_name == (unsigned long) -1)
5928 if (finfo->symbuf_count >= finfo->symbuf_size)
5930 if (! elf_link_flush_output_syms (finfo))
5934 dest = finfo->symbuf + finfo->symbuf_count;
5935 destshndx = finfo->symshndxbuf;
5936 if (destshndx != NULL)
5937 destshndx += finfo->symbuf_count;
5938 elf_swap_symbol_out (finfo->output_bfd, elfsym, (PTR) dest, (PTR) destshndx);
5939 ++finfo->symbuf_count;
5941 ++ bfd_get_symcount (finfo->output_bfd);
5946 /* Flush the output symbols to the file. */
5949 elf_link_flush_output_syms (finfo)
5950 struct elf_final_link_info *finfo;
5952 if (finfo->symbuf_count > 0)
5954 Elf_Internal_Shdr *hdr;
5958 hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
5959 pos = hdr->sh_offset + hdr->sh_size;
5960 amt = finfo->symbuf_count * sizeof (Elf_External_Sym);
5961 if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
5962 || bfd_bwrite ((PTR) finfo->symbuf, amt, finfo->output_bfd) != amt)
5965 hdr->sh_size += amt;
5967 if (finfo->symshndxbuf != NULL)
5969 hdr = &elf_tdata (finfo->output_bfd)->symtab_shndx_hdr;
5970 pos = hdr->sh_offset + hdr->sh_size;
5971 amt = finfo->symbuf_count * sizeof (Elf_External_Sym_Shndx);
5972 if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
5973 || (bfd_bwrite ((PTR) finfo->symshndxbuf, amt, finfo->output_bfd)
5977 hdr->sh_size += amt;
5980 finfo->symbuf_count = 0;
5986 /* Adjust all external symbols pointing into SEC_MERGE sections
5987 to reflect the object merging within the sections. */
5990 elf_link_sec_merge_syms (h, data)
5991 struct elf_link_hash_entry *h;
5996 if (h->root.type == bfd_link_hash_warning)
5997 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5999 if ((h->root.type == bfd_link_hash_defined
6000 || h->root.type == bfd_link_hash_defweak)
6001 && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
6002 && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
6004 bfd *output_bfd = (bfd *) data;
6006 h->root.u.def.value =
6007 _bfd_merged_section_offset (output_bfd,
6008 &h->root.u.def.section,
6009 elf_section_data (sec)->sec_info,
6010 h->root.u.def.value, (bfd_vma) 0);
6016 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
6017 allowing an unsatisfied unversioned symbol in the DSO to match a
6018 versioned symbol that would normally require an explicit version. */
6021 elf_link_check_versioned_symbol (info, h)
6022 struct bfd_link_info *info;
6023 struct elf_link_hash_entry *h;
6025 bfd *undef_bfd = h->root.u.undef.abfd;
6026 struct elf_link_loaded_list *loaded;
6028 if ((undef_bfd->flags & DYNAMIC) == 0
6029 || info->hash->creator->flavour != bfd_target_elf_flavour
6030 || elf_dt_soname (h->root.u.undef.abfd) == NULL)
6033 for (loaded = elf_hash_table (info)->loaded;
6035 loaded = loaded->next)
6038 Elf_Internal_Shdr *hdr;
6039 bfd_size_type symcount;
6040 bfd_size_type extsymcount;
6041 bfd_size_type extsymoff;
6042 Elf_Internal_Shdr *versymhdr;
6043 Elf_Internal_Sym *isym;
6044 Elf_Internal_Sym *isymend;
6045 Elf_Internal_Sym *isymbuf;
6046 Elf_External_Versym *ever;
6047 Elf_External_Versym *extversym;
6049 input = loaded->abfd;
6051 /* We check each DSO for a possible hidden versioned definition. */
6052 if (input == undef_bfd
6053 || (input->flags & DYNAMIC) == 0
6054 || elf_dynversym (input) == 0)
6057 hdr = &elf_tdata (input)->dynsymtab_hdr;
6059 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
6060 if (elf_bad_symtab (input))
6062 extsymcount = symcount;
6067 extsymcount = symcount - hdr->sh_info;
6068 extsymoff = hdr->sh_info;
6071 if (extsymcount == 0)
6074 isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
6076 if (isymbuf == NULL)
6079 /* Read in any version definitions. */
6080 versymhdr = &elf_tdata (input)->dynversym_hdr;
6081 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
6082 if (extversym == NULL)
6085 if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
6086 || (bfd_bread ((PTR) extversym, versymhdr->sh_size, input)
6087 != versymhdr->sh_size))
6095 ever = extversym + extsymoff;
6096 isymend = isymbuf + extsymcount;
6097 for (isym = isymbuf; isym < isymend; isym++, ever++)
6100 Elf_Internal_Versym iver;
6102 if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
6103 || isym->st_shndx == SHN_UNDEF)
6106 name = bfd_elf_string_from_elf_section (input,
6109 if (strcmp (name, h->root.root.string) != 0)
6112 _bfd_elf_swap_versym_in (input, ever, &iver);
6114 if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
6116 /* If we have a non-hidden versioned sym, then it should
6117 have provided a definition for the undefined sym. */
6121 if ((iver.vs_vers & VERSYM_VERSION) == 2)
6123 /* This is the oldest (default) sym. We can use it. */
6137 /* Add an external symbol to the symbol table. This is called from
6138 the hash table traversal routine. When generating a shared object,
6139 we go through the symbol table twice. The first time we output
6140 anything that might have been forced to local scope in a version
6141 script. The second time we output the symbols that are still
6145 elf_link_output_extsym (h, data)
6146 struct elf_link_hash_entry *h;
6149 struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
6150 struct elf_final_link_info *finfo = eoinfo->finfo;
6152 Elf_Internal_Sym sym;
6153 asection *input_sec;
6155 if (h->root.type == bfd_link_hash_warning)
6157 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6158 if (h->root.type == bfd_link_hash_new)
6162 /* Decide whether to output this symbol in this pass. */
6163 if (eoinfo->localsyms)
6165 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
6170 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
6174 /* If we are not creating a shared library, and this symbol is
6175 referenced by a shared library but is not defined anywhere, then
6176 warn that it is undefined. If we do not do this, the runtime
6177 linker will complain that the symbol is undefined when the
6178 program is run. We don't have to worry about symbols that are
6179 referenced by regular files, because we will already have issued
6180 warnings for them. */
6181 if (! finfo->info->relocateable
6182 && ! finfo->info->allow_shlib_undefined
6183 && ! finfo->info->shared
6184 && h->root.type == bfd_link_hash_undefined
6185 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
6186 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
6187 && ! elf_link_check_versioned_symbol (finfo->info, h))
6189 if (! ((*finfo->info->callbacks->undefined_symbol)
6190 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
6191 (asection *) NULL, (bfd_vma) 0, true)))
6193 eoinfo->failed = true;
6198 /* We don't want to output symbols that have never been mentioned by
6199 a regular file, or that we have been told to strip. However, if
6200 h->indx is set to -2, the symbol is used by a reloc and we must
6204 else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
6205 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
6206 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
6207 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
6209 else if (finfo->info->strip == strip_all
6210 || (finfo->info->strip == strip_some
6211 && bfd_hash_lookup (finfo->info->keep_hash,
6212 h->root.root.string,
6213 false, false) == NULL))
6218 /* If we're stripping it, and it's not a dynamic symbol, there's
6219 nothing else to do unless it is a forced local symbol. */
6222 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
6226 sym.st_size = h->size;
6227 sym.st_other = h->other;
6228 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
6229 sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
6230 else if (h->root.type == bfd_link_hash_undefweak
6231 || h->root.type == bfd_link_hash_defweak)
6232 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
6234 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
6236 switch (h->root.type)
6239 case bfd_link_hash_new:
6240 case bfd_link_hash_warning:
6244 case bfd_link_hash_undefined:
6245 case bfd_link_hash_undefweak:
6246 input_sec = bfd_und_section_ptr;
6247 sym.st_shndx = SHN_UNDEF;
6250 case bfd_link_hash_defined:
6251 case bfd_link_hash_defweak:
6253 input_sec = h->root.u.def.section;
6254 if (input_sec->output_section != NULL)
6257 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
6258 input_sec->output_section);
6259 if (sym.st_shndx == SHN_BAD)
6261 (*_bfd_error_handler)
6262 (_("%s: could not find output section %s for input section %s"),
6263 bfd_get_filename (finfo->output_bfd),
6264 input_sec->output_section->name,
6266 eoinfo->failed = true;
6270 /* ELF symbols in relocateable files are section relative,
6271 but in nonrelocateable files they are virtual
6273 sym.st_value = h->root.u.def.value + input_sec->output_offset;
6274 if (! finfo->info->relocateable)
6276 sym.st_value += input_sec->output_section->vma;
6277 if (h->type == STT_TLS)
6279 /* STT_TLS symbols are relative to PT_TLS segment
6281 BFD_ASSERT (finfo->first_tls_sec != NULL);
6282 sym.st_value -= finfo->first_tls_sec->vma;
6288 BFD_ASSERT (input_sec->owner == NULL
6289 || (input_sec->owner->flags & DYNAMIC) != 0);
6290 sym.st_shndx = SHN_UNDEF;
6291 input_sec = bfd_und_section_ptr;
6296 case bfd_link_hash_common:
6297 input_sec = h->root.u.c.p->section;
6298 sym.st_shndx = SHN_COMMON;
6299 sym.st_value = 1 << h->root.u.c.p->alignment_power;
6302 case bfd_link_hash_indirect:
6303 /* These symbols are created by symbol versioning. They point
6304 to the decorated version of the name. For example, if the
6305 symbol foo@@GNU_1.2 is the default, which should be used when
6306 foo is used with no version, then we add an indirect symbol
6307 foo which points to foo@@GNU_1.2. We ignore these symbols,
6308 since the indirected symbol is already in the hash table. */
6312 /* Give the processor backend a chance to tweak the symbol value,
6313 and also to finish up anything that needs to be done for this
6314 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
6315 forced local syms when non-shared is due to a historical quirk. */
6316 if ((h->dynindx != -1
6317 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
6318 && (finfo->info->shared
6319 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
6320 && elf_hash_table (finfo->info)->dynamic_sections_created)
6322 struct elf_backend_data *bed;
6324 bed = get_elf_backend_data (finfo->output_bfd);
6325 if (! ((*bed->elf_backend_finish_dynamic_symbol)
6326 (finfo->output_bfd, finfo->info, h, &sym)))
6328 eoinfo->failed = true;
6333 /* If we are marking the symbol as undefined, and there are no
6334 non-weak references to this symbol from a regular object, then
6335 mark the symbol as weak undefined; if there are non-weak
6336 references, mark the symbol as strong. We can't do this earlier,
6337 because it might not be marked as undefined until the
6338 finish_dynamic_symbol routine gets through with it. */
6339 if (sym.st_shndx == SHN_UNDEF
6340 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
6341 && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
6342 || ELF_ST_BIND (sym.st_info) == STB_WEAK))
6346 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) != 0)
6347 bindtype = STB_GLOBAL;
6349 bindtype = STB_WEAK;
6350 sym.st_info = ELF_ST_INFO (bindtype, ELF_ST_TYPE (sym.st_info));
6353 /* If a symbol is not defined locally, we clear the visibility field. */
6354 if (! finfo->info->relocateable
6355 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
6356 sym.st_other &= ~ ELF_ST_VISIBILITY (-1);
6358 /* If this symbol should be put in the .dynsym section, then put it
6359 there now. We already know the symbol index. We also fill in
6360 the entry in the .hash section. */
6361 if (h->dynindx != -1
6362 && elf_hash_table (finfo->info)->dynamic_sections_created)
6366 size_t hash_entry_size;
6367 bfd_byte *bucketpos;
6369 Elf_External_Sym *esym;
6371 sym.st_name = h->dynstr_index;
6372 esym = (Elf_External_Sym *) finfo->dynsym_sec->contents + h->dynindx;
6373 elf_swap_symbol_out (finfo->output_bfd, &sym, (PTR) esym, (PTR) 0);
6375 bucketcount = elf_hash_table (finfo->info)->bucketcount;
6376 bucket = h->elf_hash_value % bucketcount;
6378 = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
6379 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
6380 + (bucket + 2) * hash_entry_size);
6381 chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
6382 bfd_put (8 * hash_entry_size, finfo->output_bfd, (bfd_vma) h->dynindx,
6384 bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
6385 ((bfd_byte *) finfo->hash_sec->contents
6386 + (bucketcount + 2 + h->dynindx) * hash_entry_size));
6388 if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
6390 Elf_Internal_Versym iversym;
6391 Elf_External_Versym *eversym;
6393 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
6395 if (h->verinfo.verdef == NULL)
6396 iversym.vs_vers = 0;
6398 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
6402 if (h->verinfo.vertree == NULL)
6403 iversym.vs_vers = 1;
6405 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
6408 if ((h->elf_link_hash_flags & ELF_LINK_HIDDEN) != 0)
6409 iversym.vs_vers |= VERSYM_HIDDEN;
6411 eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
6412 eversym += h->dynindx;
6413 _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
6417 /* If we're stripping it, then it was just a dynamic symbol, and
6418 there's nothing else to do. */
6419 if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
6422 h->indx = bfd_get_symcount (finfo->output_bfd);
6424 if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
6426 eoinfo->failed = true;
6433 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
6434 originated from the section given by INPUT_REL_HDR) to the
6438 elf_link_output_relocs (output_bfd, input_section, input_rel_hdr,
6441 asection *input_section;
6442 Elf_Internal_Shdr *input_rel_hdr;
6443 Elf_Internal_Rela *internal_relocs;
6445 Elf_Internal_Rela *irela;
6446 Elf_Internal_Rela *irelaend;
6447 Elf_Internal_Shdr *output_rel_hdr;
6448 asection *output_section;
6449 unsigned int *rel_countp = NULL;
6450 struct elf_backend_data *bed;
6453 output_section = input_section->output_section;
6454 output_rel_hdr = NULL;
6456 if (elf_section_data (output_section)->rel_hdr.sh_entsize
6457 == input_rel_hdr->sh_entsize)
6459 output_rel_hdr = &elf_section_data (output_section)->rel_hdr;
6460 rel_countp = &elf_section_data (output_section)->rel_count;
6462 else if (elf_section_data (output_section)->rel_hdr2
6463 && (elf_section_data (output_section)->rel_hdr2->sh_entsize
6464 == input_rel_hdr->sh_entsize))
6466 output_rel_hdr = elf_section_data (output_section)->rel_hdr2;
6467 rel_countp = &elf_section_data (output_section)->rel_count2;
6471 (*_bfd_error_handler)
6472 (_("%s: relocation size mismatch in %s section %s"),
6473 bfd_get_filename (output_bfd),
6474 bfd_archive_filename (input_section->owner),
6475 input_section->name);
6476 bfd_set_error (bfd_error_wrong_object_format);
6480 bed = get_elf_backend_data (output_bfd);
6481 irela = internal_relocs;
6482 irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
6483 * bed->s->int_rels_per_ext_rel);
6485 if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
6487 Elf_External_Rel *erel;
6488 Elf_Internal_Rel *irel;
6490 amt = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rel);
6491 irel = (Elf_Internal_Rel *) bfd_zmalloc (amt);
6494 (*_bfd_error_handler) (_("Error: out of memory"));
6498 erel = ((Elf_External_Rel *) output_rel_hdr->contents + *rel_countp);
6499 for (; irela < irelaend; irela += bed->s->int_rels_per_ext_rel, erel++)
6503 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
6505 irel[i].r_offset = irela[i].r_offset;
6506 irel[i].r_info = irela[i].r_info;
6507 BFD_ASSERT (irela[i].r_addend == 0);
6510 if (bed->s->swap_reloc_out)
6511 (*bed->s->swap_reloc_out) (output_bfd, irel, (PTR) erel);
6513 elf_swap_reloc_out (output_bfd, irel, erel);
6520 Elf_External_Rela *erela;
6522 BFD_ASSERT (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
6524 erela = ((Elf_External_Rela *) output_rel_hdr->contents + *rel_countp);
6525 for (; irela < irelaend; irela += bed->s->int_rels_per_ext_rel, erela++)
6526 if (bed->s->swap_reloca_out)
6527 (*bed->s->swap_reloca_out) (output_bfd, irela, (PTR) erela);
6529 elf_swap_reloca_out (output_bfd, irela, erela);
6532 /* Bump the counter, so that we know where to add the next set of
6534 *rel_countp += NUM_SHDR_ENTRIES (input_rel_hdr);
6539 /* Link an input file into the linker output file. This function
6540 handles all the sections and relocations of the input file at once.
6541 This is so that we only have to read the local symbols once, and
6542 don't have to keep them in memory. */
6545 elf_link_input_bfd (finfo, input_bfd)
6546 struct elf_final_link_info *finfo;
6549 boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
6550 bfd *, asection *, bfd_byte *,
6551 Elf_Internal_Rela *,
6552 Elf_Internal_Sym *, asection **));
6554 Elf_Internal_Shdr *symtab_hdr;
6557 Elf_Internal_Sym *isymbuf;
6558 Elf_Internal_Sym *isym;
6559 Elf_Internal_Sym *isymend;
6561 asection **ppsection;
6563 struct elf_backend_data *bed;
6564 boolean emit_relocs;
6565 struct elf_link_hash_entry **sym_hashes;
6567 output_bfd = finfo->output_bfd;
6568 bed = get_elf_backend_data (output_bfd);
6569 relocate_section = bed->elf_backend_relocate_section;
6571 /* If this is a dynamic object, we don't want to do anything here:
6572 we don't want the local symbols, and we don't want the section
6574 if ((input_bfd->flags & DYNAMIC) != 0)
6577 emit_relocs = (finfo->info->relocateable
6578 || finfo->info->emitrelocations
6579 || bed->elf_backend_emit_relocs);
6581 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6582 if (elf_bad_symtab (input_bfd))
6584 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
6589 locsymcount = symtab_hdr->sh_info;
6590 extsymoff = symtab_hdr->sh_info;
6593 /* Read the local symbols. */
6594 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6595 if (isymbuf == NULL && locsymcount != 0)
6597 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6598 finfo->internal_syms,
6599 finfo->external_syms,
6600 finfo->locsym_shndx);
6601 if (isymbuf == NULL)
6605 /* Find local symbol sections and adjust values of symbols in
6606 SEC_MERGE sections. Write out those local symbols we know are
6607 going into the output file. */
6608 isymend = isymbuf + locsymcount;
6609 for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
6611 isym++, pindex++, ppsection++)
6615 Elf_Internal_Sym osym;
6619 if (elf_bad_symtab (input_bfd))
6621 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
6628 if (isym->st_shndx == SHN_UNDEF)
6629 isec = bfd_und_section_ptr;
6630 else if (isym->st_shndx < SHN_LORESERVE
6631 || isym->st_shndx > SHN_HIRESERVE)
6633 isec = section_from_elf_index (input_bfd, isym->st_shndx);
6635 && elf_section_data (isec)->sec_info_type == ELF_INFO_TYPE_MERGE
6636 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
6638 _bfd_merged_section_offset (output_bfd, &isec,
6639 elf_section_data (isec)->sec_info,
6640 isym->st_value, (bfd_vma) 0);
6642 else if (isym->st_shndx == SHN_ABS)
6643 isec = bfd_abs_section_ptr;
6644 else if (isym->st_shndx == SHN_COMMON)
6645 isec = bfd_com_section_ptr;
6654 /* Don't output the first, undefined, symbol. */
6655 if (ppsection == finfo->sections)
6658 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
6660 /* We never output section symbols. Instead, we use the
6661 section symbol of the corresponding section in the output
6666 /* If we are stripping all symbols, we don't want to output this
6668 if (finfo->info->strip == strip_all)
6671 /* If we are discarding all local symbols, we don't want to
6672 output this one. If we are generating a relocateable output
6673 file, then some of the local symbols may be required by
6674 relocs; we output them below as we discover that they are
6676 if (finfo->info->discard == discard_all)
6679 /* If this symbol is defined in a section which we are
6680 discarding, we don't need to keep it, but note that
6681 linker_mark is only reliable for sections that have contents.
6682 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
6683 as well as linker_mark. */
6684 if ((isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
6686 && ((! isec->linker_mark && (isec->flags & SEC_HAS_CONTENTS) != 0)
6687 || (! finfo->info->relocateable
6688 && (isec->flags & SEC_EXCLUDE) != 0)))
6691 /* Get the name of the symbol. */
6692 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
6697 /* See if we are discarding symbols with this name. */
6698 if ((finfo->info->strip == strip_some
6699 && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
6701 || (((finfo->info->discard == discard_sec_merge
6702 && (isec->flags & SEC_MERGE) && ! finfo->info->relocateable)
6703 || finfo->info->discard == discard_l)
6704 && bfd_is_local_label_name (input_bfd, name)))
6707 /* If we get here, we are going to output this symbol. */
6711 /* Adjust the section index for the output file. */
6712 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
6713 isec->output_section);
6714 if (osym.st_shndx == SHN_BAD)
6717 *pindex = bfd_get_symcount (output_bfd);
6719 /* ELF symbols in relocateable files are section relative, but
6720 in executable files they are virtual addresses. Note that
6721 this code assumes that all ELF sections have an associated
6722 BFD section with a reasonable value for output_offset; below
6723 we assume that they also have a reasonable value for
6724 output_section. Any special sections must be set up to meet
6725 these requirements. */
6726 osym.st_value += isec->output_offset;
6727 if (! finfo->info->relocateable)
6729 osym.st_value += isec->output_section->vma;
6730 if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
6732 /* STT_TLS symbols are relative to PT_TLS segment base. */
6733 BFD_ASSERT (finfo->first_tls_sec != NULL);
6734 osym.st_value -= finfo->first_tls_sec->vma;
6738 if (! elf_link_output_sym (finfo, name, &osym, isec))
6742 /* Relocate the contents of each section. */
6743 sym_hashes = elf_sym_hashes (input_bfd);
6744 for (o = input_bfd->sections; o != NULL; o = o->next)
6748 if (! o->linker_mark)
6750 /* This section was omitted from the link. */
6754 if ((o->flags & SEC_HAS_CONTENTS) == 0
6755 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
6758 if ((o->flags & SEC_LINKER_CREATED) != 0)
6760 /* Section was created by elf_link_create_dynamic_sections
6765 /* Get the contents of the section. They have been cached by a
6766 relaxation routine. Note that o is a section in an input
6767 file, so the contents field will not have been set by any of
6768 the routines which work on output files. */
6769 if (elf_section_data (o)->this_hdr.contents != NULL)
6770 contents = elf_section_data (o)->this_hdr.contents;
6773 contents = finfo->contents;
6774 if (! bfd_get_section_contents (input_bfd, o, contents,
6775 (file_ptr) 0, o->_raw_size))
6779 if ((o->flags & SEC_RELOC) != 0)
6781 Elf_Internal_Rela *internal_relocs;
6783 /* Get the swapped relocs. */
6784 internal_relocs = (NAME(_bfd_elf,link_read_relocs)
6785 (input_bfd, o, finfo->external_relocs,
6786 finfo->internal_relocs, false));
6787 if (internal_relocs == NULL
6788 && o->reloc_count > 0)
6791 /* Run through the relocs looking for any against symbols
6792 from discarded sections and section symbols from
6793 removed link-once sections. Complain about relocs
6794 against discarded sections. Zero relocs against removed
6795 link-once sections. We should really complain if
6796 anything in the final link tries to use it, but
6797 DWARF-based exception handling might have an entry in
6798 .eh_frame to describe a routine in the linkonce section,
6799 and it turns out to be hard to remove the .eh_frame
6800 entry too. FIXME. */
6801 if (!finfo->info->relocateable
6802 && !elf_section_ignore_discarded_relocs (o))
6804 Elf_Internal_Rela *rel, *relend;
6806 rel = internal_relocs;
6807 relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
6808 for ( ; rel < relend; rel++)
6810 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
6812 if (r_symndx >= locsymcount
6813 || (elf_bad_symtab (input_bfd)
6814 && finfo->sections[r_symndx] == NULL))
6816 struct elf_link_hash_entry *h;
6818 h = sym_hashes[r_symndx - extsymoff];
6819 while (h->root.type == bfd_link_hash_indirect
6820 || h->root.type == bfd_link_hash_warning)
6821 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6823 /* Complain if the definition comes from a
6824 discarded section. */
6825 if ((h->root.type == bfd_link_hash_defined
6826 || h->root.type == bfd_link_hash_defweak)
6827 && elf_discarded_section (h->root.u.def.section))
6829 if ((o->flags & SEC_DEBUGGING) != 0)
6831 BFD_ASSERT (r_symndx != 0);
6832 memset (rel, 0, sizeof (*rel));
6836 if (! ((*finfo->info->callbacks->undefined_symbol)
6837 (finfo->info, h->root.root.string,
6838 input_bfd, o, rel->r_offset,
6846 asection *sec = finfo->sections[r_symndx];
6848 if (sec != NULL && elf_discarded_section (sec))
6850 if ((o->flags & SEC_DEBUGGING) != 0
6851 || (sec->flags & SEC_LINK_ONCE) != 0)
6853 BFD_ASSERT (r_symndx != 0);
6855 = ELF_R_INFO (0, ELF_R_TYPE (rel->r_info));
6862 = _("local symbols in discarded section %s");
6864 = strlen (sec->name) + strlen (msg) - 1;
6865 char *buf = (char *) bfd_malloc (amt);
6868 sprintf (buf, msg, sec->name);
6870 buf = (char *) sec->name;
6871 ok = (*finfo->info->callbacks
6872 ->undefined_symbol) (finfo->info, buf,
6876 if (buf != sec->name)
6886 /* Relocate the section by invoking a back end routine.
6888 The back end routine is responsible for adjusting the
6889 section contents as necessary, and (if using Rela relocs
6890 and generating a relocateable output file) adjusting the
6891 reloc addend as necessary.
6893 The back end routine does not have to worry about setting
6894 the reloc address or the reloc symbol index.
6896 The back end routine is given a pointer to the swapped in
6897 internal symbols, and can access the hash table entries
6898 for the external symbols via elf_sym_hashes (input_bfd).
6900 When generating relocateable output, the back end routine
6901 must handle STB_LOCAL/STT_SECTION symbols specially. The
6902 output symbol is going to be a section symbol
6903 corresponding to the output section, which will require
6904 the addend to be adjusted. */
6906 if (! (*relocate_section) (output_bfd, finfo->info,
6907 input_bfd, o, contents,
6915 Elf_Internal_Rela *irela;
6916 Elf_Internal_Rela *irelaend;
6917 struct elf_link_hash_entry **rel_hash;
6918 Elf_Internal_Shdr *input_rel_hdr, *input_rel_hdr2;
6919 unsigned int next_erel;
6920 boolean (*reloc_emitter) PARAMS ((bfd *, asection *,
6921 Elf_Internal_Shdr *,
6922 Elf_Internal_Rela *));
6923 boolean rela_normal;
6925 input_rel_hdr = &elf_section_data (o)->rel_hdr;
6926 rela_normal = (bed->rela_normal
6927 && (input_rel_hdr->sh_entsize
6928 == sizeof (Elf_External_Rela)));
6930 /* Adjust the reloc addresses and symbol indices. */
6932 irela = internal_relocs;
6933 irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
6934 rel_hash = (elf_section_data (o->output_section)->rel_hashes
6935 + elf_section_data (o->output_section)->rel_count
6936 + elf_section_data (o->output_section)->rel_count2);
6937 for (next_erel = 0; irela < irelaend; irela++, next_erel++)
6939 unsigned long r_symndx;
6941 Elf_Internal_Sym sym;
6943 if (next_erel == bed->s->int_rels_per_ext_rel)
6949 irela->r_offset += o->output_offset;
6951 /* Relocs in an executable have to be virtual addresses. */
6952 if (!finfo->info->relocateable)
6953 irela->r_offset += o->output_section->vma;
6955 r_symndx = ELF_R_SYM (irela->r_info);
6960 if (r_symndx >= locsymcount
6961 || (elf_bad_symtab (input_bfd)
6962 && finfo->sections[r_symndx] == NULL))
6964 struct elf_link_hash_entry *rh;
6967 /* This is a reloc against a global symbol. We
6968 have not yet output all the local symbols, so
6969 we do not know the symbol index of any global
6970 symbol. We set the rel_hash entry for this
6971 reloc to point to the global hash table entry
6972 for this symbol. The symbol index is then
6973 set at the end of elf_bfd_final_link. */
6974 indx = r_symndx - extsymoff;
6975 rh = elf_sym_hashes (input_bfd)[indx];
6976 while (rh->root.type == bfd_link_hash_indirect
6977 || rh->root.type == bfd_link_hash_warning)
6978 rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
6980 /* Setting the index to -2 tells
6981 elf_link_output_extsym that this symbol is
6983 BFD_ASSERT (rh->indx < 0);
6991 /* This is a reloc against a local symbol. */
6994 sym = isymbuf[r_symndx];
6995 sec = finfo->sections[r_symndx];
6996 if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
6998 /* I suppose the backend ought to fill in the
6999 section of any STT_SECTION symbol against a
7000 processor specific section. If we have
7001 discarded a section, the output_section will
7002 be the absolute section. */
7003 if (bfd_is_abs_section (sec)
7005 && bfd_is_abs_section (sec->output_section)))
7007 else if (sec == NULL || sec->owner == NULL)
7009 bfd_set_error (bfd_error_bad_value);
7014 r_symndx = sec->output_section->target_index;
7015 BFD_ASSERT (r_symndx != 0);
7018 /* Adjust the addend according to where the
7019 section winds up in the output section. */
7021 irela->r_addend += sec->output_offset;
7025 if (finfo->indices[r_symndx] == -1)
7027 unsigned long shlink;
7031 if (finfo->info->strip == strip_all)
7033 /* You can't do ld -r -s. */
7034 bfd_set_error (bfd_error_invalid_operation);
7038 /* This symbol was skipped earlier, but
7039 since it is needed by a reloc, we
7040 must output it now. */
7041 shlink = symtab_hdr->sh_link;
7042 name = (bfd_elf_string_from_elf_section
7043 (input_bfd, shlink, sym.st_name));
7047 osec = sec->output_section;
7049 _bfd_elf_section_from_bfd_section (output_bfd,
7051 if (sym.st_shndx == SHN_BAD)
7054 sym.st_value += sec->output_offset;
7055 if (! finfo->info->relocateable)
7057 sym.st_value += osec->vma;
7058 if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
7060 /* STT_TLS symbols are relative to PT_TLS
7062 BFD_ASSERT (finfo->first_tls_sec != NULL);
7063 sym.st_value -= finfo->first_tls_sec->vma;
7067 finfo->indices[r_symndx]
7068 = bfd_get_symcount (output_bfd);
7070 if (! elf_link_output_sym (finfo, name, &sym, sec))
7074 r_symndx = finfo->indices[r_symndx];
7077 irela->r_info = ELF_R_INFO (r_symndx,
7078 ELF_R_TYPE (irela->r_info));
7081 /* Swap out the relocs. */
7082 if (bed->elf_backend_emit_relocs
7083 && !(finfo->info->relocateable
7084 || finfo->info->emitrelocations))
7085 reloc_emitter = bed->elf_backend_emit_relocs;
7087 reloc_emitter = elf_link_output_relocs;
7089 if (input_rel_hdr->sh_size != 0
7090 && ! (*reloc_emitter) (output_bfd, o, input_rel_hdr,
7094 input_rel_hdr2 = elf_section_data (o)->rel_hdr2;
7095 if (input_rel_hdr2 && input_rel_hdr2->sh_size != 0)
7097 internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
7098 * bed->s->int_rels_per_ext_rel);
7099 if (! (*reloc_emitter) (output_bfd, o, input_rel_hdr2,
7106 /* Write out the modified section contents. */
7107 if (bed->elf_backend_write_section
7108 && (*bed->elf_backend_write_section) (output_bfd, o, contents))
7110 /* Section written out. */
7112 else switch (elf_section_data (o)->sec_info_type)
7114 case ELF_INFO_TYPE_STABS:
7115 if (! (_bfd_write_section_stabs
7117 &elf_hash_table (finfo->info)->stab_info,
7118 o, &elf_section_data (o)->sec_info, contents)))
7121 case ELF_INFO_TYPE_MERGE:
7122 if (! (_bfd_write_merged_section
7123 (output_bfd, o, elf_section_data (o)->sec_info)))
7126 case ELF_INFO_TYPE_EH_FRAME:
7131 = bfd_get_section_by_name (elf_hash_table (finfo->info)->dynobj,
7133 if (! (_bfd_elf_write_section_eh_frame (output_bfd, o, ehdrsec,
7140 bfd_size_type sec_size;
7142 sec_size = (o->_cooked_size != 0 ? o->_cooked_size : o->_raw_size);
7143 if (! (o->flags & SEC_EXCLUDE)
7144 && ! bfd_set_section_contents (output_bfd, o->output_section,
7146 (file_ptr) o->output_offset,
7157 /* Generate a reloc when linking an ELF file. This is a reloc
7158 requested by the linker, and does come from any input file. This
7159 is used to build constructor and destructor tables when linking
7163 elf_reloc_link_order (output_bfd, info, output_section, link_order)
7165 struct bfd_link_info *info;
7166 asection *output_section;
7167 struct bfd_link_order *link_order;
7169 reloc_howto_type *howto;
7173 struct elf_link_hash_entry **rel_hash_ptr;
7174 Elf_Internal_Shdr *rel_hdr;
7175 struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
7177 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
7180 bfd_set_error (bfd_error_bad_value);
7184 addend = link_order->u.reloc.p->addend;
7186 /* Figure out the symbol index. */
7187 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
7188 + elf_section_data (output_section)->rel_count
7189 + elf_section_data (output_section)->rel_count2);
7190 if (link_order->type == bfd_section_reloc_link_order)
7192 indx = link_order->u.reloc.p->u.section->target_index;
7193 BFD_ASSERT (indx != 0);
7194 *rel_hash_ptr = NULL;
7198 struct elf_link_hash_entry *h;
7200 /* Treat a reloc against a defined symbol as though it were
7201 actually against the section. */
7202 h = ((struct elf_link_hash_entry *)
7203 bfd_wrapped_link_hash_lookup (output_bfd, info,
7204 link_order->u.reloc.p->u.name,
7205 false, false, true));
7207 && (h->root.type == bfd_link_hash_defined
7208 || h->root.type == bfd_link_hash_defweak))
7212 section = h->root.u.def.section;
7213 indx = section->output_section->target_index;
7214 *rel_hash_ptr = NULL;
7215 /* It seems that we ought to add the symbol value to the
7216 addend here, but in practice it has already been added
7217 because it was passed to constructor_callback. */
7218 addend += section->output_section->vma + section->output_offset;
7222 /* Setting the index to -2 tells elf_link_output_extsym that
7223 this symbol is used by a reloc. */
7230 if (! ((*info->callbacks->unattached_reloc)
7231 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
7232 (asection *) NULL, (bfd_vma) 0)))
7238 /* If this is an inplace reloc, we must write the addend into the
7240 if (howto->partial_inplace && addend != 0)
7243 bfd_reloc_status_type rstat;
7246 const char *sym_name;
7248 size = bfd_get_reloc_size (howto);
7249 buf = (bfd_byte *) bfd_zmalloc (size);
7250 if (buf == (bfd_byte *) NULL)
7252 rstat = _bfd_relocate_contents (howto, output_bfd, (bfd_vma) addend, buf);
7259 case bfd_reloc_outofrange:
7262 case bfd_reloc_overflow:
7263 if (link_order->type == bfd_section_reloc_link_order)
7264 sym_name = bfd_section_name (output_bfd,
7265 link_order->u.reloc.p->u.section);
7267 sym_name = link_order->u.reloc.p->u.name;
7268 if (! ((*info->callbacks->reloc_overflow)
7269 (info, sym_name, howto->name, addend,
7270 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
7277 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
7278 (file_ptr) link_order->offset, size);
7284 /* The address of a reloc is relative to the section in a
7285 relocateable file, and is a virtual address in an executable
7287 offset = link_order->offset;
7288 if (! info->relocateable)
7289 offset += output_section->vma;
7291 rel_hdr = &elf_section_data (output_section)->rel_hdr;
7293 if (rel_hdr->sh_type == SHT_REL)
7296 Elf_Internal_Rel *irel;
7297 Elf_External_Rel *erel;
7300 size = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rel);
7301 irel = (Elf_Internal_Rel *) bfd_zmalloc (size);
7305 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
7306 irel[i].r_offset = offset;
7307 irel[0].r_info = ELF_R_INFO (indx, howto->type);
7309 erel = ((Elf_External_Rel *) rel_hdr->contents
7310 + elf_section_data (output_section)->rel_count);
7312 if (bed->s->swap_reloc_out)
7313 (*bed->s->swap_reloc_out) (output_bfd, irel, (bfd_byte *) erel);
7315 elf_swap_reloc_out (output_bfd, irel, erel);
7322 Elf_Internal_Rela *irela;
7323 Elf_External_Rela *erela;
7326 size = bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
7327 irela = (Elf_Internal_Rela *) bfd_zmalloc (size);
7331 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
7332 irela[i].r_offset = offset;
7333 irela[0].r_info = ELF_R_INFO (indx, howto->type);
7334 irela[0].r_addend = addend;
7336 erela = ((Elf_External_Rela *) rel_hdr->contents
7337 + elf_section_data (output_section)->rel_count);
7339 if (bed->s->swap_reloca_out)
7340 (*bed->s->swap_reloca_out) (output_bfd, irela, (bfd_byte *) erela);
7342 elf_swap_reloca_out (output_bfd, irela, erela);
7345 ++elf_section_data (output_section)->rel_count;
7350 /* Allocate a pointer to live in a linker created section. */
7353 elf_create_pointer_linker_section (abfd, info, lsect, h, rel)
7355 struct bfd_link_info *info;
7356 elf_linker_section_t *lsect;
7357 struct elf_link_hash_entry *h;
7358 const Elf_Internal_Rela *rel;
7360 elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
7361 elf_linker_section_pointers_t *linker_section_ptr;
7362 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
7365 BFD_ASSERT (lsect != NULL);
7367 /* Is this a global symbol? */
7370 /* Has this symbol already been allocated? If so, our work is done. */
7371 if (_bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
7376 ptr_linker_section_ptr = &h->linker_section_pointer;
7377 /* Make sure this symbol is output as a dynamic symbol. */
7378 if (h->dynindx == -1)
7380 if (! elf_link_record_dynamic_symbol (info, h))
7384 if (lsect->rel_section)
7385 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
7389 /* Allocation of a pointer to a local symbol. */
7390 elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
7392 /* Allocate a table to hold the local symbols if first time. */
7395 unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
7396 register unsigned int i;
7399 amt *= sizeof (elf_linker_section_pointers_t *);
7400 ptr = (elf_linker_section_pointers_t **) bfd_alloc (abfd, amt);
7405 elf_local_ptr_offsets (abfd) = ptr;
7406 for (i = 0; i < num_symbols; i++)
7407 ptr[i] = (elf_linker_section_pointers_t *) 0;
7410 /* Has this symbol already been allocated? If so, our work is done. */
7411 if (_bfd_elf_find_pointer_linker_section (ptr[r_symndx],
7416 ptr_linker_section_ptr = &ptr[r_symndx];
7420 /* If we are generating a shared object, we need to
7421 output a R_<xxx>_RELATIVE reloc so that the
7422 dynamic linker can adjust this GOT entry. */
7423 BFD_ASSERT (lsect->rel_section != NULL);
7424 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
7428 /* Allocate space for a pointer in the linker section, and allocate
7429 a new pointer record from internal memory. */
7430 BFD_ASSERT (ptr_linker_section_ptr != NULL);
7431 amt = sizeof (elf_linker_section_pointers_t);
7432 linker_section_ptr = (elf_linker_section_pointers_t *) bfd_alloc (abfd, amt);
7434 if (!linker_section_ptr)
7437 linker_section_ptr->next = *ptr_linker_section_ptr;
7438 linker_section_ptr->addend = rel->r_addend;
7439 linker_section_ptr->which = lsect->which;
7440 linker_section_ptr->written_address_p = false;
7441 *ptr_linker_section_ptr = linker_section_ptr;
7444 if (lsect->hole_size && lsect->hole_offset < lsect->max_hole_offset)
7446 linker_section_ptr->offset = (lsect->section->_raw_size
7447 - lsect->hole_size + (ARCH_SIZE / 8));
7448 lsect->hole_offset += ARCH_SIZE / 8;
7449 lsect->sym_offset += ARCH_SIZE / 8;
7450 if (lsect->sym_hash)
7452 /* Bump up symbol value if needed. */
7453 lsect->sym_hash->root.u.def.value += ARCH_SIZE / 8;
7455 fprintf (stderr, "Bump up %s by %ld, current value = %ld\n",
7456 lsect->sym_hash->root.root.string,
7457 (long) ARCH_SIZE / 8,
7458 (long) lsect->sym_hash->root.u.def.value);
7464 linker_section_ptr->offset = lsect->section->_raw_size;
7466 lsect->section->_raw_size += ARCH_SIZE / 8;
7470 "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
7471 lsect->name, (long) linker_section_ptr->offset,
7472 (long) lsect->section->_raw_size);
7479 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
7482 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
7485 /* Fill in the address for a pointer generated in a linker section. */
7488 elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h,
7489 relocation, rel, relative_reloc)
7492 struct bfd_link_info *info;
7493 elf_linker_section_t *lsect;
7494 struct elf_link_hash_entry *h;
7496 const Elf_Internal_Rela *rel;
7499 elf_linker_section_pointers_t *linker_section_ptr;
7501 BFD_ASSERT (lsect != NULL);
7505 /* Handle global symbol. */
7506 linker_section_ptr = (_bfd_elf_find_pointer_linker_section
7507 (h->linker_section_pointer,
7511 BFD_ASSERT (linker_section_ptr != NULL);
7513 if (! elf_hash_table (info)->dynamic_sections_created
7516 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
7518 /* This is actually a static link, or it is a
7519 -Bsymbolic link and the symbol is defined
7520 locally. We must initialize this entry in the
7523 When doing a dynamic link, we create a .rela.<xxx>
7524 relocation entry to initialize the value. This
7525 is done in the finish_dynamic_symbol routine. */
7526 if (!linker_section_ptr->written_address_p)
7528 linker_section_ptr->written_address_p = true;
7529 bfd_put_ptr (output_bfd,
7530 relocation + linker_section_ptr->addend,
7531 (lsect->section->contents
7532 + linker_section_ptr->offset));
7538 /* Handle local symbol. */
7539 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
7540 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
7541 BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
7542 linker_section_ptr = (_bfd_elf_find_pointer_linker_section
7543 (elf_local_ptr_offsets (input_bfd)[r_symndx],
7547 BFD_ASSERT (linker_section_ptr != NULL);
7549 /* Write out pointer if it hasn't been rewritten out before. */
7550 if (!linker_section_ptr->written_address_p)
7552 linker_section_ptr->written_address_p = true;
7553 bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
7554 lsect->section->contents + linker_section_ptr->offset);
7558 asection *srel = lsect->rel_section;
7559 Elf_Internal_Rela *outrel;
7560 Elf_External_Rela *erel;
7561 struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
7565 amt = sizeof (Elf_Internal_Rela) * bed->s->int_rels_per_ext_rel;
7566 outrel = (Elf_Internal_Rela *) bfd_zmalloc (amt);
7569 (*_bfd_error_handler) (_("Error: out of memory"));
7573 /* We need to generate a relative reloc for the dynamic
7577 srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
7579 lsect->rel_section = srel;
7582 BFD_ASSERT (srel != NULL);
7584 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
7585 outrel[i].r_offset = (lsect->section->output_section->vma
7586 + lsect->section->output_offset
7587 + linker_section_ptr->offset);
7588 outrel[0].r_info = ELF_R_INFO (0, relative_reloc);
7589 outrel[0].r_addend = 0;
7590 erel = (Elf_External_Rela *) lsect->section->contents;
7591 erel += elf_section_data (lsect->section)->rel_count;
7592 elf_swap_reloca_out (output_bfd, outrel, erel);
7593 ++elf_section_data (lsect->section)->rel_count;
7600 relocation = (lsect->section->output_offset
7601 + linker_section_ptr->offset
7602 - lsect->hole_offset
7603 - lsect->sym_offset);
7607 "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
7608 lsect->name, (long) relocation, (long) relocation);
7611 /* Subtract out the addend, because it will get added back in by the normal
7613 return relocation - linker_section_ptr->addend;
7616 /* Garbage collect unused sections. */
7618 static boolean elf_gc_mark
7619 PARAMS ((struct bfd_link_info *, asection *,
7620 asection * (*) (asection *, struct bfd_link_info *,
7621 Elf_Internal_Rela *, struct elf_link_hash_entry *,
7622 Elf_Internal_Sym *)));
7624 static boolean elf_gc_sweep
7625 PARAMS ((struct bfd_link_info *,
7626 boolean (*) (bfd *, struct bfd_link_info *, asection *,
7627 const Elf_Internal_Rela *)));
7629 static boolean elf_gc_sweep_symbol
7630 PARAMS ((struct elf_link_hash_entry *, PTR));
7632 static boolean elf_gc_allocate_got_offsets
7633 PARAMS ((struct elf_link_hash_entry *, PTR));
7635 static boolean elf_gc_propagate_vtable_entries_used
7636 PARAMS ((struct elf_link_hash_entry *, PTR));
7638 static boolean elf_gc_smash_unused_vtentry_relocs
7639 PARAMS ((struct elf_link_hash_entry *, PTR));
7641 /* The mark phase of garbage collection. For a given section, mark
7642 it and any sections in this section's group, and all the sections
7643 which define symbols to which it refers. */
7646 elf_gc_mark (info, sec, gc_mark_hook)
7647 struct bfd_link_info *info;
7649 asection * (*gc_mark_hook) PARAMS ((asection *, struct bfd_link_info *,
7650 Elf_Internal_Rela *,
7651 struct elf_link_hash_entry *,
7652 Elf_Internal_Sym *));
7655 asection *group_sec;
7659 /* Mark all the sections in the group. */
7660 group_sec = elf_section_data (sec)->next_in_group;
7661 if (group_sec && !group_sec->gc_mark)
7662 if (!elf_gc_mark (info, group_sec, gc_mark_hook))
7665 /* Look through the section relocs. */
7667 if ((sec->flags & SEC_RELOC) != 0 && sec->reloc_count > 0)
7669 Elf_Internal_Rela *relstart, *rel, *relend;
7670 Elf_Internal_Shdr *symtab_hdr;
7671 struct elf_link_hash_entry **sym_hashes;
7674 bfd *input_bfd = sec->owner;
7675 struct elf_backend_data *bed = get_elf_backend_data (input_bfd);
7676 Elf_Internal_Sym *isym = NULL;
7678 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
7679 sym_hashes = elf_sym_hashes (input_bfd);
7681 /* Read the local symbols. */
7682 if (elf_bad_symtab (input_bfd))
7684 nlocsyms = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
7688 extsymoff = nlocsyms = symtab_hdr->sh_info;
7690 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
7691 if (isym == NULL && nlocsyms != 0)
7693 isym = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, nlocsyms, 0,
7699 /* Read the relocations. */
7700 relstart = (NAME(_bfd_elf,link_read_relocs)
7701 (input_bfd, sec, NULL, (Elf_Internal_Rela *) NULL,
7702 info->keep_memory));
7703 if (relstart == NULL)
7708 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7710 for (rel = relstart; rel < relend; rel++)
7712 unsigned long r_symndx;
7714 struct elf_link_hash_entry *h;
7716 r_symndx = ELF_R_SYM (rel->r_info);
7720 if (r_symndx >= nlocsyms
7721 || ELF_ST_BIND (isym[r_symndx].st_info) != STB_LOCAL)
7723 h = sym_hashes[r_symndx - extsymoff];
7724 rsec = (*gc_mark_hook) (sec, info, rel, h, NULL);
7728 rsec = (*gc_mark_hook) (sec, info, rel, NULL, &isym[r_symndx]);
7731 if (rsec && !rsec->gc_mark)
7733 if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour)
7735 else if (!elf_gc_mark (info, rsec, gc_mark_hook))
7744 if (elf_section_data (sec)->relocs != relstart)
7747 if (isym != NULL && symtab_hdr->contents != (unsigned char *) isym)
7749 if (! info->keep_memory)
7752 symtab_hdr->contents = (unsigned char *) isym;
7759 /* The sweep phase of garbage collection. Remove all garbage sections. */
7762 elf_gc_sweep (info, gc_sweep_hook)
7763 struct bfd_link_info *info;
7764 boolean (*gc_sweep_hook) PARAMS ((bfd *, struct bfd_link_info *,
7765 asection *, const Elf_Internal_Rela *));
7769 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
7773 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
7776 for (o = sub->sections; o != NULL; o = o->next)
7778 /* Keep special sections. Keep .debug sections. */
7779 if ((o->flags & SEC_LINKER_CREATED)
7780 || (o->flags & SEC_DEBUGGING))
7786 /* Skip sweeping sections already excluded. */
7787 if (o->flags & SEC_EXCLUDE)
7790 /* Since this is early in the link process, it is simple
7791 to remove a section from the output. */
7792 o->flags |= SEC_EXCLUDE;
7794 /* But we also have to update some of the relocation
7795 info we collected before. */
7797 && (o->flags & SEC_RELOC) && o->reloc_count > 0)
7799 Elf_Internal_Rela *internal_relocs;
7802 internal_relocs = (NAME(_bfd_elf,link_read_relocs)
7803 (o->owner, o, NULL, NULL, info->keep_memory));
7804 if (internal_relocs == NULL)
7807 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
7809 if (elf_section_data (o)->relocs != internal_relocs)
7810 free (internal_relocs);
7818 /* Remove the symbols that were in the swept sections from the dynamic
7819 symbol table. GCFIXME: Anyone know how to get them out of the
7820 static symbol table as well? */
7824 elf_link_hash_traverse (elf_hash_table (info),
7825 elf_gc_sweep_symbol,
7828 elf_hash_table (info)->dynsymcount = i;
7834 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
7837 elf_gc_sweep_symbol (h, idxptr)
7838 struct elf_link_hash_entry *h;
7841 int *idx = (int *) idxptr;
7843 if (h->root.type == bfd_link_hash_warning)
7844 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7846 if (h->dynindx != -1
7847 && ((h->root.type != bfd_link_hash_defined
7848 && h->root.type != bfd_link_hash_defweak)
7849 || h->root.u.def.section->gc_mark))
7850 h->dynindx = (*idx)++;
7855 /* Propogate collected vtable information. This is called through
7856 elf_link_hash_traverse. */
7859 elf_gc_propagate_vtable_entries_used (h, okp)
7860 struct elf_link_hash_entry *h;
7863 if (h->root.type == bfd_link_hash_warning)
7864 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7866 /* Those that are not vtables. */
7867 if (h->vtable_parent == NULL)
7870 /* Those vtables that do not have parents, we cannot merge. */
7871 if (h->vtable_parent == (struct elf_link_hash_entry *) -1)
7874 /* If we've already been done, exit. */
7875 if (h->vtable_entries_used && h->vtable_entries_used[-1])
7878 /* Make sure the parent's table is up to date. */
7879 elf_gc_propagate_vtable_entries_used (h->vtable_parent, okp);
7881 if (h->vtable_entries_used == NULL)
7883 /* None of this table's entries were referenced. Re-use the
7885 h->vtable_entries_used = h->vtable_parent->vtable_entries_used;
7886 h->vtable_entries_size = h->vtable_parent->vtable_entries_size;
7893 /* Or the parent's entries into ours. */
7894 cu = h->vtable_entries_used;
7896 pu = h->vtable_parent->vtable_entries_used;
7899 asection *sec = h->root.u.def.section;
7900 struct elf_backend_data *bed = get_elf_backend_data (sec->owner);
7901 int file_align = bed->s->file_align;
7903 n = h->vtable_parent->vtable_entries_size / file_align;
7918 elf_gc_smash_unused_vtentry_relocs (h, okp)
7919 struct elf_link_hash_entry *h;
7923 bfd_vma hstart, hend;
7924 Elf_Internal_Rela *relstart, *relend, *rel;
7925 struct elf_backend_data *bed;
7928 if (h->root.type == bfd_link_hash_warning)
7929 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7931 /* Take care of both those symbols that do not describe vtables as
7932 well as those that are not loaded. */
7933 if (h->vtable_parent == NULL)
7936 BFD_ASSERT (h->root.type == bfd_link_hash_defined
7937 || h->root.type == bfd_link_hash_defweak);
7939 sec = h->root.u.def.section;
7940 hstart = h->root.u.def.value;
7941 hend = hstart + h->size;
7943 relstart = (NAME(_bfd_elf,link_read_relocs)
7944 (sec->owner, sec, NULL, (Elf_Internal_Rela *) NULL, true));
7946 return *(boolean *) okp = false;
7947 bed = get_elf_backend_data (sec->owner);
7948 file_align = bed->s->file_align;
7950 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7952 for (rel = relstart; rel < relend; ++rel)
7953 if (rel->r_offset >= hstart && rel->r_offset < hend)
7955 /* If the entry is in use, do nothing. */
7956 if (h->vtable_entries_used
7957 && (rel->r_offset - hstart) < h->vtable_entries_size)
7959 bfd_vma entry = (rel->r_offset - hstart) / file_align;
7960 if (h->vtable_entries_used[entry])
7963 /* Otherwise, kill it. */
7964 rel->r_offset = rel->r_info = rel->r_addend = 0;
7970 /* Do mark and sweep of unused sections. */
7973 elf_gc_sections (abfd, info)
7975 struct bfd_link_info *info;
7979 asection * (*gc_mark_hook)
7980 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
7981 struct elf_link_hash_entry *h, Elf_Internal_Sym *));
7983 if (!get_elf_backend_data (abfd)->can_gc_sections
7984 || info->relocateable || info->emitrelocations
7985 || elf_hash_table (info)->dynamic_sections_created)
7988 /* Apply transitive closure to the vtable entry usage info. */
7989 elf_link_hash_traverse (elf_hash_table (info),
7990 elf_gc_propagate_vtable_entries_used,
7995 /* Kill the vtable relocations that were not used. */
7996 elf_link_hash_traverse (elf_hash_table (info),
7997 elf_gc_smash_unused_vtentry_relocs,
8002 /* Grovel through relocs to find out who stays ... */
8004 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
8005 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
8009 if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
8012 for (o = sub->sections; o != NULL; o = o->next)
8014 if (o->flags & SEC_KEEP)
8015 if (!elf_gc_mark (info, o, gc_mark_hook))
8020 /* ... and mark SEC_EXCLUDE for those that go. */
8021 if (!elf_gc_sweep (info, get_elf_backend_data (abfd)->gc_sweep_hook))
8027 /* Called from check_relocs to record the existance of a VTINHERIT reloc. */
8030 elf_gc_record_vtinherit (abfd, sec, h, offset)
8033 struct elf_link_hash_entry *h;
8036 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
8037 struct elf_link_hash_entry **search, *child;
8038 bfd_size_type extsymcount;
8040 /* The sh_info field of the symtab header tells us where the
8041 external symbols start. We don't care about the local symbols at
8043 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size/sizeof (Elf_External_Sym);
8044 if (!elf_bad_symtab (abfd))
8045 extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
8047 sym_hashes = elf_sym_hashes (abfd);
8048 sym_hashes_end = sym_hashes + extsymcount;
8050 /* Hunt down the child symbol, which is in this section at the same
8051 offset as the relocation. */
8052 for (search = sym_hashes; search != sym_hashes_end; ++search)
8054 if ((child = *search) != NULL
8055 && (child->root.type == bfd_link_hash_defined
8056 || child->root.type == bfd_link_hash_defweak)
8057 && child->root.u.def.section == sec
8058 && child->root.u.def.value == offset)
8062 (*_bfd_error_handler) ("%s: %s+%lu: No symbol found for INHERIT",
8063 bfd_archive_filename (abfd), sec->name,
8064 (unsigned long) offset);
8065 bfd_set_error (bfd_error_invalid_operation);
8071 /* This *should* only be the absolute section. It could potentially
8072 be that someone has defined a non-global vtable though, which
8073 would be bad. It isn't worth paging in the local symbols to be
8074 sure though; that case should simply be handled by the assembler. */
8076 child->vtable_parent = (struct elf_link_hash_entry *) -1;
8079 child->vtable_parent = h;
8084 /* Called from check_relocs to record the existance of a VTENTRY reloc. */
8087 elf_gc_record_vtentry (abfd, sec, h, addend)
8088 bfd *abfd ATTRIBUTE_UNUSED;
8089 asection *sec ATTRIBUTE_UNUSED;
8090 struct elf_link_hash_entry *h;
8093 struct elf_backend_data *bed = get_elf_backend_data (abfd);
8094 int file_align = bed->s->file_align;
8096 if (addend >= h->vtable_entries_size)
8099 boolean *ptr = h->vtable_entries_used;
8101 /* While the symbol is undefined, we have to be prepared to handle
8103 if (h->root.type == bfd_link_hash_undefined)
8110 /* Oops! We've got a reference past the defined end of
8111 the table. This is probably a bug -- shall we warn? */
8116 /* Allocate one extra entry for use as a "done" flag for the
8117 consolidation pass. */
8118 bytes = (size / file_align + 1) * sizeof (boolean);
8122 ptr = bfd_realloc (ptr - 1, (bfd_size_type) bytes);
8128 oldbytes = ((h->vtable_entries_size / file_align + 1)
8129 * sizeof (boolean));
8130 memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
8134 ptr = bfd_zmalloc ((bfd_size_type) bytes);
8139 /* And arrange for that done flag to be at index -1. */
8140 h->vtable_entries_used = ptr + 1;
8141 h->vtable_entries_size = size;
8144 h->vtable_entries_used[addend / file_align] = true;
8149 /* And an accompanying bit to work out final got entry offsets once
8150 we're done. Should be called from final_link. */
8153 elf_gc_common_finalize_got_offsets (abfd, info)
8155 struct bfd_link_info *info;
8158 struct elf_backend_data *bed = get_elf_backend_data (abfd);
8161 /* The GOT offset is relative to the .got section, but the GOT header is
8162 put into the .got.plt section, if the backend uses it. */
8163 if (bed->want_got_plt)
8166 gotoff = bed->got_header_size;
8168 /* Do the local .got entries first. */
8169 for (i = info->input_bfds; i; i = i->link_next)
8171 bfd_signed_vma *local_got;
8172 bfd_size_type j, locsymcount;
8173 Elf_Internal_Shdr *symtab_hdr;
8175 if (bfd_get_flavour (i) != bfd_target_elf_flavour)
8178 local_got = elf_local_got_refcounts (i);
8182 symtab_hdr = &elf_tdata (i)->symtab_hdr;
8183 if (elf_bad_symtab (i))
8184 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
8186 locsymcount = symtab_hdr->sh_info;
8188 for (j = 0; j < locsymcount; ++j)
8190 if (local_got[j] > 0)
8192 local_got[j] = gotoff;
8193 gotoff += ARCH_SIZE / 8;
8196 local_got[j] = (bfd_vma) -1;
8200 /* Then the global .got entries. .plt refcounts are handled by
8201 adjust_dynamic_symbol */
8202 elf_link_hash_traverse (elf_hash_table (info),
8203 elf_gc_allocate_got_offsets,
8208 /* We need a special top-level link routine to convert got reference counts
8209 to real got offsets. */
8212 elf_gc_allocate_got_offsets (h, offarg)
8213 struct elf_link_hash_entry *h;
8216 bfd_vma *off = (bfd_vma *) offarg;
8218 if (h->root.type == bfd_link_hash_warning)
8219 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8221 if (h->got.refcount > 0)
8223 h->got.offset = off[0];
8224 off[0] += ARCH_SIZE / 8;
8227 h->got.offset = (bfd_vma) -1;
8232 /* Many folk need no more in the way of final link than this, once
8233 got entry reference counting is enabled. */
8236 elf_gc_common_final_link (abfd, info)
8238 struct bfd_link_info *info;
8240 if (!elf_gc_common_finalize_got_offsets (abfd, info))
8243 /* Invoke the regular ELF backend linker to do all the work. */
8244 return elf_bfd_final_link (abfd, info);
8247 /* This function will be called though elf_link_hash_traverse to store
8248 all hash value of the exported symbols in an array. */
8251 elf_collect_hash_codes (h, data)
8252 struct elf_link_hash_entry *h;
8255 unsigned long **valuep = (unsigned long **) data;
8261 if (h->root.type == bfd_link_hash_warning)
8262 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8264 /* Ignore indirect symbols. These are added by the versioning code. */
8265 if (h->dynindx == -1)
8268 name = h->root.root.string;
8269 p = strchr (name, ELF_VER_CHR);
8272 alc = bfd_malloc ((bfd_size_type) (p - name + 1));
8273 memcpy (alc, name, (size_t) (p - name));
8274 alc[p - name] = '\0';
8278 /* Compute the hash value. */
8279 ha = bfd_elf_hash (name);
8281 /* Store the found hash value in the array given as the argument. */
8284 /* And store it in the struct so that we can put it in the hash table
8286 h->elf_hash_value = ha;
8295 elf_reloc_symbol_deleted_p (offset, cookie)
8299 struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
8301 if (rcookie->bad_symtab)
8302 rcookie->rel = rcookie->rels;
8304 for (; rcookie->rel < rcookie->relend; rcookie->rel++)
8306 unsigned long r_symndx = ELF_R_SYM (rcookie->rel->r_info);
8308 if (! rcookie->bad_symtab)
8309 if (rcookie->rel->r_offset > offset)
8311 if (rcookie->rel->r_offset != offset)
8314 if (r_symndx >= rcookie->locsymcount
8315 || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
8317 struct elf_link_hash_entry *h;
8319 h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
8321 while (h->root.type == bfd_link_hash_indirect
8322 || h->root.type == bfd_link_hash_warning)
8323 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8325 if ((h->root.type == bfd_link_hash_defined
8326 || h->root.type == bfd_link_hash_defweak)
8327 && elf_discarded_section (h->root.u.def.section))
8334 /* It's not a relocation against a global symbol,
8335 but it could be a relocation against a local
8336 symbol for a discarded section. */
8338 Elf_Internal_Sym *isym;
8340 /* Need to: get the symbol; get the section. */
8341 isym = &rcookie->locsyms[r_symndx];
8342 if (isym->st_shndx < SHN_LORESERVE || isym->st_shndx > SHN_HIRESERVE)
8344 isec = section_from_elf_index (rcookie->abfd, isym->st_shndx);
8345 if (isec != NULL && elf_discarded_section (isec))
8354 /* Discard unneeded references to discarded sections.
8355 Returns true if any section's size was changed. */
8356 /* This function assumes that the relocations are in sorted order,
8357 which is true for all known assemblers. */
8360 elf_bfd_discard_info (output_bfd, info)
8362 struct bfd_link_info *info;
8364 struct elf_reloc_cookie cookie;
8365 asection *stab, *eh, *ehdr;
8366 Elf_Internal_Shdr *symtab_hdr;
8367 struct elf_backend_data *bed;
8369 boolean ret = false;
8370 boolean strip = info->strip == strip_all || info->strip == strip_debugger;
8372 if (info->relocateable
8373 || info->traditional_format
8374 || info->hash->creator->flavour != bfd_target_elf_flavour
8375 || ! is_elf_hash_table (info))
8379 if (elf_hash_table (info)->dynobj != NULL)
8380 ehdr = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
8383 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
8385 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
8388 bed = get_elf_backend_data (abfd);
8390 if ((abfd->flags & DYNAMIC) != 0)
8396 eh = bfd_get_section_by_name (abfd, ".eh_frame");
8397 if (eh && (eh->_raw_size == 0
8398 || bfd_is_abs_section (eh->output_section)))
8405 stab = bfd_get_section_by_name (abfd, ".stab");
8406 if (stab && (stab->_raw_size == 0
8407 || bfd_is_abs_section (stab->output_section)))
8411 || elf_section_data(stab)->sec_info_type != ELF_INFO_TYPE_STABS)
8413 && (strip || ! bed->elf_backend_discard_info))
8416 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8418 cookie.sym_hashes = elf_sym_hashes (abfd);
8419 cookie.bad_symtab = elf_bad_symtab (abfd);
8420 if (cookie.bad_symtab)
8422 cookie.locsymcount =
8423 symtab_hdr->sh_size / sizeof (Elf_External_Sym);
8424 cookie.extsymoff = 0;
8428 cookie.locsymcount = symtab_hdr->sh_info;
8429 cookie.extsymoff = symtab_hdr->sh_info;
8432 cookie.locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
8433 if (cookie.locsyms == NULL && cookie.locsymcount != 0)
8435 cookie.locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8436 cookie.locsymcount, 0,
8438 if (cookie.locsyms == NULL)
8444 cookie.rels = (NAME(_bfd_elf,link_read_relocs)
8445 (abfd, stab, (PTR) NULL, (Elf_Internal_Rela *) NULL,
8446 info->keep_memory));
8449 cookie.rel = cookie.rels;
8451 cookie.rels + stab->reloc_count * bed->s->int_rels_per_ext_rel;
8452 if (_bfd_discard_section_stabs (abfd, stab,
8453 elf_section_data (stab)->sec_info,
8454 elf_reloc_symbol_deleted_p,
8457 if (elf_section_data (stab)->relocs != cookie.rels)
8466 cookie.relend = NULL;
8467 if (eh->reloc_count)
8468 cookie.rels = (NAME(_bfd_elf,link_read_relocs)
8469 (abfd, eh, (PTR) NULL, (Elf_Internal_Rela *) NULL,
8470 info->keep_memory));
8473 cookie.rel = cookie.rels;
8475 cookie.rels + eh->reloc_count * bed->s->int_rels_per_ext_rel;
8477 if (_bfd_elf_discard_section_eh_frame (abfd, info, eh, ehdr,
8478 elf_reloc_symbol_deleted_p,
8481 /* Relocs have been edited. Ensure edited version is
8482 used later in relocate_section. */
8483 elf_section_data (eh)->relocs = cookie.rels;
8486 if (cookie.rels && elf_section_data (eh)->relocs != cookie.rels)
8490 if (bed->elf_backend_discard_info)
8492 if (bed->elf_backend_discard_info (abfd, &cookie, info))
8496 if (cookie.locsyms != NULL
8497 && symtab_hdr->contents != (unsigned char *) cookie.locsyms)
8499 if (! info->keep_memory)
8500 free (cookie.locsyms);
8502 symtab_hdr->contents = (unsigned char *) cookie.locsyms;
8506 if (ehdr && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info, ehdr))
8512 elf_section_ignore_discarded_relocs (sec)
8515 struct elf_backend_data *bed;
8517 switch (elf_section_data (sec)->sec_info_type)
8519 case ELF_INFO_TYPE_STABS:
8520 case ELF_INFO_TYPE_EH_FRAME:
8526 bed = get_elf_backend_data (sec->owner);
8527 if (bed->elf_backend_ignore_discarded_relocs != NULL
8528 && (*bed->elf_backend_ignore_discarded_relocs) (sec))