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
;
1302 /* ld --just-symbols and dynamic objects don't mix very well.
1303 Test for --just-symbols by looking at info set up by
1304 _bfd_elf_link_just_syms. */
1305 if ((s
= abfd
->sections
) != NULL
1306 && elf_section_data (s
)->sec_info_type
== ELF_INFO_TYPE_JUST_SYMS
)
1309 /* Find the name to use in a DT_NEEDED entry that refers to this
1310 object. If the object has a DT_SONAME entry, we use it.
1311 Otherwise, if the generic linker stuck something in
1312 elf_dt_name, we use that. Otherwise, we just use the file
1313 name. If the generic linker put a null string into
1314 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
1315 there is a DT_SONAME entry. */
1317 name
= bfd_get_filename (abfd
);
1318 if (elf_dt_name (abfd
) != NULL
)
1320 name
= elf_dt_name (abfd
);
1323 if (elf_dt_soname (abfd
) != NULL
)
1329 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1332 Elf_External_Dyn
*dynbuf
= NULL
;
1333 Elf_External_Dyn
*extdyn
;
1334 Elf_External_Dyn
*extdynend
;
1336 unsigned long shlink
;
1340 dynbuf
= (Elf_External_Dyn
*) bfd_malloc (s
->_raw_size
);
1344 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
1345 (file_ptr
) 0, s
->_raw_size
))
1346 goto error_free_dyn
;
1348 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1350 goto error_free_dyn
;
1351 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1354 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
1357 for (; extdyn
< extdynend
; extdyn
++)
1359 Elf_Internal_Dyn dyn
;
1361 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
1362 if (dyn
.d_tag
== DT_SONAME
)
1364 unsigned int tagv
= dyn
.d_un
.d_val
;
1365 name
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1367 goto error_free_dyn
;
1369 if (dyn
.d_tag
== DT_NEEDED
)
1371 struct bfd_link_needed_list
*n
, **pn
;
1373 unsigned int tagv
= dyn
.d_un
.d_val
;
1375 amt
= sizeof (struct bfd_link_needed_list
);
1376 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
1377 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1378 if (n
== NULL
|| fnm
== NULL
)
1379 goto error_free_dyn
;
1380 amt
= strlen (fnm
) + 1;
1381 anm
= bfd_alloc (abfd
, amt
);
1383 goto error_free_dyn
;
1384 memcpy (anm
, fnm
, (size_t) amt
);
1388 for (pn
= & hash_table
->needed
;
1394 if (dyn
.d_tag
== DT_RUNPATH
)
1396 struct bfd_link_needed_list
*n
, **pn
;
1398 unsigned int tagv
= dyn
.d_un
.d_val
;
1400 /* When we see DT_RPATH before DT_RUNPATH, we have
1401 to clear runpath. Do _NOT_ bfd_release, as that
1402 frees all more recently bfd_alloc'd blocks as
1404 if (rpath
&& hash_table
->runpath
)
1405 hash_table
->runpath
= NULL
;
1407 amt
= sizeof (struct bfd_link_needed_list
);
1408 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
1409 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1410 if (n
== NULL
|| fnm
== NULL
)
1411 goto error_free_dyn
;
1412 amt
= strlen (fnm
) + 1;
1413 anm
= bfd_alloc (abfd
, amt
);
1415 goto error_free_dyn
;
1416 memcpy (anm
, fnm
, (size_t) amt
);
1420 for (pn
= & hash_table
->runpath
;
1428 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
1429 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
1431 struct bfd_link_needed_list
*n
, **pn
;
1433 unsigned int tagv
= dyn
.d_un
.d_val
;
1435 amt
= sizeof (struct bfd_link_needed_list
);
1436 n
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
1437 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1438 if (n
== NULL
|| fnm
== NULL
)
1439 goto error_free_dyn
;
1440 amt
= strlen (fnm
) + 1;
1441 anm
= bfd_alloc (abfd
, amt
);
1448 memcpy (anm
, fnm
, (size_t) amt
);
1452 for (pn
= & hash_table
->runpath
;
1464 /* We do not want to include any of the sections in a dynamic
1465 object in the output file. We hack by simply clobbering the
1466 list of sections in the BFD. This could be handled more
1467 cleanly by, say, a new section flag; the existing
1468 SEC_NEVER_LOAD flag is not the one we want, because that one
1469 still implies that the section takes up space in the output
1471 bfd_section_list_clear (abfd
);
1473 /* If this is the first dynamic object found in the link, create
1474 the special sections required for dynamic linking. */
1475 if (! hash_table
->dynamic_sections_created
)
1476 if (! elf_link_create_dynamic_sections (abfd
, info
))
1481 /* Add a DT_NEEDED entry for this dynamic object. */
1482 oldsize
= _bfd_elf_strtab_size (hash_table
->dynstr
);
1483 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, name
, false);
1484 if (strindex
== (bfd_size_type
) -1)
1487 if (oldsize
== _bfd_elf_strtab_size (hash_table
->dynstr
))
1490 Elf_External_Dyn
*dyncon
, *dynconend
;
1492 /* The hash table size did not change, which means that
1493 the dynamic object name was already entered. If we
1494 have already included this dynamic object in the
1495 link, just ignore it. There is no reason to include
1496 a particular dynamic object more than once. */
1497 sdyn
= bfd_get_section_by_name (hash_table
->dynobj
, ".dynamic");
1498 BFD_ASSERT (sdyn
!= NULL
);
1500 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
1501 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
1503 for (; dyncon
< dynconend
; dyncon
++)
1505 Elf_Internal_Dyn dyn
;
1507 elf_swap_dyn_in (hash_table
->dynobj
, dyncon
, & dyn
);
1508 if (dyn
.d_tag
== DT_NEEDED
1509 && dyn
.d_un
.d_val
== strindex
)
1511 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
1517 if (! elf_add_dynamic_entry (info
, (bfd_vma
) DT_NEEDED
, strindex
))
1521 /* Save the SONAME, if there is one, because sometimes the
1522 linker emulation code will need to know it. */
1524 name
= basename (bfd_get_filename (abfd
));
1525 elf_dt_name (abfd
) = name
;
1528 /* If this is a dynamic object, we always link against the .dynsym
1529 symbol table, not the .symtab symbol table. The dynamic linker
1530 will only see the .dynsym symbol table, so there is no reason to
1531 look at .symtab for a dynamic object. */
1533 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
1534 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1536 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1538 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1540 /* The sh_info field of the symtab header tells us where the
1541 external symbols start. We don't care about the local symbols at
1543 if (elf_bad_symtab (abfd
))
1545 extsymcount
= symcount
;
1550 extsymcount
= symcount
- hdr
->sh_info
;
1551 extsymoff
= hdr
->sh_info
;
1555 if (extsymcount
!= 0)
1557 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
1559 if (isymbuf
== NULL
)
1562 /* We store a pointer to the hash table entry for each external
1564 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
1565 sym_hash
= (struct elf_link_hash_entry
**) bfd_alloc (abfd
, amt
);
1566 if (sym_hash
== NULL
)
1567 goto error_free_sym
;
1568 elf_sym_hashes (abfd
) = sym_hash
;
1573 /* Read in any version definitions. */
1574 if (! _bfd_elf_slurp_version_tables (abfd
))
1575 goto error_free_sym
;
1577 /* Read in the symbol versions, but don't bother to convert them
1578 to internal format. */
1579 if (elf_dynversym (abfd
) != 0)
1581 Elf_Internal_Shdr
*versymhdr
;
1583 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1584 extversym
= (Elf_External_Versym
*) bfd_malloc (versymhdr
->sh_size
);
1585 if (extversym
== NULL
)
1586 goto error_free_sym
;
1587 amt
= versymhdr
->sh_size
;
1588 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
1589 || bfd_bread ((PTR
) extversym
, amt
, abfd
) != amt
)
1590 goto error_free_vers
;
1596 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
1597 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
1599 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
1606 struct elf_link_hash_entry
*h
;
1608 boolean size_change_ok
, type_change_ok
;
1609 boolean new_weakdef
;
1610 unsigned int old_alignment
;
1615 flags
= BSF_NO_FLAGS
;
1617 value
= isym
->st_value
;
1620 bind
= ELF_ST_BIND (isym
->st_info
);
1621 if (bind
== STB_LOCAL
)
1623 /* This should be impossible, since ELF requires that all
1624 global symbols follow all local symbols, and that sh_info
1625 point to the first global symbol. Unfortunatealy, Irix 5
1629 else if (bind
== STB_GLOBAL
)
1631 if (isym
->st_shndx
!= SHN_UNDEF
1632 && isym
->st_shndx
!= SHN_COMMON
)
1635 else if (bind
== STB_WEAK
)
1639 /* Leave it up to the processor backend. */
1642 if (isym
->st_shndx
== SHN_UNDEF
)
1643 sec
= bfd_und_section_ptr
;
1644 else if (isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
1646 sec
= section_from_elf_index (abfd
, isym
->st_shndx
);
1648 sec
= bfd_abs_section_ptr
;
1649 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1652 else if (isym
->st_shndx
== SHN_ABS
)
1653 sec
= bfd_abs_section_ptr
;
1654 else if (isym
->st_shndx
== SHN_COMMON
)
1656 sec
= bfd_com_section_ptr
;
1657 /* What ELF calls the size we call the value. What ELF
1658 calls the value we call the alignment. */
1659 value
= isym
->st_size
;
1663 /* Leave it up to the processor backend. */
1666 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
1668 if (name
== (const char *) NULL
)
1669 goto error_free_vers
;
1671 if (isym
->st_shndx
== SHN_COMMON
1672 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
)
1674 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
1678 tcomm
= bfd_make_section (abfd
, ".tcommon");
1680 || !bfd_set_section_flags (abfd
, tcomm
, (SEC_ALLOC
1682 | SEC_LINKER_CREATED
1683 | SEC_THREAD_LOCAL
)))
1684 goto error_free_vers
;
1688 else if (add_symbol_hook
)
1690 if (! (*add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
, &sec
,
1692 goto error_free_vers
;
1694 /* The hook function sets the name to NULL if this symbol
1695 should be skipped for some reason. */
1696 if (name
== (const char *) NULL
)
1700 /* Sanity check that all possibilities were handled. */
1701 if (sec
== (asection
*) NULL
)
1703 bfd_set_error (bfd_error_bad_value
);
1704 goto error_free_vers
;
1707 if (bfd_is_und_section (sec
)
1708 || bfd_is_com_section (sec
))
1713 size_change_ok
= false;
1714 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
1716 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1718 Elf_Internal_Versym iver
;
1719 unsigned int vernum
= 0;
1723 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
1724 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
1726 /* If this is a hidden symbol, or if it is not version
1727 1, we append the version name to the symbol name.
1728 However, we do not modify a non-hidden absolute
1729 symbol, because it might be the version symbol
1730 itself. FIXME: What if it isn't? */
1731 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
1732 || (vernum
> 1 && ! bfd_is_abs_section (sec
)))
1735 size_t namelen
, verlen
, newlen
;
1738 if (isym
->st_shndx
!= SHN_UNDEF
)
1740 if (vernum
> elf_tdata (abfd
)->dynverdef_hdr
.sh_info
)
1742 (*_bfd_error_handler
)
1743 (_("%s: %s: invalid version %u (max %d)"),
1744 bfd_archive_filename (abfd
), name
, vernum
,
1745 elf_tdata (abfd
)->dynverdef_hdr
.sh_info
);
1746 bfd_set_error (bfd_error_bad_value
);
1747 goto error_free_vers
;
1749 else if (vernum
> 1)
1751 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1757 /* We cannot simply test for the number of
1758 entries in the VERNEED section since the
1759 numbers for the needed versions do not start
1761 Elf_Internal_Verneed
*t
;
1764 for (t
= elf_tdata (abfd
)->verref
;
1768 Elf_Internal_Vernaux
*a
;
1770 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1772 if (a
->vna_other
== vernum
)
1774 verstr
= a
->vna_nodename
;
1783 (*_bfd_error_handler
)
1784 (_("%s: %s: invalid needed version %d"),
1785 bfd_archive_filename (abfd
), name
, vernum
);
1786 bfd_set_error (bfd_error_bad_value
);
1787 goto error_free_vers
;
1791 namelen
= strlen (name
);
1792 verlen
= strlen (verstr
);
1793 newlen
= namelen
+ verlen
+ 2;
1794 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
1795 && isym
->st_shndx
!= SHN_UNDEF
)
1798 newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) newlen
);
1799 if (newname
== NULL
)
1800 goto error_free_vers
;
1801 memcpy (newname
, name
, namelen
);
1802 p
= newname
+ namelen
;
1804 /* If this is a defined non-hidden version symbol,
1805 we add another @ to the name. This indicates the
1806 default version of the symbol. */
1807 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
1808 && isym
->st_shndx
!= SHN_UNDEF
)
1810 memcpy (p
, verstr
, verlen
+ 1);
1816 if (! elf_merge_symbol (abfd
, info
, name
, isym
, &sec
, &value
,
1817 sym_hash
, &override
, &type_change_ok
,
1818 &size_change_ok
, dt_needed
))
1819 goto error_free_vers
;
1825 while (h
->root
.type
== bfd_link_hash_indirect
1826 || h
->root
.type
== bfd_link_hash_warning
)
1827 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1829 /* Remember the old alignment if this is a common symbol, so
1830 that we don't reduce the alignment later on. We can't
1831 check later, because _bfd_generic_link_add_one_symbol
1832 will set a default for the alignment which we want to
1834 if (h
->root
.type
== bfd_link_hash_common
)
1835 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
1837 if (elf_tdata (abfd
)->verdef
!= NULL
1841 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
1844 if (! (_bfd_generic_link_add_one_symbol
1845 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
1846 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
1847 goto error_free_vers
;
1850 while (h
->root
.type
== bfd_link_hash_indirect
1851 || h
->root
.type
== bfd_link_hash_warning
)
1852 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1855 new_weakdef
= false;
1858 && (flags
& BSF_WEAK
) != 0
1859 && ELF_ST_TYPE (isym
->st_info
) != STT_FUNC
1860 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1861 && h
->weakdef
== NULL
)
1863 /* Keep a list of all weak defined non function symbols from
1864 a dynamic object, using the weakdef field. Later in this
1865 function we will set the weakdef field to the correct
1866 value. We only put non-function symbols from dynamic
1867 objects on this list, because that happens to be the only
1868 time we need to know the normal symbol corresponding to a
1869 weak symbol, and the information is time consuming to
1870 figure out. If the weakdef field is not already NULL,
1871 then this symbol was already defined by some previous
1872 dynamic object, and we will be using that previous
1873 definition anyhow. */
1880 /* Set the alignment of a common symbol. */
1881 if (isym
->st_shndx
== SHN_COMMON
1882 && h
->root
.type
== bfd_link_hash_common
)
1886 align
= bfd_log2 (isym
->st_value
);
1887 if (align
> old_alignment
1888 /* Permit an alignment power of zero if an alignment of one
1889 is specified and no other alignments have been specified. */
1890 || (isym
->st_value
== 1 && old_alignment
== 0))
1891 h
->root
.u
.c
.p
->alignment_power
= align
;
1894 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1900 /* Remember the symbol size and type. */
1901 if (isym
->st_size
!= 0
1902 && (definition
|| h
->size
== 0))
1904 if (h
->size
!= 0 && h
->size
!= isym
->st_size
&& ! size_change_ok
)
1905 (*_bfd_error_handler
)
1906 (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
1907 name
, (unsigned long) h
->size
,
1908 (unsigned long) isym
->st_size
, bfd_archive_filename (abfd
));
1910 h
->size
= isym
->st_size
;
1913 /* If this is a common symbol, then we always want H->SIZE
1914 to be the size of the common symbol. The code just above
1915 won't fix the size if a common symbol becomes larger. We
1916 don't warn about a size change here, because that is
1917 covered by --warn-common. */
1918 if (h
->root
.type
== bfd_link_hash_common
)
1919 h
->size
= h
->root
.u
.c
.size
;
1921 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
1922 && (definition
|| h
->type
== STT_NOTYPE
))
1924 if (h
->type
!= STT_NOTYPE
1925 && h
->type
!= ELF_ST_TYPE (isym
->st_info
)
1926 && ! type_change_ok
)
1927 (*_bfd_error_handler
)
1928 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
1929 name
, h
->type
, ELF_ST_TYPE (isym
->st_info
),
1930 bfd_archive_filename (abfd
));
1932 h
->type
= ELF_ST_TYPE (isym
->st_info
);
1935 /* If st_other has a processor-specific meaning, specific code
1936 might be needed here. */
1937 if (isym
->st_other
!= 0)
1939 /* Combine visibilities, using the most constraining one. */
1940 unsigned char hvis
= ELF_ST_VISIBILITY (h
->other
);
1941 unsigned char symvis
= ELF_ST_VISIBILITY (isym
->st_other
);
1943 if (symvis
&& (hvis
> symvis
|| hvis
== 0))
1944 h
->other
= isym
->st_other
;
1946 /* If neither has visibility, use the st_other of the
1947 definition. This is an arbitrary choice, since the
1948 other bits have no general meaning. */
1949 if (!symvis
&& !hvis
1950 && (definition
|| h
->other
== 0))
1951 h
->other
= isym
->st_other
;
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
6355 if (! finfo
->info
->relocateable
6356 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
6357 sym
.st_other
^= ELF_ST_VISIBILITY (sym
.st_other
);
6359 /* If this symbol should be put in the .dynsym section, then put it
6360 there now. We already know the symbol index. We also fill in
6361 the entry in the .hash section. */
6362 if (h
->dynindx
!= -1
6363 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
6367 size_t hash_entry_size
;
6368 bfd_byte
*bucketpos
;
6370 Elf_External_Sym
*esym
;
6372 sym
.st_name
= h
->dynstr_index
;
6373 esym
= (Elf_External_Sym
*) finfo
->dynsym_sec
->contents
+ h
->dynindx
;
6374 elf_swap_symbol_out (finfo
->output_bfd
, &sym
, (PTR
) esym
, (PTR
) 0);
6376 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
6377 bucket
= h
->elf_hash_value
% bucketcount
;
6379 = elf_section_data (finfo
->hash_sec
)->this_hdr
.sh_entsize
;
6380 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
6381 + (bucket
+ 2) * hash_entry_size
);
6382 chain
= bfd_get (8 * hash_entry_size
, finfo
->output_bfd
, bucketpos
);
6383 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, (bfd_vma
) h
->dynindx
,
6385 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, chain
,
6386 ((bfd_byte
*) finfo
->hash_sec
->contents
6387 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
6389 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
6391 Elf_Internal_Versym iversym
;
6392 Elf_External_Versym
*eversym
;
6394 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
6396 if (h
->verinfo
.verdef
== NULL
)
6397 iversym
.vs_vers
= 0;
6399 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
6403 if (h
->verinfo
.vertree
== NULL
)
6404 iversym
.vs_vers
= 1;
6406 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
6409 if ((h
->elf_link_hash_flags
& ELF_LINK_HIDDEN
) != 0)
6410 iversym
.vs_vers
|= VERSYM_HIDDEN
;
6412 eversym
= (Elf_External_Versym
*) finfo
->symver_sec
->contents
;
6413 eversym
+= h
->dynindx
;
6414 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
, eversym
);
6418 /* If we're stripping it, then it was just a dynamic symbol, and
6419 there's nothing else to do. */
6420 if (strip
|| (input_sec
->flags
& SEC_EXCLUDE
) != 0)
6423 h
->indx
= bfd_get_symcount (finfo
->output_bfd
);
6425 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
6427 eoinfo
->failed
= true;
6434 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
6435 originated from the section given by INPUT_REL_HDR) to the
6439 elf_link_output_relocs (output_bfd
, input_section
, input_rel_hdr
,
6442 asection
*input_section
;
6443 Elf_Internal_Shdr
*input_rel_hdr
;
6444 Elf_Internal_Rela
*internal_relocs
;
6446 Elf_Internal_Rela
*irela
;
6447 Elf_Internal_Rela
*irelaend
;
6448 Elf_Internal_Shdr
*output_rel_hdr
;
6449 asection
*output_section
;
6450 unsigned int *rel_countp
= NULL
;
6451 struct elf_backend_data
*bed
;
6454 output_section
= input_section
->output_section
;
6455 output_rel_hdr
= NULL
;
6457 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
6458 == input_rel_hdr
->sh_entsize
)
6460 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
6461 rel_countp
= &elf_section_data (output_section
)->rel_count
;
6463 else if (elf_section_data (output_section
)->rel_hdr2
6464 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
6465 == input_rel_hdr
->sh_entsize
))
6467 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
6468 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
6472 (*_bfd_error_handler
)
6473 (_("%s: relocation size mismatch in %s section %s"),
6474 bfd_get_filename (output_bfd
),
6475 bfd_archive_filename (input_section
->owner
),
6476 input_section
->name
);
6477 bfd_set_error (bfd_error_wrong_object_format
);
6481 bed
= get_elf_backend_data (output_bfd
);
6482 irela
= internal_relocs
;
6483 irelaend
= irela
+ (NUM_SHDR_ENTRIES (input_rel_hdr
)
6484 * bed
->s
->int_rels_per_ext_rel
);
6486 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
6488 Elf_External_Rel
*erel
;
6489 Elf_Internal_Rel
*irel
;
6491 amt
= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rel
);
6492 irel
= (Elf_Internal_Rel
*) bfd_zmalloc (amt
);
6495 (*_bfd_error_handler
) (_("Error: out of memory"));
6499 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
+ *rel_countp
);
6500 for (; irela
< irelaend
; irela
+= bed
->s
->int_rels_per_ext_rel
, erel
++)
6504 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
6506 irel
[i
].r_offset
= irela
[i
].r_offset
;
6507 irel
[i
].r_info
= irela
[i
].r_info
;
6508 BFD_ASSERT (irela
[i
].r_addend
== 0);
6511 if (bed
->s
->swap_reloc_out
)
6512 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, (PTR
) erel
);
6514 elf_swap_reloc_out (output_bfd
, irel
, erel
);
6521 Elf_External_Rela
*erela
;
6523 BFD_ASSERT (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
6525 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
+ *rel_countp
);
6526 for (; irela
< irelaend
; irela
+= bed
->s
->int_rels_per_ext_rel
, erela
++)
6527 if (bed
->s
->swap_reloca_out
)
6528 (*bed
->s
->swap_reloca_out
) (output_bfd
, irela
, (PTR
) erela
);
6530 elf_swap_reloca_out (output_bfd
, irela
, erela
);
6533 /* Bump the counter, so that we know where to add the next set of
6535 *rel_countp
+= NUM_SHDR_ENTRIES (input_rel_hdr
);
6540 /* Link an input file into the linker output file. This function
6541 handles all the sections and relocations of the input file at once.
6542 This is so that we only have to read the local symbols once, and
6543 don't have to keep them in memory. */
6546 elf_link_input_bfd (finfo
, input_bfd
)
6547 struct elf_final_link_info
*finfo
;
6550 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
6551 bfd
*, asection
*, bfd_byte
*,
6552 Elf_Internal_Rela
*,
6553 Elf_Internal_Sym
*, asection
**));
6555 Elf_Internal_Shdr
*symtab_hdr
;
6558 Elf_Internal_Sym
*isymbuf
;
6559 Elf_Internal_Sym
*isym
;
6560 Elf_Internal_Sym
*isymend
;
6562 asection
**ppsection
;
6564 struct elf_backend_data
*bed
;
6565 boolean emit_relocs
;
6566 struct elf_link_hash_entry
**sym_hashes
;
6568 output_bfd
= finfo
->output_bfd
;
6569 bed
= get_elf_backend_data (output_bfd
);
6570 relocate_section
= bed
->elf_backend_relocate_section
;
6572 /* If this is a dynamic object, we don't want to do anything here:
6573 we don't want the local symbols, and we don't want the section
6575 if ((input_bfd
->flags
& DYNAMIC
) != 0)
6578 emit_relocs
= (finfo
->info
->relocateable
6579 || finfo
->info
->emitrelocations
6580 || bed
->elf_backend_emit_relocs
);
6582 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6583 if (elf_bad_symtab (input_bfd
))
6585 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6590 locsymcount
= symtab_hdr
->sh_info
;
6591 extsymoff
= symtab_hdr
->sh_info
;
6594 /* Read the local symbols. */
6595 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6596 if (isymbuf
== NULL
&& locsymcount
!= 0)
6598 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6599 finfo
->internal_syms
,
6600 finfo
->external_syms
,
6601 finfo
->locsym_shndx
);
6602 if (isymbuf
== NULL
)
6606 /* Find local symbol sections and adjust values of symbols in
6607 SEC_MERGE sections. Write out those local symbols we know are
6608 going into the output file. */
6609 isymend
= isymbuf
+ locsymcount
;
6610 for (isym
= isymbuf
, pindex
= finfo
->indices
, ppsection
= finfo
->sections
;
6612 isym
++, pindex
++, ppsection
++)
6616 Elf_Internal_Sym osym
;
6620 if (elf_bad_symtab (input_bfd
))
6622 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
6629 if (isym
->st_shndx
== SHN_UNDEF
)
6630 isec
= bfd_und_section_ptr
;
6631 else if (isym
->st_shndx
< SHN_LORESERVE
6632 || isym
->st_shndx
> SHN_HIRESERVE
)
6634 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
6636 && elf_section_data (isec
)->sec_info_type
== ELF_INFO_TYPE_MERGE
6637 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
6639 _bfd_merged_section_offset (output_bfd
, &isec
,
6640 elf_section_data (isec
)->sec_info
,
6641 isym
->st_value
, (bfd_vma
) 0);
6643 else if (isym
->st_shndx
== SHN_ABS
)
6644 isec
= bfd_abs_section_ptr
;
6645 else if (isym
->st_shndx
== SHN_COMMON
)
6646 isec
= bfd_com_section_ptr
;
6655 /* Don't output the first, undefined, symbol. */
6656 if (ppsection
== finfo
->sections
)
6659 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
6661 /* We never output section symbols. Instead, we use the
6662 section symbol of the corresponding section in the output
6667 /* If we are stripping all symbols, we don't want to output this
6669 if (finfo
->info
->strip
== strip_all
)
6672 /* If we are discarding all local symbols, we don't want to
6673 output this one. If we are generating a relocateable output
6674 file, then some of the local symbols may be required by
6675 relocs; we output them below as we discover that they are
6677 if (finfo
->info
->discard
== discard_all
)
6680 /* If this symbol is defined in a section which we are
6681 discarding, we don't need to keep it, but note that
6682 linker_mark is only reliable for sections that have contents.
6683 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
6684 as well as linker_mark. */
6685 if ((isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
6687 && ((! isec
->linker_mark
&& (isec
->flags
& SEC_HAS_CONTENTS
) != 0)
6688 || (! finfo
->info
->relocateable
6689 && (isec
->flags
& SEC_EXCLUDE
) != 0)))
6692 /* Get the name of the symbol. */
6693 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
6698 /* See if we are discarding symbols with this name. */
6699 if ((finfo
->info
->strip
== strip_some
6700 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
6702 || (((finfo
->info
->discard
== discard_sec_merge
6703 && (isec
->flags
& SEC_MERGE
) && ! finfo
->info
->relocateable
)
6704 || finfo
->info
->discard
== discard_l
)
6705 && bfd_is_local_label_name (input_bfd
, name
)))
6708 /* If we get here, we are going to output this symbol. */
6712 /* Adjust the section index for the output file. */
6713 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
6714 isec
->output_section
);
6715 if (osym
.st_shndx
== SHN_BAD
)
6718 *pindex
= bfd_get_symcount (output_bfd
);
6720 /* ELF symbols in relocateable files are section relative, but
6721 in executable files they are virtual addresses. Note that
6722 this code assumes that all ELF sections have an associated
6723 BFD section with a reasonable value for output_offset; below
6724 we assume that they also have a reasonable value for
6725 output_section. Any special sections must be set up to meet
6726 these requirements. */
6727 osym
.st_value
+= isec
->output_offset
;
6728 if (! finfo
->info
->relocateable
)
6730 osym
.st_value
+= isec
->output_section
->vma
;
6731 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
6733 /* STT_TLS symbols are relative to PT_TLS segment base. */
6734 BFD_ASSERT (finfo
->first_tls_sec
!= NULL
);
6735 osym
.st_value
-= finfo
->first_tls_sec
->vma
;
6739 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
6743 /* Relocate the contents of each section. */
6744 sym_hashes
= elf_sym_hashes (input_bfd
);
6745 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6749 if (! o
->linker_mark
)
6751 /* This section was omitted from the link. */
6755 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
6756 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
6759 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
6761 /* Section was created by elf_link_create_dynamic_sections
6766 /* Get the contents of the section. They have been cached by a
6767 relaxation routine. Note that o is a section in an input
6768 file, so the contents field will not have been set by any of
6769 the routines which work on output files. */
6770 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
6771 contents
= elf_section_data (o
)->this_hdr
.contents
;
6774 contents
= finfo
->contents
;
6775 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
6776 (file_ptr
) 0, o
->_raw_size
))
6780 if ((o
->flags
& SEC_RELOC
) != 0)
6782 Elf_Internal_Rela
*internal_relocs
;
6784 /* Get the swapped relocs. */
6785 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
6786 (input_bfd
, o
, finfo
->external_relocs
,
6787 finfo
->internal_relocs
, false));
6788 if (internal_relocs
== NULL
6789 && o
->reloc_count
> 0)
6792 /* Run through the relocs looking for any against symbols
6793 from discarded sections and section symbols from
6794 removed link-once sections. Complain about relocs
6795 against discarded sections. Zero relocs against removed
6796 link-once sections. We should really complain if
6797 anything in the final link tries to use it, but
6798 DWARF-based exception handling might have an entry in
6799 .eh_frame to describe a routine in the linkonce section,
6800 and it turns out to be hard to remove the .eh_frame
6801 entry too. FIXME. */
6802 if (!finfo
->info
->relocateable
6803 && !elf_section_ignore_discarded_relocs (o
))
6805 Elf_Internal_Rela
*rel
, *relend
;
6807 rel
= internal_relocs
;
6808 relend
= rel
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6809 for ( ; rel
< relend
; rel
++)
6811 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
6813 if (r_symndx
>= locsymcount
6814 || (elf_bad_symtab (input_bfd
)
6815 && finfo
->sections
[r_symndx
] == NULL
))
6817 struct elf_link_hash_entry
*h
;
6819 h
= sym_hashes
[r_symndx
- extsymoff
];
6820 while (h
->root
.type
== bfd_link_hash_indirect
6821 || h
->root
.type
== bfd_link_hash_warning
)
6822 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6824 /* Complain if the definition comes from a
6825 discarded section. */
6826 if ((h
->root
.type
== bfd_link_hash_defined
6827 || h
->root
.type
== bfd_link_hash_defweak
)
6828 && elf_discarded_section (h
->root
.u
.def
.section
))
6830 if ((o
->flags
& SEC_DEBUGGING
) != 0)
6832 BFD_ASSERT (r_symndx
!= 0);
6833 memset (rel
, 0, sizeof (*rel
));
6837 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
6838 (finfo
->info
, h
->root
.root
.string
,
6839 input_bfd
, o
, rel
->r_offset
,
6847 asection
*sec
= finfo
->sections
[r_symndx
];
6849 if (sec
!= NULL
&& elf_discarded_section (sec
))
6851 if ((o
->flags
& SEC_DEBUGGING
) != 0
6852 || (sec
->flags
& SEC_LINK_ONCE
) != 0)
6854 BFD_ASSERT (r_symndx
!= 0);
6856 = ELF_R_INFO (0, ELF_R_TYPE (rel
->r_info
));
6863 = _("local symbols in discarded section %s");
6865 = strlen (sec
->name
) + strlen (msg
) - 1;
6866 char *buf
= (char *) bfd_malloc (amt
);
6869 sprintf (buf
, msg
, sec
->name
);
6871 buf
= (char *) sec
->name
;
6872 ok
= (*finfo
->info
->callbacks
6873 ->undefined_symbol
) (finfo
->info
, buf
,
6877 if (buf
!= sec
->name
)
6887 /* Relocate the section by invoking a back end routine.
6889 The back end routine is responsible for adjusting the
6890 section contents as necessary, and (if using Rela relocs
6891 and generating a relocateable output file) adjusting the
6892 reloc addend as necessary.
6894 The back end routine does not have to worry about setting
6895 the reloc address or the reloc symbol index.
6897 The back end routine is given a pointer to the swapped in
6898 internal symbols, and can access the hash table entries
6899 for the external symbols via elf_sym_hashes (input_bfd).
6901 When generating relocateable output, the back end routine
6902 must handle STB_LOCAL/STT_SECTION symbols specially. The
6903 output symbol is going to be a section symbol
6904 corresponding to the output section, which will require
6905 the addend to be adjusted. */
6907 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
6908 input_bfd
, o
, contents
,
6916 Elf_Internal_Rela
*irela
;
6917 Elf_Internal_Rela
*irelaend
;
6918 struct elf_link_hash_entry
**rel_hash
;
6919 Elf_Internal_Shdr
*input_rel_hdr
, *input_rel_hdr2
;
6920 unsigned int next_erel
;
6921 boolean (*reloc_emitter
) PARAMS ((bfd
*, asection
*,
6922 Elf_Internal_Shdr
*,
6923 Elf_Internal_Rela
*));
6924 boolean rela_normal
;
6926 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
6927 rela_normal
= (bed
->rela_normal
6928 && (input_rel_hdr
->sh_entsize
6929 == sizeof (Elf_External_Rela
)));
6931 /* Adjust the reloc addresses and symbol indices. */
6933 irela
= internal_relocs
;
6934 irelaend
= irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6935 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
6936 + elf_section_data (o
->output_section
)->rel_count
6937 + elf_section_data (o
->output_section
)->rel_count2
);
6938 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
6940 unsigned long r_symndx
;
6942 Elf_Internal_Sym sym
;
6944 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
6950 irela
->r_offset
+= o
->output_offset
;
6952 /* Relocs in an executable have to be virtual addresses. */
6953 if (!finfo
->info
->relocateable
)
6954 irela
->r_offset
+= o
->output_section
->vma
;
6956 r_symndx
= ELF_R_SYM (irela
->r_info
);
6961 if (r_symndx
>= locsymcount
6962 || (elf_bad_symtab (input_bfd
)
6963 && finfo
->sections
[r_symndx
] == NULL
))
6965 struct elf_link_hash_entry
*rh
;
6968 /* This is a reloc against a global symbol. We
6969 have not yet output all the local symbols, so
6970 we do not know the symbol index of any global
6971 symbol. We set the rel_hash entry for this
6972 reloc to point to the global hash table entry
6973 for this symbol. The symbol index is then
6974 set at the end of elf_bfd_final_link. */
6975 indx
= r_symndx
- extsymoff
;
6976 rh
= elf_sym_hashes (input_bfd
)[indx
];
6977 while (rh
->root
.type
== bfd_link_hash_indirect
6978 || rh
->root
.type
== bfd_link_hash_warning
)
6979 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
6981 /* Setting the index to -2 tells
6982 elf_link_output_extsym that this symbol is
6984 BFD_ASSERT (rh
->indx
< 0);
6992 /* This is a reloc against a local symbol. */
6995 sym
= isymbuf
[r_symndx
];
6996 sec
= finfo
->sections
[r_symndx
];
6997 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
6999 /* I suppose the backend ought to fill in the
7000 section of any STT_SECTION symbol against a
7001 processor specific section. If we have
7002 discarded a section, the output_section will
7003 be the absolute section. */
7004 if (bfd_is_abs_section (sec
)
7006 && bfd_is_abs_section (sec
->output_section
)))
7008 else if (sec
== NULL
|| sec
->owner
== NULL
)
7010 bfd_set_error (bfd_error_bad_value
);
7015 r_symndx
= sec
->output_section
->target_index
;
7016 BFD_ASSERT (r_symndx
!= 0);
7019 /* Adjust the addend according to where the
7020 section winds up in the output section. */
7022 irela
->r_addend
+= sec
->output_offset
;
7026 if (finfo
->indices
[r_symndx
] == -1)
7028 unsigned long shlink
;
7032 if (finfo
->info
->strip
== strip_all
)
7034 /* You can't do ld -r -s. */
7035 bfd_set_error (bfd_error_invalid_operation
);
7039 /* This symbol was skipped earlier, but
7040 since it is needed by a reloc, we
7041 must output it now. */
7042 shlink
= symtab_hdr
->sh_link
;
7043 name
= (bfd_elf_string_from_elf_section
7044 (input_bfd
, shlink
, sym
.st_name
));
7048 osec
= sec
->output_section
;
7050 _bfd_elf_section_from_bfd_section (output_bfd
,
7052 if (sym
.st_shndx
== SHN_BAD
)
7055 sym
.st_value
+= sec
->output_offset
;
7056 if (! finfo
->info
->relocateable
)
7058 sym
.st_value
+= osec
->vma
;
7059 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
7061 /* STT_TLS symbols are relative to PT_TLS
7063 BFD_ASSERT (finfo
->first_tls_sec
!= NULL
);
7064 sym
.st_value
-= finfo
->first_tls_sec
->vma
;
7068 finfo
->indices
[r_symndx
]
7069 = bfd_get_symcount (output_bfd
);
7071 if (! elf_link_output_sym (finfo
, name
, &sym
, sec
))
7075 r_symndx
= finfo
->indices
[r_symndx
];
7078 irela
->r_info
= ELF_R_INFO (r_symndx
,
7079 ELF_R_TYPE (irela
->r_info
));
7082 /* Swap out the relocs. */
7083 if (bed
->elf_backend_emit_relocs
7084 && !(finfo
->info
->relocateable
7085 || finfo
->info
->emitrelocations
))
7086 reloc_emitter
= bed
->elf_backend_emit_relocs
;
7088 reloc_emitter
= elf_link_output_relocs
;
7090 if (input_rel_hdr
->sh_size
!= 0
7091 && ! (*reloc_emitter
) (output_bfd
, o
, input_rel_hdr
,
7095 input_rel_hdr2
= elf_section_data (o
)->rel_hdr2
;
7096 if (input_rel_hdr2
&& input_rel_hdr2
->sh_size
!= 0)
7098 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
7099 * bed
->s
->int_rels_per_ext_rel
);
7100 if (! (*reloc_emitter
) (output_bfd
, o
, input_rel_hdr2
,
7107 /* Write out the modified section contents. */
7108 if (bed
->elf_backend_write_section
7109 && (*bed
->elf_backend_write_section
) (output_bfd
, o
, contents
))
7111 /* Section written out. */
7113 else switch (elf_section_data (o
)->sec_info_type
)
7115 case ELF_INFO_TYPE_STABS
:
7116 if (! (_bfd_write_section_stabs
7118 &elf_hash_table (finfo
->info
)->stab_info
,
7119 o
, &elf_section_data (o
)->sec_info
, contents
)))
7122 case ELF_INFO_TYPE_MERGE
:
7123 if (! (_bfd_write_merged_section
7124 (output_bfd
, o
, elf_section_data (o
)->sec_info
)))
7127 case ELF_INFO_TYPE_EH_FRAME
:
7132 = bfd_get_section_by_name (elf_hash_table (finfo
->info
)->dynobj
,
7134 if (! (_bfd_elf_write_section_eh_frame (output_bfd
, o
, ehdrsec
,
7141 bfd_size_type sec_size
;
7143 sec_size
= (o
->_cooked_size
!= 0 ? o
->_cooked_size
: o
->_raw_size
);
7144 if (! (o
->flags
& SEC_EXCLUDE
)
7145 && ! bfd_set_section_contents (output_bfd
, o
->output_section
,
7147 (file_ptr
) o
->output_offset
,
7158 /* Generate a reloc when linking an ELF file. This is a reloc
7159 requested by the linker, and does come from any input file. This
7160 is used to build constructor and destructor tables when linking
7164 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
7166 struct bfd_link_info
*info
;
7167 asection
*output_section
;
7168 struct bfd_link_order
*link_order
;
7170 reloc_howto_type
*howto
;
7174 struct elf_link_hash_entry
**rel_hash_ptr
;
7175 Elf_Internal_Shdr
*rel_hdr
;
7176 struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
7178 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
7181 bfd_set_error (bfd_error_bad_value
);
7185 addend
= link_order
->u
.reloc
.p
->addend
;
7187 /* Figure out the symbol index. */
7188 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
7189 + elf_section_data (output_section
)->rel_count
7190 + elf_section_data (output_section
)->rel_count2
);
7191 if (link_order
->type
== bfd_section_reloc_link_order
)
7193 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
7194 BFD_ASSERT (indx
!= 0);
7195 *rel_hash_ptr
= NULL
;
7199 struct elf_link_hash_entry
*h
;
7201 /* Treat a reloc against a defined symbol as though it were
7202 actually against the section. */
7203 h
= ((struct elf_link_hash_entry
*)
7204 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
7205 link_order
->u
.reloc
.p
->u
.name
,
7206 false, false, true));
7208 && (h
->root
.type
== bfd_link_hash_defined
7209 || h
->root
.type
== bfd_link_hash_defweak
))
7213 section
= h
->root
.u
.def
.section
;
7214 indx
= section
->output_section
->target_index
;
7215 *rel_hash_ptr
= NULL
;
7216 /* It seems that we ought to add the symbol value to the
7217 addend here, but in practice it has already been added
7218 because it was passed to constructor_callback. */
7219 addend
+= section
->output_section
->vma
+ section
->output_offset
;
7223 /* Setting the index to -2 tells elf_link_output_extsym that
7224 this symbol is used by a reloc. */
7231 if (! ((*info
->callbacks
->unattached_reloc
)
7232 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
7233 (asection
*) NULL
, (bfd_vma
) 0)))
7239 /* If this is an inplace reloc, we must write the addend into the
7241 if (howto
->partial_inplace
&& addend
!= 0)
7244 bfd_reloc_status_type rstat
;
7247 const char *sym_name
;
7249 size
= bfd_get_reloc_size (howto
);
7250 buf
= (bfd_byte
*) bfd_zmalloc (size
);
7251 if (buf
== (bfd_byte
*) NULL
)
7253 rstat
= _bfd_relocate_contents (howto
, output_bfd
, (bfd_vma
) addend
, buf
);
7260 case bfd_reloc_outofrange
:
7263 case bfd_reloc_overflow
:
7264 if (link_order
->type
== bfd_section_reloc_link_order
)
7265 sym_name
= bfd_section_name (output_bfd
,
7266 link_order
->u
.reloc
.p
->u
.section
);
7268 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
7269 if (! ((*info
->callbacks
->reloc_overflow
)
7270 (info
, sym_name
, howto
->name
, addend
,
7271 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
7278 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
7279 (file_ptr
) link_order
->offset
, size
);
7285 /* The address of a reloc is relative to the section in a
7286 relocateable file, and is a virtual address in an executable
7288 offset
= link_order
->offset
;
7289 if (! info
->relocateable
)
7290 offset
+= output_section
->vma
;
7292 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
7294 if (rel_hdr
->sh_type
== SHT_REL
)
7297 Elf_Internal_Rel
*irel
;
7298 Elf_External_Rel
*erel
;
7301 size
= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rel
);
7302 irel
= (Elf_Internal_Rel
*) bfd_zmalloc (size
);
7306 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
7307 irel
[i
].r_offset
= offset
;
7308 irel
[0].r_info
= ELF_R_INFO (indx
, howto
->type
);
7310 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
7311 + elf_section_data (output_section
)->rel_count
);
7313 if (bed
->s
->swap_reloc_out
)
7314 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, (bfd_byte
*) erel
);
7316 elf_swap_reloc_out (output_bfd
, irel
, erel
);
7323 Elf_Internal_Rela
*irela
;
7324 Elf_External_Rela
*erela
;
7327 size
= bed
->s
->int_rels_per_ext_rel
* sizeof (Elf_Internal_Rela
);
7328 irela
= (Elf_Internal_Rela
*) bfd_zmalloc (size
);
7332 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
7333 irela
[i
].r_offset
= offset
;
7334 irela
[0].r_info
= ELF_R_INFO (indx
, howto
->type
);
7335 irela
[0].r_addend
= addend
;
7337 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
7338 + elf_section_data (output_section
)->rel_count
);
7340 if (bed
->s
->swap_reloca_out
)
7341 (*bed
->s
->swap_reloca_out
) (output_bfd
, irela
, (bfd_byte
*) erela
);
7343 elf_swap_reloca_out (output_bfd
, irela
, erela
);
7346 ++elf_section_data (output_section
)->rel_count
;
7351 /* Allocate a pointer to live in a linker created section. */
7354 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
7356 struct bfd_link_info
*info
;
7357 elf_linker_section_t
*lsect
;
7358 struct elf_link_hash_entry
*h
;
7359 const Elf_Internal_Rela
*rel
;
7361 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
7362 elf_linker_section_pointers_t
*linker_section_ptr
;
7363 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
7366 BFD_ASSERT (lsect
!= NULL
);
7368 /* Is this a global symbol? */
7371 /* Has this symbol already been allocated? If so, our work is done. */
7372 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
7377 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
7378 /* Make sure this symbol is output as a dynamic symbol. */
7379 if (h
->dynindx
== -1)
7381 if (! elf_link_record_dynamic_symbol (info
, h
))
7385 if (lsect
->rel_section
)
7386 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
7390 /* Allocation of a pointer to a local symbol. */
7391 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
7393 /* Allocate a table to hold the local symbols if first time. */
7396 unsigned int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
7397 register unsigned int i
;
7400 amt
*= sizeof (elf_linker_section_pointers_t
*);
7401 ptr
= (elf_linker_section_pointers_t
**) bfd_alloc (abfd
, amt
);
7406 elf_local_ptr_offsets (abfd
) = ptr
;
7407 for (i
= 0; i
< num_symbols
; i
++)
7408 ptr
[i
] = (elf_linker_section_pointers_t
*) 0;
7411 /* Has this symbol already been allocated? If so, our work is done. */
7412 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
7417 ptr_linker_section_ptr
= &ptr
[r_symndx
];
7421 /* If we are generating a shared object, we need to
7422 output a R_<xxx>_RELATIVE reloc so that the
7423 dynamic linker can adjust this GOT entry. */
7424 BFD_ASSERT (lsect
->rel_section
!= NULL
);
7425 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
7429 /* Allocate space for a pointer in the linker section, and allocate
7430 a new pointer record from internal memory. */
7431 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
7432 amt
= sizeof (elf_linker_section_pointers_t
);
7433 linker_section_ptr
= (elf_linker_section_pointers_t
*) bfd_alloc (abfd
, amt
);
7435 if (!linker_section_ptr
)
7438 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
7439 linker_section_ptr
->addend
= rel
->r_addend
;
7440 linker_section_ptr
->which
= lsect
->which
;
7441 linker_section_ptr
->written_address_p
= false;
7442 *ptr_linker_section_ptr
= linker_section_ptr
;
7445 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
7447 linker_section_ptr
->offset
= (lsect
->section
->_raw_size
7448 - lsect
->hole_size
+ (ARCH_SIZE
/ 8));
7449 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
7450 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
7451 if (lsect
->sym_hash
)
7453 /* Bump up symbol value if needed. */
7454 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
7456 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
7457 lsect
->sym_hash
->root
.root
.string
,
7458 (long) ARCH_SIZE
/ 8,
7459 (long) lsect
->sym_hash
->root
.u
.def
.value
);
7465 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
7467 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
7471 "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
7472 lsect
->name
, (long) linker_section_ptr
->offset
,
7473 (long) lsect
->section
->_raw_size
);
7480 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
7483 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
7486 /* Fill in the address for a pointer generated in a linker section. */
7489 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
,
7490 relocation
, rel
, relative_reloc
)
7493 struct bfd_link_info
*info
;
7494 elf_linker_section_t
*lsect
;
7495 struct elf_link_hash_entry
*h
;
7497 const Elf_Internal_Rela
*rel
;
7500 elf_linker_section_pointers_t
*linker_section_ptr
;
7502 BFD_ASSERT (lsect
!= NULL
);
7506 /* Handle global symbol. */
7507 linker_section_ptr
= (_bfd_elf_find_pointer_linker_section
7508 (h
->linker_section_pointer
,
7512 BFD_ASSERT (linker_section_ptr
!= NULL
);
7514 if (! elf_hash_table (info
)->dynamic_sections_created
7517 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
7519 /* This is actually a static link, or it is a
7520 -Bsymbolic link and the symbol is defined
7521 locally. We must initialize this entry in the
7524 When doing a dynamic link, we create a .rela.<xxx>
7525 relocation entry to initialize the value. This
7526 is done in the finish_dynamic_symbol routine. */
7527 if (!linker_section_ptr
->written_address_p
)
7529 linker_section_ptr
->written_address_p
= true;
7530 bfd_put_ptr (output_bfd
,
7531 relocation
+ linker_section_ptr
->addend
,
7532 (lsect
->section
->contents
7533 + linker_section_ptr
->offset
));
7539 /* Handle local symbol. */
7540 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
7541 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
7542 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
7543 linker_section_ptr
= (_bfd_elf_find_pointer_linker_section
7544 (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
7548 BFD_ASSERT (linker_section_ptr
!= NULL
);
7550 /* Write out pointer if it hasn't been rewritten out before. */
7551 if (!linker_section_ptr
->written_address_p
)
7553 linker_section_ptr
->written_address_p
= true;
7554 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
7555 lsect
->section
->contents
+ linker_section_ptr
->offset
);
7559 asection
*srel
= lsect
->rel_section
;
7560 Elf_Internal_Rela
*outrel
;
7561 Elf_External_Rela
*erel
;
7562 struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
7566 amt
= sizeof (Elf_Internal_Rela
) * bed
->s
->int_rels_per_ext_rel
;
7567 outrel
= (Elf_Internal_Rela
*) bfd_zmalloc (amt
);
7570 (*_bfd_error_handler
) (_("Error: out of memory"));
7574 /* We need to generate a relative reloc for the dynamic
7578 srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
7580 lsect
->rel_section
= srel
;
7583 BFD_ASSERT (srel
!= NULL
);
7585 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
7586 outrel
[i
].r_offset
= (lsect
->section
->output_section
->vma
7587 + lsect
->section
->output_offset
7588 + linker_section_ptr
->offset
);
7589 outrel
[0].r_info
= ELF_R_INFO (0, relative_reloc
);
7590 outrel
[0].r_addend
= 0;
7591 erel
= (Elf_External_Rela
*) lsect
->section
->contents
;
7592 erel
+= elf_section_data (lsect
->section
)->rel_count
;
7593 elf_swap_reloca_out (output_bfd
, outrel
, erel
);
7594 ++elf_section_data (lsect
->section
)->rel_count
;
7601 relocation
= (lsect
->section
->output_offset
7602 + linker_section_ptr
->offset
7603 - lsect
->hole_offset
7604 - lsect
->sym_offset
);
7608 "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
7609 lsect
->name
, (long) relocation
, (long) relocation
);
7612 /* Subtract out the addend, because it will get added back in by the normal
7614 return relocation
- linker_section_ptr
->addend
;
7617 /* Garbage collect unused sections. */
7619 static boolean elf_gc_mark
7620 PARAMS ((struct bfd_link_info
*, asection
*,
7621 asection
* (*) (asection
*, struct bfd_link_info
*,
7622 Elf_Internal_Rela
*, struct elf_link_hash_entry
*,
7623 Elf_Internal_Sym
*)));
7625 static boolean elf_gc_sweep
7626 PARAMS ((struct bfd_link_info
*,
7627 boolean (*) (bfd
*, struct bfd_link_info
*, asection
*,
7628 const Elf_Internal_Rela
*)));
7630 static boolean elf_gc_sweep_symbol
7631 PARAMS ((struct elf_link_hash_entry
*, PTR
));
7633 static boolean elf_gc_allocate_got_offsets
7634 PARAMS ((struct elf_link_hash_entry
*, PTR
));
7636 static boolean elf_gc_propagate_vtable_entries_used
7637 PARAMS ((struct elf_link_hash_entry
*, PTR
));
7639 static boolean elf_gc_smash_unused_vtentry_relocs
7640 PARAMS ((struct elf_link_hash_entry
*, PTR
));
7642 /* The mark phase of garbage collection. For a given section, mark
7643 it and any sections in this section's group, and all the sections
7644 which define symbols to which it refers. */
7647 elf_gc_mark (info
, sec
, gc_mark_hook
)
7648 struct bfd_link_info
*info
;
7650 asection
* (*gc_mark_hook
) PARAMS ((asection
*, struct bfd_link_info
*,
7651 Elf_Internal_Rela
*,
7652 struct elf_link_hash_entry
*,
7653 Elf_Internal_Sym
*));
7656 asection
*group_sec
;
7660 /* Mark all the sections in the group. */
7661 group_sec
= elf_section_data (sec
)->next_in_group
;
7662 if (group_sec
&& !group_sec
->gc_mark
)
7663 if (!elf_gc_mark (info
, group_sec
, gc_mark_hook
))
7666 /* Look through the section relocs. */
7668 if ((sec
->flags
& SEC_RELOC
) != 0 && sec
->reloc_count
> 0)
7670 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7671 Elf_Internal_Shdr
*symtab_hdr
;
7672 struct elf_link_hash_entry
**sym_hashes
;
7675 bfd
*input_bfd
= sec
->owner
;
7676 struct elf_backend_data
*bed
= get_elf_backend_data (input_bfd
);
7677 Elf_Internal_Sym
*isym
= NULL
;
7679 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
7680 sym_hashes
= elf_sym_hashes (input_bfd
);
7682 /* Read the local symbols. */
7683 if (elf_bad_symtab (input_bfd
))
7685 nlocsyms
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
7689 extsymoff
= nlocsyms
= symtab_hdr
->sh_info
;
7691 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
7692 if (isym
== NULL
&& nlocsyms
!= 0)
7694 isym
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, nlocsyms
, 0,
7700 /* Read the relocations. */
7701 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
7702 (input_bfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
7703 info
->keep_memory
));
7704 if (relstart
== NULL
)
7709 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7711 for (rel
= relstart
; rel
< relend
; rel
++)
7713 unsigned long r_symndx
;
7715 struct elf_link_hash_entry
*h
;
7717 r_symndx
= ELF_R_SYM (rel
->r_info
);
7721 if (r_symndx
>= nlocsyms
7722 || ELF_ST_BIND (isym
[r_symndx
].st_info
) != STB_LOCAL
)
7724 h
= sym_hashes
[r_symndx
- extsymoff
];
7725 rsec
= (*gc_mark_hook
) (sec
, info
, rel
, h
, NULL
);
7729 rsec
= (*gc_mark_hook
) (sec
, info
, rel
, NULL
, &isym
[r_symndx
]);
7732 if (rsec
&& !rsec
->gc_mark
)
7734 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
)
7736 else if (!elf_gc_mark (info
, rsec
, gc_mark_hook
))
7745 if (elf_section_data (sec
)->relocs
!= relstart
)
7748 if (isym
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isym
)
7750 if (! info
->keep_memory
)
7753 symtab_hdr
->contents
= (unsigned char *) isym
;
7760 /* The sweep phase of garbage collection. Remove all garbage sections. */
7763 elf_gc_sweep (info
, gc_sweep_hook
)
7764 struct bfd_link_info
*info
;
7765 boolean (*gc_sweep_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
7766 asection
*, const Elf_Internal_Rela
*));
7770 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
7774 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
7777 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
7779 /* Keep special sections. Keep .debug sections. */
7780 if ((o
->flags
& SEC_LINKER_CREATED
)
7781 || (o
->flags
& SEC_DEBUGGING
))
7787 /* Skip sweeping sections already excluded. */
7788 if (o
->flags
& SEC_EXCLUDE
)
7791 /* Since this is early in the link process, it is simple
7792 to remove a section from the output. */
7793 o
->flags
|= SEC_EXCLUDE
;
7795 /* But we also have to update some of the relocation
7796 info we collected before. */
7798 && (o
->flags
& SEC_RELOC
) && o
->reloc_count
> 0)
7800 Elf_Internal_Rela
*internal_relocs
;
7803 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
7804 (o
->owner
, o
, NULL
, NULL
, info
->keep_memory
));
7805 if (internal_relocs
== NULL
)
7808 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
7810 if (elf_section_data (o
)->relocs
!= internal_relocs
)
7811 free (internal_relocs
);
7819 /* Remove the symbols that were in the swept sections from the dynamic
7820 symbol table. GCFIXME: Anyone know how to get them out of the
7821 static symbol table as well? */
7825 elf_link_hash_traverse (elf_hash_table (info
),
7826 elf_gc_sweep_symbol
,
7829 elf_hash_table (info
)->dynsymcount
= i
;
7835 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
7838 elf_gc_sweep_symbol (h
, idxptr
)
7839 struct elf_link_hash_entry
*h
;
7842 int *idx
= (int *) idxptr
;
7844 if (h
->root
.type
== bfd_link_hash_warning
)
7845 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7847 if (h
->dynindx
!= -1
7848 && ((h
->root
.type
!= bfd_link_hash_defined
7849 && h
->root
.type
!= bfd_link_hash_defweak
)
7850 || h
->root
.u
.def
.section
->gc_mark
))
7851 h
->dynindx
= (*idx
)++;
7856 /* Propogate collected vtable information. This is called through
7857 elf_link_hash_traverse. */
7860 elf_gc_propagate_vtable_entries_used (h
, okp
)
7861 struct elf_link_hash_entry
*h
;
7864 if (h
->root
.type
== bfd_link_hash_warning
)
7865 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7867 /* Those that are not vtables. */
7868 if (h
->vtable_parent
== NULL
)
7871 /* Those vtables that do not have parents, we cannot merge. */
7872 if (h
->vtable_parent
== (struct elf_link_hash_entry
*) -1)
7875 /* If we've already been done, exit. */
7876 if (h
->vtable_entries_used
&& h
->vtable_entries_used
[-1])
7879 /* Make sure the parent's table is up to date. */
7880 elf_gc_propagate_vtable_entries_used (h
->vtable_parent
, okp
);
7882 if (h
->vtable_entries_used
== NULL
)
7884 /* None of this table's entries were referenced. Re-use the
7886 h
->vtable_entries_used
= h
->vtable_parent
->vtable_entries_used
;
7887 h
->vtable_entries_size
= h
->vtable_parent
->vtable_entries_size
;
7894 /* Or the parent's entries into ours. */
7895 cu
= h
->vtable_entries_used
;
7897 pu
= h
->vtable_parent
->vtable_entries_used
;
7900 asection
*sec
= h
->root
.u
.def
.section
;
7901 struct elf_backend_data
*bed
= get_elf_backend_data (sec
->owner
);
7902 int file_align
= bed
->s
->file_align
;
7904 n
= h
->vtable_parent
->vtable_entries_size
/ file_align
;
7919 elf_gc_smash_unused_vtentry_relocs (h
, okp
)
7920 struct elf_link_hash_entry
*h
;
7924 bfd_vma hstart
, hend
;
7925 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
7926 struct elf_backend_data
*bed
;
7929 if (h
->root
.type
== bfd_link_hash_warning
)
7930 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7932 /* Take care of both those symbols that do not describe vtables as
7933 well as those that are not loaded. */
7934 if (h
->vtable_parent
== NULL
)
7937 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
7938 || h
->root
.type
== bfd_link_hash_defweak
);
7940 sec
= h
->root
.u
.def
.section
;
7941 hstart
= h
->root
.u
.def
.value
;
7942 hend
= hstart
+ h
->size
;
7944 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
7945 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
, true));
7947 return *(boolean
*) okp
= false;
7948 bed
= get_elf_backend_data (sec
->owner
);
7949 file_align
= bed
->s
->file_align
;
7951 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7953 for (rel
= relstart
; rel
< relend
; ++rel
)
7954 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
7956 /* If the entry is in use, do nothing. */
7957 if (h
->vtable_entries_used
7958 && (rel
->r_offset
- hstart
) < h
->vtable_entries_size
)
7960 bfd_vma entry
= (rel
->r_offset
- hstart
) / file_align
;
7961 if (h
->vtable_entries_used
[entry
])
7964 /* Otherwise, kill it. */
7965 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
7971 /* Do mark and sweep of unused sections. */
7974 elf_gc_sections (abfd
, info
)
7976 struct bfd_link_info
*info
;
7980 asection
* (*gc_mark_hook
)
7981 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
7982 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*));
7984 if (!get_elf_backend_data (abfd
)->can_gc_sections
7985 || info
->relocateable
|| info
->emitrelocations
7986 || elf_hash_table (info
)->dynamic_sections_created
)
7989 /* Apply transitive closure to the vtable entry usage info. */
7990 elf_link_hash_traverse (elf_hash_table (info
),
7991 elf_gc_propagate_vtable_entries_used
,
7996 /* Kill the vtable relocations that were not used. */
7997 elf_link_hash_traverse (elf_hash_table (info
),
7998 elf_gc_smash_unused_vtentry_relocs
,
8003 /* Grovel through relocs to find out who stays ... */
8005 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
8006 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
8010 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
8013 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
8015 if (o
->flags
& SEC_KEEP
)
8016 if (!elf_gc_mark (info
, o
, gc_mark_hook
))
8021 /* ... and mark SEC_EXCLUDE for those that go. */
8022 if (!elf_gc_sweep (info
, get_elf_backend_data (abfd
)->gc_sweep_hook
))
8028 /* Called from check_relocs to record the existance of a VTINHERIT reloc. */
8031 elf_gc_record_vtinherit (abfd
, sec
, h
, offset
)
8034 struct elf_link_hash_entry
*h
;
8037 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
8038 struct elf_link_hash_entry
**search
, *child
;
8039 bfd_size_type extsymcount
;
8041 /* The sh_info field of the symtab header tells us where the
8042 external symbols start. We don't care about the local symbols at
8044 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/sizeof (Elf_External_Sym
);
8045 if (!elf_bad_symtab (abfd
))
8046 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
8048 sym_hashes
= elf_sym_hashes (abfd
);
8049 sym_hashes_end
= sym_hashes
+ extsymcount
;
8051 /* Hunt down the child symbol, which is in this section at the same
8052 offset as the relocation. */
8053 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
8055 if ((child
= *search
) != NULL
8056 && (child
->root
.type
== bfd_link_hash_defined
8057 || child
->root
.type
== bfd_link_hash_defweak
)
8058 && child
->root
.u
.def
.section
== sec
8059 && child
->root
.u
.def
.value
== offset
)
8063 (*_bfd_error_handler
) ("%s: %s+%lu: No symbol found for INHERIT",
8064 bfd_archive_filename (abfd
), sec
->name
,
8065 (unsigned long) offset
);
8066 bfd_set_error (bfd_error_invalid_operation
);
8072 /* This *should* only be the absolute section. It could potentially
8073 be that someone has defined a non-global vtable though, which
8074 would be bad. It isn't worth paging in the local symbols to be
8075 sure though; that case should simply be handled by the assembler. */
8077 child
->vtable_parent
= (struct elf_link_hash_entry
*) -1;
8080 child
->vtable_parent
= h
;
8085 /* Called from check_relocs to record the existance of a VTENTRY reloc. */
8088 elf_gc_record_vtentry (abfd
, sec
, h
, addend
)
8089 bfd
*abfd ATTRIBUTE_UNUSED
;
8090 asection
*sec ATTRIBUTE_UNUSED
;
8091 struct elf_link_hash_entry
*h
;
8094 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8095 int file_align
= bed
->s
->file_align
;
8097 if (addend
>= h
->vtable_entries_size
)
8100 boolean
*ptr
= h
->vtable_entries_used
;
8102 /* While the symbol is undefined, we have to be prepared to handle
8104 if (h
->root
.type
== bfd_link_hash_undefined
)
8111 /* Oops! We've got a reference past the defined end of
8112 the table. This is probably a bug -- shall we warn? */
8117 /* Allocate one extra entry for use as a "done" flag for the
8118 consolidation pass. */
8119 bytes
= (size
/ file_align
+ 1) * sizeof (boolean
);
8123 ptr
= bfd_realloc (ptr
- 1, (bfd_size_type
) bytes
);
8129 oldbytes
= ((h
->vtable_entries_size
/ file_align
+ 1)
8130 * sizeof (boolean
));
8131 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
8135 ptr
= bfd_zmalloc ((bfd_size_type
) bytes
);
8140 /* And arrange for that done flag to be at index -1. */
8141 h
->vtable_entries_used
= ptr
+ 1;
8142 h
->vtable_entries_size
= size
;
8145 h
->vtable_entries_used
[addend
/ file_align
] = true;
8150 /* And an accompanying bit to work out final got entry offsets once
8151 we're done. Should be called from final_link. */
8154 elf_gc_common_finalize_got_offsets (abfd
, info
)
8156 struct bfd_link_info
*info
;
8159 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8162 /* The GOT offset is relative to the .got section, but the GOT header is
8163 put into the .got.plt section, if the backend uses it. */
8164 if (bed
->want_got_plt
)
8167 gotoff
= bed
->got_header_size
;
8169 /* Do the local .got entries first. */
8170 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
8172 bfd_signed_vma
*local_got
;
8173 bfd_size_type j
, locsymcount
;
8174 Elf_Internal_Shdr
*symtab_hdr
;
8176 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
8179 local_got
= elf_local_got_refcounts (i
);
8183 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
8184 if (elf_bad_symtab (i
))
8185 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
8187 locsymcount
= symtab_hdr
->sh_info
;
8189 for (j
= 0; j
< locsymcount
; ++j
)
8191 if (local_got
[j
] > 0)
8193 local_got
[j
] = gotoff
;
8194 gotoff
+= ARCH_SIZE
/ 8;
8197 local_got
[j
] = (bfd_vma
) -1;
8201 /* Then the global .got entries. .plt refcounts are handled by
8202 adjust_dynamic_symbol */
8203 elf_link_hash_traverse (elf_hash_table (info
),
8204 elf_gc_allocate_got_offsets
,
8209 /* We need a special top-level link routine to convert got reference counts
8210 to real got offsets. */
8213 elf_gc_allocate_got_offsets (h
, offarg
)
8214 struct elf_link_hash_entry
*h
;
8217 bfd_vma
*off
= (bfd_vma
*) offarg
;
8219 if (h
->root
.type
== bfd_link_hash_warning
)
8220 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8222 if (h
->got
.refcount
> 0)
8224 h
->got
.offset
= off
[0];
8225 off
[0] += ARCH_SIZE
/ 8;
8228 h
->got
.offset
= (bfd_vma
) -1;
8233 /* Many folk need no more in the way of final link than this, once
8234 got entry reference counting is enabled. */
8237 elf_gc_common_final_link (abfd
, info
)
8239 struct bfd_link_info
*info
;
8241 if (!elf_gc_common_finalize_got_offsets (abfd
, info
))
8244 /* Invoke the regular ELF backend linker to do all the work. */
8245 return elf_bfd_final_link (abfd
, info
);
8248 /* This function will be called though elf_link_hash_traverse to store
8249 all hash value of the exported symbols in an array. */
8252 elf_collect_hash_codes (h
, data
)
8253 struct elf_link_hash_entry
*h
;
8256 unsigned long **valuep
= (unsigned long **) data
;
8262 if (h
->root
.type
== bfd_link_hash_warning
)
8263 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8265 /* Ignore indirect symbols. These are added by the versioning code. */
8266 if (h
->dynindx
== -1)
8269 name
= h
->root
.root
.string
;
8270 p
= strchr (name
, ELF_VER_CHR
);
8273 alc
= bfd_malloc ((bfd_size_type
) (p
- name
+ 1));
8274 memcpy (alc
, name
, (size_t) (p
- name
));
8275 alc
[p
- name
] = '\0';
8279 /* Compute the hash value. */
8280 ha
= bfd_elf_hash (name
);
8282 /* Store the found hash value in the array given as the argument. */
8285 /* And store it in the struct so that we can put it in the hash table
8287 h
->elf_hash_value
= ha
;
8296 elf_reloc_symbol_deleted_p (offset
, cookie
)
8300 struct elf_reloc_cookie
*rcookie
= (struct elf_reloc_cookie
*) cookie
;
8302 if (rcookie
->bad_symtab
)
8303 rcookie
->rel
= rcookie
->rels
;
8305 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
8307 unsigned long r_symndx
= ELF_R_SYM (rcookie
->rel
->r_info
);
8309 if (! rcookie
->bad_symtab
)
8310 if (rcookie
->rel
->r_offset
> offset
)
8312 if (rcookie
->rel
->r_offset
!= offset
)
8315 if (r_symndx
>= rcookie
->locsymcount
8316 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
8318 struct elf_link_hash_entry
*h
;
8320 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
8322 while (h
->root
.type
== bfd_link_hash_indirect
8323 || h
->root
.type
== bfd_link_hash_warning
)
8324 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8326 if ((h
->root
.type
== bfd_link_hash_defined
8327 || h
->root
.type
== bfd_link_hash_defweak
)
8328 && elf_discarded_section (h
->root
.u
.def
.section
))
8335 /* It's not a relocation against a global symbol,
8336 but it could be a relocation against a local
8337 symbol for a discarded section. */
8339 Elf_Internal_Sym
*isym
;
8341 /* Need to: get the symbol; get the section. */
8342 isym
= &rcookie
->locsyms
[r_symndx
];
8343 if (isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
8345 isec
= section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
8346 if (isec
!= NULL
&& elf_discarded_section (isec
))
8355 /* Discard unneeded references to discarded sections.
8356 Returns true if any section's size was changed. */
8357 /* This function assumes that the relocations are in sorted order,
8358 which is true for all known assemblers. */
8361 elf_bfd_discard_info (output_bfd
, info
)
8363 struct bfd_link_info
*info
;
8365 struct elf_reloc_cookie cookie
;
8366 asection
*stab
, *eh
, *ehdr
;
8367 Elf_Internal_Shdr
*symtab_hdr
;
8368 struct elf_backend_data
*bed
;
8370 boolean ret
= false;
8371 boolean strip
= info
->strip
== strip_all
|| info
->strip
== strip_debugger
;
8373 if (info
->relocateable
8374 || info
->traditional_format
8375 || info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
8376 || ! is_elf_hash_table (info
))
8380 if (elf_hash_table (info
)->dynobj
!= NULL
)
8381 ehdr
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
8384 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
8386 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
8389 bed
= get_elf_backend_data (abfd
);
8391 if ((abfd
->flags
& DYNAMIC
) != 0)
8397 eh
= bfd_get_section_by_name (abfd
, ".eh_frame");
8398 if (eh
&& (eh
->_raw_size
== 0
8399 || bfd_is_abs_section (eh
->output_section
)))
8406 stab
= bfd_get_section_by_name (abfd
, ".stab");
8407 if (stab
&& (stab
->_raw_size
== 0
8408 || bfd_is_abs_section (stab
->output_section
)))
8412 || elf_section_data(stab
)->sec_info_type
!= ELF_INFO_TYPE_STABS
)
8414 && (strip
|| ! bed
->elf_backend_discard_info
))
8417 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8419 cookie
.sym_hashes
= elf_sym_hashes (abfd
);
8420 cookie
.bad_symtab
= elf_bad_symtab (abfd
);
8421 if (cookie
.bad_symtab
)
8423 cookie
.locsymcount
=
8424 symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
8425 cookie
.extsymoff
= 0;
8429 cookie
.locsymcount
= symtab_hdr
->sh_info
;
8430 cookie
.extsymoff
= symtab_hdr
->sh_info
;
8433 cookie
.locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
8434 if (cookie
.locsyms
== NULL
&& cookie
.locsymcount
!= 0)
8436 cookie
.locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
8437 cookie
.locsymcount
, 0,
8439 if (cookie
.locsyms
== NULL
)
8445 cookie
.rels
= (NAME(_bfd_elf
,link_read_relocs
)
8446 (abfd
, stab
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
8447 info
->keep_memory
));
8450 cookie
.rel
= cookie
.rels
;
8452 cookie
.rels
+ stab
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
8453 if (_bfd_discard_section_stabs (abfd
, stab
,
8454 elf_section_data (stab
)->sec_info
,
8455 elf_reloc_symbol_deleted_p
,
8458 if (elf_section_data (stab
)->relocs
!= cookie
.rels
)
8467 cookie
.relend
= NULL
;
8468 if (eh
->reloc_count
)
8469 cookie
.rels
= (NAME(_bfd_elf
,link_read_relocs
)
8470 (abfd
, eh
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
8471 info
->keep_memory
));
8474 cookie
.rel
= cookie
.rels
;
8476 cookie
.rels
+ eh
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
8478 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, eh
, ehdr
,
8479 elf_reloc_symbol_deleted_p
,
8482 /* Relocs have been edited. Ensure edited version is
8483 used later in relocate_section. */
8484 elf_section_data (eh
)->relocs
= cookie
.rels
;
8487 if (cookie
.rels
&& elf_section_data (eh
)->relocs
!= cookie
.rels
)
8491 if (bed
->elf_backend_discard_info
)
8493 if (bed
->elf_backend_discard_info (abfd
, &cookie
, info
))
8497 if (cookie
.locsyms
!= NULL
8498 && symtab_hdr
->contents
!= (unsigned char *) cookie
.locsyms
)
8500 if (! info
->keep_memory
)
8501 free (cookie
.locsyms
);
8503 symtab_hdr
->contents
= (unsigned char *) cookie
.locsyms
;
8507 if (ehdr
&& _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
, ehdr
))
8513 elf_section_ignore_discarded_relocs (sec
)
8516 struct elf_backend_data
*bed
;
8518 switch (elf_section_data (sec
)->sec_info_type
)
8520 case ELF_INFO_TYPE_STABS
:
8521 case ELF_INFO_TYPE_EH_FRAME
:
8527 bed
= get_elf_backend_data (sec
->owner
);
8528 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
8529 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))