2 Copyright 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 /* This struct is used to pass information to routines called via
23 elf_link_hash_traverse which must return failure. */
25 struct elf_info_failed
28 struct bfd_link_info
*info
;
31 static boolean elf_link_add_object_symbols
32 PARAMS ((bfd
*, struct bfd_link_info
*));
33 static boolean elf_link_add_archive_symbols
34 PARAMS ((bfd
*, struct bfd_link_info
*));
35 static boolean elf_merge_symbol
36 PARAMS ((bfd
*, struct bfd_link_info
*, const char *, Elf_Internal_Sym
*,
37 asection
**, bfd_vma
*, struct elf_link_hash_entry
**,
38 boolean
*, boolean
*, boolean
*));
39 static boolean elf_export_symbol
40 PARAMS ((struct elf_link_hash_entry
*, PTR
));
41 static boolean elf_fix_symbol_flags
42 PARAMS ((struct elf_link_hash_entry
*, struct elf_info_failed
*));
43 static boolean elf_adjust_dynamic_symbol
44 PARAMS ((struct elf_link_hash_entry
*, PTR
));
45 static boolean elf_link_find_version_dependencies
46 PARAMS ((struct elf_link_hash_entry
*, PTR
));
47 static boolean elf_link_find_version_dependencies
48 PARAMS ((struct elf_link_hash_entry
*, PTR
));
49 static boolean elf_link_assign_sym_version
50 PARAMS ((struct elf_link_hash_entry
*, PTR
));
51 static boolean elf_link_renumber_dynsyms
52 PARAMS ((struct elf_link_hash_entry
*, PTR
));
53 static boolean elf_collect_hash_codes
54 PARAMS ((struct elf_link_hash_entry
*, PTR
));
55 static boolean elf_link_read_relocs_from_section
56 PARAMS ((bfd
*, Elf_Internal_Shdr
*, PTR
, Elf_Internal_Rela
*));
57 static void elf_link_remove_section_and_adjust_dynindices
58 PARAMS ((struct bfd_link_info
*, asection
*));
59 static void elf_link_output_relocs
60 PARAMS ((bfd
*, asection
*, Elf_Internal_Shdr
*, Elf_Internal_Rela
*));
61 static boolean elf_link_size_reloc_section
62 PARAMS ((bfd
*, Elf_Internal_Shdr
*, asection
*));
64 /* Given an ELF BFD, add symbols to the global hash table as
68 elf_bfd_link_add_symbols (abfd
, info
)
70 struct bfd_link_info
*info
;
72 switch (bfd_get_format (abfd
))
75 return elf_link_add_object_symbols (abfd
, info
);
77 return elf_link_add_archive_symbols (abfd
, info
);
79 bfd_set_error (bfd_error_wrong_format
);
85 /* Add symbols from an ELF archive file to the linker hash table. We
86 don't use _bfd_generic_link_add_archive_symbols because of a
87 problem which arises on UnixWare. The UnixWare libc.so is an
88 archive which includes an entry libc.so.1 which defines a bunch of
89 symbols. The libc.so archive also includes a number of other
90 object files, which also define symbols, some of which are the same
91 as those defined in libc.so.1. Correct linking requires that we
92 consider each object file in turn, and include it if it defines any
93 symbols we need. _bfd_generic_link_add_archive_symbols does not do
94 this; it looks through the list of undefined symbols, and includes
95 any object file which defines them. When this algorithm is used on
96 UnixWare, it winds up pulling in libc.so.1 early and defining a
97 bunch of symbols. This means that some of the other objects in the
98 archive are not included in the link, which is incorrect since they
99 precede libc.so.1 in the archive.
101 Fortunately, ELF archive handling is simpler than that done by
102 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
103 oddities. In ELF, if we find a symbol in the archive map, and the
104 symbol is currently undefined, we know that we must pull in that
107 Unfortunately, we do have to make multiple passes over the symbol
108 table until nothing further is resolved. */
111 elf_link_add_archive_symbols (abfd
, info
)
113 struct bfd_link_info
*info
;
116 boolean
*defined
= NULL
;
117 boolean
*included
= NULL
;
121 if (! bfd_has_map (abfd
))
123 /* An empty archive is a special case. */
124 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
126 bfd_set_error (bfd_error_no_armap
);
130 /* Keep track of all symbols we know to be already defined, and all
131 files we know to be already included. This is to speed up the
132 second and subsequent passes. */
133 c
= bfd_ardata (abfd
)->symdef_count
;
136 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
137 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
138 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
140 memset (defined
, 0, c
* sizeof (boolean
));
141 memset (included
, 0, c
* sizeof (boolean
));
143 symdefs
= bfd_ardata (abfd
)->symdefs
;
156 symdefend
= symdef
+ c
;
157 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
159 struct elf_link_hash_entry
*h
;
161 struct bfd_link_hash_entry
*undefs_tail
;
164 if (defined
[i
] || included
[i
])
166 if (symdef
->file_offset
== last
)
172 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
173 false, false, false);
179 /* If this is a default version (the name contains @@),
180 look up the symbol again without the version. The
181 effect is that references to the symbol without the
182 version will be matched by the default symbol in the
185 p
= strchr (symdef
->name
, ELF_VER_CHR
);
186 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
189 copy
= bfd_alloc (abfd
, p
- symdef
->name
+ 1);
192 memcpy (copy
, symdef
->name
, p
- symdef
->name
);
193 copy
[p
- symdef
->name
] = '\0';
195 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
196 false, false, false);
198 bfd_release (abfd
, copy
);
204 if (h
->root
.type
!= bfd_link_hash_undefined
)
206 if (h
->root
.type
!= bfd_link_hash_undefweak
)
211 /* We need to include this archive member. */
213 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
214 if (element
== (bfd
*) NULL
)
217 if (! bfd_check_format (element
, bfd_object
))
220 /* Doublecheck that we have not included this object
221 already--it should be impossible, but there may be
222 something wrong with the archive. */
223 if (element
->archive_pass
!= 0)
225 bfd_set_error (bfd_error_bad_value
);
228 element
->archive_pass
= 1;
230 undefs_tail
= info
->hash
->undefs_tail
;
232 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
235 if (! elf_link_add_object_symbols (element
, info
))
238 /* If there are any new undefined symbols, we need to make
239 another pass through the archive in order to see whether
240 they can be defined. FIXME: This isn't perfect, because
241 common symbols wind up on undefs_tail and because an
242 undefined symbol which is defined later on in this pass
243 does not require another pass. This isn't a bug, but it
244 does make the code less efficient than it could be. */
245 if (undefs_tail
!= info
->hash
->undefs_tail
)
248 /* Look backward to mark all symbols from this object file
249 which we have already seen in this pass. */
253 included
[mark
] = true;
258 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
260 /* We mark subsequent symbols from this object file as we go
261 on through the loop. */
262 last
= symdef
->file_offset
;
273 if (defined
!= (boolean
*) NULL
)
275 if (included
!= (boolean
*) NULL
)
280 /* This function is called when we want to define a new symbol. It
281 handles the various cases which arise when we find a definition in
282 a dynamic object, or when there is already a definition in a
283 dynamic object. The new symbol is described by NAME, SYM, PSEC,
284 and PVALUE. We set SYM_HASH to the hash table entry. We set
285 OVERRIDE if the old symbol is overriding a new definition. We set
286 TYPE_CHANGE_OK if it is OK for the type to change. We set
287 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
288 change, we mean that we shouldn't warn if the type or size does
292 elf_merge_symbol (abfd
, info
, name
, sym
, psec
, pvalue
, sym_hash
,
293 override
, type_change_ok
, size_change_ok
)
295 struct bfd_link_info
*info
;
297 Elf_Internal_Sym
*sym
;
300 struct elf_link_hash_entry
**sym_hash
;
302 boolean
*type_change_ok
;
303 boolean
*size_change_ok
;
306 struct elf_link_hash_entry
*h
;
309 boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
314 bind
= ELF_ST_BIND (sym
->st_info
);
316 if (! bfd_is_und_section (sec
))
317 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, false, false);
319 h
= ((struct elf_link_hash_entry
*)
320 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true, false, false));
325 /* This code is for coping with dynamic objects, and is only useful
326 if we are doing an ELF link. */
327 if (info
->hash
->creator
!= abfd
->xvec
)
330 /* For merging, we only care about real symbols. */
332 while (h
->root
.type
== bfd_link_hash_indirect
333 || h
->root
.type
== bfd_link_hash_warning
)
334 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
336 /* If we just created the symbol, mark it as being an ELF symbol.
337 Other than that, there is nothing to do--there is no merge issue
338 with a newly defined symbol--so we just return. */
340 if (h
->root
.type
== bfd_link_hash_new
)
342 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
346 /* OLDBFD is a BFD associated with the existing symbol. */
348 switch (h
->root
.type
)
354 case bfd_link_hash_undefined
:
355 case bfd_link_hash_undefweak
:
356 oldbfd
= h
->root
.u
.undef
.abfd
;
359 case bfd_link_hash_defined
:
360 case bfd_link_hash_defweak
:
361 oldbfd
= h
->root
.u
.def
.section
->owner
;
364 case bfd_link_hash_common
:
365 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
369 /* In cases involving weak versioned symbols, we may wind up trying
370 to merge a symbol with itself. Catch that here, to avoid the
371 confusion that results if we try to override a symbol with
376 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
377 respectively, is from a dynamic object. */
379 if ((abfd
->flags
& DYNAMIC
) != 0)
384 if (oldbfd
== NULL
|| (oldbfd
->flags
& DYNAMIC
) == 0)
389 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
390 respectively, appear to be a definition rather than reference. */
392 if (bfd_is_und_section (sec
) || bfd_is_com_section (sec
))
397 if (h
->root
.type
== bfd_link_hash_undefined
398 || h
->root
.type
== bfd_link_hash_undefweak
399 || h
->root
.type
== bfd_link_hash_common
)
404 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
405 symbol, respectively, appears to be a common symbol in a dynamic
406 object. If a symbol appears in an uninitialized section, and is
407 not weak, and is not a function, then it may be a common symbol
408 which was resolved when the dynamic object was created. We want
409 to treat such symbols specially, because they raise special
410 considerations when setting the symbol size: if the symbol
411 appears as a common symbol in a regular object, and the size in
412 the regular object is larger, we must make sure that we use the
413 larger size. This problematic case can always be avoided in C,
414 but it must be handled correctly when using Fortran shared
417 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
418 likewise for OLDDYNCOMMON and OLDDEF.
420 Note that this test is just a heuristic, and that it is quite
421 possible to have an uninitialized symbol in a shared object which
422 is really a definition, rather than a common symbol. This could
423 lead to some minor confusion when the symbol really is a common
424 symbol in some regular object. However, I think it will be
429 && (sec
->flags
& SEC_ALLOC
) != 0
430 && (sec
->flags
& SEC_LOAD
) == 0
433 && ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
436 newdyncommon
= false;
440 && h
->root
.type
== bfd_link_hash_defined
441 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
442 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
443 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
445 && h
->type
!= STT_FUNC
)
448 olddyncommon
= false;
450 /* It's OK to change the type if either the existing symbol or the
451 new symbol is weak. */
453 if (h
->root
.type
== bfd_link_hash_defweak
454 || h
->root
.type
== bfd_link_hash_undefweak
456 *type_change_ok
= true;
458 /* It's OK to change the size if either the existing symbol or the
459 new symbol is weak, or if the old symbol is undefined. */
462 || h
->root
.type
== bfd_link_hash_undefined
)
463 *size_change_ok
= true;
465 /* If both the old and the new symbols look like common symbols in a
466 dynamic object, set the size of the symbol to the larger of the
471 && sym
->st_size
!= h
->size
)
473 /* Since we think we have two common symbols, issue a multiple
474 common warning if desired. Note that we only warn if the
475 size is different. If the size is the same, we simply let
476 the old symbol override the new one as normally happens with
477 symbols defined in dynamic objects. */
479 if (! ((*info
->callbacks
->multiple_common
)
480 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
481 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
484 if (sym
->st_size
> h
->size
)
485 h
->size
= sym
->st_size
;
487 *size_change_ok
= true;
490 /* If we are looking at a dynamic object, and we have found a
491 definition, we need to see if the symbol was already defined by
492 some other object. If so, we want to use the existing
493 definition, and we do not want to report a multiple symbol
494 definition error; we do this by clobbering *PSEC to be
497 We treat a common symbol as a definition if the symbol in the
498 shared library is a function, since common symbols always
499 represent variables; this can cause confusion in principle, but
500 any such confusion would seem to indicate an erroneous program or
501 shared library. We also permit a common symbol in a regular
502 object to override a weak symbol in a shared object.
504 We prefer a non-weak definition in a shared library to a weak
505 definition in the executable. */
510 || (h
->root
.type
== bfd_link_hash_common
512 || ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
)))
513 && (h
->root
.type
!= bfd_link_hash_defweak
514 || bind
== STB_WEAK
))
518 newdyncommon
= false;
520 *psec
= sec
= bfd_und_section_ptr
;
521 *size_change_ok
= true;
523 /* If we get here when the old symbol is a common symbol, then
524 we are explicitly letting it override a weak symbol or
525 function in a dynamic object, and we don't want to warn about
526 a type change. If the old symbol is a defined symbol, a type
527 change warning may still be appropriate. */
529 if (h
->root
.type
== bfd_link_hash_common
)
530 *type_change_ok
= true;
533 /* Handle the special case of an old common symbol merging with a
534 new symbol which looks like a common symbol in a shared object.
535 We change *PSEC and *PVALUE to make the new symbol look like a
536 common symbol, and let _bfd_generic_link_add_one_symbol will do
540 && h
->root
.type
== bfd_link_hash_common
)
544 newdyncommon
= false;
545 *pvalue
= sym
->st_size
;
546 *psec
= sec
= bfd_com_section_ptr
;
547 *size_change_ok
= true;
550 /* If the old symbol is from a dynamic object, and the new symbol is
551 a definition which is not from a dynamic object, then the new
552 symbol overrides the old symbol. Symbols from regular files
553 always take precedence over symbols from dynamic objects, even if
554 they are defined after the dynamic object in the link.
556 As above, we again permit a common symbol in a regular object to
557 override a definition in a shared object if the shared object
558 symbol is a function or is weak.
560 As above, we permit a non-weak definition in a shared object to
561 override a weak definition in a regular object. */
565 || (bfd_is_com_section (sec
)
566 && (h
->root
.type
== bfd_link_hash_defweak
567 || h
->type
== STT_FUNC
)))
570 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
572 || h
->root
.type
== bfd_link_hash_defweak
))
574 /* Change the hash table entry to undefined, and let
575 _bfd_generic_link_add_one_symbol do the right thing with the
578 h
->root
.type
= bfd_link_hash_undefined
;
579 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
580 *size_change_ok
= true;
583 olddyncommon
= false;
585 /* We again permit a type change when a common symbol may be
586 overriding a function. */
588 if (bfd_is_com_section (sec
))
589 *type_change_ok
= true;
591 /* This union may have been set to be non-NULL when this symbol
592 was seen in a dynamic object. We must force the union to be
593 NULL, so that it is correct for a regular symbol. */
595 h
->verinfo
.vertree
= NULL
;
597 /* In this special case, if H is the target of an indirection,
598 we want the caller to frob with H rather than with the
599 indirect symbol. That will permit the caller to redefine the
600 target of the indirection, rather than the indirect symbol
601 itself. FIXME: This will break the -y option if we store a
602 symbol with a different name. */
606 /* Handle the special case of a new common symbol merging with an
607 old symbol that looks like it might be a common symbol defined in
608 a shared object. Note that we have already handled the case in
609 which a new common symbol should simply override the definition
610 in the shared library. */
613 && bfd_is_com_section (sec
)
616 /* It would be best if we could set the hash table entry to a
617 common symbol, but we don't know what to use for the section
619 if (! ((*info
->callbacks
->multiple_common
)
620 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
621 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
624 /* If the predumed common symbol in the dynamic object is
625 larger, pretend that the new symbol has its size. */
627 if (h
->size
> *pvalue
)
630 /* FIXME: We no longer know the alignment required by the symbol
631 in the dynamic object, so we just wind up using the one from
632 the regular object. */
635 olddyncommon
= false;
637 h
->root
.type
= bfd_link_hash_undefined
;
638 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
640 *size_change_ok
= true;
641 *type_change_ok
= true;
643 h
->verinfo
.vertree
= NULL
;
646 /* Handle the special case of a weak definition in a regular object
647 followed by a non-weak definition in a shared object. In this
648 case, we prefer the definition in the shared object. */
650 && h
->root
.type
== bfd_link_hash_defweak
655 /* To make this work we have to frob the flags so that the rest
656 of the code does not think we are using the regular
658 h
->elf_link_hash_flags
&= ~ ELF_LINK_HASH_DEF_REGULAR
;
659 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
661 /* If H is the target of an indirection, we want the caller to
662 use H rather than the indirect symbol. Otherwise if we are
663 defining a new indirect symbol we will wind up attaching it
664 to the entry we are overriding. */
668 /* Handle the special case of a non-weak definition in a shared
669 object followed by a weak definition in a regular object. In
670 this case we prefer to definition in the shared object. To make
671 this work we have to tell the caller to not treat the new symbol
675 && h
->root
.type
!= bfd_link_hash_defweak
684 /* Add symbols from an ELF object file to the linker hash table. */
687 elf_link_add_object_symbols (abfd
, info
)
689 struct bfd_link_info
*info
;
691 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
692 const Elf_Internal_Sym
*,
693 const char **, flagword
*,
694 asection
**, bfd_vma
*));
695 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
696 asection
*, const Elf_Internal_Rela
*));
698 Elf_Internal_Shdr
*hdr
;
702 Elf_External_Sym
*buf
= NULL
;
703 struct elf_link_hash_entry
**sym_hash
;
705 bfd_byte
*dynver
= NULL
;
706 Elf_External_Versym
*extversym
= NULL
;
707 Elf_External_Versym
*ever
;
708 Elf_External_Dyn
*dynbuf
= NULL
;
709 struct elf_link_hash_entry
*weaks
;
710 Elf_External_Sym
*esym
;
711 Elf_External_Sym
*esymend
;
713 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
714 collect
= get_elf_backend_data (abfd
)->collect
;
716 if ((abfd
->flags
& DYNAMIC
) == 0)
722 /* You can't use -r against a dynamic object. Also, there's no
723 hope of using a dynamic object which does not exactly match
724 the format of the output file. */
725 if (info
->relocateable
|| info
->hash
->creator
!= abfd
->xvec
)
727 bfd_set_error (bfd_error_invalid_operation
);
732 /* As a GNU extension, any input sections which are named
733 .gnu.warning.SYMBOL are treated as warning symbols for the given
734 symbol. This differs from .gnu.warning sections, which generate
735 warnings when they are included in an output file. */
740 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
744 name
= bfd_get_section_name (abfd
, s
);
745 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
750 name
+= sizeof ".gnu.warning." - 1;
752 /* If this is a shared object, then look up the symbol
753 in the hash table. If it is there, and it is already
754 been defined, then we will not be using the entry
755 from this shared object, so we don't need to warn.
756 FIXME: If we see the definition in a regular object
757 later on, we will warn, but we shouldn't. The only
758 fix is to keep track of what warnings we are supposed
759 to emit, and then handle them all at the end of the
761 if (dynamic
&& abfd
->xvec
== info
->hash
->creator
)
763 struct elf_link_hash_entry
*h
;
765 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
768 /* FIXME: What about bfd_link_hash_common? */
770 && (h
->root
.type
== bfd_link_hash_defined
771 || h
->root
.type
== bfd_link_hash_defweak
))
773 /* We don't want to issue this warning. Clobber
774 the section size so that the warning does not
775 get copied into the output file. */
781 sz
= bfd_section_size (abfd
, s
);
782 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
786 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
791 if (! (_bfd_generic_link_add_one_symbol
792 (info
, abfd
, name
, BSF_WARNING
, s
, (bfd_vma
) 0, msg
,
793 false, collect
, (struct bfd_link_hash_entry
**) NULL
)))
796 if (! info
->relocateable
)
798 /* Clobber the section size so that the warning does
799 not get copied into the output file. */
806 /* If this is a dynamic object, we always link against the .dynsym
807 symbol table, not the .symtab symbol table. The dynamic linker
808 will only see the .dynsym symbol table, so there is no reason to
809 look at .symtab for a dynamic object. */
811 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
812 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
814 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
818 /* Read in any version definitions. */
820 if (! _bfd_elf_slurp_version_tables (abfd
))
823 /* Read in the symbol versions, but don't bother to convert them
824 to internal format. */
825 if (elf_dynversym (abfd
) != 0)
827 Elf_Internal_Shdr
*versymhdr
;
829 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
830 extversym
= (Elf_External_Versym
*) bfd_malloc (hdr
->sh_size
);
831 if (extversym
== NULL
)
833 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
834 || (bfd_read ((PTR
) extversym
, 1, versymhdr
->sh_size
, abfd
)
835 != versymhdr
->sh_size
))
840 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
842 /* The sh_info field of the symtab header tells us where the
843 external symbols start. We don't care about the local symbols at
845 if (elf_bad_symtab (abfd
))
847 extsymcount
= symcount
;
852 extsymcount
= symcount
- hdr
->sh_info
;
853 extsymoff
= hdr
->sh_info
;
856 buf
= ((Elf_External_Sym
*)
857 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
858 if (buf
== NULL
&& extsymcount
!= 0)
861 /* We store a pointer to the hash table entry for each external
863 sym_hash
= ((struct elf_link_hash_entry
**)
865 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
866 if (sym_hash
== NULL
)
868 elf_sym_hashes (abfd
) = sym_hash
;
872 /* If we are creating a shared library, create all the dynamic
873 sections immediately. We need to attach them to something,
874 so we attach them to this BFD, provided it is the right
875 format. FIXME: If there are no input BFD's of the same
876 format as the output, we can't make a shared library. */
878 && ! elf_hash_table (info
)->dynamic_sections_created
879 && abfd
->xvec
== info
->hash
->creator
)
881 if (! elf_link_create_dynamic_sections (abfd
, info
))
890 bfd_size_type oldsize
;
891 bfd_size_type strindex
;
893 /* Find the name to use in a DT_NEEDED entry that refers to this
894 object. If the object has a DT_SONAME entry, we use it.
895 Otherwise, if the generic linker stuck something in
896 elf_dt_name, we use that. Otherwise, we just use the file
897 name. If the generic linker put a null string into
898 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
899 there is a DT_SONAME entry. */
901 name
= bfd_get_filename (abfd
);
902 if (elf_dt_name (abfd
) != NULL
)
904 name
= elf_dt_name (abfd
);
908 s
= bfd_get_section_by_name (abfd
, ".dynamic");
911 Elf_External_Dyn
*extdyn
;
912 Elf_External_Dyn
*extdynend
;
916 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
920 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
921 (file_ptr
) 0, s
->_raw_size
))
924 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
927 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
930 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
931 for (; extdyn
< extdynend
; extdyn
++)
933 Elf_Internal_Dyn dyn
;
935 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
936 if (dyn
.d_tag
== DT_SONAME
)
938 name
= bfd_elf_string_from_elf_section (abfd
, link
,
943 if (dyn
.d_tag
== DT_NEEDED
)
945 struct bfd_link_needed_list
*n
, **pn
;
948 n
= ((struct bfd_link_needed_list
*)
949 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
950 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
952 if (n
== NULL
|| fnm
== NULL
)
954 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
961 for (pn
= &elf_hash_table (info
)->needed
;
973 /* We do not want to include any of the sections in a dynamic
974 object in the output file. We hack by simply clobbering the
975 list of sections in the BFD. This could be handled more
976 cleanly by, say, a new section flag; the existing
977 SEC_NEVER_LOAD flag is not the one we want, because that one
978 still implies that the section takes up space in the output
980 abfd
->sections
= NULL
;
981 abfd
->section_count
= 0;
983 /* If this is the first dynamic object found in the link, create
984 the special sections required for dynamic linking. */
985 if (! elf_hash_table (info
)->dynamic_sections_created
)
987 if (! elf_link_create_dynamic_sections (abfd
, info
))
993 /* Add a DT_NEEDED entry for this dynamic object. */
994 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
995 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
997 if (strindex
== (bfd_size_type
) -1)
1000 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
1003 Elf_External_Dyn
*dyncon
, *dynconend
;
1005 /* The hash table size did not change, which means that
1006 the dynamic object name was already entered. If we
1007 have already included this dynamic object in the
1008 link, just ignore it. There is no reason to include
1009 a particular dynamic object more than once. */
1010 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
1012 BFD_ASSERT (sdyn
!= NULL
);
1014 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
1015 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
1017 for (; dyncon
< dynconend
; dyncon
++)
1019 Elf_Internal_Dyn dyn
;
1021 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
1023 if (dyn
.d_tag
== DT_NEEDED
1024 && dyn
.d_un
.d_val
== strindex
)
1028 if (extversym
!= NULL
)
1035 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
1039 /* Save the SONAME, if there is one, because sometimes the
1040 linker emulation code will need to know it. */
1042 name
= bfd_get_filename (abfd
);
1043 elf_dt_name (abfd
) = name
;
1047 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
1049 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
1050 != extsymcount
* sizeof (Elf_External_Sym
)))
1055 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
1056 esymend
= buf
+ extsymcount
;
1059 esym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
1061 Elf_Internal_Sym sym
;
1067 struct elf_link_hash_entry
*h
;
1069 boolean size_change_ok
, type_change_ok
;
1070 boolean new_weakdef
;
1071 unsigned int old_alignment
;
1073 elf_swap_symbol_in (abfd
, esym
, &sym
);
1075 flags
= BSF_NO_FLAGS
;
1077 value
= sym
.st_value
;
1080 bind
= ELF_ST_BIND (sym
.st_info
);
1081 if (bind
== STB_LOCAL
)
1083 /* This should be impossible, since ELF requires that all
1084 global symbols follow all local symbols, and that sh_info
1085 point to the first global symbol. Unfortunatealy, Irix 5
1089 else if (bind
== STB_GLOBAL
)
1091 if (sym
.st_shndx
!= SHN_UNDEF
1092 && sym
.st_shndx
!= SHN_COMMON
)
1097 else if (bind
== STB_WEAK
)
1101 /* Leave it up to the processor backend. */
1104 if (sym
.st_shndx
== SHN_UNDEF
)
1105 sec
= bfd_und_section_ptr
;
1106 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
1108 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
1110 sec
= bfd_abs_section_ptr
;
1111 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1114 else if (sym
.st_shndx
== SHN_ABS
)
1115 sec
= bfd_abs_section_ptr
;
1116 else if (sym
.st_shndx
== SHN_COMMON
)
1118 sec
= bfd_com_section_ptr
;
1119 /* What ELF calls the size we call the value. What ELF
1120 calls the value we call the alignment. */
1121 value
= sym
.st_size
;
1125 /* Leave it up to the processor backend. */
1128 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
1129 if (name
== (const char *) NULL
)
1132 if (add_symbol_hook
)
1134 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
1138 /* The hook function sets the name to NULL if this symbol
1139 should be skipped for some reason. */
1140 if (name
== (const char *) NULL
)
1144 /* Sanity check that all possibilities were handled. */
1145 if (sec
== (asection
*) NULL
)
1147 bfd_set_error (bfd_error_bad_value
);
1151 if (bfd_is_und_section (sec
)
1152 || bfd_is_com_section (sec
))
1157 size_change_ok
= false;
1158 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
1160 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1162 Elf_Internal_Versym iver
;
1163 unsigned int vernum
= 0;
1168 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
1169 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
1171 /* If this is a hidden symbol, or if it is not version
1172 1, we append the version name to the symbol name.
1173 However, we do not modify a non-hidden absolute
1174 symbol, because it might be the version symbol
1175 itself. FIXME: What if it isn't? */
1176 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
1177 || (vernum
> 1 && ! bfd_is_abs_section (sec
)))
1180 int namelen
, newlen
;
1183 if (sym
.st_shndx
!= SHN_UNDEF
)
1185 if (vernum
> elf_tdata (abfd
)->dynverdef_hdr
.sh_info
)
1187 (*_bfd_error_handler
)
1188 (_("%s: %s: invalid version %u (max %d)"),
1189 bfd_get_filename (abfd
), name
, vernum
,
1190 elf_tdata (abfd
)->dynverdef_hdr
.sh_info
);
1191 bfd_set_error (bfd_error_bad_value
);
1194 else if (vernum
> 1)
1196 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1202 /* We cannot simply test for the number of
1203 entries in the VERNEED section since the
1204 numbers for the needed versions do not start
1206 Elf_Internal_Verneed
*t
;
1209 for (t
= elf_tdata (abfd
)->verref
;
1213 Elf_Internal_Vernaux
*a
;
1215 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1217 if (a
->vna_other
== vernum
)
1219 verstr
= a
->vna_nodename
;
1228 (*_bfd_error_handler
)
1229 (_("%s: %s: invalid needed version %d"),
1230 bfd_get_filename (abfd
), name
, vernum
);
1231 bfd_set_error (bfd_error_bad_value
);
1236 namelen
= strlen (name
);
1237 newlen
= namelen
+ strlen (verstr
) + 2;
1238 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
1241 newname
= (char *) bfd_alloc (abfd
, newlen
);
1242 if (newname
== NULL
)
1244 strcpy (newname
, name
);
1245 p
= newname
+ namelen
;
1247 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
1255 if (! elf_merge_symbol (abfd
, info
, name
, &sym
, &sec
, &value
,
1256 sym_hash
, &override
, &type_change_ok
,
1264 while (h
->root
.type
== bfd_link_hash_indirect
1265 || h
->root
.type
== bfd_link_hash_warning
)
1266 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1268 /* Remember the old alignment if this is a common symbol, so
1269 that we don't reduce the alignment later on. We can't
1270 check later, because _bfd_generic_link_add_one_symbol
1271 will set a default for the alignment which we want to
1273 if (h
->root
.type
== bfd_link_hash_common
)
1274 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
1276 if (elf_tdata (abfd
)->verdef
!= NULL
1280 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
1283 if (! (_bfd_generic_link_add_one_symbol
1284 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
1285 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
1289 while (h
->root
.type
== bfd_link_hash_indirect
1290 || h
->root
.type
== bfd_link_hash_warning
)
1291 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1294 new_weakdef
= false;
1297 && (flags
& BSF_WEAK
) != 0
1298 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
1299 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1300 && h
->weakdef
== NULL
)
1302 /* Keep a list of all weak defined non function symbols from
1303 a dynamic object, using the weakdef field. Later in this
1304 function we will set the weakdef field to the correct
1305 value. We only put non-function symbols from dynamic
1306 objects on this list, because that happens to be the only
1307 time we need to know the normal symbol corresponding to a
1308 weak symbol, and the information is time consuming to
1309 figure out. If the weakdef field is not already NULL,
1310 then this symbol was already defined by some previous
1311 dynamic object, and we will be using that previous
1312 definition anyhow. */
1319 /* Set the alignment of a common symbol. */
1320 if (sym
.st_shndx
== SHN_COMMON
1321 && h
->root
.type
== bfd_link_hash_common
)
1325 align
= bfd_log2 (sym
.st_value
);
1326 if (align
> old_alignment
)
1327 h
->root
.u
.c
.p
->alignment_power
= align
;
1330 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1336 /* Remember the symbol size and type. */
1337 if (sym
.st_size
!= 0
1338 && (definition
|| h
->size
== 0))
1340 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
1341 (*_bfd_error_handler
)
1342 (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
1343 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
1344 bfd_get_filename (abfd
));
1346 h
->size
= sym
.st_size
;
1349 /* If this is a common symbol, then we always want H->SIZE
1350 to be the size of the common symbol. The code just above
1351 won't fix the size if a common symbol becomes larger. We
1352 don't warn about a size change here, because that is
1353 covered by --warn-common. */
1354 if (h
->root
.type
== bfd_link_hash_common
)
1355 h
->size
= h
->root
.u
.c
.size
;
1357 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
1358 && (definition
|| h
->type
== STT_NOTYPE
))
1360 if (h
->type
!= STT_NOTYPE
1361 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
1362 && ! type_change_ok
)
1363 (*_bfd_error_handler
)
1364 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
1365 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
1366 bfd_get_filename (abfd
));
1368 h
->type
= ELF_ST_TYPE (sym
.st_info
);
1371 if (sym
.st_other
!= 0
1372 && (definition
|| h
->other
== 0))
1373 h
->other
= sym
.st_other
;
1375 /* Set a flag in the hash table entry indicating the type of
1376 reference or definition we just found. Keep a count of
1377 the number of dynamic symbols we find. A dynamic symbol
1378 is one which is referenced or defined by both a regular
1379 object and a shared object. */
1380 old_flags
= h
->elf_link_hash_flags
;
1386 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
1387 if (bind
!= STB_WEAK
)
1388 new_flag
|= ELF_LINK_HASH_REF_REGULAR_NONWEAK
;
1391 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
1393 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1394 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
1400 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
1402 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
1403 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
1404 | ELF_LINK_HASH_REF_REGULAR
)) != 0
1405 || (h
->weakdef
!= NULL
1407 && h
->weakdef
->dynindx
!= -1))
1411 h
->elf_link_hash_flags
|= new_flag
;
1413 /* If this symbol has a version, and it is the default
1414 version, we create an indirect symbol from the default
1415 name to the fully decorated name. This will cause
1416 external references which do not specify a version to be
1417 bound to this version of the symbol. */
1422 p
= strchr (name
, ELF_VER_CHR
);
1423 if (p
!= NULL
&& p
[1] == ELF_VER_CHR
)
1426 struct elf_link_hash_entry
*hi
;
1429 shortname
= bfd_hash_allocate (&info
->hash
->table
,
1431 if (shortname
== NULL
)
1433 strncpy (shortname
, name
, p
- name
);
1434 shortname
[p
- name
] = '\0';
1436 /* We are going to create a new symbol. Merge it
1437 with any existing symbol with this name. For the
1438 purposes of the merge, act as though we were
1439 defining the symbol we just defined, although we
1440 actually going to define an indirect symbol. */
1441 type_change_ok
= false;
1442 size_change_ok
= false;
1443 if (! elf_merge_symbol (abfd
, info
, shortname
, &sym
, &sec
,
1444 &value
, &hi
, &override
,
1445 &type_change_ok
, &size_change_ok
))
1450 if (! (_bfd_generic_link_add_one_symbol
1451 (info
, abfd
, shortname
, BSF_INDIRECT
,
1452 bfd_ind_section_ptr
, (bfd_vma
) 0, name
, false,
1453 collect
, (struct bfd_link_hash_entry
**) &hi
)))
1458 /* In this case the symbol named SHORTNAME is
1459 overriding the indirect symbol we want to
1460 add. We were planning on making SHORTNAME an
1461 indirect symbol referring to NAME. SHORTNAME
1462 is the name without a version. NAME is the
1463 fully versioned name, and it is the default
1466 Overriding means that we already saw a
1467 definition for the symbol SHORTNAME in a
1468 regular object, and it is overriding the
1469 symbol defined in the dynamic object.
1471 When this happens, we actually want to change
1472 NAME, the symbol we just added, to refer to
1473 SHORTNAME. This will cause references to
1474 NAME in the shared object to become
1475 references to SHORTNAME in the regular
1476 object. This is what we expect when we
1477 override a function in a shared object: that
1478 the references in the shared object will be
1479 mapped to the definition in the regular
1482 while (hi
->root
.type
== bfd_link_hash_indirect
1483 || hi
->root
.type
== bfd_link_hash_warning
)
1484 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1486 h
->root
.type
= bfd_link_hash_indirect
;
1487 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1488 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
1490 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEF_DYNAMIC
;
1491 hi
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1492 if (hi
->elf_link_hash_flags
1493 & (ELF_LINK_HASH_REF_REGULAR
1494 | ELF_LINK_HASH_DEF_REGULAR
))
1496 if (! _bfd_elf_link_record_dynamic_symbol (info
,
1502 /* Now set HI to H, so that the following code
1503 will set the other fields correctly. */
1507 /* If there is a duplicate definition somewhere,
1508 then HI may not point to an indirect symbol. We
1509 will have reported an error to the user in that
1512 if (hi
->root
.type
== bfd_link_hash_indirect
)
1514 struct elf_link_hash_entry
*ht
;
1516 /* If the symbol became indirect, then we assume
1517 that we have not seen a definition before. */
1518 BFD_ASSERT ((hi
->elf_link_hash_flags
1519 & (ELF_LINK_HASH_DEF_DYNAMIC
1520 | ELF_LINK_HASH_DEF_REGULAR
))
1523 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1525 /* Copy down any references that we may have
1526 already seen to the symbol which just became
1528 ht
->elf_link_hash_flags
|=
1529 (hi
->elf_link_hash_flags
1530 & (ELF_LINK_HASH_REF_DYNAMIC
1531 | ELF_LINK_HASH_REF_REGULAR
1532 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1534 /* Copy over the global and procedure linkage table
1535 offset entries. These may have been already set
1536 up by a check_relocs routine. */
1537 if (ht
->got
.offset
== (bfd_vma
) -1)
1539 ht
->got
.offset
= hi
->got
.offset
;
1540 hi
->got
.offset
= (bfd_vma
) -1;
1542 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1544 if (ht
->plt
.offset
== (bfd_vma
) -1)
1546 ht
->plt
.offset
= hi
->plt
.offset
;
1547 hi
->plt
.offset
= (bfd_vma
) -1;
1549 BFD_ASSERT (hi
->plt
.offset
== (bfd_vma
) -1);
1551 if (ht
->dynindx
== -1)
1553 ht
->dynindx
= hi
->dynindx
;
1554 ht
->dynstr_index
= hi
->dynstr_index
;
1556 hi
->dynstr_index
= 0;
1558 BFD_ASSERT (hi
->dynindx
== -1);
1560 /* FIXME: There may be other information to copy
1561 over for particular targets. */
1563 /* See if the new flags lead us to realize that
1564 the symbol must be dynamic. */
1570 || ((hi
->elf_link_hash_flags
1571 & ELF_LINK_HASH_REF_DYNAMIC
)
1577 if ((hi
->elf_link_hash_flags
1578 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1584 /* We also need to define an indirection from the
1585 nondefault version of the symbol. */
1587 shortname
= bfd_hash_allocate (&info
->hash
->table
,
1589 if (shortname
== NULL
)
1591 strncpy (shortname
, name
, p
- name
);
1592 strcpy (shortname
+ (p
- name
), p
+ 1);
1594 /* Once again, merge with any existing symbol. */
1595 type_change_ok
= false;
1596 size_change_ok
= false;
1597 if (! elf_merge_symbol (abfd
, info
, shortname
, &sym
, &sec
,
1598 &value
, &hi
, &override
,
1599 &type_change_ok
, &size_change_ok
))
1604 /* Here SHORTNAME is a versioned name, so we
1605 don't expect to see the type of override we
1606 do in the case above. */
1607 (*_bfd_error_handler
)
1608 (_("%s: warning: unexpected redefinition of `%s'"),
1609 bfd_get_filename (abfd
), shortname
);
1613 if (! (_bfd_generic_link_add_one_symbol
1614 (info
, abfd
, shortname
, BSF_INDIRECT
,
1615 bfd_ind_section_ptr
, (bfd_vma
) 0, name
, false,
1616 collect
, (struct bfd_link_hash_entry
**) &hi
)))
1619 /* If there is a duplicate definition somewhere,
1620 then HI may not point to an indirect symbol.
1621 We will have reported an error to the user in
1624 if (hi
->root
.type
== bfd_link_hash_indirect
)
1626 /* If the symbol became indirect, then we
1627 assume that we have not seen a definition
1629 BFD_ASSERT ((hi
->elf_link_hash_flags
1630 & (ELF_LINK_HASH_DEF_DYNAMIC
1631 | ELF_LINK_HASH_DEF_REGULAR
))
1634 /* Copy down any references that we may have
1635 already seen to the symbol which just
1637 h
->elf_link_hash_flags
|=
1638 (hi
->elf_link_hash_flags
1639 & (ELF_LINK_HASH_REF_DYNAMIC
1640 | ELF_LINK_HASH_REF_REGULAR
1641 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1643 /* Copy over the global and procedure linkage
1644 table offset entries. These may have been
1645 already set up by a check_relocs routine. */
1646 if (h
->got
.offset
== (bfd_vma
) -1)
1648 h
->got
.offset
= hi
->got
.offset
;
1649 hi
->got
.offset
= (bfd_vma
) -1;
1651 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1653 if (h
->plt
.offset
== (bfd_vma
) -1)
1655 h
->plt
.offset
= hi
->plt
.offset
;
1656 hi
->plt
.offset
= (bfd_vma
) -1;
1658 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1660 if (h
->dynindx
== -1)
1662 h
->dynindx
= hi
->dynindx
;
1663 h
->dynstr_index
= hi
->dynstr_index
;
1665 hi
->dynstr_index
= 0;
1667 BFD_ASSERT (hi
->dynindx
== -1);
1669 /* FIXME: There may be other information to
1670 copy over for particular targets. */
1672 /* See if the new flags lead us to realize
1673 that the symbol must be dynamic. */
1679 || ((hi
->elf_link_hash_flags
1680 & ELF_LINK_HASH_REF_DYNAMIC
)
1686 if ((hi
->elf_link_hash_flags
1687 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1696 if (dynsym
&& h
->dynindx
== -1)
1698 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1700 if (h
->weakdef
!= NULL
1702 && h
->weakdef
->dynindx
== -1)
1704 if (! _bfd_elf_link_record_dynamic_symbol (info
,
1712 /* Now set the weakdefs field correctly for all the weak defined
1713 symbols we found. The only way to do this is to search all the
1714 symbols. Since we only need the information for non functions in
1715 dynamic objects, that's the only time we actually put anything on
1716 the list WEAKS. We need this information so that if a regular
1717 object refers to a symbol defined weakly in a dynamic object, the
1718 real symbol in the dynamic object is also put in the dynamic
1719 symbols; we also must arrange for both symbols to point to the
1720 same memory location. We could handle the general case of symbol
1721 aliasing, but a general symbol alias can only be generated in
1722 assembler code, handling it correctly would be very time
1723 consuming, and other ELF linkers don't handle general aliasing
1725 while (weaks
!= NULL
)
1727 struct elf_link_hash_entry
*hlook
;
1730 struct elf_link_hash_entry
**hpp
;
1731 struct elf_link_hash_entry
**hppend
;
1734 weaks
= hlook
->weakdef
;
1735 hlook
->weakdef
= NULL
;
1737 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
1738 || hlook
->root
.type
== bfd_link_hash_defweak
1739 || hlook
->root
.type
== bfd_link_hash_common
1740 || hlook
->root
.type
== bfd_link_hash_indirect
);
1741 slook
= hlook
->root
.u
.def
.section
;
1742 vlook
= hlook
->root
.u
.def
.value
;
1744 hpp
= elf_sym_hashes (abfd
);
1745 hppend
= hpp
+ extsymcount
;
1746 for (; hpp
< hppend
; hpp
++)
1748 struct elf_link_hash_entry
*h
;
1751 if (h
!= NULL
&& h
!= hlook
1752 && h
->root
.type
== bfd_link_hash_defined
1753 && h
->root
.u
.def
.section
== slook
1754 && h
->root
.u
.def
.value
== vlook
)
1758 /* If the weak definition is in the list of dynamic
1759 symbols, make sure the real definition is put there
1761 if (hlook
->dynindx
!= -1
1762 && h
->dynindx
== -1)
1764 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1768 /* If the real definition is in the list of dynamic
1769 symbols, make sure the weak definition is put there
1770 as well. If we don't do this, then the dynamic
1771 loader might not merge the entries for the real
1772 definition and the weak definition. */
1773 if (h
->dynindx
!= -1
1774 && hlook
->dynindx
== -1)
1776 if (! _bfd_elf_link_record_dynamic_symbol (info
, hlook
))
1791 if (extversym
!= NULL
)
1797 /* If this object is the same format as the output object, and it is
1798 not a shared library, then let the backend look through the
1801 This is required to build global offset table entries and to
1802 arrange for dynamic relocs. It is not required for the
1803 particular common case of linking non PIC code, even when linking
1804 against shared libraries, but unfortunately there is no way of
1805 knowing whether an object file has been compiled PIC or not.
1806 Looking through the relocs is not particularly time consuming.
1807 The problem is that we must either (1) keep the relocs in memory,
1808 which causes the linker to require additional runtime memory or
1809 (2) read the relocs twice from the input file, which wastes time.
1810 This would be a good case for using mmap.
1812 I have no idea how to handle linking PIC code into a file of a
1813 different format. It probably can't be done. */
1814 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
1816 && abfd
->xvec
== info
->hash
->creator
1817 && check_relocs
!= NULL
)
1821 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1823 Elf_Internal_Rela
*internal_relocs
;
1826 if ((o
->flags
& SEC_RELOC
) == 0
1827 || o
->reloc_count
== 0
1828 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
1829 && (o
->flags
& SEC_DEBUGGING
) != 0)
1830 || bfd_is_abs_section (o
->output_section
))
1833 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
1834 (abfd
, o
, (PTR
) NULL
,
1835 (Elf_Internal_Rela
*) NULL
,
1836 info
->keep_memory
));
1837 if (internal_relocs
== NULL
)
1840 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
1842 if (! info
->keep_memory
)
1843 free (internal_relocs
);
1850 /* If this is a non-traditional, non-relocateable link, try to
1851 optimize the handling of the .stab/.stabstr sections. */
1853 && ! info
->relocateable
1854 && ! info
->traditional_format
1855 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1856 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
1858 asection
*stab
, *stabstr
;
1860 stab
= bfd_get_section_by_name (abfd
, ".stab");
1863 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
1865 if (stabstr
!= NULL
)
1867 struct bfd_elf_section_data
*secdata
;
1869 secdata
= elf_section_data (stab
);
1870 if (! _bfd_link_section_stabs (abfd
,
1871 &elf_hash_table (info
)->stab_info
,
1873 &secdata
->stab_info
))
1888 if (extversym
!= NULL
)
1893 /* Create some sections which will be filled in with dynamic linking
1894 information. ABFD is an input file which requires dynamic sections
1895 to be created. The dynamic sections take up virtual memory space
1896 when the final executable is run, so we need to create them before
1897 addresses are assigned to the output sections. We work out the
1898 actual contents and size of these sections later. */
1901 elf_link_create_dynamic_sections (abfd
, info
)
1903 struct bfd_link_info
*info
;
1906 register asection
*s
;
1907 struct elf_link_hash_entry
*h
;
1908 struct elf_backend_data
*bed
;
1910 if (elf_hash_table (info
)->dynamic_sections_created
)
1913 /* Make sure that all dynamic sections use the same input BFD. */
1914 if (elf_hash_table (info
)->dynobj
== NULL
)
1915 elf_hash_table (info
)->dynobj
= abfd
;
1917 abfd
= elf_hash_table (info
)->dynobj
;
1919 /* Note that we set the SEC_IN_MEMORY flag for all of these
1921 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1922 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1924 /* A dynamically linked executable has a .interp section, but a
1925 shared library does not. */
1928 s
= bfd_make_section (abfd
, ".interp");
1930 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1934 /* Create sections to hold version informations. These are removed
1935 if they are not needed. */
1936 s
= bfd_make_section (abfd
, ".gnu.version_d");
1938 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1939 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1942 s
= bfd_make_section (abfd
, ".gnu.version");
1944 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1945 || ! bfd_set_section_alignment (abfd
, s
, 1))
1948 s
= bfd_make_section (abfd
, ".gnu.version_r");
1950 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1951 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1954 s
= bfd_make_section (abfd
, ".dynsym");
1956 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1957 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1960 s
= bfd_make_section (abfd
, ".dynstr");
1962 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1965 /* Create a strtab to hold the dynamic symbol names. */
1966 if (elf_hash_table (info
)->dynstr
== NULL
)
1968 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1969 if (elf_hash_table (info
)->dynstr
== NULL
)
1973 s
= bfd_make_section (abfd
, ".dynamic");
1975 || ! bfd_set_section_flags (abfd
, s
, flags
)
1976 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1979 /* The special symbol _DYNAMIC is always set to the start of the
1980 .dynamic section. This call occurs before we have processed the
1981 symbols for any dynamic object, so we don't have to worry about
1982 overriding a dynamic definition. We could set _DYNAMIC in a
1983 linker script, but we only want to define it if we are, in fact,
1984 creating a .dynamic section. We don't want to define it if there
1985 is no .dynamic section, since on some ELF platforms the start up
1986 code examines it to decide how to initialize the process. */
1988 if (! (_bfd_generic_link_add_one_symbol
1989 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1990 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1991 (struct bfd_link_hash_entry
**) &h
)))
1993 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1994 h
->type
= STT_OBJECT
;
1997 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2000 bed
= get_elf_backend_data (abfd
);
2002 s
= bfd_make_section (abfd
, ".hash");
2004 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
2005 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
2007 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
2009 /* Let the backend create the rest of the sections. This lets the
2010 backend set the right flags. The backend will normally create
2011 the .got and .plt sections. */
2012 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
2015 elf_hash_table (info
)->dynamic_sections_created
= true;
2020 /* Add an entry to the .dynamic table. */
2023 elf_add_dynamic_entry (info
, tag
, val
)
2024 struct bfd_link_info
*info
;
2028 Elf_Internal_Dyn dyn
;
2032 bfd_byte
*newcontents
;
2034 dynobj
= elf_hash_table (info
)->dynobj
;
2036 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
2037 BFD_ASSERT (s
!= NULL
);
2039 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
2040 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
2041 if (newcontents
== NULL
)
2045 dyn
.d_un
.d_val
= val
;
2046 elf_swap_dyn_out (dynobj
, &dyn
,
2047 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
2049 s
->_raw_size
= newsize
;
2050 s
->contents
= newcontents
;
2056 /* Read and swap the relocs from the section indicated by SHDR. This
2057 may be either a REL or a RELA section. The relocations are
2058 translated into RELA relocations and stored in INTERNAL_RELOCS,
2059 which should have already been allocated to contain enough space.
2060 The EXTERNAL_RELOCS are a buffer where the external form of the
2061 relocations should be stored.
2063 Returns false if something goes wrong. */
2066 elf_link_read_relocs_from_section (abfd
, shdr
, external_relocs
,
2069 Elf_Internal_Shdr
*shdr
;
2070 PTR external_relocs
;
2071 Elf_Internal_Rela
*internal_relocs
;
2073 struct elf_backend_data
*bed
;
2075 /* If there aren't any relocations, that's OK. */
2079 /* Position ourselves at the start of the section. */
2080 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2083 /* Read the relocations. */
2084 if (bfd_read (external_relocs
, 1, shdr
->sh_size
, abfd
)
2088 bed
= get_elf_backend_data (abfd
);
2090 /* Convert the external relocations to the internal format. */
2091 if (shdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2093 Elf_External_Rel
*erel
;
2094 Elf_External_Rel
*erelend
;
2095 Elf_Internal_Rela
*irela
;
2096 Elf_Internal_Rel
*irel
;
2098 erel
= (Elf_External_Rel
*) external_relocs
;
2099 erelend
= erel
+ shdr
->sh_size
/ shdr
->sh_entsize
;
2100 irela
= internal_relocs
;
2101 irel
= bfd_alloc (abfd
, (bed
->s
->int_rels_per_ext_rel
2102 * sizeof (Elf_Internal_Rel
)));
2103 for (; erel
< erelend
; erel
++, irela
+= bed
->s
->int_rels_per_ext_rel
)
2107 if (bed
->s
->swap_reloc_in
)
2108 (*bed
->s
->swap_reloc_in
) (abfd
, (bfd_byte
*) erel
, irel
);
2110 elf_swap_reloc_in (abfd
, erel
, irel
);
2112 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; ++i
)
2114 irela
[i
].r_offset
= irel
[i
].r_offset
;
2115 irela
[i
].r_info
= irel
[i
].r_info
;
2116 irela
[i
].r_addend
= 0;
2122 Elf_External_Rela
*erela
;
2123 Elf_External_Rela
*erelaend
;
2124 Elf_Internal_Rela
*irela
;
2126 BFD_ASSERT (shdr
->sh_entsize
== sizeof (Elf_External_Rela
));
2128 erela
= (Elf_External_Rela
*) external_relocs
;
2129 erelaend
= erela
+ shdr
->sh_size
/ shdr
->sh_entsize
;
2130 irela
= internal_relocs
;
2131 for (; erela
< erelaend
; erela
++, irela
+= bed
->s
->int_rels_per_ext_rel
)
2133 if (bed
->s
->swap_reloca_in
)
2134 (*bed
->s
->swap_reloca_in
) (abfd
, (bfd_byte
*) erela
, irela
);
2136 elf_swap_reloca_in (abfd
, erela
, irela
);
2143 /* Read and swap the relocs for a section O. They may have been
2144 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2145 not NULL, they are used as buffers to read into. They are known to
2146 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2147 the return value is allocated using either malloc or bfd_alloc,
2148 according to the KEEP_MEMORY argument. If O has two relocation
2149 sections (both REL and RELA relocations), then the REL_HDR
2150 relocations will appear first in INTERNAL_RELOCS, followed by the
2151 REL_HDR2 relocations. */
2154 NAME(_bfd_elf
,link_read_relocs
) (abfd
, o
, external_relocs
, internal_relocs
,
2158 PTR external_relocs
;
2159 Elf_Internal_Rela
*internal_relocs
;
2160 boolean keep_memory
;
2162 Elf_Internal_Shdr
*rel_hdr
;
2164 Elf_Internal_Rela
*alloc2
= NULL
;
2165 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2167 if (elf_section_data (o
)->relocs
!= NULL
)
2168 return elf_section_data (o
)->relocs
;
2170 if (o
->reloc_count
== 0)
2173 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2175 if (internal_relocs
== NULL
)
2179 size
= (o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
2180 * sizeof (Elf_Internal_Rela
));
2182 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2184 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2185 if (internal_relocs
== NULL
)
2189 if (external_relocs
== NULL
)
2191 size_t size
= (size_t) rel_hdr
->sh_size
;
2193 if (elf_section_data (o
)->rel_hdr2
)
2194 size
+= (size_t) elf_section_data (o
)->rel_hdr2
->sh_size
;
2195 alloc1
= (PTR
) bfd_malloc (size
);
2198 external_relocs
= alloc1
;
2201 if (!elf_link_read_relocs_from_section (abfd
, rel_hdr
,
2205 if (!elf_link_read_relocs_from_section
2207 elf_section_data (o
)->rel_hdr2
,
2208 ((bfd_byte
*) external_relocs
) + rel_hdr
->sh_size
,
2209 internal_relocs
+ (rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
2210 * bed
->s
->int_rels_per_ext_rel
)))
2213 /* Cache the results for next time, if we can. */
2215 elf_section_data (o
)->relocs
= internal_relocs
;
2220 /* Don't free alloc2, since if it was allocated we are passing it
2221 back (under the name of internal_relocs). */
2223 return internal_relocs
;
2234 /* Record an assignment to a symbol made by a linker script. We need
2235 this in case some dynamic object refers to this symbol. */
2239 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
2241 struct bfd_link_info
*info
;
2245 struct elf_link_hash_entry
*h
;
2247 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
2250 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
2254 if (h
->root
.type
== bfd_link_hash_new
)
2255 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
2257 /* If this symbol is being provided by the linker script, and it is
2258 currently defined by a dynamic object, but not by a regular
2259 object, then mark it as undefined so that the generic linker will
2260 force the correct value. */
2262 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2263 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2264 h
->root
.type
= bfd_link_hash_undefined
;
2266 /* If this symbol is not being provided by the linker script, and it is
2267 currently defined by a dynamic object, but not by a regular object,
2268 then clear out any version information because the symbol will not be
2269 associated with the dynamic object any more. */
2271 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2272 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2273 h
->verinfo
.verdef
= NULL
;
2275 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2276 h
->type
= STT_OBJECT
;
2278 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
2279 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
2281 && h
->dynindx
== -1)
2283 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2286 /* If this is a weak defined symbol, and we know a corresponding
2287 real symbol from the same dynamic object, make sure the real
2288 symbol is also made into a dynamic symbol. */
2289 if (h
->weakdef
!= NULL
2290 && h
->weakdef
->dynindx
== -1)
2292 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
2300 /* This structure is used to pass information to
2301 elf_link_assign_sym_version. */
2303 struct elf_assign_sym_version_info
2307 /* General link information. */
2308 struct bfd_link_info
*info
;
2310 struct bfd_elf_version_tree
*verdefs
;
2311 /* Whether we are exporting all dynamic symbols. */
2312 boolean export_dynamic
;
2313 /* Whether we removed any symbols from the dynamic symbol table. */
2314 boolean removed_dynamic
;
2315 /* Whether we had a failure. */
2319 /* This structure is used to pass information to
2320 elf_link_find_version_dependencies. */
2322 struct elf_find_verdep_info
2326 /* General link information. */
2327 struct bfd_link_info
*info
;
2328 /* The number of dependencies. */
2330 /* Whether we had a failure. */
2334 /* Array used to determine the number of hash table buckets to use
2335 based on the number of symbols there are. If there are fewer than
2336 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
2337 fewer than 37 we use 17 buckets, and so forth. We never use more
2338 than 32771 buckets. */
2340 static const size_t elf_buckets
[] =
2342 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
2346 /* Compute bucket count for hashing table. We do not use a static set
2347 of possible tables sizes anymore. Instead we determine for all
2348 possible reasonable sizes of the table the outcome (i.e., the
2349 number of collisions etc) and choose the best solution. The
2350 weighting functions are not too simple to allow the table to grow
2351 without bounds. Instead one of the weighting factors is the size.
2352 Therefore the result is always a good payoff between few collisions
2353 (= short chain lengths) and table size. */
2355 compute_bucket_count (info
)
2356 struct bfd_link_info
*info
;
2358 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
2360 unsigned long int *hashcodes
;
2361 unsigned long int *hashcodesp
;
2362 unsigned long int i
;
2364 /* Compute the hash values for all exported symbols. At the same
2365 time store the values in an array so that we could use them for
2367 hashcodes
= (unsigned long int *) bfd_malloc (dynsymcount
2368 * sizeof (unsigned long int));
2369 if (hashcodes
== NULL
)
2371 hashcodesp
= hashcodes
;
2373 /* Put all hash values in HASHCODES. */
2374 elf_link_hash_traverse (elf_hash_table (info
),
2375 elf_collect_hash_codes
, &hashcodesp
);
2377 /* We have a problem here. The following code to optimize the table
2378 size requires an integer type with more the 32 bits. If
2379 BFD_HOST_U_64_BIT is set we know about such a type. */
2380 #ifdef BFD_HOST_U_64_BIT
2381 if (info
->optimize
== true)
2383 unsigned long int nsyms
= hashcodesp
- hashcodes
;
2386 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
2387 unsigned long int *counts
;
2389 /* Possible optimization parameters: if we have NSYMS symbols we say
2390 that the hashing table must at least have NSYMS/4 and at most
2392 minsize
= nsyms
/ 4;
2395 best_size
= maxsize
= nsyms
* 2;
2397 /* Create array where we count the collisions in. We must use bfd_malloc
2398 since the size could be large. */
2399 counts
= (unsigned long int *) bfd_malloc (maxsize
2400 * sizeof (unsigned long int));
2407 /* Compute the "optimal" size for the hash table. The criteria is a
2408 minimal chain length. The minor criteria is (of course) the size
2410 for (i
= minsize
; i
< maxsize
; ++i
)
2412 /* Walk through the array of hashcodes and count the collisions. */
2413 BFD_HOST_U_64_BIT max
;
2414 unsigned long int j
;
2415 unsigned long int fact
;
2417 memset (counts
, '\0', i
* sizeof (unsigned long int));
2419 /* Determine how often each hash bucket is used. */
2420 for (j
= 0; j
< nsyms
; ++j
)
2421 ++counts
[hashcodes
[j
] % i
];
2423 /* For the weight function we need some information about the
2424 pagesize on the target. This is information need not be 100%
2425 accurate. Since this information is not available (so far) we
2426 define it here to a reasonable default value. If it is crucial
2427 to have a better value some day simply define this value. */
2428 # ifndef BFD_TARGET_PAGESIZE
2429 # define BFD_TARGET_PAGESIZE (4096)
2432 /* We in any case need 2 + NSYMS entries for the size values and
2434 max
= (2 + nsyms
) * (ARCH_SIZE
/ 8);
2437 /* Variant 1: optimize for short chains. We add the squares
2438 of all the chain lengths (which favous many small chain
2439 over a few long chains). */
2440 for (j
= 0; j
< i
; ++j
)
2441 max
+= counts
[j
] * counts
[j
];
2443 /* This adds penalties for the overall size of the table. */
2444 fact
= i
/ (BFD_TARGET_PAGESIZE
/ (ARCH_SIZE
/ 8)) + 1;
2447 /* Variant 2: Optimize a lot more for small table. Here we
2448 also add squares of the size but we also add penalties for
2449 empty slots (the +1 term). */
2450 for (j
= 0; j
< i
; ++j
)
2451 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
2453 /* The overall size of the table is considered, but not as
2454 strong as in variant 1, where it is squared. */
2455 fact
= i
/ (BFD_TARGET_PAGESIZE
/ (ARCH_SIZE
/ 8)) + 1;
2459 /* Compare with current best results. */
2460 if (max
< best_chlen
)
2470 #endif /* defined (BFD_HOST_U_64_BIT) */
2472 /* This is the fallback solution if no 64bit type is available or if we
2473 are not supposed to spend much time on optimizations. We select the
2474 bucket count using a fixed set of numbers. */
2475 for (i
= 0; elf_buckets
[i
] != 0; i
++)
2477 best_size
= elf_buckets
[i
];
2478 if (dynsymcount
< elf_buckets
[i
+ 1])
2483 /* Free the arrays we needed. */
2489 /* Remove SECTION from the BFD. If a symbol for SECTION was going to
2490 be put into the dynamic symbol table, remove it, and renumber
2491 subsequent entries. */
2494 elf_link_remove_section_and_adjust_dynindices (info
, section
)
2495 struct bfd_link_info
*info
;
2498 /* Remove the section from the output list. */
2499 _bfd_strip_section_from_output (section
);
2501 if (elf_section_data (section
->output_section
)->dynindx
)
2506 /* We were going to output an entry in the dynamic symbol table
2507 for the symbol corresponding to this section. Now, the
2508 section is gone. So, we must renumber the dynamic indices of
2509 all subsequent sections and all other entries in the dynamic
2511 elf_section_data (section
->output_section
)->dynindx
= 0;
2512 for (s
= section
->output_section
->next
; s
; s
= s
->next
)
2513 if (elf_section_data (s
)->dynindx
)
2514 --elf_section_data (s
)->dynindx
;
2516 elf_link_hash_traverse (elf_hash_table (info
),
2517 _bfd_elf_link_adjust_dynindx
,
2520 /* There is one less dynamic symbol than there was before. */
2521 --elf_hash_table (info
)->dynsymcount
;
2525 /* Set up the sizes and contents of the ELF dynamic sections. This is
2526 called by the ELF linker emulation before_allocation routine. We
2527 must set the sizes of the sections before the linker sets the
2528 addresses of the various sections. */
2531 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
2532 export_dynamic
, filter_shlib
,
2533 auxiliary_filters
, info
, sinterpptr
,
2538 boolean export_dynamic
;
2539 const char *filter_shlib
;
2540 const char * const *auxiliary_filters
;
2541 struct bfd_link_info
*info
;
2542 asection
**sinterpptr
;
2543 struct bfd_elf_version_tree
*verdefs
;
2545 bfd_size_type soname_indx
;
2547 struct elf_backend_data
*bed
;
2548 bfd_size_type old_dynsymcount
;
2549 struct elf_assign_sym_version_info asvinfo
;
2553 soname_indx
= (bfd_size_type
) -1;
2555 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
2558 /* The backend may have to create some sections regardless of whether
2559 we're dynamic or not. */
2560 bed
= get_elf_backend_data (output_bfd
);
2561 if (bed
->elf_backend_always_size_sections
2562 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
2565 dynobj
= elf_hash_table (info
)->dynobj
;
2567 /* If there were no dynamic objects in the link, there is nothing to
2572 /* If we are supposed to export all symbols into the dynamic symbol
2573 table (this is not the normal case), then do so. */
2576 struct elf_info_failed eif
;
2580 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
2586 if (elf_hash_table (info
)->dynamic_sections_created
)
2588 struct elf_info_failed eif
;
2589 struct elf_link_hash_entry
*h
;
2590 bfd_size_type strsize
;
2592 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
2593 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
2597 soname_indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2598 soname
, true, true);
2599 if (soname_indx
== (bfd_size_type
) -1
2600 || ! elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
2606 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
2614 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
2616 if (indx
== (bfd_size_type
) -1
2617 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
2621 if (filter_shlib
!= NULL
)
2625 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2626 filter_shlib
, true, true);
2627 if (indx
== (bfd_size_type
) -1
2628 || ! elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
2632 if (auxiliary_filters
!= NULL
)
2634 const char * const *p
;
2636 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
2640 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2642 if (indx
== (bfd_size_type
) -1
2643 || ! elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
2648 /* Attach all the symbols to their version information. */
2649 asvinfo
.output_bfd
= output_bfd
;
2650 asvinfo
.info
= info
;
2651 asvinfo
.verdefs
= verdefs
;
2652 asvinfo
.export_dynamic
= export_dynamic
;
2653 asvinfo
.removed_dynamic
= false;
2654 asvinfo
.failed
= false;
2656 elf_link_hash_traverse (elf_hash_table (info
),
2657 elf_link_assign_sym_version
,
2662 /* Find all symbols which were defined in a dynamic object and make
2663 the backend pick a reasonable value for them. */
2666 elf_link_hash_traverse (elf_hash_table (info
),
2667 elf_adjust_dynamic_symbol
,
2672 /* Add some entries to the .dynamic section. We fill in some of the
2673 values later, in elf_bfd_final_link, but we must add the entries
2674 now so that we know the final size of the .dynamic section. */
2676 /* If there are initialization and/or finalization functions to
2677 call then add the corresponding DT_INIT/DT_FINI entries. */
2678 h
= (info
->init_function
2679 ? elf_link_hash_lookup (elf_hash_table (info
),
2680 info
->init_function
, false,
2684 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2685 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2687 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
2690 h
= (info
->fini_function
2691 ? elf_link_hash_lookup (elf_hash_table (info
),
2692 info
->fini_function
, false,
2696 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2697 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2699 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
2703 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
2704 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
2705 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
2706 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
2707 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
2708 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
2709 sizeof (Elf_External_Sym
)))
2713 /* The backend must work out the sizes of all the other dynamic
2715 old_dynsymcount
= elf_hash_table (info
)->dynsymcount
;
2716 if (bed
->elf_backend_size_dynamic_sections
2717 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
2720 if (elf_hash_table (info
)->dynamic_sections_created
)
2724 size_t bucketcount
= 0;
2725 Elf_Internal_Sym isym
;
2726 size_t hash_entry_size
;
2728 /* Set up the version definition section. */
2729 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
2730 BFD_ASSERT (s
!= NULL
);
2732 /* We may have created additional version definitions if we are
2733 just linking a regular application. */
2734 verdefs
= asvinfo
.verdefs
;
2736 if (verdefs
== NULL
)
2737 elf_link_remove_section_and_adjust_dynindices (info
, s
);
2742 struct bfd_elf_version_tree
*t
;
2744 Elf_Internal_Verdef def
;
2745 Elf_Internal_Verdaux defaux
;
2747 if (asvinfo
.removed_dynamic
)
2749 /* Some dynamic symbols were changed to be local
2750 symbols. In this case, we renumber all of the
2751 dynamic symbols, so that we don't have a hole. If
2752 the backend changed dynsymcount, then assume that the
2753 new symbols are at the start. This is the case on
2754 the MIPS. FIXME: The names of the removed symbols
2755 will still be in the dynamic string table, wasting
2757 elf_hash_table (info
)->dynsymcount
=
2758 1 + (elf_hash_table (info
)->dynsymcount
- old_dynsymcount
);
2759 elf_link_hash_traverse (elf_hash_table (info
),
2760 elf_link_renumber_dynsyms
,
2767 /* Make space for the base version. */
2768 size
+= sizeof (Elf_External_Verdef
);
2769 size
+= sizeof (Elf_External_Verdaux
);
2772 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2774 struct bfd_elf_version_deps
*n
;
2776 size
+= sizeof (Elf_External_Verdef
);
2777 size
+= sizeof (Elf_External_Verdaux
);
2780 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2781 size
+= sizeof (Elf_External_Verdaux
);
2784 s
->_raw_size
= size
;
2785 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
2786 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2789 /* Fill in the version definition section. */
2793 def
.vd_version
= VER_DEF_CURRENT
;
2794 def
.vd_flags
= VER_FLG_BASE
;
2797 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2798 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2799 + sizeof (Elf_External_Verdaux
));
2801 if (soname_indx
!= (bfd_size_type
) -1)
2803 def
.vd_hash
= bfd_elf_hash (soname
);
2804 defaux
.vda_name
= soname_indx
;
2811 name
= output_bfd
->filename
;
2812 def
.vd_hash
= bfd_elf_hash (name
);
2813 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2815 if (indx
== (bfd_size_type
) -1)
2817 defaux
.vda_name
= indx
;
2819 defaux
.vda_next
= 0;
2821 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2822 (Elf_External_Verdef
*)p
);
2823 p
+= sizeof (Elf_External_Verdef
);
2824 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2825 (Elf_External_Verdaux
*) p
);
2826 p
+= sizeof (Elf_External_Verdaux
);
2828 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2831 struct bfd_elf_version_deps
*n
;
2832 struct elf_link_hash_entry
*h
;
2835 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2838 /* Add a symbol representing this version. */
2840 if (! (_bfd_generic_link_add_one_symbol
2841 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
2842 (bfd_vma
) 0, (const char *) NULL
, false,
2843 get_elf_backend_data (dynobj
)->collect
,
2844 (struct bfd_link_hash_entry
**) &h
)))
2846 h
->elf_link_hash_flags
&= ~ ELF_LINK_NON_ELF
;
2847 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2848 h
->type
= STT_OBJECT
;
2849 h
->verinfo
.vertree
= t
;
2851 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2854 def
.vd_version
= VER_DEF_CURRENT
;
2856 if (t
->globals
== NULL
&& t
->locals
== NULL
&& ! t
->used
)
2857 def
.vd_flags
|= VER_FLG_WEAK
;
2858 def
.vd_ndx
= t
->vernum
+ 1;
2859 def
.vd_cnt
= cdeps
+ 1;
2860 def
.vd_hash
= bfd_elf_hash (t
->name
);
2861 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2862 if (t
->next
!= NULL
)
2863 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2864 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
2868 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2869 (Elf_External_Verdef
*) p
);
2870 p
+= sizeof (Elf_External_Verdef
);
2872 defaux
.vda_name
= h
->dynstr_index
;
2873 if (t
->deps
== NULL
)
2874 defaux
.vda_next
= 0;
2876 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2877 t
->name_indx
= defaux
.vda_name
;
2879 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2880 (Elf_External_Verdaux
*) p
);
2881 p
+= sizeof (Elf_External_Verdaux
);
2883 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2885 if (n
->version_needed
== NULL
)
2887 /* This can happen if there was an error in the
2889 defaux
.vda_name
= 0;
2892 defaux
.vda_name
= n
->version_needed
->name_indx
;
2893 if (n
->next
== NULL
)
2894 defaux
.vda_next
= 0;
2896 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2898 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2899 (Elf_External_Verdaux
*) p
);
2900 p
+= sizeof (Elf_External_Verdaux
);
2904 if (! elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
2905 || ! elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
2908 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
2911 /* Work out the size of the version reference section. */
2913 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
2914 BFD_ASSERT (s
!= NULL
);
2916 struct elf_find_verdep_info sinfo
;
2918 sinfo
.output_bfd
= output_bfd
;
2920 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
2921 if (sinfo
.vers
== 0)
2923 sinfo
.failed
= false;
2925 elf_link_hash_traverse (elf_hash_table (info
),
2926 elf_link_find_version_dependencies
,
2929 if (elf_tdata (output_bfd
)->verref
== NULL
)
2930 elf_link_remove_section_and_adjust_dynindices (info
, s
);
2933 Elf_Internal_Verneed
*t
;
2938 /* Build the version definition section. */
2941 for (t
= elf_tdata (output_bfd
)->verref
;
2945 Elf_Internal_Vernaux
*a
;
2947 size
+= sizeof (Elf_External_Verneed
);
2949 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2950 size
+= sizeof (Elf_External_Vernaux
);
2953 s
->_raw_size
= size
;
2954 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, size
);
2955 if (s
->contents
== NULL
)
2959 for (t
= elf_tdata (output_bfd
)->verref
;
2964 Elf_Internal_Vernaux
*a
;
2968 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2971 t
->vn_version
= VER_NEED_CURRENT
;
2973 if (elf_dt_name (t
->vn_bfd
) != NULL
)
2974 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2975 elf_dt_name (t
->vn_bfd
),
2978 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2979 t
->vn_bfd
->filename
, true, false);
2980 if (indx
== (bfd_size_type
) -1)
2983 t
->vn_aux
= sizeof (Elf_External_Verneed
);
2984 if (t
->vn_nextref
== NULL
)
2987 t
->vn_next
= (sizeof (Elf_External_Verneed
)
2988 + caux
* sizeof (Elf_External_Vernaux
));
2990 _bfd_elf_swap_verneed_out (output_bfd
, t
,
2991 (Elf_External_Verneed
*) p
);
2992 p
+= sizeof (Elf_External_Verneed
);
2994 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2996 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
2997 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2998 a
->vna_nodename
, true, false);
2999 if (indx
== (bfd_size_type
) -1)
3002 if (a
->vna_nextptr
== NULL
)
3005 a
->vna_next
= sizeof (Elf_External_Vernaux
);
3007 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
3008 (Elf_External_Vernaux
*) p
);
3009 p
+= sizeof (Elf_External_Vernaux
);
3013 if (! elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
3014 || ! elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
3017 elf_tdata (output_bfd
)->cverrefs
= crefs
;
3021 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
3023 /* Work out the size of the symbol version section. */
3024 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3025 BFD_ASSERT (s
!= NULL
);
3026 if (dynsymcount
== 0
3027 || (verdefs
== NULL
&& elf_tdata (output_bfd
)->verref
== NULL
))
3029 elf_link_remove_section_and_adjust_dynindices (info
, s
);
3030 /* The DYNSYMCOUNT might have changed if we were going to
3031 output a dynamic symbol table entry for S. */
3032 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
3036 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Versym
);
3037 s
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, s
->_raw_size
);
3038 if (s
->contents
== NULL
)
3041 if (! elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
3045 /* Set the size of the .dynsym and .hash sections. We counted
3046 the number of dynamic symbols in elf_link_add_object_symbols.
3047 We will build the contents of .dynsym and .hash when we build
3048 the final symbol table, because until then we do not know the
3049 correct value to give the symbols. We built the .dynstr
3050 section as we went along in elf_link_add_object_symbols. */
3051 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
3052 BFD_ASSERT (s
!= NULL
);
3053 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
3054 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
3055 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3058 /* The first entry in .dynsym is a dummy symbol. */
3065 elf_swap_symbol_out (output_bfd
, &isym
,
3066 (PTR
) (Elf_External_Sym
*) s
->contents
);
3068 /* Compute the size of the hashing table. As a side effect this
3069 computes the hash values for all the names we export. */
3070 bucketcount
= compute_bucket_count (info
);
3072 s
= bfd_get_section_by_name (dynobj
, ".hash");
3073 BFD_ASSERT (s
!= NULL
);
3074 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
3075 s
->_raw_size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
3076 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
3077 if (s
->contents
== NULL
)
3079 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
3081 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
3082 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
3083 s
->contents
+ hash_entry_size
);
3085 elf_hash_table (info
)->bucketcount
= bucketcount
;
3087 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
3088 BFD_ASSERT (s
!= NULL
);
3089 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
3091 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
3098 /* Fix up the flags for a symbol. This handles various cases which
3099 can only be fixed after all the input files are seen. This is
3100 currently called by both adjust_dynamic_symbol and
3101 assign_sym_version, which is unnecessary but perhaps more robust in
3102 the face of future changes. */
3105 elf_fix_symbol_flags (h
, eif
)
3106 struct elf_link_hash_entry
*h
;
3107 struct elf_info_failed
*eif
;
3109 /* If this symbol was mentioned in a non-ELF file, try to set
3110 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
3111 permit a non-ELF file to correctly refer to a symbol defined in
3112 an ELF dynamic object. */
3113 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
3115 if (h
->root
.type
!= bfd_link_hash_defined
3116 && h
->root
.type
!= bfd_link_hash_defweak
)
3117 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
3118 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
3121 if (h
->root
.u
.def
.section
->owner
!= NULL
3122 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
3123 == bfd_target_elf_flavour
))
3124 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
3125 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
3127 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3130 if (h
->dynindx
== -1
3131 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3132 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0))
3134 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3143 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
3144 was first seen in a non-ELF file. Fortunately, if the symbol
3145 was first seen in an ELF file, we're probably OK unless the
3146 symbol was defined in a non-ELF file. Catch that case here.
3147 FIXME: We're still in trouble if the symbol was first seen in
3148 a dynamic object, and then later in a non-ELF regular object. */
3149 if ((h
->root
.type
== bfd_link_hash_defined
3150 || h
->root
.type
== bfd_link_hash_defweak
)
3151 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3152 && (h
->root
.u
.def
.section
->owner
!= NULL
3153 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
3154 != bfd_target_elf_flavour
)
3155 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
3156 && (h
->elf_link_hash_flags
3157 & ELF_LINK_HASH_DEF_DYNAMIC
) == 0)))
3158 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3161 /* If this is a final link, and the symbol was defined as a common
3162 symbol in a regular object file, and there was no definition in
3163 any dynamic object, then the linker will have allocated space for
3164 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
3165 flag will not have been set. */
3166 if (h
->root
.type
== bfd_link_hash_defined
3167 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3168 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
3169 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3170 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
3171 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3173 /* If -Bsymbolic was used (which means to bind references to global
3174 symbols to the definition within the shared object), and this
3175 symbol was defined in a regular object, then it actually doesn't
3176 need a PLT entry. */
3177 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
3178 && eif
->info
->shared
3179 && eif
->info
->symbolic
3180 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
3182 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3183 h
->plt
.offset
= (bfd_vma
) -1;
3189 /* Make the backend pick a good value for a dynamic symbol. This is
3190 called via elf_link_hash_traverse, and also calls itself
3194 elf_adjust_dynamic_symbol (h
, data
)
3195 struct elf_link_hash_entry
*h
;
3198 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
3200 struct elf_backend_data
*bed
;
3202 /* Ignore indirect symbols. These are added by the versioning code. */
3203 if (h
->root
.type
== bfd_link_hash_indirect
)
3206 /* Fix the symbol flags. */
3207 if (! elf_fix_symbol_flags (h
, eif
))
3210 /* If this symbol does not require a PLT entry, and it is not
3211 defined by a dynamic object, or is not referenced by a regular
3212 object, ignore it. We do have to handle a weak defined symbol,
3213 even if no regular object refers to it, if we decided to add it
3214 to the dynamic symbol table. FIXME: Do we normally need to worry
3215 about symbols which are defined by one dynamic object and
3216 referenced by another one? */
3217 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
3218 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
3219 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3220 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
3221 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
3223 h
->plt
.offset
= (bfd_vma
) -1;
3227 /* If we've already adjusted this symbol, don't do it again. This
3228 can happen via a recursive call. */
3229 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
3232 /* Don't look at this symbol again. Note that we must set this
3233 after checking the above conditions, because we may look at a
3234 symbol once, decide not to do anything, and then get called
3235 recursively later after REF_REGULAR is set below. */
3236 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
3238 /* If this is a weak definition, and we know a real definition, and
3239 the real symbol is not itself defined by a regular object file,
3240 then get a good value for the real definition. We handle the
3241 real symbol first, for the convenience of the backend routine.
3243 Note that there is a confusing case here. If the real definition
3244 is defined by a regular object file, we don't get the real symbol
3245 from the dynamic object, but we do get the weak symbol. If the
3246 processor backend uses a COPY reloc, then if some routine in the
3247 dynamic object changes the real symbol, we will not see that
3248 change in the corresponding weak symbol. This is the way other
3249 ELF linkers work as well, and seems to be a result of the shared
3252 I will clarify this issue. Most SVR4 shared libraries define the
3253 variable _timezone and define timezone as a weak synonym. The
3254 tzset call changes _timezone. If you write
3255 extern int timezone;
3257 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
3258 you might expect that, since timezone is a synonym for _timezone,
3259 the same number will print both times. However, if the processor
3260 backend uses a COPY reloc, then actually timezone will be copied
3261 into your process image, and, since you define _timezone
3262 yourself, _timezone will not. Thus timezone and _timezone will
3263 wind up at different memory locations. The tzset call will set
3264 _timezone, leaving timezone unchanged. */
3266 if (h
->weakdef
!= NULL
)
3268 struct elf_link_hash_entry
*weakdef
;
3270 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
3271 || h
->root
.type
== bfd_link_hash_defweak
);
3272 weakdef
= h
->weakdef
;
3273 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
3274 || weakdef
->root
.type
== bfd_link_hash_defweak
);
3275 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
3276 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
3278 /* This symbol is defined by a regular object file, so we
3279 will not do anything special. Clear weakdef for the
3280 convenience of the processor backend. */
3285 /* There is an implicit reference by a regular object file
3286 via the weak symbol. */
3287 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
3288 if (h
->weakdef
->elf_link_hash_flags
3289 & ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3290 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR_NONWEAK
;
3291 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
3296 /* If a symbol has no type and no size and does not require a PLT
3297 entry, then we are probably about to do the wrong thing here: we
3298 are probably going to create a COPY reloc for an empty object.
3299 This case can arise when a shared object is built with assembly
3300 code, and the assembly code fails to set the symbol type. */
3302 && h
->type
== STT_NOTYPE
3303 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
3304 (*_bfd_error_handler
)
3305 (_("warning: type and size of dynamic symbol `%s' are not defined"),
3306 h
->root
.root
.string
);
3308 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
3309 bed
= get_elf_backend_data (dynobj
);
3310 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
3319 /* This routine is used to export all defined symbols into the dynamic
3320 symbol table. It is called via elf_link_hash_traverse. */
3323 elf_export_symbol (h
, data
)
3324 struct elf_link_hash_entry
*h
;
3327 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
3329 /* Ignore indirect symbols. These are added by the versioning code. */
3330 if (h
->root
.type
== bfd_link_hash_indirect
)
3333 if (h
->dynindx
== -1
3334 && (h
->elf_link_hash_flags
3335 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
3337 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3347 /* Look through the symbols which are defined in other shared
3348 libraries and referenced here. Update the list of version
3349 dependencies. This will be put into the .gnu.version_r section.
3350 This function is called via elf_link_hash_traverse. */
3353 elf_link_find_version_dependencies (h
, data
)
3354 struct elf_link_hash_entry
*h
;
3357 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
3358 Elf_Internal_Verneed
*t
;
3359 Elf_Internal_Vernaux
*a
;
3361 /* We only care about symbols defined in shared objects with version
3363 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3364 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
3366 || h
->verinfo
.verdef
== NULL
)
3369 /* See if we already know about this version. */
3370 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
3372 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
3375 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
3376 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
3382 /* This is a new version. Add it to tree we are building. */
3386 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *t
);
3389 rinfo
->failed
= true;
3393 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
3394 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
3395 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
3398 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *a
);
3400 /* Note that we are copying a string pointer here, and testing it
3401 above. If bfd_elf_string_from_elf_section is ever changed to
3402 discard the string data when low in memory, this will have to be
3404 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
3406 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
3407 a
->vna_nextptr
= t
->vn_auxptr
;
3409 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
3412 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
3419 /* Figure out appropriate versions for all the symbols. We may not
3420 have the version number script until we have read all of the input
3421 files, so until that point we don't know which symbols should be
3422 local. This function is called via elf_link_hash_traverse. */
3425 elf_link_assign_sym_version (h
, data
)
3426 struct elf_link_hash_entry
*h
;
3429 struct elf_assign_sym_version_info
*sinfo
=
3430 (struct elf_assign_sym_version_info
*) data
;
3431 struct bfd_link_info
*info
= sinfo
->info
;
3432 struct elf_info_failed eif
;
3435 /* Fix the symbol flags. */
3438 if (! elf_fix_symbol_flags (h
, &eif
))
3441 sinfo
->failed
= true;
3445 /* We only need version numbers for symbols defined in regular
3447 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3450 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
3451 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3453 struct bfd_elf_version_tree
*t
;
3458 /* There are two consecutive ELF_VER_CHR characters if this is
3459 not a hidden symbol. */
3461 if (*p
== ELF_VER_CHR
)
3467 /* If there is no version string, we can just return out. */
3471 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3475 /* Look for the version. If we find it, it is no longer weak. */
3476 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3478 if (strcmp (t
->name
, p
) == 0)
3482 struct bfd_elf_version_expr
*d
;
3484 len
= p
- h
->root
.root
.string
;
3485 alc
= bfd_alloc (sinfo
->output_bfd
, len
);
3488 strncpy (alc
, h
->root
.root
.string
, len
- 1);
3489 alc
[len
- 1] = '\0';
3490 if (alc
[len
- 2] == ELF_VER_CHR
)
3491 alc
[len
- 2] = '\0';
3493 h
->verinfo
.vertree
= t
;
3497 if (t
->globals
!= NULL
)
3499 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3500 if ((*d
->match
) (d
, alc
))
3504 /* See if there is anything to force this symbol to
3506 if (d
== NULL
&& t
->locals
!= NULL
)
3508 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3510 if ((*d
->match
) (d
, alc
))
3512 if (h
->dynindx
!= -1
3514 && ! sinfo
->export_dynamic
)
3516 sinfo
->removed_dynamic
= true;
3517 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3518 h
->elf_link_hash_flags
&=~
3519 ELF_LINK_HASH_NEEDS_PLT
;
3521 h
->plt
.offset
= (bfd_vma
) -1;
3522 /* FIXME: The name of the symbol has
3523 already been recorded in the dynamic
3524 string table section. */
3532 bfd_release (sinfo
->output_bfd
, alc
);
3537 /* If we are building an application, we need to create a
3538 version node for this version. */
3539 if (t
== NULL
&& ! info
->shared
)
3541 struct bfd_elf_version_tree
**pp
;
3544 /* If we aren't going to export this symbol, we don't need
3545 to worry about it. */
3546 if (h
->dynindx
== -1)
3549 t
= ((struct bfd_elf_version_tree
*)
3550 bfd_alloc (sinfo
->output_bfd
, sizeof *t
));
3553 sinfo
->failed
= true;
3562 t
->name_indx
= (unsigned int) -1;
3566 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3568 t
->vernum
= version_index
;
3572 h
->verinfo
.vertree
= t
;
3576 /* We could not find the version for a symbol when
3577 generating a shared archive. Return an error. */
3578 (*_bfd_error_handler
)
3579 (_("%s: undefined versioned symbol name %s"),
3580 bfd_get_filename (sinfo
->output_bfd
), h
->root
.root
.string
);
3581 bfd_set_error (bfd_error_bad_value
);
3582 sinfo
->failed
= true;
3587 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3590 /* If we don't have a version for this symbol, see if we can find
3592 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
3594 struct bfd_elf_version_tree
*t
;
3595 struct bfd_elf_version_tree
*deflt
;
3596 struct bfd_elf_version_expr
*d
;
3598 /* See if can find what version this symbol is in. If the
3599 symbol is supposed to be local, then don't actually register
3602 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3604 if (t
->globals
!= NULL
)
3606 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3608 if ((*d
->match
) (d
, h
->root
.root
.string
))
3610 h
->verinfo
.vertree
= t
;
3619 if (t
->locals
!= NULL
)
3621 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3623 if (d
->pattern
[0] == '*' && d
->pattern
[1] == '\0')
3625 else if ((*d
->match
) (d
, h
->root
.root
.string
))
3627 h
->verinfo
.vertree
= t
;
3628 if (h
->dynindx
!= -1
3630 && ! sinfo
->export_dynamic
)
3632 sinfo
->removed_dynamic
= true;
3633 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3634 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3636 h
->plt
.offset
= (bfd_vma
) -1;
3637 /* FIXME: The name of the symbol has already
3638 been recorded in the dynamic string table
3650 if (deflt
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3652 h
->verinfo
.vertree
= deflt
;
3653 if (h
->dynindx
!= -1
3655 && ! sinfo
->export_dynamic
)
3657 sinfo
->removed_dynamic
= true;
3658 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3659 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3661 h
->plt
.offset
= (bfd_vma
) -1;
3662 /* FIXME: The name of the symbol has already been
3663 recorded in the dynamic string table section. */
3671 /* This function is used to renumber the dynamic symbols, if some of
3672 them are removed because they are marked as local. This is called
3673 via elf_link_hash_traverse. */
3676 elf_link_renumber_dynsyms (h
, data
)
3677 struct elf_link_hash_entry
*h
;
3680 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
3682 if (h
->dynindx
!= -1)
3684 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3685 ++elf_hash_table (info
)->dynsymcount
;
3691 /* Final phase of ELF linker. */
3693 /* A structure we use to avoid passing large numbers of arguments. */
3695 struct elf_final_link_info
3697 /* General link information. */
3698 struct bfd_link_info
*info
;
3701 /* Symbol string table. */
3702 struct bfd_strtab_hash
*symstrtab
;
3703 /* .dynsym section. */
3704 asection
*dynsym_sec
;
3705 /* .hash section. */
3707 /* symbol version section (.gnu.version). */
3708 asection
*symver_sec
;
3709 /* Buffer large enough to hold contents of any section. */
3711 /* Buffer large enough to hold external relocs of any section. */
3712 PTR external_relocs
;
3713 /* Buffer large enough to hold internal relocs of any section. */
3714 Elf_Internal_Rela
*internal_relocs
;
3715 /* Buffer large enough to hold external local symbols of any input
3717 Elf_External_Sym
*external_syms
;
3718 /* Buffer large enough to hold internal local symbols of any input
3720 Elf_Internal_Sym
*internal_syms
;
3721 /* Array large enough to hold a symbol index for each local symbol
3722 of any input BFD. */
3724 /* Array large enough to hold a section pointer for each local
3725 symbol of any input BFD. */
3726 asection
**sections
;
3727 /* Buffer to hold swapped out symbols. */
3728 Elf_External_Sym
*symbuf
;
3729 /* Number of swapped out symbols in buffer. */
3730 size_t symbuf_count
;
3731 /* Number of symbols which fit in symbuf. */
3735 static boolean elf_link_output_sym
3736 PARAMS ((struct elf_final_link_info
*, const char *,
3737 Elf_Internal_Sym
*, asection
*));
3738 static boolean elf_link_flush_output_syms
3739 PARAMS ((struct elf_final_link_info
*));
3740 static boolean elf_link_output_extsym
3741 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3742 static boolean elf_link_input_bfd
3743 PARAMS ((struct elf_final_link_info
*, bfd
*));
3744 static boolean elf_reloc_link_order
3745 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
3746 struct bfd_link_order
*));
3748 /* This struct is used to pass information to elf_link_output_extsym. */
3750 struct elf_outext_info
3754 struct elf_final_link_info
*finfo
;
3757 /* Compute the size of, and allocate space for, REL_HDR which is the
3758 section header for a section containing relocations for O. */
3761 elf_link_size_reloc_section (abfd
, rel_hdr
, o
)
3763 Elf_Internal_Shdr
*rel_hdr
;
3766 register struct elf_link_hash_entry
**p
, **pend
;
3768 /* We are overestimating the size required for the relocation
3769 sections, in the case that we are using both REL and RELA
3770 relocations for a single section. In that case, RELOC_COUNT will
3771 be the total number of relocations required, and we allocate
3772 space for that many REL relocations as well as that many RELA
3773 relocations. This approximation is wasteful of disk space.
3774 However, until we keep track of how many of each kind of
3775 relocation is required, it's difficult to calculate the right
3777 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
3779 /* The contents field must last into write_object_contents, so we
3780 allocate it with bfd_alloc rather than malloc. */
3781 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
3782 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
3785 p
= ((struct elf_link_hash_entry
**)
3786 bfd_malloc (o
->reloc_count
3787 * sizeof (struct elf_link_hash_entry
*)));
3788 if (p
== NULL
&& o
->reloc_count
!= 0)
3791 elf_section_data (o
)->rel_hashes
= p
;
3792 pend
= p
+ o
->reloc_count
;
3793 for (; p
< pend
; p
++)
3799 /* Do the final step of an ELF link. */
3802 elf_bfd_final_link (abfd
, info
)
3804 struct bfd_link_info
*info
;
3808 struct elf_final_link_info finfo
;
3809 register asection
*o
;
3810 register struct bfd_link_order
*p
;
3812 size_t max_contents_size
;
3813 size_t max_external_reloc_size
;
3814 size_t max_internal_reloc_count
;
3815 size_t max_sym_count
;
3817 Elf_Internal_Sym elfsym
;
3819 Elf_Internal_Shdr
*symtab_hdr
;
3820 Elf_Internal_Shdr
*symstrtab_hdr
;
3821 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3822 struct elf_outext_info eoinfo
;
3825 abfd
->flags
|= DYNAMIC
;
3827 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
3828 dynobj
= elf_hash_table (info
)->dynobj
;
3831 finfo
.output_bfd
= abfd
;
3832 finfo
.symstrtab
= elf_stringtab_init ();
3833 if (finfo
.symstrtab
== NULL
)
3838 finfo
.dynsym_sec
= NULL
;
3839 finfo
.hash_sec
= NULL
;
3840 finfo
.symver_sec
= NULL
;
3844 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
3845 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
3846 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
3847 finfo
.symver_sec
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3848 /* Note that it is OK if symver_sec is NULL. */
3851 finfo
.contents
= NULL
;
3852 finfo
.external_relocs
= NULL
;
3853 finfo
.internal_relocs
= NULL
;
3854 finfo
.external_syms
= NULL
;
3855 finfo
.internal_syms
= NULL
;
3856 finfo
.indices
= NULL
;
3857 finfo
.sections
= NULL
;
3858 finfo
.symbuf
= NULL
;
3859 finfo
.symbuf_count
= 0;
3861 /* Count up the number of relocations we will output for each output
3862 section, so that we know the sizes of the reloc sections. We
3863 also figure out some maximum sizes. */
3864 max_contents_size
= 0;
3865 max_external_reloc_size
= 0;
3866 max_internal_reloc_count
= 0;
3868 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3872 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3874 if (p
->type
== bfd_section_reloc_link_order
3875 || p
->type
== bfd_symbol_reloc_link_order
)
3877 else if (p
->type
== bfd_indirect_link_order
)
3881 sec
= p
->u
.indirect
.section
;
3883 /* Mark all sections which are to be included in the
3884 link. This will normally be every section. We need
3885 to do this so that we can identify any sections which
3886 the linker has decided to not include. */
3887 sec
->linker_mark
= true;
3889 if (info
->relocateable
)
3890 o
->reloc_count
+= sec
->reloc_count
;
3892 if (sec
->_raw_size
> max_contents_size
)
3893 max_contents_size
= sec
->_raw_size
;
3894 if (sec
->_cooked_size
> max_contents_size
)
3895 max_contents_size
= sec
->_cooked_size
;
3897 /* We are interested in just local symbols, not all
3899 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
3900 && (sec
->owner
->flags
& DYNAMIC
) == 0)
3904 if (elf_bad_symtab (sec
->owner
))
3905 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
3906 / sizeof (Elf_External_Sym
));
3908 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
3910 if (sym_count
> max_sym_count
)
3911 max_sym_count
= sym_count
;
3913 if ((sec
->flags
& SEC_RELOC
) != 0)
3917 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
3918 if (ext_size
> max_external_reloc_size
)
3919 max_external_reloc_size
= ext_size
;
3920 if (sec
->reloc_count
> max_internal_reloc_count
)
3921 max_internal_reloc_count
= sec
->reloc_count
;
3927 if (o
->reloc_count
> 0)
3928 o
->flags
|= SEC_RELOC
;
3931 /* Explicitly clear the SEC_RELOC flag. The linker tends to
3932 set it (this is probably a bug) and if it is set
3933 assign_section_numbers will create a reloc section. */
3934 o
->flags
&=~ SEC_RELOC
;
3937 /* If the SEC_ALLOC flag is not set, force the section VMA to
3938 zero. This is done in elf_fake_sections as well, but forcing
3939 the VMA to 0 here will ensure that relocs against these
3940 sections are handled correctly. */
3941 if ((o
->flags
& SEC_ALLOC
) == 0
3942 && ! o
->user_set_vma
)
3946 /* Figure out the file positions for everything but the symbol table
3947 and the relocs. We set symcount to force assign_section_numbers
3948 to create a symbol table. */
3949 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
3950 BFD_ASSERT (! abfd
->output_has_begun
);
3951 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
3954 /* That created the reloc sections. Set their sizes, and assign
3955 them file positions, and allocate some buffers. */
3956 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3958 if ((o
->flags
& SEC_RELOC
) != 0)
3960 if (!elf_link_size_reloc_section (abfd
,
3961 &elf_section_data (o
)->rel_hdr
,
3965 if (elf_section_data (o
)->rel_hdr2
3966 && !elf_link_size_reloc_section (abfd
,
3967 elf_section_data (o
)->rel_hdr2
,
3973 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3975 /* We have now assigned file positions for all the sections except
3976 .symtab and .strtab. We start the .symtab section at the current
3977 file position, and write directly to it. We build the .strtab
3978 section in memory. */
3979 bfd_get_symcount (abfd
) = 0;
3980 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3981 /* sh_name is set in prep_headers. */
3982 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3983 symtab_hdr
->sh_flags
= 0;
3984 symtab_hdr
->sh_addr
= 0;
3985 symtab_hdr
->sh_size
= 0;
3986 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
3987 /* sh_link is set in assign_section_numbers. */
3988 /* sh_info is set below. */
3989 /* sh_offset is set just below. */
3990 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
3992 off
= elf_tdata (abfd
)->next_file_pos
;
3993 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
3995 /* Note that at this point elf_tdata (abfd)->next_file_pos is
3996 incorrect. We do not yet know the size of the .symtab section.
3997 We correct next_file_pos below, after we do know the size. */
3999 /* Allocate a buffer to hold swapped out symbols. This is to avoid
4000 continuously seeking to the right position in the file. */
4001 if (! info
->keep_memory
|| max_sym_count
< 20)
4002 finfo
.symbuf_size
= 20;
4004 finfo
.symbuf_size
= max_sym_count
;
4005 finfo
.symbuf
= ((Elf_External_Sym
*)
4006 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
4007 if (finfo
.symbuf
== NULL
)
4010 /* Start writing out the symbol table. The first symbol is always a
4012 if (info
->strip
!= strip_all
|| info
->relocateable
)
4014 elfsym
.st_value
= 0;
4017 elfsym
.st_other
= 0;
4018 elfsym
.st_shndx
= SHN_UNDEF
;
4019 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
4020 &elfsym
, bfd_und_section_ptr
))
4025 /* Some standard ELF linkers do this, but we don't because it causes
4026 bootstrap comparison failures. */
4027 /* Output a file symbol for the output file as the second symbol.
4028 We output this even if we are discarding local symbols, although
4029 I'm not sure if this is correct. */
4030 elfsym
.st_value
= 0;
4032 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
4033 elfsym
.st_other
= 0;
4034 elfsym
.st_shndx
= SHN_ABS
;
4035 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
4036 &elfsym
, bfd_abs_section_ptr
))
4040 /* Output a symbol for each section. We output these even if we are
4041 discarding local symbols, since they are used for relocs. These
4042 symbols have no names. We store the index of each one in the
4043 index field of the section, so that we can find it again when
4044 outputting relocs. */
4045 if (info
->strip
!= strip_all
|| info
->relocateable
)
4048 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4049 elfsym
.st_other
= 0;
4050 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
4052 o
= section_from_elf_index (abfd
, i
);
4054 o
->target_index
= bfd_get_symcount (abfd
);
4055 elfsym
.st_shndx
= i
;
4056 if (info
->relocateable
|| o
== NULL
)
4057 elfsym
.st_value
= 0;
4059 elfsym
.st_value
= o
->vma
;
4060 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
4066 /* Allocate some memory to hold information read in from the input
4068 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
4069 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
4070 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
4071 bfd_malloc (max_internal_reloc_count
4072 * sizeof (Elf_Internal_Rela
)
4073 * bed
->s
->int_rels_per_ext_rel
));
4074 finfo
.external_syms
= ((Elf_External_Sym
*)
4075 bfd_malloc (max_sym_count
4076 * sizeof (Elf_External_Sym
)));
4077 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
4078 bfd_malloc (max_sym_count
4079 * sizeof (Elf_Internal_Sym
)));
4080 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
4081 finfo
.sections
= ((asection
**)
4082 bfd_malloc (max_sym_count
* sizeof (asection
*)));
4083 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
4084 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
4085 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
4086 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
4087 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
4088 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
4089 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
4092 /* Since ELF permits relocations to be against local symbols, we
4093 must have the local symbols available when we do the relocations.
4094 Since we would rather only read the local symbols once, and we
4095 would rather not keep them in memory, we handle all the
4096 relocations for a single input file at the same time.
4098 Unfortunately, there is no way to know the total number of local
4099 symbols until we have seen all of them, and the local symbol
4100 indices precede the global symbol indices. This means that when
4101 we are generating relocateable output, and we see a reloc against
4102 a global symbol, we can not know the symbol index until we have
4103 finished examining all the local symbols to see which ones we are
4104 going to output. To deal with this, we keep the relocations in
4105 memory, and don't output them until the end of the link. This is
4106 an unfortunate waste of memory, but I don't see a good way around
4107 it. Fortunately, it only happens when performing a relocateable
4108 link, which is not the common case. FIXME: If keep_memory is set
4109 we could write the relocs out and then read them again; I don't
4110 know how bad the memory loss will be. */
4112 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
4113 sub
->output_has_begun
= false;
4114 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4116 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
4118 if (p
->type
== bfd_indirect_link_order
4119 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4120 == bfd_target_elf_flavour
))
4122 sub
= p
->u
.indirect
.section
->owner
;
4123 if (! sub
->output_has_begun
)
4125 if (! elf_link_input_bfd (&finfo
, sub
))
4127 sub
->output_has_begun
= true;
4130 else if (p
->type
== bfd_section_reloc_link_order
4131 || p
->type
== bfd_symbol_reloc_link_order
)
4133 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
4138 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4144 /* That wrote out all the local symbols. Finish up the symbol table
4145 with the global symbols. */
4147 if (info
->strip
!= strip_all
&& info
->shared
)
4149 /* Output any global symbols that got converted to local in a
4150 version script. We do this in a separate step since ELF
4151 requires all local symbols to appear prior to any global
4152 symbols. FIXME: We should only do this if some global
4153 symbols were, in fact, converted to become local. FIXME:
4154 Will this work correctly with the Irix 5 linker? */
4155 eoinfo
.failed
= false;
4156 eoinfo
.finfo
= &finfo
;
4157 eoinfo
.localsyms
= true;
4158 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
4164 /* The sh_info field records the index of the first non local
4166 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
4168 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
4170 /* We get the global symbols from the hash table. */
4171 eoinfo
.failed
= false;
4172 eoinfo
.localsyms
= false;
4173 eoinfo
.finfo
= &finfo
;
4174 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
4179 /* Flush all symbols to the file. */
4180 if (! elf_link_flush_output_syms (&finfo
))
4183 /* Now we know the size of the symtab section. */
4184 off
+= symtab_hdr
->sh_size
;
4186 /* Finish up and write out the symbol string table (.strtab)
4188 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4189 /* sh_name was set in prep_headers. */
4190 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4191 symstrtab_hdr
->sh_flags
= 0;
4192 symstrtab_hdr
->sh_addr
= 0;
4193 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
4194 symstrtab_hdr
->sh_entsize
= 0;
4195 symstrtab_hdr
->sh_link
= 0;
4196 symstrtab_hdr
->sh_info
= 0;
4197 /* sh_offset is set just below. */
4198 symstrtab_hdr
->sh_addralign
= 1;
4200 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
4201 elf_tdata (abfd
)->next_file_pos
= off
;
4203 if (bfd_get_symcount (abfd
) > 0)
4205 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
4206 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
4210 /* Adjust the relocs to have the correct symbol indices. */
4211 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4213 struct elf_link_hash_entry
**rel_hash
;
4214 Elf_Internal_Shdr
*rel_hdr
;
4216 if ((o
->flags
& SEC_RELOC
) == 0)
4219 rel_hash
= elf_section_data (o
)->rel_hashes
;
4220 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4221 BFD_ASSERT (elf_section_data (o
)->rel_count
== o
->reloc_count
);
4222 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
4224 if (*rel_hash
== NULL
)
4227 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
4229 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4231 Elf_External_Rel
*erel
;
4232 Elf_Internal_Rel irel
;
4234 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
4235 elf_swap_reloc_in (abfd
, erel
, &irel
);
4236 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
4237 ELF_R_TYPE (irel
.r_info
));
4238 elf_swap_reloc_out (abfd
, &irel
, erel
);
4242 Elf_External_Rela
*erela
;
4243 Elf_Internal_Rela irela
;
4245 BFD_ASSERT (rel_hdr
->sh_entsize
4246 == sizeof (Elf_External_Rela
));
4248 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
4249 elf_swap_reloca_in (abfd
, erela
, &irela
);
4250 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
4251 ELF_R_TYPE (irela
.r_info
));
4252 elf_swap_reloca_out (abfd
, &irela
, erela
);
4256 /* Set the reloc_count field to 0 to prevent write_relocs from
4257 trying to swap the relocs out itself. */
4261 /* If we are linking against a dynamic object, or generating a
4262 shared library, finish up the dynamic linking information. */
4265 Elf_External_Dyn
*dyncon
, *dynconend
;
4267 /* Fix up .dynamic entries. */
4268 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
4269 BFD_ASSERT (o
!= NULL
);
4271 dyncon
= (Elf_External_Dyn
*) o
->contents
;
4272 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
4273 for (; dyncon
< dynconend
; dyncon
++)
4275 Elf_Internal_Dyn dyn
;
4279 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4286 name
= info
->init_function
;
4289 name
= info
->fini_function
;
4292 struct elf_link_hash_entry
*h
;
4294 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4295 false, false, true);
4297 && (h
->root
.type
== bfd_link_hash_defined
4298 || h
->root
.type
== bfd_link_hash_defweak
))
4300 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
4301 o
= h
->root
.u
.def
.section
;
4302 if (o
->output_section
!= NULL
)
4303 dyn
.d_un
.d_val
+= (o
->output_section
->vma
4304 + o
->output_offset
);
4307 /* The symbol is imported from another shared
4308 library and does not apply to this one. */
4312 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4327 name
= ".gnu.version_d";
4330 name
= ".gnu.version_r";
4333 name
= ".gnu.version";
4335 o
= bfd_get_section_by_name (abfd
, name
);
4336 BFD_ASSERT (o
!= NULL
);
4337 dyn
.d_un
.d_ptr
= o
->vma
;
4338 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4345 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
4350 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
4352 Elf_Internal_Shdr
*hdr
;
4354 hdr
= elf_elfsections (abfd
)[i
];
4355 if (hdr
->sh_type
== type
4356 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
4358 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
4359 dyn
.d_un
.d_val
+= hdr
->sh_size
;
4362 if (dyn
.d_un
.d_val
== 0
4363 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
4364 dyn
.d_un
.d_val
= hdr
->sh_addr
;
4368 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4374 /* If we have created any dynamic sections, then output them. */
4377 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
4380 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
4382 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4383 || o
->_raw_size
== 0)
4385 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
4387 /* At this point, we are only interested in sections
4388 created by elf_link_create_dynamic_sections. */
4391 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
4393 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
4395 if (! bfd_set_section_contents (abfd
, o
->output_section
,
4396 o
->contents
, o
->output_offset
,
4404 /* The contents of the .dynstr section are actually in a
4406 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
4407 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4408 || ! _bfd_stringtab_emit (abfd
,
4409 elf_hash_table (info
)->dynstr
))
4415 /* If we have optimized stabs strings, output them. */
4416 if (elf_hash_table (info
)->stab_info
!= NULL
)
4418 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
4422 if (finfo
.symstrtab
!= NULL
)
4423 _bfd_stringtab_free (finfo
.symstrtab
);
4424 if (finfo
.contents
!= NULL
)
4425 free (finfo
.contents
);
4426 if (finfo
.external_relocs
!= NULL
)
4427 free (finfo
.external_relocs
);
4428 if (finfo
.internal_relocs
!= NULL
)
4429 free (finfo
.internal_relocs
);
4430 if (finfo
.external_syms
!= NULL
)
4431 free (finfo
.external_syms
);
4432 if (finfo
.internal_syms
!= NULL
)
4433 free (finfo
.internal_syms
);
4434 if (finfo
.indices
!= NULL
)
4435 free (finfo
.indices
);
4436 if (finfo
.sections
!= NULL
)
4437 free (finfo
.sections
);
4438 if (finfo
.symbuf
!= NULL
)
4439 free (finfo
.symbuf
);
4440 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4442 if ((o
->flags
& SEC_RELOC
) != 0
4443 && elf_section_data (o
)->rel_hashes
!= NULL
)
4444 free (elf_section_data (o
)->rel_hashes
);
4447 elf_tdata (abfd
)->linker
= true;
4452 if (finfo
.symstrtab
!= NULL
)
4453 _bfd_stringtab_free (finfo
.symstrtab
);
4454 if (finfo
.contents
!= NULL
)
4455 free (finfo
.contents
);
4456 if (finfo
.external_relocs
!= NULL
)
4457 free (finfo
.external_relocs
);
4458 if (finfo
.internal_relocs
!= NULL
)
4459 free (finfo
.internal_relocs
);
4460 if (finfo
.external_syms
!= NULL
)
4461 free (finfo
.external_syms
);
4462 if (finfo
.internal_syms
!= NULL
)
4463 free (finfo
.internal_syms
);
4464 if (finfo
.indices
!= NULL
)
4465 free (finfo
.indices
);
4466 if (finfo
.sections
!= NULL
)
4467 free (finfo
.sections
);
4468 if (finfo
.symbuf
!= NULL
)
4469 free (finfo
.symbuf
);
4470 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4472 if ((o
->flags
& SEC_RELOC
) != 0
4473 && elf_section_data (o
)->rel_hashes
!= NULL
)
4474 free (elf_section_data (o
)->rel_hashes
);
4480 /* Add a symbol to the output symbol table. */
4483 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
4484 struct elf_final_link_info
*finfo
;
4486 Elf_Internal_Sym
*elfsym
;
4487 asection
*input_sec
;
4489 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
4490 struct bfd_link_info
*info
,
4495 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
4496 elf_backend_link_output_symbol_hook
;
4497 if (output_symbol_hook
!= NULL
)
4499 if (! ((*output_symbol_hook
)
4500 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
4504 if (name
== (const char *) NULL
|| *name
== '\0')
4505 elfsym
->st_name
= 0;
4506 else if (input_sec
->flags
& SEC_EXCLUDE
)
4507 elfsym
->st_name
= 0;
4510 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
4513 if (elfsym
->st_name
== (unsigned long) -1)
4517 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
4519 if (! elf_link_flush_output_syms (finfo
))
4523 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
4524 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
4525 ++finfo
->symbuf_count
;
4527 ++ bfd_get_symcount (finfo
->output_bfd
);
4532 /* Flush the output symbols to the file. */
4535 elf_link_flush_output_syms (finfo
)
4536 struct elf_final_link_info
*finfo
;
4538 if (finfo
->symbuf_count
> 0)
4540 Elf_Internal_Shdr
*symtab
;
4542 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
4544 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
4546 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
4547 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
4548 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
4551 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
4553 finfo
->symbuf_count
= 0;
4559 /* Add an external symbol to the symbol table. This is called from
4560 the hash table traversal routine. When generating a shared object,
4561 we go through the symbol table twice. The first time we output
4562 anything that might have been forced to local scope in a version
4563 script. The second time we output the symbols that are still
4567 elf_link_output_extsym (h
, data
)
4568 struct elf_link_hash_entry
*h
;
4571 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
4572 struct elf_final_link_info
*finfo
= eoinfo
->finfo
;
4574 Elf_Internal_Sym sym
;
4575 asection
*input_sec
;
4577 /* Decide whether to output this symbol in this pass. */
4578 if (eoinfo
->localsyms
)
4580 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
4585 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4589 /* If we are not creating a shared library, and this symbol is
4590 referenced by a shared library but is not defined anywhere, then
4591 warn that it is undefined. If we do not do this, the runtime
4592 linker will complain that the symbol is undefined when the
4593 program is run. We don't have to worry about symbols that are
4594 referenced by regular files, because we will already have issued
4595 warnings for them. */
4596 if (! finfo
->info
->relocateable
4597 && ! (finfo
->info
->shared
4598 && !finfo
->info
->no_undefined
)
4599 && h
->root
.type
== bfd_link_hash_undefined
4600 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
4601 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4603 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4604 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
4605 (asection
*) NULL
, 0)))
4607 eoinfo
->failed
= true;
4612 /* We don't want to output symbols that have never been mentioned by
4613 a regular file, or that we have been told to strip. However, if
4614 h->indx is set to -2, the symbol is used by a reloc and we must
4618 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4619 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
4620 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
4621 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4623 else if (finfo
->info
->strip
== strip_all
4624 || (finfo
->info
->strip
== strip_some
4625 && bfd_hash_lookup (finfo
->info
->keep_hash
,
4626 h
->root
.root
.string
,
4627 false, false) == NULL
))
4632 /* If we're stripping it, and it's not a dynamic symbol, there's
4633 nothing else to do. */
4634 if (strip
&& h
->dynindx
== -1)
4638 sym
.st_size
= h
->size
;
4639 sym
.st_other
= h
->other
;
4640 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4641 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
4642 else if (h
->root
.type
== bfd_link_hash_undefweak
4643 || h
->root
.type
== bfd_link_hash_defweak
)
4644 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4646 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
4648 switch (h
->root
.type
)
4651 case bfd_link_hash_new
:
4655 case bfd_link_hash_undefined
:
4656 input_sec
= bfd_und_section_ptr
;
4657 sym
.st_shndx
= SHN_UNDEF
;
4660 case bfd_link_hash_undefweak
:
4661 input_sec
= bfd_und_section_ptr
;
4662 sym
.st_shndx
= SHN_UNDEF
;
4665 case bfd_link_hash_defined
:
4666 case bfd_link_hash_defweak
:
4668 input_sec
= h
->root
.u
.def
.section
;
4669 if (input_sec
->output_section
!= NULL
)
4672 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
4673 input_sec
->output_section
);
4674 if (sym
.st_shndx
== (unsigned short) -1)
4676 (*_bfd_error_handler
)
4677 (_("%s: could not find output section %s for input section %s"),
4678 bfd_get_filename (finfo
->output_bfd
),
4679 input_sec
->output_section
->name
,
4681 eoinfo
->failed
= true;
4685 /* ELF symbols in relocateable files are section relative,
4686 but in nonrelocateable files they are virtual
4688 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
4689 if (! finfo
->info
->relocateable
)
4690 sym
.st_value
+= input_sec
->output_section
->vma
;
4694 BFD_ASSERT (input_sec
->owner
== NULL
4695 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
4696 sym
.st_shndx
= SHN_UNDEF
;
4697 input_sec
= bfd_und_section_ptr
;
4702 case bfd_link_hash_common
:
4703 input_sec
= h
->root
.u
.c
.p
->section
;
4704 sym
.st_shndx
= SHN_COMMON
;
4705 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
4708 case bfd_link_hash_indirect
:
4709 /* These symbols are created by symbol versioning. They point
4710 to the decorated version of the name. For example, if the
4711 symbol foo@@GNU_1.2 is the default, which should be used when
4712 foo is used with no version, then we add an indirect symbol
4713 foo which points to foo@@GNU_1.2. We ignore these symbols,
4714 since the indirected symbol is already in the hash table. If
4715 the indirect symbol is non-ELF, fall through and output it. */
4716 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) == 0)
4720 case bfd_link_hash_warning
:
4721 /* We can't represent these symbols in ELF, although a warning
4722 symbol may have come from a .gnu.warning.SYMBOL section. We
4723 just put the target symbol in the hash table. If the target
4724 symbol does not really exist, don't do anything. */
4725 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
4727 return (elf_link_output_extsym
4728 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
4731 /* Give the processor backend a chance to tweak the symbol value,
4732 and also to finish up anything that needs to be done for this
4734 if ((h
->dynindx
!= -1
4735 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4736 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4738 struct elf_backend_data
*bed
;
4740 bed
= get_elf_backend_data (finfo
->output_bfd
);
4741 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
4742 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
4744 eoinfo
->failed
= true;
4749 /* If we are marking the symbol as undefined, and there are no
4750 non-weak references to this symbol from a regular object, then
4751 mark the symbol as weak undefined. We can't do this earlier,
4752 because it might not be marked as undefined until the
4753 finish_dynamic_symbol routine gets through with it. */
4754 if (sym
.st_shndx
== SHN_UNDEF
4755 && sym
.st_info
== ELF_ST_INFO (STB_GLOBAL
, h
->type
)
4756 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
4757 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
) == 0)
4758 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4760 /* If this symbol should be put in the .dynsym section, then put it
4761 there now. We have already know the symbol index. We also fill
4762 in the entry in the .hash section. */
4763 if (h
->dynindx
!= -1
4764 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4768 size_t hash_entry_size
;
4769 bfd_byte
*bucketpos
;
4772 sym
.st_name
= h
->dynstr_index
;
4774 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
4775 (PTR
) (((Elf_External_Sym
*)
4776 finfo
->dynsym_sec
->contents
)
4779 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
4780 bucket
= h
->elf_hash_value
% bucketcount
;
4782 = elf_section_data (finfo
->hash_sec
)->this_hdr
.sh_entsize
;
4783 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
4784 + (bucket
+ 2) * hash_entry_size
);
4785 chain
= bfd_get (8 * hash_entry_size
, finfo
->output_bfd
, bucketpos
);
4786 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, h
->dynindx
, bucketpos
);
4787 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, chain
,
4788 ((bfd_byte
*) finfo
->hash_sec
->contents
4789 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
4791 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
4793 Elf_Internal_Versym iversym
;
4795 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4797 if (h
->verinfo
.verdef
== NULL
)
4798 iversym
.vs_vers
= 0;
4800 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
4804 if (h
->verinfo
.vertree
== NULL
)
4805 iversym
.vs_vers
= 1;
4807 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
4810 if ((h
->elf_link_hash_flags
& ELF_LINK_HIDDEN
) != 0)
4811 iversym
.vs_vers
|= VERSYM_HIDDEN
;
4813 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
,
4814 (((Elf_External_Versym
*)
4815 finfo
->symver_sec
->contents
)
4820 /* If we're stripping it, then it was just a dynamic symbol, and
4821 there's nothing else to do. */
4825 h
->indx
= bfd_get_symcount (finfo
->output_bfd
);
4827 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
4829 eoinfo
->failed
= true;
4836 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
4837 originated from the section given by INPUT_REL_HDR) to the
4841 elf_link_output_relocs (output_bfd
, input_section
, input_rel_hdr
,
4844 asection
*input_section
;
4845 Elf_Internal_Shdr
*input_rel_hdr
;
4846 Elf_Internal_Rela
*internal_relocs
;
4848 Elf_Internal_Rela
*irela
;
4849 Elf_Internal_Rela
*irelaend
;
4850 Elf_Internal_Shdr
*output_rel_hdr
;
4851 asection
*output_section
;
4852 unsigned int *rel_countp
;
4854 output_section
= input_section
->output_section
;
4855 output_rel_hdr
= NULL
;
4857 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
4858 == input_rel_hdr
->sh_entsize
)
4860 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
4861 rel_countp
= &elf_section_data (output_section
)->rel_count
;
4863 else if (elf_section_data (output_section
)->rel_hdr2
4864 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
4865 == input_rel_hdr
->sh_entsize
))
4867 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
4868 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
4871 BFD_ASSERT (output_rel_hdr
!= NULL
);
4873 irela
= internal_relocs
;
4874 irelaend
= irela
+ input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
4875 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4877 Elf_External_Rel
*erel
;
4879 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
+ *rel_countp
);
4880 for (; irela
< irelaend
; irela
++, erel
++)
4882 Elf_Internal_Rel irel
;
4884 irel
.r_offset
= irela
->r_offset
;
4885 irel
.r_info
= irela
->r_info
;
4886 BFD_ASSERT (irela
->r_addend
== 0);
4887 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
4892 Elf_External_Rela
*erela
;
4894 BFD_ASSERT (input_rel_hdr
->sh_entsize
4895 == sizeof (Elf_External_Rela
));
4896 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
+ *rel_countp
);
4897 for (; irela
< irelaend
; irela
++, erela
++)
4898 elf_swap_reloca_out (output_bfd
, irela
, erela
);
4901 /* Bump the counter, so that we know where to add the next set of
4903 *rel_countp
+= input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
4906 /* Link an input file into the linker output file. This function
4907 handles all the sections and relocations of the input file at once.
4908 This is so that we only have to read the local symbols once, and
4909 don't have to keep them in memory. */
4912 elf_link_input_bfd (finfo
, input_bfd
)
4913 struct elf_final_link_info
*finfo
;
4916 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
4917 bfd
*, asection
*, bfd_byte
*,
4918 Elf_Internal_Rela
*,
4919 Elf_Internal_Sym
*, asection
**));
4921 Elf_Internal_Shdr
*symtab_hdr
;
4924 Elf_External_Sym
*external_syms
;
4925 Elf_External_Sym
*esym
;
4926 Elf_External_Sym
*esymend
;
4927 Elf_Internal_Sym
*isym
;
4929 asection
**ppsection
;
4931 struct elf_backend_data
*bed
;
4933 output_bfd
= finfo
->output_bfd
;
4934 bed
= get_elf_backend_data (output_bfd
);
4935 relocate_section
= bed
->elf_backend_relocate_section
;
4937 /* If this is a dynamic object, we don't want to do anything here:
4938 we don't want the local symbols, and we don't want the section
4940 if ((input_bfd
->flags
& DYNAMIC
) != 0)
4943 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4944 if (elf_bad_symtab (input_bfd
))
4946 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4951 locsymcount
= symtab_hdr
->sh_info
;
4952 extsymoff
= symtab_hdr
->sh_info
;
4955 /* Read the local symbols. */
4956 if (symtab_hdr
->contents
!= NULL
)
4957 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
4958 else if (locsymcount
== 0)
4959 external_syms
= NULL
;
4962 external_syms
= finfo
->external_syms
;
4963 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
4964 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
4965 locsymcount
, input_bfd
)
4966 != locsymcount
* sizeof (Elf_External_Sym
)))
4970 /* Swap in the local symbols and write out the ones which we know
4971 are going into the output file. */
4972 esym
= external_syms
;
4973 esymend
= esym
+ locsymcount
;
4974 isym
= finfo
->internal_syms
;
4975 pindex
= finfo
->indices
;
4976 ppsection
= finfo
->sections
;
4977 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
4981 Elf_Internal_Sym osym
;
4983 elf_swap_symbol_in (input_bfd
, esym
, isym
);
4986 if (elf_bad_symtab (input_bfd
))
4988 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
4995 if (isym
->st_shndx
== SHN_UNDEF
)
4996 isec
= bfd_und_section_ptr
;
4997 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
4998 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
4999 else if (isym
->st_shndx
== SHN_ABS
)
5000 isec
= bfd_abs_section_ptr
;
5001 else if (isym
->st_shndx
== SHN_COMMON
)
5002 isec
= bfd_com_section_ptr
;
5011 /* Don't output the first, undefined, symbol. */
5012 if (esym
== external_syms
)
5015 /* If we are stripping all symbols, we don't want to output this
5017 if (finfo
->info
->strip
== strip_all
)
5020 /* We never output section symbols. Instead, we use the section
5021 symbol of the corresponding section in the output file. */
5022 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5025 /* If we are discarding all local symbols, we don't want to
5026 output this one. If we are generating a relocateable output
5027 file, then some of the local symbols may be required by
5028 relocs; we output them below as we discover that they are
5030 if (finfo
->info
->discard
== discard_all
)
5033 /* If this symbol is defined in a section which we are
5034 discarding, we don't need to keep it, but note that
5035 linker_mark is only reliable for sections that have contents.
5036 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
5037 as well as linker_mark. */
5038 if (isym
->st_shndx
> 0
5039 && isym
->st_shndx
< SHN_LORESERVE
5041 && ((! isec
->linker_mark
&& (isec
->flags
& SEC_HAS_CONTENTS
) != 0)
5042 || (! finfo
->info
->relocateable
5043 && (isec
->flags
& SEC_EXCLUDE
) != 0)))
5046 /* Get the name of the symbol. */
5047 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5052 /* See if we are discarding symbols with this name. */
5053 if ((finfo
->info
->strip
== strip_some
5054 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5056 || (finfo
->info
->discard
== discard_l
5057 && bfd_is_local_label_name (input_bfd
, name
)))
5060 /* If we get here, we are going to output this symbol. */
5064 /* Adjust the section index for the output file. */
5065 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
5066 isec
->output_section
);
5067 if (osym
.st_shndx
== (unsigned short) -1)
5070 *pindex
= bfd_get_symcount (output_bfd
);
5072 /* ELF symbols in relocateable files are section relative, but
5073 in executable files they are virtual addresses. Note that
5074 this code assumes that all ELF sections have an associated
5075 BFD section with a reasonable value for output_offset; below
5076 we assume that they also have a reasonable value for
5077 output_section. Any special sections must be set up to meet
5078 these requirements. */
5079 osym
.st_value
+= isec
->output_offset
;
5080 if (! finfo
->info
->relocateable
)
5081 osym
.st_value
+= isec
->output_section
->vma
;
5083 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
5087 /* Relocate the contents of each section. */
5088 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5092 if (! o
->linker_mark
)
5094 /* This section was omitted from the link. */
5098 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5099 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
5102 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
5104 /* Section was created by elf_link_create_dynamic_sections
5109 /* Get the contents of the section. They have been cached by a
5110 relaxation routine. Note that o is a section in an input
5111 file, so the contents field will not have been set by any of
5112 the routines which work on output files. */
5113 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
5114 contents
= elf_section_data (o
)->this_hdr
.contents
;
5117 contents
= finfo
->contents
;
5118 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
5119 (file_ptr
) 0, o
->_raw_size
))
5123 if ((o
->flags
& SEC_RELOC
) != 0)
5125 Elf_Internal_Rela
*internal_relocs
;
5127 /* Get the swapped relocs. */
5128 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
5129 (input_bfd
, o
, finfo
->external_relocs
,
5130 finfo
->internal_relocs
, false));
5131 if (internal_relocs
== NULL
5132 && o
->reloc_count
> 0)
5135 /* Relocate the section by invoking a back end routine.
5137 The back end routine is responsible for adjusting the
5138 section contents as necessary, and (if using Rela relocs
5139 and generating a relocateable output file) adjusting the
5140 reloc addend as necessary.
5142 The back end routine does not have to worry about setting
5143 the reloc address or the reloc symbol index.
5145 The back end routine is given a pointer to the swapped in
5146 internal symbols, and can access the hash table entries
5147 for the external symbols via elf_sym_hashes (input_bfd).
5149 When generating relocateable output, the back end routine
5150 must handle STB_LOCAL/STT_SECTION symbols specially. The
5151 output symbol is going to be a section symbol
5152 corresponding to the output section, which will require
5153 the addend to be adjusted. */
5155 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
5156 input_bfd
, o
, contents
,
5158 finfo
->internal_syms
,
5162 if (finfo
->info
->relocateable
)
5164 Elf_Internal_Rela
*irela
;
5165 Elf_Internal_Rela
*irelaend
;
5166 struct elf_link_hash_entry
**rel_hash
;
5167 Elf_Internal_Shdr
*input_rel_hdr
;
5169 /* Adjust the reloc addresses and symbol indices. */
5171 irela
= internal_relocs
;
5173 irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5174 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
5175 + elf_section_data (o
->output_section
)->rel_count
);
5176 for (; irela
< irelaend
; irela
++, rel_hash
++)
5178 unsigned long r_symndx
;
5179 Elf_Internal_Sym
*isym
;
5182 irela
->r_offset
+= o
->output_offset
;
5184 r_symndx
= ELF_R_SYM (irela
->r_info
);
5189 if (r_symndx
>= locsymcount
5190 || (elf_bad_symtab (input_bfd
)
5191 && finfo
->sections
[r_symndx
] == NULL
))
5193 struct elf_link_hash_entry
*rh
;
5196 /* This is a reloc against a global symbol. We
5197 have not yet output all the local symbols, so
5198 we do not know the symbol index of any global
5199 symbol. We set the rel_hash entry for this
5200 reloc to point to the global hash table entry
5201 for this symbol. The symbol index is then
5202 set at the end of elf_bfd_final_link. */
5203 indx
= r_symndx
- extsymoff
;
5204 rh
= elf_sym_hashes (input_bfd
)[indx
];
5205 while (rh
->root
.type
== bfd_link_hash_indirect
5206 || rh
->root
.type
== bfd_link_hash_warning
)
5207 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
5209 /* Setting the index to -2 tells
5210 elf_link_output_extsym that this symbol is
5212 BFD_ASSERT (rh
->indx
< 0);
5220 /* This is a reloc against a local symbol. */
5223 isym
= finfo
->internal_syms
+ r_symndx
;
5224 sec
= finfo
->sections
[r_symndx
];
5225 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5227 /* I suppose the backend ought to fill in the
5228 section of any STT_SECTION symbol against a
5229 processor specific section. If we have
5230 discarded a section, the output_section will
5231 be the absolute section. */
5233 && (bfd_is_abs_section (sec
)
5234 || (sec
->output_section
!= NULL
5235 && bfd_is_abs_section (sec
->output_section
))))
5237 else if (sec
== NULL
|| sec
->owner
== NULL
)
5239 bfd_set_error (bfd_error_bad_value
);
5244 r_symndx
= sec
->output_section
->target_index
;
5245 BFD_ASSERT (r_symndx
!= 0);
5250 if (finfo
->indices
[r_symndx
] == -1)
5256 if (finfo
->info
->strip
== strip_all
)
5258 /* You can't do ld -r -s. */
5259 bfd_set_error (bfd_error_invalid_operation
);
5263 /* This symbol was skipped earlier, but
5264 since it is needed by a reloc, we
5265 must output it now. */
5266 link
= symtab_hdr
->sh_link
;
5267 name
= bfd_elf_string_from_elf_section (input_bfd
,
5273 osec
= sec
->output_section
;
5275 _bfd_elf_section_from_bfd_section (output_bfd
,
5277 if (isym
->st_shndx
== (unsigned short) -1)
5280 isym
->st_value
+= sec
->output_offset
;
5281 if (! finfo
->info
->relocateable
)
5282 isym
->st_value
+= osec
->vma
;
5284 finfo
->indices
[r_symndx
] = bfd_get_symcount (output_bfd
);
5286 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
5290 r_symndx
= finfo
->indices
[r_symndx
];
5293 irela
->r_info
= ELF_R_INFO (r_symndx
,
5294 ELF_R_TYPE (irela
->r_info
));
5297 /* Swap out the relocs. */
5298 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5299 elf_link_output_relocs (output_bfd
, o
,
5303 += input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
5304 input_rel_hdr
= elf_section_data (o
)->rel_hdr2
;
5306 elf_link_output_relocs (output_bfd
, o
,
5312 /* Write out the modified section contents. */
5313 if (elf_section_data (o
)->stab_info
== NULL
)
5315 if (! (o
->flags
& SEC_EXCLUDE
) &&
5316 ! bfd_set_section_contents (output_bfd
, o
->output_section
,
5317 contents
, o
->output_offset
,
5318 (o
->_cooked_size
!= 0
5325 if (! (_bfd_write_section_stabs
5326 (output_bfd
, &elf_hash_table (finfo
->info
)->stab_info
,
5327 o
, &elf_section_data (o
)->stab_info
, contents
)))
5335 /* Generate a reloc when linking an ELF file. This is a reloc
5336 requested by the linker, and does come from any input file. This
5337 is used to build constructor and destructor tables when linking
5341 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
5343 struct bfd_link_info
*info
;
5344 asection
*output_section
;
5345 struct bfd_link_order
*link_order
;
5347 reloc_howto_type
*howto
;
5351 struct elf_link_hash_entry
**rel_hash_ptr
;
5352 Elf_Internal_Shdr
*rel_hdr
;
5354 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5357 bfd_set_error (bfd_error_bad_value
);
5361 addend
= link_order
->u
.reloc
.p
->addend
;
5363 /* Figure out the symbol index. */
5364 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
5365 + elf_section_data (output_section
)->rel_count
);
5366 if (link_order
->type
== bfd_section_reloc_link_order
)
5368 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
5369 BFD_ASSERT (indx
!= 0);
5370 *rel_hash_ptr
= NULL
;
5374 struct elf_link_hash_entry
*h
;
5376 /* Treat a reloc against a defined symbol as though it were
5377 actually against the section. */
5378 h
= ((struct elf_link_hash_entry
*)
5379 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
5380 link_order
->u
.reloc
.p
->u
.name
,
5381 false, false, true));
5383 && (h
->root
.type
== bfd_link_hash_defined
5384 || h
->root
.type
== bfd_link_hash_defweak
))
5388 section
= h
->root
.u
.def
.section
;
5389 indx
= section
->output_section
->target_index
;
5390 *rel_hash_ptr
= NULL
;
5391 /* It seems that we ought to add the symbol value to the
5392 addend here, but in practice it has already been added
5393 because it was passed to constructor_callback. */
5394 addend
+= section
->output_section
->vma
+ section
->output_offset
;
5398 /* Setting the index to -2 tells elf_link_output_extsym that
5399 this symbol is used by a reloc. */
5406 if (! ((*info
->callbacks
->unattached_reloc
)
5407 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5408 (asection
*) NULL
, (bfd_vma
) 0)))
5414 /* If this is an inplace reloc, we must write the addend into the
5416 if (howto
->partial_inplace
&& addend
!= 0)
5419 bfd_reloc_status_type rstat
;
5423 size
= bfd_get_reloc_size (howto
);
5424 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5425 if (buf
== (bfd_byte
*) NULL
)
5427 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5433 case bfd_reloc_outofrange
:
5435 case bfd_reloc_overflow
:
5436 if (! ((*info
->callbacks
->reloc_overflow
)
5438 (link_order
->type
== bfd_section_reloc_link_order
5439 ? bfd_section_name (output_bfd
,
5440 link_order
->u
.reloc
.p
->u
.section
)
5441 : link_order
->u
.reloc
.p
->u
.name
),
5442 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
5450 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
5451 (file_ptr
) link_order
->offset
, size
);
5457 /* The address of a reloc is relative to the section in a
5458 relocateable file, and is a virtual address in an executable
5460 offset
= link_order
->offset
;
5461 if (! info
->relocateable
)
5462 offset
+= output_section
->vma
;
5464 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
5466 if (rel_hdr
->sh_type
== SHT_REL
)
5468 Elf_Internal_Rel irel
;
5469 Elf_External_Rel
*erel
;
5471 irel
.r_offset
= offset
;
5472 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5473 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
5474 + elf_section_data (output_section
)->rel_count
);
5475 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
5479 Elf_Internal_Rela irela
;
5480 Elf_External_Rela
*erela
;
5482 irela
.r_offset
= offset
;
5483 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5484 irela
.r_addend
= addend
;
5485 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
5486 + elf_section_data (output_section
)->rel_count
);
5487 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
5490 ++elf_section_data (output_section
)->rel_count
;
5496 /* Allocate a pointer to live in a linker created section. */
5499 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
5501 struct bfd_link_info
*info
;
5502 elf_linker_section_t
*lsect
;
5503 struct elf_link_hash_entry
*h
;
5504 const Elf_Internal_Rela
*rel
;
5506 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
5507 elf_linker_section_pointers_t
*linker_section_ptr
;
5508 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
5510 BFD_ASSERT (lsect
!= NULL
);
5512 /* Is this a global symbol? */
5515 /* Has this symbol already been allocated, if so, our work is done */
5516 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5521 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
5522 /* Make sure this symbol is output as a dynamic symbol. */
5523 if (h
->dynindx
== -1)
5525 if (! elf_link_record_dynamic_symbol (info
, h
))
5529 if (lsect
->rel_section
)
5530 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5533 else /* Allocation of a pointer to a local symbol */
5535 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
5537 /* Allocate a table to hold the local symbols if first time */
5540 unsigned int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
5541 register unsigned int i
;
5543 ptr
= (elf_linker_section_pointers_t
**)
5544 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
5549 elf_local_ptr_offsets (abfd
) = ptr
;
5550 for (i
= 0; i
< num_symbols
; i
++)
5551 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
5554 /* Has this symbol already been allocated, if so, our work is done */
5555 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
5560 ptr_linker_section_ptr
= &ptr
[r_symndx
];
5564 /* If we are generating a shared object, we need to
5565 output a R_<xxx>_RELATIVE reloc so that the
5566 dynamic linker can adjust this GOT entry. */
5567 BFD_ASSERT (lsect
->rel_section
!= NULL
);
5568 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5572 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
5573 from internal memory. */
5574 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
5575 linker_section_ptr
= (elf_linker_section_pointers_t
*)
5576 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
5578 if (!linker_section_ptr
)
5581 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
5582 linker_section_ptr
->addend
= rel
->r_addend
;
5583 linker_section_ptr
->which
= lsect
->which
;
5584 linker_section_ptr
->written_address_p
= false;
5585 *ptr_linker_section_ptr
= linker_section_ptr
;
5588 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
5590 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
5591 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
5592 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
5593 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
5595 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
5597 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
5598 lsect
->sym_hash
->root
.root
.string
,
5599 (long)ARCH_SIZE
/ 8,
5600 (long)lsect
->sym_hash
->root
.u
.def
.value
);
5606 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
5608 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
5611 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
5612 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
5620 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
5623 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
5626 /* Fill in the address for a pointer generated in alinker section. */
5629 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
5632 struct bfd_link_info
*info
;
5633 elf_linker_section_t
*lsect
;
5634 struct elf_link_hash_entry
*h
;
5636 const Elf_Internal_Rela
*rel
;
5639 elf_linker_section_pointers_t
*linker_section_ptr
;
5641 BFD_ASSERT (lsect
!= NULL
);
5643 if (h
!= NULL
) /* global symbol */
5645 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5649 BFD_ASSERT (linker_section_ptr
!= NULL
);
5651 if (! elf_hash_table (info
)->dynamic_sections_created
5654 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
5656 /* This is actually a static link, or it is a
5657 -Bsymbolic link and the symbol is defined
5658 locally. We must initialize this entry in the
5661 When doing a dynamic link, we create a .rela.<xxx>
5662 relocation entry to initialize the value. This
5663 is done in the finish_dynamic_symbol routine. */
5664 if (!linker_section_ptr
->written_address_p
)
5666 linker_section_ptr
->written_address_p
= true;
5667 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5668 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5672 else /* local symbol */
5674 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
5675 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
5676 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
5677 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
5681 BFD_ASSERT (linker_section_ptr
!= NULL
);
5683 /* Write out pointer if it hasn't been rewritten out before */
5684 if (!linker_section_ptr
->written_address_p
)
5686 linker_section_ptr
->written_address_p
= true;
5687 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5688 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5692 asection
*srel
= lsect
->rel_section
;
5693 Elf_Internal_Rela outrel
;
5695 /* We need to generate a relative reloc for the dynamic linker. */
5697 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
5700 BFD_ASSERT (srel
!= NULL
);
5702 outrel
.r_offset
= (lsect
->section
->output_section
->vma
5703 + lsect
->section
->output_offset
5704 + linker_section_ptr
->offset
);
5705 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
5706 outrel
.r_addend
= 0;
5707 elf_swap_reloca_out (output_bfd
, &outrel
,
5708 (((Elf_External_Rela
*)
5709 lsect
->section
->contents
)
5710 + elf_section_data (lsect
->section
)->rel_count
));
5711 ++elf_section_data (lsect
->section
)->rel_count
;
5716 relocation
= (lsect
->section
->output_offset
5717 + linker_section_ptr
->offset
5718 - lsect
->hole_offset
5719 - lsect
->sym_offset
);
5722 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
5723 lsect
->name
, (long)relocation
, (long)relocation
);
5726 /* Subtract out the addend, because it will get added back in by the normal
5728 return relocation
- linker_section_ptr
->addend
;
5731 /* Garbage collect unused sections. */
5733 static boolean elf_gc_mark
5734 PARAMS ((struct bfd_link_info
*info
, asection
*sec
,
5735 asection
* (*gc_mark_hook
)
5736 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5737 struct elf_link_hash_entry
*, Elf_Internal_Sym
*))));
5739 static boolean elf_gc_sweep
5740 PARAMS ((struct bfd_link_info
*info
,
5741 boolean (*gc_sweep_hook
)
5742 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5743 const Elf_Internal_Rela
*relocs
))));
5745 static boolean elf_gc_sweep_symbol
5746 PARAMS ((struct elf_link_hash_entry
*h
, PTR idxptr
));
5748 static boolean elf_gc_allocate_got_offsets
5749 PARAMS ((struct elf_link_hash_entry
*h
, PTR offarg
));
5751 static boolean elf_gc_propagate_vtable_entries_used
5752 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5754 static boolean elf_gc_smash_unused_vtentry_relocs
5755 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5757 /* The mark phase of garbage collection. For a given section, mark
5758 it, and all the sections which define symbols to which it refers. */
5761 elf_gc_mark (info
, sec
, gc_mark_hook
)
5762 struct bfd_link_info
*info
;
5764 asection
* (*gc_mark_hook
)
5765 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5766 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
5772 /* Look through the section relocs. */
5774 if ((sec
->flags
& SEC_RELOC
) != 0 && sec
->reloc_count
> 0)
5776 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
5777 Elf_Internal_Shdr
*symtab_hdr
;
5778 struct elf_link_hash_entry
**sym_hashes
;
5781 Elf_External_Sym
*locsyms
, *freesyms
= NULL
;
5782 bfd
*input_bfd
= sec
->owner
;
5783 struct elf_backend_data
*bed
= get_elf_backend_data (input_bfd
);
5785 /* GCFIXME: how to arrange so that relocs and symbols are not
5786 reread continually? */
5788 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5789 sym_hashes
= elf_sym_hashes (input_bfd
);
5791 /* Read the local symbols. */
5792 if (elf_bad_symtab (input_bfd
))
5794 nlocsyms
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5798 extsymoff
= nlocsyms
= symtab_hdr
->sh_info
;
5799 if (symtab_hdr
->contents
)
5800 locsyms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
5801 else if (nlocsyms
== 0)
5805 locsyms
= freesyms
=
5806 bfd_malloc (nlocsyms
* sizeof (Elf_External_Sym
));
5807 if (freesyms
== NULL
5808 || bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5809 || (bfd_read (locsyms
, sizeof (Elf_External_Sym
),
5810 nlocsyms
, input_bfd
)
5811 != nlocsyms
* sizeof (Elf_External_Sym
)))
5818 /* Read the relocations. */
5819 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
5820 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5821 info
->keep_memory
));
5822 if (relstart
== NULL
)
5827 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5829 for (rel
= relstart
; rel
< relend
; rel
++)
5831 unsigned long r_symndx
;
5833 struct elf_link_hash_entry
*h
;
5836 r_symndx
= ELF_R_SYM (rel
->r_info
);
5840 if (elf_bad_symtab (sec
->owner
))
5842 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5843 if (ELF_ST_BIND (s
.st_info
) == STB_LOCAL
)
5844 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5847 h
= sym_hashes
[r_symndx
- extsymoff
];
5848 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5851 else if (r_symndx
>= nlocsyms
)
5853 h
= sym_hashes
[r_symndx
- extsymoff
];
5854 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5858 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5859 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5862 if (rsec
&& !rsec
->gc_mark
)
5863 if (!elf_gc_mark (info
, rsec
, gc_mark_hook
))
5871 if (!info
->keep_memory
)
5881 /* The sweep phase of garbage collection. Remove all garbage sections. */
5884 elf_gc_sweep (info
, gc_sweep_hook
)
5885 struct bfd_link_info
*info
;
5886 boolean (*gc_sweep_hook
)
5887 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5888 const Elf_Internal_Rela
*relocs
));
5892 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5896 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5898 /* Keep special sections. Keep .debug sections. */
5899 if ((o
->flags
& SEC_LINKER_CREATED
)
5900 || (o
->flags
& SEC_DEBUGGING
))
5906 /* Skip sweeping sections already excluded. */
5907 if (o
->flags
& SEC_EXCLUDE
)
5910 /* Since this is early in the link process, it is simple
5911 to remove a section from the output. */
5912 o
->flags
|= SEC_EXCLUDE
;
5914 /* But we also have to update some of the relocation
5915 info we collected before. */
5917 && (o
->flags
& SEC_RELOC
) && o
->reloc_count
> 0)
5919 Elf_Internal_Rela
*internal_relocs
;
5922 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
5923 (o
->owner
, o
, NULL
, NULL
, info
->keep_memory
));
5924 if (internal_relocs
== NULL
)
5927 r
= (*gc_sweep_hook
)(o
->owner
, info
, o
, internal_relocs
);
5929 if (!info
->keep_memory
)
5930 free (internal_relocs
);
5938 /* Remove the symbols that were in the swept sections from the dynamic
5939 symbol table. GCFIXME: Anyone know how to get them out of the
5940 static symbol table as well? */
5944 elf_link_hash_traverse (elf_hash_table (info
),
5945 elf_gc_sweep_symbol
,
5948 elf_hash_table (info
)->dynsymcount
= i
;
5954 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
5957 elf_gc_sweep_symbol (h
, idxptr
)
5958 struct elf_link_hash_entry
*h
;
5961 int *idx
= (int *) idxptr
;
5963 if (h
->dynindx
!= -1
5964 && ((h
->root
.type
!= bfd_link_hash_defined
5965 && h
->root
.type
!= bfd_link_hash_defweak
)
5966 || h
->root
.u
.def
.section
->gc_mark
))
5967 h
->dynindx
= (*idx
)++;
5972 /* Propogate collected vtable information. This is called through
5973 elf_link_hash_traverse. */
5976 elf_gc_propagate_vtable_entries_used (h
, okp
)
5977 struct elf_link_hash_entry
*h
;
5980 /* Those that are not vtables. */
5981 if (h
->vtable_parent
== NULL
)
5984 /* Those vtables that do not have parents, we cannot merge. */
5985 if (h
->vtable_parent
== (struct elf_link_hash_entry
*) -1)
5988 /* If we've already been done, exit. */
5989 if (h
->vtable_entries_used
&& h
->vtable_entries_used
[-1])
5992 /* Make sure the parent's table is up to date. */
5993 elf_gc_propagate_vtable_entries_used (h
->vtable_parent
, okp
);
5995 if (h
->vtable_entries_used
== NULL
)
5997 /* None of this table's entries were referenced. Re-use the
5999 h
->vtable_entries_used
= h
->vtable_parent
->vtable_entries_used
;
6000 h
->vtable_entries_size
= h
->vtable_parent
->vtable_entries_size
;
6007 /* Or the parent's entries into ours. */
6008 cu
= h
->vtable_entries_used
;
6010 pu
= h
->vtable_parent
->vtable_entries_used
;
6013 n
= h
->vtable_parent
->vtable_entries_size
/ FILE_ALIGN
;
6016 if (*pu
) *cu
= true;
6026 elf_gc_smash_unused_vtentry_relocs (h
, okp
)
6027 struct elf_link_hash_entry
*h
;
6031 bfd_vma hstart
, hend
;
6032 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
6033 struct elf_backend_data
*bed
;
6035 /* Take care of both those symbols that do not describe vtables as
6036 well as those that are not loaded. */
6037 if (h
->vtable_parent
== NULL
)
6040 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
6041 || h
->root
.type
== bfd_link_hash_defweak
);
6043 sec
= h
->root
.u
.def
.section
;
6044 hstart
= h
->root
.u
.def
.value
;
6045 hend
= hstart
+ h
->size
;
6047 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
6048 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
, true));
6050 return *(boolean
*)okp
= false;
6051 bed
= get_elf_backend_data (sec
->owner
);
6052 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6054 for (rel
= relstart
; rel
< relend
; ++rel
)
6055 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
6057 /* If the entry is in use, do nothing. */
6058 if (h
->vtable_entries_used
6059 && (rel
->r_offset
- hstart
) < h
->vtable_entries_size
)
6061 bfd_vma entry
= (rel
->r_offset
- hstart
) / FILE_ALIGN
;
6062 if (h
->vtable_entries_used
[entry
])
6065 /* Otherwise, kill it. */
6066 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
6072 /* Do mark and sweep of unused sections. */
6075 elf_gc_sections (abfd
, info
)
6077 struct bfd_link_info
*info
;
6081 asection
* (*gc_mark_hook
)
6082 PARAMS ((bfd
*abfd
, struct bfd_link_info
*, Elf_Internal_Rela
*,
6083 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*));
6085 if (!get_elf_backend_data (abfd
)->can_gc_sections
6086 || info
->relocateable
6087 || elf_hash_table (info
)->dynamic_sections_created
)
6090 /* Apply transitive closure to the vtable entry usage info. */
6091 elf_link_hash_traverse (elf_hash_table (info
),
6092 elf_gc_propagate_vtable_entries_used
,
6097 /* Kill the vtable relocations that were not used. */
6098 elf_link_hash_traverse (elf_hash_table (info
),
6099 elf_gc_smash_unused_vtentry_relocs
,
6104 /* Grovel through relocs to find out who stays ... */
6106 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
6107 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
6110 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
6112 if (o
->flags
& SEC_KEEP
)
6113 if (!elf_gc_mark (info
, o
, gc_mark_hook
))
6118 /* ... and mark SEC_EXCLUDE for those that go. */
6119 if (!elf_gc_sweep(info
, get_elf_backend_data (abfd
)->gc_sweep_hook
))
6125 /* Called from check_relocs to record the existance of a VTINHERIT reloc. */
6128 elf_gc_record_vtinherit (abfd
, sec
, h
, offset
)
6131 struct elf_link_hash_entry
*h
;
6134 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
6135 struct elf_link_hash_entry
**search
, *child
;
6136 bfd_size_type extsymcount
;
6138 /* The sh_info field of the symtab header tells us where the
6139 external symbols start. We don't care about the local symbols at
6141 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/sizeof (Elf_External_Sym
);
6142 if (!elf_bad_symtab (abfd
))
6143 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
6145 sym_hashes
= elf_sym_hashes (abfd
);
6146 sym_hashes_end
= sym_hashes
+ extsymcount
;
6148 /* Hunt down the child symbol, which is in this section at the same
6149 offset as the relocation. */
6150 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
6152 if ((child
= *search
) != NULL
6153 && (child
->root
.type
== bfd_link_hash_defined
6154 || child
->root
.type
== bfd_link_hash_defweak
)
6155 && child
->root
.u
.def
.section
== sec
6156 && child
->root
.u
.def
.value
== offset
)
6160 (*_bfd_error_handler
) ("%s: %s+%lu: No symbol found for INHERIT",
6161 bfd_get_filename (abfd
), sec
->name
,
6162 (unsigned long)offset
);
6163 bfd_set_error (bfd_error_invalid_operation
);
6169 /* This *should* only be the absolute section. It could potentially
6170 be that someone has defined a non-global vtable though, which
6171 would be bad. It isn't worth paging in the local symbols to be
6172 sure though; that case should simply be handled by the assembler. */
6174 child
->vtable_parent
= (struct elf_link_hash_entry
*) -1;
6177 child
->vtable_parent
= h
;
6182 /* Called from check_relocs to record the existance of a VTENTRY reloc. */
6185 elf_gc_record_vtentry (abfd
, sec
, h
, addend
)
6188 struct elf_link_hash_entry
*h
;
6191 if (addend
>= h
->vtable_entries_size
)
6194 boolean
*ptr
= h
->vtable_entries_used
;
6196 /* While the symbol is undefined, we have to be prepared to handle
6198 if (h
->root
.type
== bfd_link_hash_undefined
)
6205 /* Oops! We've got a reference past the defined end of
6206 the table. This is probably a bug -- shall we warn? */
6211 /* Allocate one extra entry for use as a "done" flag for the
6212 consolidation pass. */
6213 bytes
= (size
/ FILE_ALIGN
+ 1) * sizeof(boolean
);
6219 ptr
= realloc (ptr
-1, bytes
);
6223 oldbytes
= (h
->vtable_entries_size
/FILE_ALIGN
+ 1) * sizeof(boolean
);
6224 memset (ptr
+ oldbytes
, 0, bytes
- oldbytes
);
6228 ptr
= calloc (1, bytes
);
6233 /* And arrange for that done flag to be at index -1. */
6234 h
->vtable_entries_used
= ptr
+1;
6235 h
->vtable_entries_size
= size
;
6237 h
->vtable_entries_used
[addend
/ FILE_ALIGN
] = true;
6242 /* And an accompanying bit to work out final got entry offsets once
6243 we're done. Should be called from final_link. */
6246 elf_gc_common_finalize_got_offsets (abfd
, info
)
6248 struct bfd_link_info
*info
;
6251 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6254 /* The GOT offset is relative to the .got section, but the GOT header is
6255 put into the .got.plt section, if the backend uses it. */
6256 if (bed
->want_got_plt
)
6259 gotoff
= bed
->got_header_size
;
6261 /* Do the local .got entries first. */
6262 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
6264 bfd_signed_vma
*local_got
= elf_local_got_refcounts (i
);
6265 bfd_size_type j
, locsymcount
;
6266 Elf_Internal_Shdr
*symtab_hdr
;
6271 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
6272 if (elf_bad_symtab (i
))
6273 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6275 locsymcount
= symtab_hdr
->sh_info
;
6277 for (j
= 0; j
< locsymcount
; ++j
)
6279 if (local_got
[j
] > 0)
6281 local_got
[j
] = gotoff
;
6282 gotoff
+= ARCH_SIZE
/ 8;
6285 local_got
[j
] = (bfd_vma
) -1;
6289 /* Then the global .got and .plt entries. */
6290 elf_link_hash_traverse (elf_hash_table (info
),
6291 elf_gc_allocate_got_offsets
,
6296 /* We need a special top-level link routine to convert got reference counts
6297 to real got offsets. */
6300 elf_gc_allocate_got_offsets (h
, offarg
)
6301 struct elf_link_hash_entry
*h
;
6304 bfd_vma
*off
= (bfd_vma
*) offarg
;
6306 if (h
->got
.refcount
> 0)
6308 h
->got
.offset
= off
[0];
6309 off
[0] += ARCH_SIZE
/ 8;
6312 h
->got
.offset
= (bfd_vma
) -1;
6317 /* Many folk need no more in the way of final link than this, once
6318 got entry reference counting is enabled. */
6321 elf_gc_common_final_link (abfd
, info
)
6323 struct bfd_link_info
*info
;
6325 if (!elf_gc_common_finalize_got_offsets (abfd
, info
))
6328 /* Invoke the regular ELF backend linker to do all the work. */
6329 return elf_bfd_final_link (abfd
, info
);
6332 /* This function will be called though elf_link_hash_traverse to store
6333 all hash value of the exported symbols in an array. */
6336 elf_collect_hash_codes (h
, data
)
6337 struct elf_link_hash_entry
*h
;
6340 unsigned long **valuep
= (unsigned long **) data
;
6346 /* Ignore indirect symbols. These are added by the versioning code. */
6347 if (h
->dynindx
== -1)
6350 name
= h
->root
.root
.string
;
6351 p
= strchr (name
, ELF_VER_CHR
);
6354 alc
= bfd_malloc (p
- name
+ 1);
6355 memcpy (alc
, name
, p
- name
);
6356 alc
[p
- name
] = '\0';
6360 /* Compute the hash value. */
6361 ha
= bfd_elf_hash (name
);
6363 /* Store the found hash value in the array given as the argument. */
6366 /* And store it in the struct so that we can put it in the hash table
6368 h
->elf_hash_value
= ha
;