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 ((const unsigned char *) soname
);
2804 defaux
.vda_name
= soname_indx
;
2811 name
= output_bfd
->filename
;
2812 def
.vd_hash
= bfd_elf_hash ((const unsigned char *) 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 ((const unsigned char *) 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 ((const unsigned char *)
2998 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2999 a
->vna_nodename
, true, false);
3000 if (indx
== (bfd_size_type
) -1)
3003 if (a
->vna_nextptr
== NULL
)
3006 a
->vna_next
= sizeof (Elf_External_Vernaux
);
3008 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
3009 (Elf_External_Vernaux
*) p
);
3010 p
+= sizeof (Elf_External_Vernaux
);
3014 if (! elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
3015 || ! elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
3018 elf_tdata (output_bfd
)->cverrefs
= crefs
;
3022 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
3024 /* Work out the size of the symbol version section. */
3025 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3026 BFD_ASSERT (s
!= NULL
);
3027 if (dynsymcount
== 0
3028 || (verdefs
== NULL
&& elf_tdata (output_bfd
)->verref
== NULL
))
3030 elf_link_remove_section_and_adjust_dynindices (info
, s
);
3031 /* The DYNSYMCOUNT might have changed if we were going to
3032 output a dynamic symbol table entry for S. */
3033 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
3037 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Versym
);
3038 s
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, s
->_raw_size
);
3039 if (s
->contents
== NULL
)
3042 if (! elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
3046 /* Set the size of the .dynsym and .hash sections. We counted
3047 the number of dynamic symbols in elf_link_add_object_symbols.
3048 We will build the contents of .dynsym and .hash when we build
3049 the final symbol table, because until then we do not know the
3050 correct value to give the symbols. We built the .dynstr
3051 section as we went along in elf_link_add_object_symbols. */
3052 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
3053 BFD_ASSERT (s
!= NULL
);
3054 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
3055 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
3056 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3059 /* The first entry in .dynsym is a dummy symbol. */
3066 elf_swap_symbol_out (output_bfd
, &isym
,
3067 (PTR
) (Elf_External_Sym
*) s
->contents
);
3069 /* Compute the size of the hashing table. As a side effect this
3070 computes the hash values for all the names we export. */
3071 bucketcount
= compute_bucket_count (info
);
3073 s
= bfd_get_section_by_name (dynobj
, ".hash");
3074 BFD_ASSERT (s
!= NULL
);
3075 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
3076 s
->_raw_size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
3077 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
3078 if (s
->contents
== NULL
)
3080 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
3082 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
3083 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
3084 s
->contents
+ hash_entry_size
);
3086 elf_hash_table (info
)->bucketcount
= bucketcount
;
3088 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
3089 BFD_ASSERT (s
!= NULL
);
3090 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
3092 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
3099 /* Fix up the flags for a symbol. This handles various cases which
3100 can only be fixed after all the input files are seen. This is
3101 currently called by both adjust_dynamic_symbol and
3102 assign_sym_version, which is unnecessary but perhaps more robust in
3103 the face of future changes. */
3106 elf_fix_symbol_flags (h
, eif
)
3107 struct elf_link_hash_entry
*h
;
3108 struct elf_info_failed
*eif
;
3110 /* If this symbol was mentioned in a non-ELF file, try to set
3111 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
3112 permit a non-ELF file to correctly refer to a symbol defined in
3113 an ELF dynamic object. */
3114 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
3116 if (h
->root
.type
!= bfd_link_hash_defined
3117 && h
->root
.type
!= bfd_link_hash_defweak
)
3118 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
3119 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
3122 if (h
->root
.u
.def
.section
->owner
!= NULL
3123 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
3124 == bfd_target_elf_flavour
))
3125 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
3126 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
3128 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3131 if (h
->dynindx
== -1
3132 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3133 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0))
3135 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3144 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
3145 was first seen in a non-ELF file. Fortunately, if the symbol
3146 was first seen in an ELF file, we're probably OK unless the
3147 symbol was defined in a non-ELF file. Catch that case here.
3148 FIXME: We're still in trouble if the symbol was first seen in
3149 a dynamic object, and then later in a non-ELF regular object. */
3150 if ((h
->root
.type
== bfd_link_hash_defined
3151 || h
->root
.type
== bfd_link_hash_defweak
)
3152 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3153 && (h
->root
.u
.def
.section
->owner
!= NULL
3154 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
3155 != bfd_target_elf_flavour
)
3156 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
3157 && (h
->elf_link_hash_flags
3158 & ELF_LINK_HASH_DEF_DYNAMIC
) == 0)))
3159 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3162 /* If this is a final link, and the symbol was defined as a common
3163 symbol in a regular object file, and there was no definition in
3164 any dynamic object, then the linker will have allocated space for
3165 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
3166 flag will not have been set. */
3167 if (h
->root
.type
== bfd_link_hash_defined
3168 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3169 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
3170 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3171 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
3172 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3174 /* If -Bsymbolic was used (which means to bind references to global
3175 symbols to the definition within the shared object), and this
3176 symbol was defined in a regular object, then it actually doesn't
3177 need a PLT entry. */
3178 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
3179 && eif
->info
->shared
3180 && eif
->info
->symbolic
3181 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
3183 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3184 h
->plt
.offset
= (bfd_vma
) -1;
3190 /* Make the backend pick a good value for a dynamic symbol. This is
3191 called via elf_link_hash_traverse, and also calls itself
3195 elf_adjust_dynamic_symbol (h
, data
)
3196 struct elf_link_hash_entry
*h
;
3199 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
3201 struct elf_backend_data
*bed
;
3203 /* Ignore indirect symbols. These are added by the versioning code. */
3204 if (h
->root
.type
== bfd_link_hash_indirect
)
3207 /* Fix the symbol flags. */
3208 if (! elf_fix_symbol_flags (h
, eif
))
3211 /* If this symbol does not require a PLT entry, and it is not
3212 defined by a dynamic object, or is not referenced by a regular
3213 object, ignore it. We do have to handle a weak defined symbol,
3214 even if no regular object refers to it, if we decided to add it
3215 to the dynamic symbol table. FIXME: Do we normally need to worry
3216 about symbols which are defined by one dynamic object and
3217 referenced by another one? */
3218 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
3219 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
3220 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3221 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
3222 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
3224 h
->plt
.offset
= (bfd_vma
) -1;
3228 /* If we've already adjusted this symbol, don't do it again. This
3229 can happen via a recursive call. */
3230 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
3233 /* Don't look at this symbol again. Note that we must set this
3234 after checking the above conditions, because we may look at a
3235 symbol once, decide not to do anything, and then get called
3236 recursively later after REF_REGULAR is set below. */
3237 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
3239 /* If this is a weak definition, and we know a real definition, and
3240 the real symbol is not itself defined by a regular object file,
3241 then get a good value for the real definition. We handle the
3242 real symbol first, for the convenience of the backend routine.
3244 Note that there is a confusing case here. If the real definition
3245 is defined by a regular object file, we don't get the real symbol
3246 from the dynamic object, but we do get the weak symbol. If the
3247 processor backend uses a COPY reloc, then if some routine in the
3248 dynamic object changes the real symbol, we will not see that
3249 change in the corresponding weak symbol. This is the way other
3250 ELF linkers work as well, and seems to be a result of the shared
3253 I will clarify this issue. Most SVR4 shared libraries define the
3254 variable _timezone and define timezone as a weak synonym. The
3255 tzset call changes _timezone. If you write
3256 extern int timezone;
3258 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
3259 you might expect that, since timezone is a synonym for _timezone,
3260 the same number will print both times. However, if the processor
3261 backend uses a COPY reloc, then actually timezone will be copied
3262 into your process image, and, since you define _timezone
3263 yourself, _timezone will not. Thus timezone and _timezone will
3264 wind up at different memory locations. The tzset call will set
3265 _timezone, leaving timezone unchanged. */
3267 if (h
->weakdef
!= NULL
)
3269 struct elf_link_hash_entry
*weakdef
;
3271 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
3272 || h
->root
.type
== bfd_link_hash_defweak
);
3273 weakdef
= h
->weakdef
;
3274 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
3275 || weakdef
->root
.type
== bfd_link_hash_defweak
);
3276 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
3277 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
3279 /* This symbol is defined by a regular object file, so we
3280 will not do anything special. Clear weakdef for the
3281 convenience of the processor backend. */
3286 /* There is an implicit reference by a regular object file
3287 via the weak symbol. */
3288 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
3289 if (h
->weakdef
->elf_link_hash_flags
3290 & ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3291 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR_NONWEAK
;
3292 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
3297 /* If a symbol has no type and no size and does not require a PLT
3298 entry, then we are probably about to do the wrong thing here: we
3299 are probably going to create a COPY reloc for an empty object.
3300 This case can arise when a shared object is built with assembly
3301 code, and the assembly code fails to set the symbol type. */
3303 && h
->type
== STT_NOTYPE
3304 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
3305 (*_bfd_error_handler
)
3306 (_("warning: type and size of dynamic symbol `%s' are not defined"),
3307 h
->root
.root
.string
);
3309 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
3310 bed
= get_elf_backend_data (dynobj
);
3311 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
3320 /* This routine is used to export all defined symbols into the dynamic
3321 symbol table. It is called via elf_link_hash_traverse. */
3324 elf_export_symbol (h
, data
)
3325 struct elf_link_hash_entry
*h
;
3328 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
3330 /* Ignore indirect symbols. These are added by the versioning code. */
3331 if (h
->root
.type
== bfd_link_hash_indirect
)
3334 if (h
->dynindx
== -1
3335 && (h
->elf_link_hash_flags
3336 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
3338 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3348 /* Look through the symbols which are defined in other shared
3349 libraries and referenced here. Update the list of version
3350 dependencies. This will be put into the .gnu.version_r section.
3351 This function is called via elf_link_hash_traverse. */
3354 elf_link_find_version_dependencies (h
, data
)
3355 struct elf_link_hash_entry
*h
;
3358 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
3359 Elf_Internal_Verneed
*t
;
3360 Elf_Internal_Vernaux
*a
;
3362 /* We only care about symbols defined in shared objects with version
3364 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3365 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
3367 || h
->verinfo
.verdef
== NULL
)
3370 /* See if we already know about this version. */
3371 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
3373 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
3376 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
3377 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
3383 /* This is a new version. Add it to tree we are building. */
3387 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *t
);
3390 rinfo
->failed
= true;
3394 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
3395 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
3396 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
3399 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *a
);
3401 /* Note that we are copying a string pointer here, and testing it
3402 above. If bfd_elf_string_from_elf_section is ever changed to
3403 discard the string data when low in memory, this will have to be
3405 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
3407 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
3408 a
->vna_nextptr
= t
->vn_auxptr
;
3410 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
3413 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
3420 /* Figure out appropriate versions for all the symbols. We may not
3421 have the version number script until we have read all of the input
3422 files, so until that point we don't know which symbols should be
3423 local. This function is called via elf_link_hash_traverse. */
3426 elf_link_assign_sym_version (h
, data
)
3427 struct elf_link_hash_entry
*h
;
3430 struct elf_assign_sym_version_info
*sinfo
=
3431 (struct elf_assign_sym_version_info
*) data
;
3432 struct bfd_link_info
*info
= sinfo
->info
;
3433 struct elf_info_failed eif
;
3436 /* Fix the symbol flags. */
3439 if (! elf_fix_symbol_flags (h
, &eif
))
3442 sinfo
->failed
= true;
3446 /* We only need version numbers for symbols defined in regular
3448 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3451 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
3452 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3454 struct bfd_elf_version_tree
*t
;
3459 /* There are two consecutive ELF_VER_CHR characters if this is
3460 not a hidden symbol. */
3462 if (*p
== ELF_VER_CHR
)
3468 /* If there is no version string, we can just return out. */
3472 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3476 /* Look for the version. If we find it, it is no longer weak. */
3477 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3479 if (strcmp (t
->name
, p
) == 0)
3483 struct bfd_elf_version_expr
*d
;
3485 len
= p
- h
->root
.root
.string
;
3486 alc
= bfd_alloc (sinfo
->output_bfd
, len
);
3489 strncpy (alc
, h
->root
.root
.string
, len
- 1);
3490 alc
[len
- 1] = '\0';
3491 if (alc
[len
- 2] == ELF_VER_CHR
)
3492 alc
[len
- 2] = '\0';
3494 h
->verinfo
.vertree
= t
;
3498 if (t
->globals
!= NULL
)
3500 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3501 if ((*d
->match
) (d
, alc
))
3505 /* See if there is anything to force this symbol to
3507 if (d
== NULL
&& t
->locals
!= NULL
)
3509 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3511 if ((*d
->match
) (d
, alc
))
3513 if (h
->dynindx
!= -1
3515 && ! sinfo
->export_dynamic
)
3517 sinfo
->removed_dynamic
= true;
3518 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3519 h
->elf_link_hash_flags
&=~
3520 ELF_LINK_HASH_NEEDS_PLT
;
3522 h
->plt
.offset
= (bfd_vma
) -1;
3523 /* FIXME: The name of the symbol has
3524 already been recorded in the dynamic
3525 string table section. */
3533 bfd_release (sinfo
->output_bfd
, alc
);
3538 /* If we are building an application, we need to create a
3539 version node for this version. */
3540 if (t
== NULL
&& ! info
->shared
)
3542 struct bfd_elf_version_tree
**pp
;
3545 /* If we aren't going to export this symbol, we don't need
3546 to worry about it. */
3547 if (h
->dynindx
== -1)
3550 t
= ((struct bfd_elf_version_tree
*)
3551 bfd_alloc (sinfo
->output_bfd
, sizeof *t
));
3554 sinfo
->failed
= true;
3563 t
->name_indx
= (unsigned int) -1;
3567 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3569 t
->vernum
= version_index
;
3573 h
->verinfo
.vertree
= t
;
3577 /* We could not find the version for a symbol when
3578 generating a shared archive. Return an error. */
3579 (*_bfd_error_handler
)
3580 (_("%s: undefined versioned symbol name %s"),
3581 bfd_get_filename (sinfo
->output_bfd
), h
->root
.root
.string
);
3582 bfd_set_error (bfd_error_bad_value
);
3583 sinfo
->failed
= true;
3588 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3591 /* If we don't have a version for this symbol, see if we can find
3593 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
3595 struct bfd_elf_version_tree
*t
;
3596 struct bfd_elf_version_tree
*deflt
;
3597 struct bfd_elf_version_expr
*d
;
3599 /* See if can find what version this symbol is in. If the
3600 symbol is supposed to be local, then don't actually register
3603 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3605 if (t
->globals
!= NULL
)
3607 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3609 if ((*d
->match
) (d
, h
->root
.root
.string
))
3611 h
->verinfo
.vertree
= t
;
3620 if (t
->locals
!= NULL
)
3622 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3624 if (d
->pattern
[0] == '*' && d
->pattern
[1] == '\0')
3626 else if ((*d
->match
) (d
, h
->root
.root
.string
))
3628 h
->verinfo
.vertree
= t
;
3629 if (h
->dynindx
!= -1
3631 && ! sinfo
->export_dynamic
)
3633 sinfo
->removed_dynamic
= true;
3634 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3635 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3637 h
->plt
.offset
= (bfd_vma
) -1;
3638 /* FIXME: The name of the symbol has already
3639 been recorded in the dynamic string table
3651 if (deflt
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3653 h
->verinfo
.vertree
= deflt
;
3654 if (h
->dynindx
!= -1
3656 && ! sinfo
->export_dynamic
)
3658 sinfo
->removed_dynamic
= true;
3659 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3660 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3662 h
->plt
.offset
= (bfd_vma
) -1;
3663 /* FIXME: The name of the symbol has already been
3664 recorded in the dynamic string table section. */
3672 /* This function is used to renumber the dynamic symbols, if some of
3673 them are removed because they are marked as local. This is called
3674 via elf_link_hash_traverse. */
3677 elf_link_renumber_dynsyms (h
, data
)
3678 struct elf_link_hash_entry
*h
;
3681 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
3683 if (h
->dynindx
!= -1)
3685 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3686 ++elf_hash_table (info
)->dynsymcount
;
3692 /* Final phase of ELF linker. */
3694 /* A structure we use to avoid passing large numbers of arguments. */
3696 struct elf_final_link_info
3698 /* General link information. */
3699 struct bfd_link_info
*info
;
3702 /* Symbol string table. */
3703 struct bfd_strtab_hash
*symstrtab
;
3704 /* .dynsym section. */
3705 asection
*dynsym_sec
;
3706 /* .hash section. */
3708 /* symbol version section (.gnu.version). */
3709 asection
*symver_sec
;
3710 /* Buffer large enough to hold contents of any section. */
3712 /* Buffer large enough to hold external relocs of any section. */
3713 PTR external_relocs
;
3714 /* Buffer large enough to hold internal relocs of any section. */
3715 Elf_Internal_Rela
*internal_relocs
;
3716 /* Buffer large enough to hold external local symbols of any input
3718 Elf_External_Sym
*external_syms
;
3719 /* Buffer large enough to hold internal local symbols of any input
3721 Elf_Internal_Sym
*internal_syms
;
3722 /* Array large enough to hold a symbol index for each local symbol
3723 of any input BFD. */
3725 /* Array large enough to hold a section pointer for each local
3726 symbol of any input BFD. */
3727 asection
**sections
;
3728 /* Buffer to hold swapped out symbols. */
3729 Elf_External_Sym
*symbuf
;
3730 /* Number of swapped out symbols in buffer. */
3731 size_t symbuf_count
;
3732 /* Number of symbols which fit in symbuf. */
3736 static boolean elf_link_output_sym
3737 PARAMS ((struct elf_final_link_info
*, const char *,
3738 Elf_Internal_Sym
*, asection
*));
3739 static boolean elf_link_flush_output_syms
3740 PARAMS ((struct elf_final_link_info
*));
3741 static boolean elf_link_output_extsym
3742 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3743 static boolean elf_link_input_bfd
3744 PARAMS ((struct elf_final_link_info
*, bfd
*));
3745 static boolean elf_reloc_link_order
3746 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
3747 struct bfd_link_order
*));
3749 /* This struct is used to pass information to elf_link_output_extsym. */
3751 struct elf_outext_info
3755 struct elf_final_link_info
*finfo
;
3758 /* Compute the size of, and allocate space for, REL_HDR which is the
3759 section header for a section containing relocations for O. */
3762 elf_link_size_reloc_section (abfd
, rel_hdr
, o
)
3764 Elf_Internal_Shdr
*rel_hdr
;
3767 register struct elf_link_hash_entry
**p
, **pend
;
3769 /* We are overestimating the size required for the relocation
3770 sections, in the case that we are using both REL and RELA
3771 relocations for a single section. In that case, RELOC_COUNT will
3772 be the total number of relocations required, and we allocate
3773 space for that many REL relocations as well as that many RELA
3774 relocations. This approximation is wasteful of disk space.
3775 However, until we keep track of how many of each kind of
3776 relocation is required, it's difficult to calculate the right
3778 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
3780 /* The contents field must last into write_object_contents, so we
3781 allocate it with bfd_alloc rather than malloc. */
3782 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
3783 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
3786 p
= ((struct elf_link_hash_entry
**)
3787 bfd_malloc (o
->reloc_count
3788 * sizeof (struct elf_link_hash_entry
*)));
3789 if (p
== NULL
&& o
->reloc_count
!= 0)
3792 elf_section_data (o
)->rel_hashes
= p
;
3793 pend
= p
+ o
->reloc_count
;
3794 for (; p
< pend
; p
++)
3800 /* Do the final step of an ELF link. */
3803 elf_bfd_final_link (abfd
, info
)
3805 struct bfd_link_info
*info
;
3809 struct elf_final_link_info finfo
;
3810 register asection
*o
;
3811 register struct bfd_link_order
*p
;
3813 size_t max_contents_size
;
3814 size_t max_external_reloc_size
;
3815 size_t max_internal_reloc_count
;
3816 size_t max_sym_count
;
3818 Elf_Internal_Sym elfsym
;
3820 Elf_Internal_Shdr
*symtab_hdr
;
3821 Elf_Internal_Shdr
*symstrtab_hdr
;
3822 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3823 struct elf_outext_info eoinfo
;
3826 abfd
->flags
|= DYNAMIC
;
3828 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
3829 dynobj
= elf_hash_table (info
)->dynobj
;
3832 finfo
.output_bfd
= abfd
;
3833 finfo
.symstrtab
= elf_stringtab_init ();
3834 if (finfo
.symstrtab
== NULL
)
3839 finfo
.dynsym_sec
= NULL
;
3840 finfo
.hash_sec
= NULL
;
3841 finfo
.symver_sec
= NULL
;
3845 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
3846 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
3847 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
3848 finfo
.symver_sec
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3849 /* Note that it is OK if symver_sec is NULL. */
3852 finfo
.contents
= NULL
;
3853 finfo
.external_relocs
= NULL
;
3854 finfo
.internal_relocs
= NULL
;
3855 finfo
.external_syms
= NULL
;
3856 finfo
.internal_syms
= NULL
;
3857 finfo
.indices
= NULL
;
3858 finfo
.sections
= NULL
;
3859 finfo
.symbuf
= NULL
;
3860 finfo
.symbuf_count
= 0;
3862 /* Count up the number of relocations we will output for each output
3863 section, so that we know the sizes of the reloc sections. We
3864 also figure out some maximum sizes. */
3865 max_contents_size
= 0;
3866 max_external_reloc_size
= 0;
3867 max_internal_reloc_count
= 0;
3869 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3873 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3875 if (p
->type
== bfd_section_reloc_link_order
3876 || p
->type
== bfd_symbol_reloc_link_order
)
3878 else if (p
->type
== bfd_indirect_link_order
)
3882 sec
= p
->u
.indirect
.section
;
3884 /* Mark all sections which are to be included in the
3885 link. This will normally be every section. We need
3886 to do this so that we can identify any sections which
3887 the linker has decided to not include. */
3888 sec
->linker_mark
= true;
3890 if (info
->relocateable
)
3891 o
->reloc_count
+= sec
->reloc_count
;
3893 if (sec
->_raw_size
> max_contents_size
)
3894 max_contents_size
= sec
->_raw_size
;
3895 if (sec
->_cooked_size
> max_contents_size
)
3896 max_contents_size
= sec
->_cooked_size
;
3898 /* We are interested in just local symbols, not all
3900 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
3901 && (sec
->owner
->flags
& DYNAMIC
) == 0)
3905 if (elf_bad_symtab (sec
->owner
))
3906 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
3907 / sizeof (Elf_External_Sym
));
3909 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
3911 if (sym_count
> max_sym_count
)
3912 max_sym_count
= sym_count
;
3914 if ((sec
->flags
& SEC_RELOC
) != 0)
3918 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
3919 if (ext_size
> max_external_reloc_size
)
3920 max_external_reloc_size
= ext_size
;
3921 if (sec
->reloc_count
> max_internal_reloc_count
)
3922 max_internal_reloc_count
= sec
->reloc_count
;
3928 if (o
->reloc_count
> 0)
3929 o
->flags
|= SEC_RELOC
;
3932 /* Explicitly clear the SEC_RELOC flag. The linker tends to
3933 set it (this is probably a bug) and if it is set
3934 assign_section_numbers will create a reloc section. */
3935 o
->flags
&=~ SEC_RELOC
;
3938 /* If the SEC_ALLOC flag is not set, force the section VMA to
3939 zero. This is done in elf_fake_sections as well, but forcing
3940 the VMA to 0 here will ensure that relocs against these
3941 sections are handled correctly. */
3942 if ((o
->flags
& SEC_ALLOC
) == 0
3943 && ! o
->user_set_vma
)
3947 /* Figure out the file positions for everything but the symbol table
3948 and the relocs. We set symcount to force assign_section_numbers
3949 to create a symbol table. */
3950 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
3951 BFD_ASSERT (! abfd
->output_has_begun
);
3952 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
3955 /* That created the reloc sections. Set their sizes, and assign
3956 them file positions, and allocate some buffers. */
3957 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3959 if ((o
->flags
& SEC_RELOC
) != 0)
3961 if (!elf_link_size_reloc_section (abfd
,
3962 &elf_section_data (o
)->rel_hdr
,
3966 if (elf_section_data (o
)->rel_hdr2
3967 && !elf_link_size_reloc_section (abfd
,
3968 elf_section_data (o
)->rel_hdr2
,
3974 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3976 /* We have now assigned file positions for all the sections except
3977 .symtab and .strtab. We start the .symtab section at the current
3978 file position, and write directly to it. We build the .strtab
3979 section in memory. */
3980 bfd_get_symcount (abfd
) = 0;
3981 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3982 /* sh_name is set in prep_headers. */
3983 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3984 symtab_hdr
->sh_flags
= 0;
3985 symtab_hdr
->sh_addr
= 0;
3986 symtab_hdr
->sh_size
= 0;
3987 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
3988 /* sh_link is set in assign_section_numbers. */
3989 /* sh_info is set below. */
3990 /* sh_offset is set just below. */
3991 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
3993 off
= elf_tdata (abfd
)->next_file_pos
;
3994 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
3996 /* Note that at this point elf_tdata (abfd)->next_file_pos is
3997 incorrect. We do not yet know the size of the .symtab section.
3998 We correct next_file_pos below, after we do know the size. */
4000 /* Allocate a buffer to hold swapped out symbols. This is to avoid
4001 continuously seeking to the right position in the file. */
4002 if (! info
->keep_memory
|| max_sym_count
< 20)
4003 finfo
.symbuf_size
= 20;
4005 finfo
.symbuf_size
= max_sym_count
;
4006 finfo
.symbuf
= ((Elf_External_Sym
*)
4007 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
4008 if (finfo
.symbuf
== NULL
)
4011 /* Start writing out the symbol table. The first symbol is always a
4013 if (info
->strip
!= strip_all
|| info
->relocateable
)
4015 elfsym
.st_value
= 0;
4018 elfsym
.st_other
= 0;
4019 elfsym
.st_shndx
= SHN_UNDEF
;
4020 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
4021 &elfsym
, bfd_und_section_ptr
))
4026 /* Some standard ELF linkers do this, but we don't because it causes
4027 bootstrap comparison failures. */
4028 /* Output a file symbol for the output file as the second symbol.
4029 We output this even if we are discarding local symbols, although
4030 I'm not sure if this is correct. */
4031 elfsym
.st_value
= 0;
4033 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
4034 elfsym
.st_other
= 0;
4035 elfsym
.st_shndx
= SHN_ABS
;
4036 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
4037 &elfsym
, bfd_abs_section_ptr
))
4041 /* Output a symbol for each section. We output these even if we are
4042 discarding local symbols, since they are used for relocs. These
4043 symbols have no names. We store the index of each one in the
4044 index field of the section, so that we can find it again when
4045 outputting relocs. */
4046 if (info
->strip
!= strip_all
|| info
->relocateable
)
4049 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4050 elfsym
.st_other
= 0;
4051 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
4053 o
= section_from_elf_index (abfd
, i
);
4055 o
->target_index
= bfd_get_symcount (abfd
);
4056 elfsym
.st_shndx
= i
;
4057 if (info
->relocateable
|| o
== NULL
)
4058 elfsym
.st_value
= 0;
4060 elfsym
.st_value
= o
->vma
;
4061 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
4067 /* Allocate some memory to hold information read in from the input
4069 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
4070 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
4071 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
4072 bfd_malloc (max_internal_reloc_count
4073 * sizeof (Elf_Internal_Rela
)
4074 * bed
->s
->int_rels_per_ext_rel
));
4075 finfo
.external_syms
= ((Elf_External_Sym
*)
4076 bfd_malloc (max_sym_count
4077 * sizeof (Elf_External_Sym
)));
4078 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
4079 bfd_malloc (max_sym_count
4080 * sizeof (Elf_Internal_Sym
)));
4081 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
4082 finfo
.sections
= ((asection
**)
4083 bfd_malloc (max_sym_count
* sizeof (asection
*)));
4084 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
4085 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
4086 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
4087 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
4088 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
4089 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
4090 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
4093 /* Since ELF permits relocations to be against local symbols, we
4094 must have the local symbols available when we do the relocations.
4095 Since we would rather only read the local symbols once, and we
4096 would rather not keep them in memory, we handle all the
4097 relocations for a single input file at the same time.
4099 Unfortunately, there is no way to know the total number of local
4100 symbols until we have seen all of them, and the local symbol
4101 indices precede the global symbol indices. This means that when
4102 we are generating relocateable output, and we see a reloc against
4103 a global symbol, we can not know the symbol index until we have
4104 finished examining all the local symbols to see which ones we are
4105 going to output. To deal with this, we keep the relocations in
4106 memory, and don't output them until the end of the link. This is
4107 an unfortunate waste of memory, but I don't see a good way around
4108 it. Fortunately, it only happens when performing a relocateable
4109 link, which is not the common case. FIXME: If keep_memory is set
4110 we could write the relocs out and then read them again; I don't
4111 know how bad the memory loss will be. */
4113 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
4114 sub
->output_has_begun
= false;
4115 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4117 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
4119 if (p
->type
== bfd_indirect_link_order
4120 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4121 == bfd_target_elf_flavour
))
4123 sub
= p
->u
.indirect
.section
->owner
;
4124 if (! sub
->output_has_begun
)
4126 if (! elf_link_input_bfd (&finfo
, sub
))
4128 sub
->output_has_begun
= true;
4131 else if (p
->type
== bfd_section_reloc_link_order
4132 || p
->type
== bfd_symbol_reloc_link_order
)
4134 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
4139 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4145 /* That wrote out all the local symbols. Finish up the symbol table
4146 with the global symbols. */
4148 if (info
->strip
!= strip_all
&& info
->shared
)
4150 /* Output any global symbols that got converted to local in a
4151 version script. We do this in a separate step since ELF
4152 requires all local symbols to appear prior to any global
4153 symbols. FIXME: We should only do this if some global
4154 symbols were, in fact, converted to become local. FIXME:
4155 Will this work correctly with the Irix 5 linker? */
4156 eoinfo
.failed
= false;
4157 eoinfo
.finfo
= &finfo
;
4158 eoinfo
.localsyms
= true;
4159 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
4165 /* The sh_info field records the index of the first non local
4167 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
4169 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
4171 /* We get the global symbols from the hash table. */
4172 eoinfo
.failed
= false;
4173 eoinfo
.localsyms
= false;
4174 eoinfo
.finfo
= &finfo
;
4175 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
4180 /* Flush all symbols to the file. */
4181 if (! elf_link_flush_output_syms (&finfo
))
4184 /* Now we know the size of the symtab section. */
4185 off
+= symtab_hdr
->sh_size
;
4187 /* Finish up and write out the symbol string table (.strtab)
4189 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4190 /* sh_name was set in prep_headers. */
4191 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4192 symstrtab_hdr
->sh_flags
= 0;
4193 symstrtab_hdr
->sh_addr
= 0;
4194 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
4195 symstrtab_hdr
->sh_entsize
= 0;
4196 symstrtab_hdr
->sh_link
= 0;
4197 symstrtab_hdr
->sh_info
= 0;
4198 /* sh_offset is set just below. */
4199 symstrtab_hdr
->sh_addralign
= 1;
4201 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
4202 elf_tdata (abfd
)->next_file_pos
= off
;
4204 if (bfd_get_symcount (abfd
) > 0)
4206 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
4207 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
4211 /* Adjust the relocs to have the correct symbol indices. */
4212 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4214 struct elf_link_hash_entry
**rel_hash
;
4215 Elf_Internal_Shdr
*rel_hdr
;
4217 if ((o
->flags
& SEC_RELOC
) == 0)
4220 rel_hash
= elf_section_data (o
)->rel_hashes
;
4221 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4222 BFD_ASSERT (elf_section_data (o
)->rel_count
== o
->reloc_count
);
4223 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
4225 if (*rel_hash
== NULL
)
4228 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
4230 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4232 Elf_External_Rel
*erel
;
4233 Elf_Internal_Rel irel
;
4235 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
4236 elf_swap_reloc_in (abfd
, erel
, &irel
);
4237 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
4238 ELF_R_TYPE (irel
.r_info
));
4239 elf_swap_reloc_out (abfd
, &irel
, erel
);
4243 Elf_External_Rela
*erela
;
4244 Elf_Internal_Rela irela
;
4246 BFD_ASSERT (rel_hdr
->sh_entsize
4247 == sizeof (Elf_External_Rela
));
4249 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
4250 elf_swap_reloca_in (abfd
, erela
, &irela
);
4251 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
4252 ELF_R_TYPE (irela
.r_info
));
4253 elf_swap_reloca_out (abfd
, &irela
, erela
);
4257 /* Set the reloc_count field to 0 to prevent write_relocs from
4258 trying to swap the relocs out itself. */
4262 /* If we are linking against a dynamic object, or generating a
4263 shared library, finish up the dynamic linking information. */
4266 Elf_External_Dyn
*dyncon
, *dynconend
;
4268 /* Fix up .dynamic entries. */
4269 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
4270 BFD_ASSERT (o
!= NULL
);
4272 dyncon
= (Elf_External_Dyn
*) o
->contents
;
4273 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
4274 for (; dyncon
< dynconend
; dyncon
++)
4276 Elf_Internal_Dyn dyn
;
4280 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4287 name
= info
->init_function
;
4290 name
= info
->fini_function
;
4293 struct elf_link_hash_entry
*h
;
4295 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4296 false, false, true);
4298 && (h
->root
.type
== bfd_link_hash_defined
4299 || h
->root
.type
== bfd_link_hash_defweak
))
4301 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
4302 o
= h
->root
.u
.def
.section
;
4303 if (o
->output_section
!= NULL
)
4304 dyn
.d_un
.d_val
+= (o
->output_section
->vma
4305 + o
->output_offset
);
4308 /* The symbol is imported from another shared
4309 library and does not apply to this one. */
4313 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4328 name
= ".gnu.version_d";
4331 name
= ".gnu.version_r";
4334 name
= ".gnu.version";
4336 o
= bfd_get_section_by_name (abfd
, name
);
4337 BFD_ASSERT (o
!= NULL
);
4338 dyn
.d_un
.d_ptr
= o
->vma
;
4339 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4346 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
4351 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
4353 Elf_Internal_Shdr
*hdr
;
4355 hdr
= elf_elfsections (abfd
)[i
];
4356 if (hdr
->sh_type
== type
4357 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
4359 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
4360 dyn
.d_un
.d_val
+= hdr
->sh_size
;
4363 if (dyn
.d_un
.d_val
== 0
4364 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
4365 dyn
.d_un
.d_val
= hdr
->sh_addr
;
4369 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4375 /* If we have created any dynamic sections, then output them. */
4378 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
4381 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
4383 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4384 || o
->_raw_size
== 0)
4386 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
4388 /* At this point, we are only interested in sections
4389 created by elf_link_create_dynamic_sections. */
4392 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
4394 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
4396 if (! bfd_set_section_contents (abfd
, o
->output_section
,
4397 o
->contents
, o
->output_offset
,
4405 /* The contents of the .dynstr section are actually in a
4407 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
4408 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4409 || ! _bfd_stringtab_emit (abfd
,
4410 elf_hash_table (info
)->dynstr
))
4416 /* If we have optimized stabs strings, output them. */
4417 if (elf_hash_table (info
)->stab_info
!= NULL
)
4419 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
4423 if (finfo
.symstrtab
!= NULL
)
4424 _bfd_stringtab_free (finfo
.symstrtab
);
4425 if (finfo
.contents
!= NULL
)
4426 free (finfo
.contents
);
4427 if (finfo
.external_relocs
!= NULL
)
4428 free (finfo
.external_relocs
);
4429 if (finfo
.internal_relocs
!= NULL
)
4430 free (finfo
.internal_relocs
);
4431 if (finfo
.external_syms
!= NULL
)
4432 free (finfo
.external_syms
);
4433 if (finfo
.internal_syms
!= NULL
)
4434 free (finfo
.internal_syms
);
4435 if (finfo
.indices
!= NULL
)
4436 free (finfo
.indices
);
4437 if (finfo
.sections
!= NULL
)
4438 free (finfo
.sections
);
4439 if (finfo
.symbuf
!= NULL
)
4440 free (finfo
.symbuf
);
4441 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4443 if ((o
->flags
& SEC_RELOC
) != 0
4444 && elf_section_data (o
)->rel_hashes
!= NULL
)
4445 free (elf_section_data (o
)->rel_hashes
);
4448 elf_tdata (abfd
)->linker
= true;
4453 if (finfo
.symstrtab
!= NULL
)
4454 _bfd_stringtab_free (finfo
.symstrtab
);
4455 if (finfo
.contents
!= NULL
)
4456 free (finfo
.contents
);
4457 if (finfo
.external_relocs
!= NULL
)
4458 free (finfo
.external_relocs
);
4459 if (finfo
.internal_relocs
!= NULL
)
4460 free (finfo
.internal_relocs
);
4461 if (finfo
.external_syms
!= NULL
)
4462 free (finfo
.external_syms
);
4463 if (finfo
.internal_syms
!= NULL
)
4464 free (finfo
.internal_syms
);
4465 if (finfo
.indices
!= NULL
)
4466 free (finfo
.indices
);
4467 if (finfo
.sections
!= NULL
)
4468 free (finfo
.sections
);
4469 if (finfo
.symbuf
!= NULL
)
4470 free (finfo
.symbuf
);
4471 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4473 if ((o
->flags
& SEC_RELOC
) != 0
4474 && elf_section_data (o
)->rel_hashes
!= NULL
)
4475 free (elf_section_data (o
)->rel_hashes
);
4481 /* Add a symbol to the output symbol table. */
4484 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
4485 struct elf_final_link_info
*finfo
;
4487 Elf_Internal_Sym
*elfsym
;
4488 asection
*input_sec
;
4490 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
4491 struct bfd_link_info
*info
,
4496 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
4497 elf_backend_link_output_symbol_hook
;
4498 if (output_symbol_hook
!= NULL
)
4500 if (! ((*output_symbol_hook
)
4501 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
4505 if (name
== (const char *) NULL
|| *name
== '\0')
4506 elfsym
->st_name
= 0;
4507 else if (input_sec
->flags
& SEC_EXCLUDE
)
4508 elfsym
->st_name
= 0;
4511 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
4514 if (elfsym
->st_name
== (unsigned long) -1)
4518 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
4520 if (! elf_link_flush_output_syms (finfo
))
4524 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
4525 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
4526 ++finfo
->symbuf_count
;
4528 ++ bfd_get_symcount (finfo
->output_bfd
);
4533 /* Flush the output symbols to the file. */
4536 elf_link_flush_output_syms (finfo
)
4537 struct elf_final_link_info
*finfo
;
4539 if (finfo
->symbuf_count
> 0)
4541 Elf_Internal_Shdr
*symtab
;
4543 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
4545 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
4547 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
4548 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
4549 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
4552 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
4554 finfo
->symbuf_count
= 0;
4560 /* Add an external symbol to the symbol table. This is called from
4561 the hash table traversal routine. When generating a shared object,
4562 we go through the symbol table twice. The first time we output
4563 anything that might have been forced to local scope in a version
4564 script. The second time we output the symbols that are still
4568 elf_link_output_extsym (h
, data
)
4569 struct elf_link_hash_entry
*h
;
4572 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
4573 struct elf_final_link_info
*finfo
= eoinfo
->finfo
;
4575 Elf_Internal_Sym sym
;
4576 asection
*input_sec
;
4578 /* Decide whether to output this symbol in this pass. */
4579 if (eoinfo
->localsyms
)
4581 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
4586 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4590 /* If we are not creating a shared library, and this symbol is
4591 referenced by a shared library but is not defined anywhere, then
4592 warn that it is undefined. If we do not do this, the runtime
4593 linker will complain that the symbol is undefined when the
4594 program is run. We don't have to worry about symbols that are
4595 referenced by regular files, because we will already have issued
4596 warnings for them. */
4597 if (! finfo
->info
->relocateable
4598 && ! (finfo
->info
->shared
4599 && !finfo
->info
->no_undefined
)
4600 && h
->root
.type
== bfd_link_hash_undefined
4601 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
4602 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4604 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4605 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
4606 (asection
*) NULL
, 0)))
4608 eoinfo
->failed
= true;
4613 /* We don't want to output symbols that have never been mentioned by
4614 a regular file, or that we have been told to strip. However, if
4615 h->indx is set to -2, the symbol is used by a reloc and we must
4619 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4620 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
4621 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
4622 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4624 else if (finfo
->info
->strip
== strip_all
4625 || (finfo
->info
->strip
== strip_some
4626 && bfd_hash_lookup (finfo
->info
->keep_hash
,
4627 h
->root
.root
.string
,
4628 false, false) == NULL
))
4633 /* If we're stripping it, and it's not a dynamic symbol, there's
4634 nothing else to do. */
4635 if (strip
&& h
->dynindx
== -1)
4639 sym
.st_size
= h
->size
;
4640 sym
.st_other
= h
->other
;
4641 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4642 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
4643 else if (h
->root
.type
== bfd_link_hash_undefweak
4644 || h
->root
.type
== bfd_link_hash_defweak
)
4645 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4647 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
4649 switch (h
->root
.type
)
4652 case bfd_link_hash_new
:
4656 case bfd_link_hash_undefined
:
4657 input_sec
= bfd_und_section_ptr
;
4658 sym
.st_shndx
= SHN_UNDEF
;
4661 case bfd_link_hash_undefweak
:
4662 input_sec
= bfd_und_section_ptr
;
4663 sym
.st_shndx
= SHN_UNDEF
;
4666 case bfd_link_hash_defined
:
4667 case bfd_link_hash_defweak
:
4669 input_sec
= h
->root
.u
.def
.section
;
4670 if (input_sec
->output_section
!= NULL
)
4673 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
4674 input_sec
->output_section
);
4675 if (sym
.st_shndx
== (unsigned short) -1)
4677 (*_bfd_error_handler
)
4678 (_("%s: could not find output section %s for input section %s"),
4679 bfd_get_filename (finfo
->output_bfd
),
4680 input_sec
->output_section
->name
,
4682 eoinfo
->failed
= true;
4686 /* ELF symbols in relocateable files are section relative,
4687 but in nonrelocateable files they are virtual
4689 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
4690 if (! finfo
->info
->relocateable
)
4691 sym
.st_value
+= input_sec
->output_section
->vma
;
4695 BFD_ASSERT (input_sec
->owner
== NULL
4696 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
4697 sym
.st_shndx
= SHN_UNDEF
;
4698 input_sec
= bfd_und_section_ptr
;
4703 case bfd_link_hash_common
:
4704 input_sec
= h
->root
.u
.c
.p
->section
;
4705 sym
.st_shndx
= SHN_COMMON
;
4706 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
4709 case bfd_link_hash_indirect
:
4710 /* These symbols are created by symbol versioning. They point
4711 to the decorated version of the name. For example, if the
4712 symbol foo@@GNU_1.2 is the default, which should be used when
4713 foo is used with no version, then we add an indirect symbol
4714 foo which points to foo@@GNU_1.2. We ignore these symbols,
4715 since the indirected symbol is already in the hash table. If
4716 the indirect symbol is non-ELF, fall through and output it. */
4717 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) == 0)
4721 case bfd_link_hash_warning
:
4722 /* We can't represent these symbols in ELF, although a warning
4723 symbol may have come from a .gnu.warning.SYMBOL section. We
4724 just put the target symbol in the hash table. If the target
4725 symbol does not really exist, don't do anything. */
4726 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
4728 return (elf_link_output_extsym
4729 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
4732 /* Give the processor backend a chance to tweak the symbol value,
4733 and also to finish up anything that needs to be done for this
4735 if ((h
->dynindx
!= -1
4736 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4737 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4739 struct elf_backend_data
*bed
;
4741 bed
= get_elf_backend_data (finfo
->output_bfd
);
4742 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
4743 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
4745 eoinfo
->failed
= true;
4750 /* If we are marking the symbol as undefined, and there are no
4751 non-weak references to this symbol from a regular object, then
4752 mark the symbol as weak undefined. We can't do this earlier,
4753 because it might not be marked as undefined until the
4754 finish_dynamic_symbol routine gets through with it. */
4755 if (sym
.st_shndx
== SHN_UNDEF
4756 && sym
.st_info
== ELF_ST_INFO (STB_GLOBAL
, h
->type
)
4757 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
4758 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
) == 0)
4759 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4761 /* If this symbol should be put in the .dynsym section, then put it
4762 there now. We have already know the symbol index. We also fill
4763 in the entry in the .hash section. */
4764 if (h
->dynindx
!= -1
4765 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4769 size_t hash_entry_size
;
4770 bfd_byte
*bucketpos
;
4773 sym
.st_name
= h
->dynstr_index
;
4775 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
4776 (PTR
) (((Elf_External_Sym
*)
4777 finfo
->dynsym_sec
->contents
)
4780 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
4781 bucket
= h
->elf_hash_value
% bucketcount
;
4783 = elf_section_data (finfo
->hash_sec
)->this_hdr
.sh_entsize
;
4784 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
4785 + (bucket
+ 2) * hash_entry_size
);
4786 chain
= bfd_get (8 * hash_entry_size
, finfo
->output_bfd
, bucketpos
);
4787 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, h
->dynindx
, bucketpos
);
4788 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, chain
,
4789 ((bfd_byte
*) finfo
->hash_sec
->contents
4790 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
4792 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
4794 Elf_Internal_Versym iversym
;
4796 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4798 if (h
->verinfo
.verdef
== NULL
)
4799 iversym
.vs_vers
= 0;
4801 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
4805 if (h
->verinfo
.vertree
== NULL
)
4806 iversym
.vs_vers
= 1;
4808 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
4811 if ((h
->elf_link_hash_flags
& ELF_LINK_HIDDEN
) != 0)
4812 iversym
.vs_vers
|= VERSYM_HIDDEN
;
4814 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
,
4815 (((Elf_External_Versym
*)
4816 finfo
->symver_sec
->contents
)
4821 /* If we're stripping it, then it was just a dynamic symbol, and
4822 there's nothing else to do. */
4826 h
->indx
= bfd_get_symcount (finfo
->output_bfd
);
4828 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
4830 eoinfo
->failed
= true;
4837 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
4838 originated from the section given by INPUT_REL_HDR) to the
4842 elf_link_output_relocs (output_bfd
, input_section
, input_rel_hdr
,
4845 asection
*input_section
;
4846 Elf_Internal_Shdr
*input_rel_hdr
;
4847 Elf_Internal_Rela
*internal_relocs
;
4849 Elf_Internal_Rela
*irela
;
4850 Elf_Internal_Rela
*irelaend
;
4851 Elf_Internal_Shdr
*output_rel_hdr
;
4852 asection
*output_section
;
4853 unsigned int *rel_countp
;
4855 output_section
= input_section
->output_section
;
4856 output_rel_hdr
= NULL
;
4858 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
4859 == input_rel_hdr
->sh_entsize
)
4861 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
4862 rel_countp
= &elf_section_data (output_section
)->rel_count
;
4864 else if (elf_section_data (output_section
)->rel_hdr2
4865 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
4866 == input_rel_hdr
->sh_entsize
))
4868 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
4869 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
4872 BFD_ASSERT (output_rel_hdr
!= NULL
);
4874 irela
= internal_relocs
;
4875 irelaend
= irela
+ input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
4876 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4878 Elf_External_Rel
*erel
;
4880 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
+ *rel_countp
);
4881 for (; irela
< irelaend
; irela
++, erel
++)
4883 Elf_Internal_Rel irel
;
4885 irel
.r_offset
= irela
->r_offset
;
4886 irel
.r_info
= irela
->r_info
;
4887 BFD_ASSERT (irela
->r_addend
== 0);
4888 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
4893 Elf_External_Rela
*erela
;
4895 BFD_ASSERT (input_rel_hdr
->sh_entsize
4896 == sizeof (Elf_External_Rela
));
4897 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
+ *rel_countp
);
4898 for (; irela
< irelaend
; irela
++, erela
++)
4899 elf_swap_reloca_out (output_bfd
, irela
, erela
);
4902 /* Bump the counter, so that we know where to add the next set of
4904 *rel_countp
+= input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
4907 /* Link an input file into the linker output file. This function
4908 handles all the sections and relocations of the input file at once.
4909 This is so that we only have to read the local symbols once, and
4910 don't have to keep them in memory. */
4913 elf_link_input_bfd (finfo
, input_bfd
)
4914 struct elf_final_link_info
*finfo
;
4917 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
4918 bfd
*, asection
*, bfd_byte
*,
4919 Elf_Internal_Rela
*,
4920 Elf_Internal_Sym
*, asection
**));
4922 Elf_Internal_Shdr
*symtab_hdr
;
4925 Elf_External_Sym
*external_syms
;
4926 Elf_External_Sym
*esym
;
4927 Elf_External_Sym
*esymend
;
4928 Elf_Internal_Sym
*isym
;
4930 asection
**ppsection
;
4932 struct elf_backend_data
*bed
;
4934 output_bfd
= finfo
->output_bfd
;
4935 bed
= get_elf_backend_data (output_bfd
);
4936 relocate_section
= bed
->elf_backend_relocate_section
;
4938 /* If this is a dynamic object, we don't want to do anything here:
4939 we don't want the local symbols, and we don't want the section
4941 if ((input_bfd
->flags
& DYNAMIC
) != 0)
4944 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4945 if (elf_bad_symtab (input_bfd
))
4947 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4952 locsymcount
= symtab_hdr
->sh_info
;
4953 extsymoff
= symtab_hdr
->sh_info
;
4956 /* Read the local symbols. */
4957 if (symtab_hdr
->contents
!= NULL
)
4958 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
4959 else if (locsymcount
== 0)
4960 external_syms
= NULL
;
4963 external_syms
= finfo
->external_syms
;
4964 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
4965 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
4966 locsymcount
, input_bfd
)
4967 != locsymcount
* sizeof (Elf_External_Sym
)))
4971 /* Swap in the local symbols and write out the ones which we know
4972 are going into the output file. */
4973 esym
= external_syms
;
4974 esymend
= esym
+ locsymcount
;
4975 isym
= finfo
->internal_syms
;
4976 pindex
= finfo
->indices
;
4977 ppsection
= finfo
->sections
;
4978 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
4982 Elf_Internal_Sym osym
;
4984 elf_swap_symbol_in (input_bfd
, esym
, isym
);
4987 if (elf_bad_symtab (input_bfd
))
4989 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
4996 if (isym
->st_shndx
== SHN_UNDEF
)
4997 isec
= bfd_und_section_ptr
;
4998 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
4999 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5000 else if (isym
->st_shndx
== SHN_ABS
)
5001 isec
= bfd_abs_section_ptr
;
5002 else if (isym
->st_shndx
== SHN_COMMON
)
5003 isec
= bfd_com_section_ptr
;
5012 /* Don't output the first, undefined, symbol. */
5013 if (esym
== external_syms
)
5016 /* If we are stripping all symbols, we don't want to output this
5018 if (finfo
->info
->strip
== strip_all
)
5021 /* We never output section symbols. Instead, we use the section
5022 symbol of the corresponding section in the output file. */
5023 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5026 /* If we are discarding all local symbols, we don't want to
5027 output this one. If we are generating a relocateable output
5028 file, then some of the local symbols may be required by
5029 relocs; we output them below as we discover that they are
5031 if (finfo
->info
->discard
== discard_all
)
5034 /* If this symbol is defined in a section which we are
5035 discarding, we don't need to keep it, but note that
5036 linker_mark is only reliable for sections that have contents.
5037 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
5038 as well as linker_mark. */
5039 if (isym
->st_shndx
> 0
5040 && isym
->st_shndx
< SHN_LORESERVE
5042 && ((! isec
->linker_mark
&& (isec
->flags
& SEC_HAS_CONTENTS
) != 0)
5043 || (! finfo
->info
->relocateable
5044 && (isec
->flags
& SEC_EXCLUDE
) != 0)))
5047 /* Get the name of the symbol. */
5048 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5053 /* See if we are discarding symbols with this name. */
5054 if ((finfo
->info
->strip
== strip_some
5055 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5057 || (finfo
->info
->discard
== discard_l
5058 && bfd_is_local_label_name (input_bfd
, name
)))
5061 /* If we get here, we are going to output this symbol. */
5065 /* Adjust the section index for the output file. */
5066 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
5067 isec
->output_section
);
5068 if (osym
.st_shndx
== (unsigned short) -1)
5071 *pindex
= bfd_get_symcount (output_bfd
);
5073 /* ELF symbols in relocateable files are section relative, but
5074 in executable files they are virtual addresses. Note that
5075 this code assumes that all ELF sections have an associated
5076 BFD section with a reasonable value for output_offset; below
5077 we assume that they also have a reasonable value for
5078 output_section. Any special sections must be set up to meet
5079 these requirements. */
5080 osym
.st_value
+= isec
->output_offset
;
5081 if (! finfo
->info
->relocateable
)
5082 osym
.st_value
+= isec
->output_section
->vma
;
5084 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
5088 /* Relocate the contents of each section. */
5089 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5093 if (! o
->linker_mark
)
5095 /* This section was omitted from the link. */
5099 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5100 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
5103 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
5105 /* Section was created by elf_link_create_dynamic_sections
5110 /* Get the contents of the section. They have been cached by a
5111 relaxation routine. Note that o is a section in an input
5112 file, so the contents field will not have been set by any of
5113 the routines which work on output files. */
5114 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
5115 contents
= elf_section_data (o
)->this_hdr
.contents
;
5118 contents
= finfo
->contents
;
5119 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
5120 (file_ptr
) 0, o
->_raw_size
))
5124 if ((o
->flags
& SEC_RELOC
) != 0)
5126 Elf_Internal_Rela
*internal_relocs
;
5128 /* Get the swapped relocs. */
5129 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
5130 (input_bfd
, o
, finfo
->external_relocs
,
5131 finfo
->internal_relocs
, false));
5132 if (internal_relocs
== NULL
5133 && o
->reloc_count
> 0)
5136 /* Relocate the section by invoking a back end routine.
5138 The back end routine is responsible for adjusting the
5139 section contents as necessary, and (if using Rela relocs
5140 and generating a relocateable output file) adjusting the
5141 reloc addend as necessary.
5143 The back end routine does not have to worry about setting
5144 the reloc address or the reloc symbol index.
5146 The back end routine is given a pointer to the swapped in
5147 internal symbols, and can access the hash table entries
5148 for the external symbols via elf_sym_hashes (input_bfd).
5150 When generating relocateable output, the back end routine
5151 must handle STB_LOCAL/STT_SECTION symbols specially. The
5152 output symbol is going to be a section symbol
5153 corresponding to the output section, which will require
5154 the addend to be adjusted. */
5156 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
5157 input_bfd
, o
, contents
,
5159 finfo
->internal_syms
,
5163 if (finfo
->info
->relocateable
)
5165 Elf_Internal_Rela
*irela
;
5166 Elf_Internal_Rela
*irelaend
;
5167 struct elf_link_hash_entry
**rel_hash
;
5168 Elf_Internal_Shdr
*input_rel_hdr
;
5170 /* Adjust the reloc addresses and symbol indices. */
5172 irela
= internal_relocs
;
5174 irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5175 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
5176 + elf_section_data (o
->output_section
)->rel_count
);
5177 for (; irela
< irelaend
; irela
++, rel_hash
++)
5179 unsigned long r_symndx
;
5180 Elf_Internal_Sym
*isym
;
5183 irela
->r_offset
+= o
->output_offset
;
5185 r_symndx
= ELF_R_SYM (irela
->r_info
);
5190 if (r_symndx
>= locsymcount
5191 || (elf_bad_symtab (input_bfd
)
5192 && finfo
->sections
[r_symndx
] == NULL
))
5194 struct elf_link_hash_entry
*rh
;
5197 /* This is a reloc against a global symbol. We
5198 have not yet output all the local symbols, so
5199 we do not know the symbol index of any global
5200 symbol. We set the rel_hash entry for this
5201 reloc to point to the global hash table entry
5202 for this symbol. The symbol index is then
5203 set at the end of elf_bfd_final_link. */
5204 indx
= r_symndx
- extsymoff
;
5205 rh
= elf_sym_hashes (input_bfd
)[indx
];
5206 while (rh
->root
.type
== bfd_link_hash_indirect
5207 || rh
->root
.type
== bfd_link_hash_warning
)
5208 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
5210 /* Setting the index to -2 tells
5211 elf_link_output_extsym that this symbol is
5213 BFD_ASSERT (rh
->indx
< 0);
5221 /* This is a reloc against a local symbol. */
5224 isym
= finfo
->internal_syms
+ r_symndx
;
5225 sec
= finfo
->sections
[r_symndx
];
5226 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5228 /* I suppose the backend ought to fill in the
5229 section of any STT_SECTION symbol against a
5230 processor specific section. If we have
5231 discarded a section, the output_section will
5232 be the absolute section. */
5234 && (bfd_is_abs_section (sec
)
5235 || (sec
->output_section
!= NULL
5236 && bfd_is_abs_section (sec
->output_section
))))
5238 else if (sec
== NULL
|| sec
->owner
== NULL
)
5240 bfd_set_error (bfd_error_bad_value
);
5245 r_symndx
= sec
->output_section
->target_index
;
5246 BFD_ASSERT (r_symndx
!= 0);
5251 if (finfo
->indices
[r_symndx
] == -1)
5257 if (finfo
->info
->strip
== strip_all
)
5259 /* You can't do ld -r -s. */
5260 bfd_set_error (bfd_error_invalid_operation
);
5264 /* This symbol was skipped earlier, but
5265 since it is needed by a reloc, we
5266 must output it now. */
5267 link
= symtab_hdr
->sh_link
;
5268 name
= bfd_elf_string_from_elf_section (input_bfd
,
5274 osec
= sec
->output_section
;
5276 _bfd_elf_section_from_bfd_section (output_bfd
,
5278 if (isym
->st_shndx
== (unsigned short) -1)
5281 isym
->st_value
+= sec
->output_offset
;
5282 if (! finfo
->info
->relocateable
)
5283 isym
->st_value
+= osec
->vma
;
5285 finfo
->indices
[r_symndx
] = bfd_get_symcount (output_bfd
);
5287 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
5291 r_symndx
= finfo
->indices
[r_symndx
];
5294 irela
->r_info
= ELF_R_INFO (r_symndx
,
5295 ELF_R_TYPE (irela
->r_info
));
5298 /* Swap out the relocs. */
5299 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5300 elf_link_output_relocs (output_bfd
, o
,
5304 += input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
5305 input_rel_hdr
= elf_section_data (o
)->rel_hdr2
;
5307 elf_link_output_relocs (output_bfd
, o
,
5313 /* Write out the modified section contents. */
5314 if (elf_section_data (o
)->stab_info
== NULL
)
5316 if (! (o
->flags
& SEC_EXCLUDE
) &&
5317 ! bfd_set_section_contents (output_bfd
, o
->output_section
,
5318 contents
, o
->output_offset
,
5319 (o
->_cooked_size
!= 0
5326 if (! (_bfd_write_section_stabs
5327 (output_bfd
, &elf_hash_table (finfo
->info
)->stab_info
,
5328 o
, &elf_section_data (o
)->stab_info
, contents
)))
5336 /* Generate a reloc when linking an ELF file. This is a reloc
5337 requested by the linker, and does come from any input file. This
5338 is used to build constructor and destructor tables when linking
5342 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
5344 struct bfd_link_info
*info
;
5345 asection
*output_section
;
5346 struct bfd_link_order
*link_order
;
5348 reloc_howto_type
*howto
;
5352 struct elf_link_hash_entry
**rel_hash_ptr
;
5353 Elf_Internal_Shdr
*rel_hdr
;
5355 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5358 bfd_set_error (bfd_error_bad_value
);
5362 addend
= link_order
->u
.reloc
.p
->addend
;
5364 /* Figure out the symbol index. */
5365 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
5366 + elf_section_data (output_section
)->rel_count
);
5367 if (link_order
->type
== bfd_section_reloc_link_order
)
5369 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
5370 BFD_ASSERT (indx
!= 0);
5371 *rel_hash_ptr
= NULL
;
5375 struct elf_link_hash_entry
*h
;
5377 /* Treat a reloc against a defined symbol as though it were
5378 actually against the section. */
5379 h
= ((struct elf_link_hash_entry
*)
5380 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
5381 link_order
->u
.reloc
.p
->u
.name
,
5382 false, false, true));
5384 && (h
->root
.type
== bfd_link_hash_defined
5385 || h
->root
.type
== bfd_link_hash_defweak
))
5389 section
= h
->root
.u
.def
.section
;
5390 indx
= section
->output_section
->target_index
;
5391 *rel_hash_ptr
= NULL
;
5392 /* It seems that we ought to add the symbol value to the
5393 addend here, but in practice it has already been added
5394 because it was passed to constructor_callback. */
5395 addend
+= section
->output_section
->vma
+ section
->output_offset
;
5399 /* Setting the index to -2 tells elf_link_output_extsym that
5400 this symbol is used by a reloc. */
5407 if (! ((*info
->callbacks
->unattached_reloc
)
5408 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5409 (asection
*) NULL
, (bfd_vma
) 0)))
5415 /* If this is an inplace reloc, we must write the addend into the
5417 if (howto
->partial_inplace
&& addend
!= 0)
5420 bfd_reloc_status_type rstat
;
5424 size
= bfd_get_reloc_size (howto
);
5425 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5426 if (buf
== (bfd_byte
*) NULL
)
5428 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5434 case bfd_reloc_outofrange
:
5436 case bfd_reloc_overflow
:
5437 if (! ((*info
->callbacks
->reloc_overflow
)
5439 (link_order
->type
== bfd_section_reloc_link_order
5440 ? bfd_section_name (output_bfd
,
5441 link_order
->u
.reloc
.p
->u
.section
)
5442 : link_order
->u
.reloc
.p
->u
.name
),
5443 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
5451 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
5452 (file_ptr
) link_order
->offset
, size
);
5458 /* The address of a reloc is relative to the section in a
5459 relocateable file, and is a virtual address in an executable
5461 offset
= link_order
->offset
;
5462 if (! info
->relocateable
)
5463 offset
+= output_section
->vma
;
5465 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
5467 if (rel_hdr
->sh_type
== SHT_REL
)
5469 Elf_Internal_Rel irel
;
5470 Elf_External_Rel
*erel
;
5472 irel
.r_offset
= offset
;
5473 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5474 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
5475 + elf_section_data (output_section
)->rel_count
);
5476 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
5480 Elf_Internal_Rela irela
;
5481 Elf_External_Rela
*erela
;
5483 irela
.r_offset
= offset
;
5484 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5485 irela
.r_addend
= addend
;
5486 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
5487 + elf_section_data (output_section
)->rel_count
);
5488 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
5491 ++elf_section_data (output_section
)->rel_count
;
5497 /* Allocate a pointer to live in a linker created section. */
5500 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
5502 struct bfd_link_info
*info
;
5503 elf_linker_section_t
*lsect
;
5504 struct elf_link_hash_entry
*h
;
5505 const Elf_Internal_Rela
*rel
;
5507 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
5508 elf_linker_section_pointers_t
*linker_section_ptr
;
5509 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
5511 BFD_ASSERT (lsect
!= NULL
);
5513 /* Is this a global symbol? */
5516 /* Has this symbol already been allocated, if so, our work is done */
5517 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5522 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
5523 /* Make sure this symbol is output as a dynamic symbol. */
5524 if (h
->dynindx
== -1)
5526 if (! elf_link_record_dynamic_symbol (info
, h
))
5530 if (lsect
->rel_section
)
5531 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5534 else /* Allocation of a pointer to a local symbol */
5536 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
5538 /* Allocate a table to hold the local symbols if first time */
5541 unsigned int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
5542 register unsigned int i
;
5544 ptr
= (elf_linker_section_pointers_t
**)
5545 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
5550 elf_local_ptr_offsets (abfd
) = ptr
;
5551 for (i
= 0; i
< num_symbols
; i
++)
5552 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
5555 /* Has this symbol already been allocated, if so, our work is done */
5556 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
5561 ptr_linker_section_ptr
= &ptr
[r_symndx
];
5565 /* If we are generating a shared object, we need to
5566 output a R_<xxx>_RELATIVE reloc so that the
5567 dynamic linker can adjust this GOT entry. */
5568 BFD_ASSERT (lsect
->rel_section
!= NULL
);
5569 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5573 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
5574 from internal memory. */
5575 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
5576 linker_section_ptr
= (elf_linker_section_pointers_t
*)
5577 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
5579 if (!linker_section_ptr
)
5582 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
5583 linker_section_ptr
->addend
= rel
->r_addend
;
5584 linker_section_ptr
->which
= lsect
->which
;
5585 linker_section_ptr
->written_address_p
= false;
5586 *ptr_linker_section_ptr
= linker_section_ptr
;
5589 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
5591 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
5592 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
5593 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
5594 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
5596 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
5598 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
5599 lsect
->sym_hash
->root
.root
.string
,
5600 (long)ARCH_SIZE
/ 8,
5601 (long)lsect
->sym_hash
->root
.u
.def
.value
);
5607 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
5609 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
5612 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
5613 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
5621 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
5624 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
5627 /* Fill in the address for a pointer generated in alinker section. */
5630 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
5633 struct bfd_link_info
*info
;
5634 elf_linker_section_t
*lsect
;
5635 struct elf_link_hash_entry
*h
;
5637 const Elf_Internal_Rela
*rel
;
5640 elf_linker_section_pointers_t
*linker_section_ptr
;
5642 BFD_ASSERT (lsect
!= NULL
);
5644 if (h
!= NULL
) /* global symbol */
5646 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5650 BFD_ASSERT (linker_section_ptr
!= NULL
);
5652 if (! elf_hash_table (info
)->dynamic_sections_created
5655 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
5657 /* This is actually a static link, or it is a
5658 -Bsymbolic link and the symbol is defined
5659 locally. We must initialize this entry in the
5662 When doing a dynamic link, we create a .rela.<xxx>
5663 relocation entry to initialize the value. This
5664 is done in the finish_dynamic_symbol routine. */
5665 if (!linker_section_ptr
->written_address_p
)
5667 linker_section_ptr
->written_address_p
= true;
5668 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5669 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5673 else /* local symbol */
5675 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
5676 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
5677 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
5678 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
5682 BFD_ASSERT (linker_section_ptr
!= NULL
);
5684 /* Write out pointer if it hasn't been rewritten out before */
5685 if (!linker_section_ptr
->written_address_p
)
5687 linker_section_ptr
->written_address_p
= true;
5688 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5689 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5693 asection
*srel
= lsect
->rel_section
;
5694 Elf_Internal_Rela outrel
;
5696 /* We need to generate a relative reloc for the dynamic linker. */
5698 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
5701 BFD_ASSERT (srel
!= NULL
);
5703 outrel
.r_offset
= (lsect
->section
->output_section
->vma
5704 + lsect
->section
->output_offset
5705 + linker_section_ptr
->offset
);
5706 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
5707 outrel
.r_addend
= 0;
5708 elf_swap_reloca_out (output_bfd
, &outrel
,
5709 (((Elf_External_Rela
*)
5710 lsect
->section
->contents
)
5711 + elf_section_data (lsect
->section
)->rel_count
));
5712 ++elf_section_data (lsect
->section
)->rel_count
;
5717 relocation
= (lsect
->section
->output_offset
5718 + linker_section_ptr
->offset
5719 - lsect
->hole_offset
5720 - lsect
->sym_offset
);
5723 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
5724 lsect
->name
, (long)relocation
, (long)relocation
);
5727 /* Subtract out the addend, because it will get added back in by the normal
5729 return relocation
- linker_section_ptr
->addend
;
5732 /* Garbage collect unused sections. */
5734 static boolean elf_gc_mark
5735 PARAMS ((struct bfd_link_info
*info
, asection
*sec
,
5736 asection
* (*gc_mark_hook
)
5737 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5738 struct elf_link_hash_entry
*, Elf_Internal_Sym
*))));
5740 static boolean elf_gc_sweep
5741 PARAMS ((struct bfd_link_info
*info
,
5742 boolean (*gc_sweep_hook
)
5743 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5744 const Elf_Internal_Rela
*relocs
))));
5746 static boolean elf_gc_sweep_symbol
5747 PARAMS ((struct elf_link_hash_entry
*h
, PTR idxptr
));
5749 static boolean elf_gc_allocate_got_offsets
5750 PARAMS ((struct elf_link_hash_entry
*h
, PTR offarg
));
5752 static boolean elf_gc_propagate_vtable_entries_used
5753 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5755 static boolean elf_gc_smash_unused_vtentry_relocs
5756 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5758 /* The mark phase of garbage collection. For a given section, mark
5759 it, and all the sections which define symbols to which it refers. */
5762 elf_gc_mark (info
, sec
, gc_mark_hook
)
5763 struct bfd_link_info
*info
;
5765 asection
* (*gc_mark_hook
)
5766 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5767 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
5773 /* Look through the section relocs. */
5775 if ((sec
->flags
& SEC_RELOC
) != 0 && sec
->reloc_count
> 0)
5777 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
5778 Elf_Internal_Shdr
*symtab_hdr
;
5779 struct elf_link_hash_entry
**sym_hashes
;
5782 Elf_External_Sym
*locsyms
, *freesyms
= NULL
;
5783 bfd
*input_bfd
= sec
->owner
;
5784 struct elf_backend_data
*bed
= get_elf_backend_data (input_bfd
);
5786 /* GCFIXME: how to arrange so that relocs and symbols are not
5787 reread continually? */
5789 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5790 sym_hashes
= elf_sym_hashes (input_bfd
);
5792 /* Read the local symbols. */
5793 if (elf_bad_symtab (input_bfd
))
5795 nlocsyms
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5799 extsymoff
= nlocsyms
= symtab_hdr
->sh_info
;
5800 if (symtab_hdr
->contents
)
5801 locsyms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
5802 else if (nlocsyms
== 0)
5806 locsyms
= freesyms
=
5807 bfd_malloc (nlocsyms
* sizeof (Elf_External_Sym
));
5808 if (freesyms
== NULL
5809 || bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5810 || (bfd_read (locsyms
, sizeof (Elf_External_Sym
),
5811 nlocsyms
, input_bfd
)
5812 != nlocsyms
* sizeof (Elf_External_Sym
)))
5819 /* Read the relocations. */
5820 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
5821 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5822 info
->keep_memory
));
5823 if (relstart
== NULL
)
5828 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5830 for (rel
= relstart
; rel
< relend
; rel
++)
5832 unsigned long r_symndx
;
5834 struct elf_link_hash_entry
*h
;
5837 r_symndx
= ELF_R_SYM (rel
->r_info
);
5841 if (elf_bad_symtab (sec
->owner
))
5843 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5844 if (ELF_ST_BIND (s
.st_info
) == STB_LOCAL
)
5845 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5848 h
= sym_hashes
[r_symndx
- extsymoff
];
5849 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5852 else if (r_symndx
>= nlocsyms
)
5854 h
= sym_hashes
[r_symndx
- extsymoff
];
5855 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5859 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5860 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5863 if (rsec
&& !rsec
->gc_mark
)
5864 if (!elf_gc_mark (info
, rsec
, gc_mark_hook
))
5872 if (!info
->keep_memory
)
5882 /* The sweep phase of garbage collection. Remove all garbage sections. */
5885 elf_gc_sweep (info
, gc_sweep_hook
)
5886 struct bfd_link_info
*info
;
5887 boolean (*gc_sweep_hook
)
5888 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5889 const Elf_Internal_Rela
*relocs
));
5893 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5897 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5899 /* Keep special sections. Keep .debug sections. */
5900 if ((o
->flags
& SEC_LINKER_CREATED
)
5901 || (o
->flags
& SEC_DEBUGGING
))
5907 /* Skip sweeping sections already excluded. */
5908 if (o
->flags
& SEC_EXCLUDE
)
5911 /* Since this is early in the link process, it is simple
5912 to remove a section from the output. */
5913 o
->flags
|= SEC_EXCLUDE
;
5915 /* But we also have to update some of the relocation
5916 info we collected before. */
5918 && (o
->flags
& SEC_RELOC
) && o
->reloc_count
> 0)
5920 Elf_Internal_Rela
*internal_relocs
;
5923 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
5924 (o
->owner
, o
, NULL
, NULL
, info
->keep_memory
));
5925 if (internal_relocs
== NULL
)
5928 r
= (*gc_sweep_hook
)(o
->owner
, info
, o
, internal_relocs
);
5930 if (!info
->keep_memory
)
5931 free (internal_relocs
);
5939 /* Remove the symbols that were in the swept sections from the dynamic
5940 symbol table. GCFIXME: Anyone know how to get them out of the
5941 static symbol table as well? */
5945 elf_link_hash_traverse (elf_hash_table (info
),
5946 elf_gc_sweep_symbol
,
5949 elf_hash_table (info
)->dynsymcount
= i
;
5955 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
5958 elf_gc_sweep_symbol (h
, idxptr
)
5959 struct elf_link_hash_entry
*h
;
5962 int *idx
= (int *) idxptr
;
5964 if (h
->dynindx
!= -1
5965 && ((h
->root
.type
!= bfd_link_hash_defined
5966 && h
->root
.type
!= bfd_link_hash_defweak
)
5967 || h
->root
.u
.def
.section
->gc_mark
))
5968 h
->dynindx
= (*idx
)++;
5973 /* Propogate collected vtable information. This is called through
5974 elf_link_hash_traverse. */
5977 elf_gc_propagate_vtable_entries_used (h
, okp
)
5978 struct elf_link_hash_entry
*h
;
5981 /* Those that are not vtables. */
5982 if (h
->vtable_parent
== NULL
)
5985 /* Those vtables that do not have parents, we cannot merge. */
5986 if (h
->vtable_parent
== (struct elf_link_hash_entry
*) -1)
5989 /* If we've already been done, exit. */
5990 if (h
->vtable_entries_used
&& h
->vtable_entries_used
[-1])
5993 /* Make sure the parent's table is up to date. */
5994 elf_gc_propagate_vtable_entries_used (h
->vtable_parent
, okp
);
5996 if (h
->vtable_entries_used
== NULL
)
5998 /* None of this table's entries were referenced. Re-use the
6000 h
->vtable_entries_used
= h
->vtable_parent
->vtable_entries_used
;
6001 h
->vtable_entries_size
= h
->vtable_parent
->vtable_entries_size
;
6008 /* Or the parent's entries into ours. */
6009 cu
= h
->vtable_entries_used
;
6011 pu
= h
->vtable_parent
->vtable_entries_used
;
6014 n
= h
->vtable_parent
->vtable_entries_size
/ FILE_ALIGN
;
6017 if (*pu
) *cu
= true;
6027 elf_gc_smash_unused_vtentry_relocs (h
, okp
)
6028 struct elf_link_hash_entry
*h
;
6032 bfd_vma hstart
, hend
;
6033 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
6034 struct elf_backend_data
*bed
;
6036 /* Take care of both those symbols that do not describe vtables as
6037 well as those that are not loaded. */
6038 if (h
->vtable_parent
== NULL
)
6041 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
6042 || h
->root
.type
== bfd_link_hash_defweak
);
6044 sec
= h
->root
.u
.def
.section
;
6045 hstart
= h
->root
.u
.def
.value
;
6046 hend
= hstart
+ h
->size
;
6048 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
6049 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
, true));
6051 return *(boolean
*)okp
= false;
6052 bed
= get_elf_backend_data (sec
->owner
);
6053 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6055 for (rel
= relstart
; rel
< relend
; ++rel
)
6056 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
6058 /* If the entry is in use, do nothing. */
6059 if (h
->vtable_entries_used
6060 && (rel
->r_offset
- hstart
) < h
->vtable_entries_size
)
6062 bfd_vma entry
= (rel
->r_offset
- hstart
) / FILE_ALIGN
;
6063 if (h
->vtable_entries_used
[entry
])
6066 /* Otherwise, kill it. */
6067 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
6073 /* Do mark and sweep of unused sections. */
6076 elf_gc_sections (abfd
, info
)
6078 struct bfd_link_info
*info
;
6082 asection
* (*gc_mark_hook
)
6083 PARAMS ((bfd
*abfd
, struct bfd_link_info
*, Elf_Internal_Rela
*,
6084 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*));
6086 if (!get_elf_backend_data (abfd
)->can_gc_sections
6087 || info
->relocateable
6088 || elf_hash_table (info
)->dynamic_sections_created
)
6091 /* Apply transitive closure to the vtable entry usage info. */
6092 elf_link_hash_traverse (elf_hash_table (info
),
6093 elf_gc_propagate_vtable_entries_used
,
6098 /* Kill the vtable relocations that were not used. */
6099 elf_link_hash_traverse (elf_hash_table (info
),
6100 elf_gc_smash_unused_vtentry_relocs
,
6105 /* Grovel through relocs to find out who stays ... */
6107 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
6108 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
6111 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
6113 if (o
->flags
& SEC_KEEP
)
6114 if (!elf_gc_mark (info
, o
, gc_mark_hook
))
6119 /* ... and mark SEC_EXCLUDE for those that go. */
6120 if (!elf_gc_sweep(info
, get_elf_backend_data (abfd
)->gc_sweep_hook
))
6126 /* Called from check_relocs to record the existance of a VTINHERIT reloc. */
6129 elf_gc_record_vtinherit (abfd
, sec
, h
, offset
)
6132 struct elf_link_hash_entry
*h
;
6135 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
6136 struct elf_link_hash_entry
**search
, *child
;
6137 bfd_size_type extsymcount
;
6139 /* The sh_info field of the symtab header tells us where the
6140 external symbols start. We don't care about the local symbols at
6142 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/sizeof (Elf_External_Sym
);
6143 if (!elf_bad_symtab (abfd
))
6144 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
6146 sym_hashes
= elf_sym_hashes (abfd
);
6147 sym_hashes_end
= sym_hashes
+ extsymcount
;
6149 /* Hunt down the child symbol, which is in this section at the same
6150 offset as the relocation. */
6151 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
6153 if ((child
= *search
) != NULL
6154 && (child
->root
.type
== bfd_link_hash_defined
6155 || child
->root
.type
== bfd_link_hash_defweak
)
6156 && child
->root
.u
.def
.section
== sec
6157 && child
->root
.u
.def
.value
== offset
)
6161 (*_bfd_error_handler
) ("%s: %s+%lu: No symbol found for INHERIT",
6162 bfd_get_filename (abfd
), sec
->name
,
6163 (unsigned long)offset
);
6164 bfd_set_error (bfd_error_invalid_operation
);
6170 /* This *should* only be the absolute section. It could potentially
6171 be that someone has defined a non-global vtable though, which
6172 would be bad. It isn't worth paging in the local symbols to be
6173 sure though; that case should simply be handled by the assembler. */
6175 child
->vtable_parent
= (struct elf_link_hash_entry
*) -1;
6178 child
->vtable_parent
= h
;
6183 /* Called from check_relocs to record the existance of a VTENTRY reloc. */
6186 elf_gc_record_vtentry (abfd
, sec
, h
, addend
)
6189 struct elf_link_hash_entry
*h
;
6192 if (addend
>= h
->vtable_entries_size
)
6195 boolean
*ptr
= h
->vtable_entries_used
;
6197 /* While the symbol is undefined, we have to be prepared to handle
6199 if (h
->root
.type
== bfd_link_hash_undefined
)
6206 /* Oops! We've got a reference past the defined end of
6207 the table. This is probably a bug -- shall we warn? */
6212 /* Allocate one extra entry for use as a "done" flag for the
6213 consolidation pass. */
6214 bytes
= (size
/ FILE_ALIGN
+ 1) * sizeof(boolean
);
6220 ptr
= realloc (ptr
-1, bytes
);
6224 oldbytes
= (h
->vtable_entries_size
/FILE_ALIGN
+ 1) * sizeof(boolean
);
6225 memset (ptr
+ oldbytes
, 0, bytes
- oldbytes
);
6229 ptr
= calloc (1, bytes
);
6234 /* And arrange for that done flag to be at index -1. */
6235 h
->vtable_entries_used
= ptr
+1;
6236 h
->vtable_entries_size
= size
;
6238 h
->vtable_entries_used
[addend
/ FILE_ALIGN
] = true;
6243 /* And an accompanying bit to work out final got entry offsets once
6244 we're done. Should be called from final_link. */
6247 elf_gc_common_finalize_got_offsets (abfd
, info
)
6249 struct bfd_link_info
*info
;
6252 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6255 /* The GOT offset is relative to the .got section, but the GOT header is
6256 put into the .got.plt section, if the backend uses it. */
6257 if (bed
->want_got_plt
)
6260 gotoff
= bed
->got_header_size
;
6262 /* Do the local .got entries first. */
6263 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
6265 bfd_signed_vma
*local_got
= elf_local_got_refcounts (i
);
6266 bfd_size_type j
, locsymcount
;
6267 Elf_Internal_Shdr
*symtab_hdr
;
6272 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
6273 if (elf_bad_symtab (i
))
6274 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6276 locsymcount
= symtab_hdr
->sh_info
;
6278 for (j
= 0; j
< locsymcount
; ++j
)
6280 if (local_got
[j
] > 0)
6282 local_got
[j
] = gotoff
;
6283 gotoff
+= ARCH_SIZE
/ 8;
6286 local_got
[j
] = (bfd_vma
) -1;
6290 /* Then the global .got and .plt entries. */
6291 elf_link_hash_traverse (elf_hash_table (info
),
6292 elf_gc_allocate_got_offsets
,
6297 /* We need a special top-level link routine to convert got reference counts
6298 to real got offsets. */
6301 elf_gc_allocate_got_offsets (h
, offarg
)
6302 struct elf_link_hash_entry
*h
;
6305 bfd_vma
*off
= (bfd_vma
*) offarg
;
6307 if (h
->got
.refcount
> 0)
6309 h
->got
.offset
= off
[0];
6310 off
[0] += ARCH_SIZE
/ 8;
6313 h
->got
.offset
= (bfd_vma
) -1;
6318 /* Many folk need no more in the way of final link than this, once
6319 got entry reference counting is enabled. */
6322 elf_gc_common_final_link (abfd
, info
)
6324 struct bfd_link_info
*info
;
6326 if (!elf_gc_common_finalize_got_offsets (abfd
, info
))
6329 /* Invoke the regular ELF backend linker to do all the work. */
6330 return elf_bfd_final_link (abfd
, info
);
6333 /* This function will be called though elf_link_hash_traverse to store
6334 all hash value of the exported symbols in an array. */
6337 elf_collect_hash_codes (h
, data
)
6338 struct elf_link_hash_entry
*h
;
6341 unsigned long **valuep
= (unsigned long **) data
;
6347 /* Ignore indirect symbols. These are added by the versioning code. */
6348 if (h
->dynindx
== -1)
6351 name
= h
->root
.root
.string
;
6352 p
= strchr (name
, ELF_VER_CHR
);
6355 alc
= bfd_malloc (p
- name
+ 1);
6356 memcpy (alc
, name
, p
- name
);
6357 alc
[p
- name
] = '\0';
6361 /* Compute the hash value. */
6362 ha
= bfd_elf_hash (name
);
6364 /* Store the found hash value in the array given as the argument. */
6367 /* And store it in the struct so that we can put it in the hash table
6369 h
->elf_hash_value
= ha
;