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_collect_hash_codes
52 PARAMS ((struct elf_link_hash_entry
*, PTR
));
53 static boolean elf_link_read_relocs_from_section
54 PARAMS ((bfd
*, Elf_Internal_Shdr
*, PTR
, Elf_Internal_Rela
*));
55 static void elf_link_output_relocs
56 PARAMS ((bfd
*, asection
*, Elf_Internal_Shdr
*, Elf_Internal_Rela
*));
57 static boolean elf_link_size_reloc_section
58 PARAMS ((bfd
*, Elf_Internal_Shdr
*, asection
*));
60 /* Given an ELF BFD, add symbols to the global hash table as
64 elf_bfd_link_add_symbols (abfd
, info
)
66 struct bfd_link_info
*info
;
68 switch (bfd_get_format (abfd
))
71 return elf_link_add_object_symbols (abfd
, info
);
73 return elf_link_add_archive_symbols (abfd
, info
);
75 bfd_set_error (bfd_error_wrong_format
);
81 /* Add symbols from an ELF archive file to the linker hash table. We
82 don't use _bfd_generic_link_add_archive_symbols because of a
83 problem which arises on UnixWare. The UnixWare libc.so is an
84 archive which includes an entry libc.so.1 which defines a bunch of
85 symbols. The libc.so archive also includes a number of other
86 object files, which also define symbols, some of which are the same
87 as those defined in libc.so.1. Correct linking requires that we
88 consider each object file in turn, and include it if it defines any
89 symbols we need. _bfd_generic_link_add_archive_symbols does not do
90 this; it looks through the list of undefined symbols, and includes
91 any object file which defines them. When this algorithm is used on
92 UnixWare, it winds up pulling in libc.so.1 early and defining a
93 bunch of symbols. This means that some of the other objects in the
94 archive are not included in the link, which is incorrect since they
95 precede libc.so.1 in the archive.
97 Fortunately, ELF archive handling is simpler than that done by
98 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
99 oddities. In ELF, if we find a symbol in the archive map, and the
100 symbol is currently undefined, we know that we must pull in that
103 Unfortunately, we do have to make multiple passes over the symbol
104 table until nothing further is resolved. */
107 elf_link_add_archive_symbols (abfd
, info
)
109 struct bfd_link_info
*info
;
112 boolean
*defined
= NULL
;
113 boolean
*included
= NULL
;
117 if (! bfd_has_map (abfd
))
119 /* An empty archive is a special case. */
120 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
122 bfd_set_error (bfd_error_no_armap
);
126 /* Keep track of all symbols we know to be already defined, and all
127 files we know to be already included. This is to speed up the
128 second and subsequent passes. */
129 c
= bfd_ardata (abfd
)->symdef_count
;
132 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
133 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
134 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
136 memset (defined
, 0, c
* sizeof (boolean
));
137 memset (included
, 0, c
* sizeof (boolean
));
139 symdefs
= bfd_ardata (abfd
)->symdefs
;
152 symdefend
= symdef
+ c
;
153 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
155 struct elf_link_hash_entry
*h
;
157 struct bfd_link_hash_entry
*undefs_tail
;
160 if (defined
[i
] || included
[i
])
162 if (symdef
->file_offset
== last
)
168 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
169 false, false, false);
175 /* If this is a default version (the name contains @@),
176 look up the symbol again without the version. The
177 effect is that references to the symbol without the
178 version will be matched by the default symbol in the
181 p
= strchr (symdef
->name
, ELF_VER_CHR
);
182 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
185 copy
= bfd_alloc (abfd
, p
- symdef
->name
+ 1);
188 memcpy (copy
, symdef
->name
, p
- symdef
->name
);
189 copy
[p
- symdef
->name
] = '\0';
191 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
192 false, false, false);
194 bfd_release (abfd
, copy
);
200 if (h
->root
.type
!= bfd_link_hash_undefined
)
202 if (h
->root
.type
!= bfd_link_hash_undefweak
)
207 /* We need to include this archive member. */
209 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
210 if (element
== (bfd
*) NULL
)
213 if (! bfd_check_format (element
, bfd_object
))
216 /* Doublecheck that we have not included this object
217 already--it should be impossible, but there may be
218 something wrong with the archive. */
219 if (element
->archive_pass
!= 0)
221 bfd_set_error (bfd_error_bad_value
);
224 element
->archive_pass
= 1;
226 undefs_tail
= info
->hash
->undefs_tail
;
228 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
231 if (! elf_link_add_object_symbols (element
, info
))
234 /* If there are any new undefined symbols, we need to make
235 another pass through the archive in order to see whether
236 they can be defined. FIXME: This isn't perfect, because
237 common symbols wind up on undefs_tail and because an
238 undefined symbol which is defined later on in this pass
239 does not require another pass. This isn't a bug, but it
240 does make the code less efficient than it could be. */
241 if (undefs_tail
!= info
->hash
->undefs_tail
)
244 /* Look backward to mark all symbols from this object file
245 which we have already seen in this pass. */
249 included
[mark
] = true;
254 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
256 /* We mark subsequent symbols from this object file as we go
257 on through the loop. */
258 last
= symdef
->file_offset
;
269 if (defined
!= (boolean
*) NULL
)
271 if (included
!= (boolean
*) NULL
)
276 /* This function is called when we want to define a new symbol. It
277 handles the various cases which arise when we find a definition in
278 a dynamic object, or when there is already a definition in a
279 dynamic object. The new symbol is described by NAME, SYM, PSEC,
280 and PVALUE. We set SYM_HASH to the hash table entry. We set
281 OVERRIDE if the old symbol is overriding a new definition. We set
282 TYPE_CHANGE_OK if it is OK for the type to change. We set
283 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
284 change, we mean that we shouldn't warn if the type or size does
288 elf_merge_symbol (abfd
, info
, name
, sym
, psec
, pvalue
, sym_hash
,
289 override
, type_change_ok
, size_change_ok
)
291 struct bfd_link_info
*info
;
293 Elf_Internal_Sym
*sym
;
296 struct elf_link_hash_entry
**sym_hash
;
298 boolean
*type_change_ok
;
299 boolean
*size_change_ok
;
302 struct elf_link_hash_entry
*h
;
305 boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
310 bind
= ELF_ST_BIND (sym
->st_info
);
312 if (! bfd_is_und_section (sec
))
313 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, false, false);
315 h
= ((struct elf_link_hash_entry
*)
316 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true, false, false));
321 /* This code is for coping with dynamic objects, and is only useful
322 if we are doing an ELF link. */
323 if (info
->hash
->creator
!= abfd
->xvec
)
326 /* For merging, we only care about real symbols. */
328 while (h
->root
.type
== bfd_link_hash_indirect
329 || h
->root
.type
== bfd_link_hash_warning
)
330 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
332 /* If we just created the symbol, mark it as being an ELF symbol.
333 Other than that, there is nothing to do--there is no merge issue
334 with a newly defined symbol--so we just return. */
336 if (h
->root
.type
== bfd_link_hash_new
)
338 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
342 /* OLDBFD is a BFD associated with the existing symbol. */
344 switch (h
->root
.type
)
350 case bfd_link_hash_undefined
:
351 case bfd_link_hash_undefweak
:
352 oldbfd
= h
->root
.u
.undef
.abfd
;
355 case bfd_link_hash_defined
:
356 case bfd_link_hash_defweak
:
357 oldbfd
= h
->root
.u
.def
.section
->owner
;
360 case bfd_link_hash_common
:
361 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
365 /* In cases involving weak versioned symbols, we may wind up trying
366 to merge a symbol with itself. Catch that here, to avoid the
367 confusion that results if we try to override a symbol with
372 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
373 respectively, is from a dynamic object. */
375 if ((abfd
->flags
& DYNAMIC
) != 0)
380 if (oldbfd
== NULL
|| (oldbfd
->flags
& DYNAMIC
) == 0)
385 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
386 respectively, appear to be a definition rather than reference. */
388 if (bfd_is_und_section (sec
) || bfd_is_com_section (sec
))
393 if (h
->root
.type
== bfd_link_hash_undefined
394 || h
->root
.type
== bfd_link_hash_undefweak
395 || h
->root
.type
== bfd_link_hash_common
)
400 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
401 symbol, respectively, appears to be a common symbol in a dynamic
402 object. If a symbol appears in an uninitialized section, and is
403 not weak, and is not a function, then it may be a common symbol
404 which was resolved when the dynamic object was created. We want
405 to treat such symbols specially, because they raise special
406 considerations when setting the symbol size: if the symbol
407 appears as a common symbol in a regular object, and the size in
408 the regular object is larger, we must make sure that we use the
409 larger size. This problematic case can always be avoided in C,
410 but it must be handled correctly when using Fortran shared
413 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
414 likewise for OLDDYNCOMMON and OLDDEF.
416 Note that this test is just a heuristic, and that it is quite
417 possible to have an uninitialized symbol in a shared object which
418 is really a definition, rather than a common symbol. This could
419 lead to some minor confusion when the symbol really is a common
420 symbol in some regular object. However, I think it will be
425 && (sec
->flags
& SEC_ALLOC
) != 0
426 && (sec
->flags
& SEC_LOAD
) == 0
429 && ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
432 newdyncommon
= false;
436 && h
->root
.type
== bfd_link_hash_defined
437 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
438 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
439 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
441 && h
->type
!= STT_FUNC
)
444 olddyncommon
= false;
446 /* It's OK to change the type if either the existing symbol or the
447 new symbol is weak. */
449 if (h
->root
.type
== bfd_link_hash_defweak
450 || h
->root
.type
== bfd_link_hash_undefweak
452 *type_change_ok
= true;
454 /* It's OK to change the size if either the existing symbol or the
455 new symbol is weak, or if the old symbol is undefined. */
458 || h
->root
.type
== bfd_link_hash_undefined
)
459 *size_change_ok
= true;
461 /* If both the old and the new symbols look like common symbols in a
462 dynamic object, set the size of the symbol to the larger of the
467 && sym
->st_size
!= h
->size
)
469 /* Since we think we have two common symbols, issue a multiple
470 common warning if desired. Note that we only warn if the
471 size is different. If the size is the same, we simply let
472 the old symbol override the new one as normally happens with
473 symbols defined in dynamic objects. */
475 if (! ((*info
->callbacks
->multiple_common
)
476 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
477 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
480 if (sym
->st_size
> h
->size
)
481 h
->size
= sym
->st_size
;
483 *size_change_ok
= true;
486 /* If we are looking at a dynamic object, and we have found a
487 definition, we need to see if the symbol was already defined by
488 some other object. If so, we want to use the existing
489 definition, and we do not want to report a multiple symbol
490 definition error; we do this by clobbering *PSEC to be
493 We treat a common symbol as a definition if the symbol in the
494 shared library is a function, since common symbols always
495 represent variables; this can cause confusion in principle, but
496 any such confusion would seem to indicate an erroneous program or
497 shared library. We also permit a common symbol in a regular
498 object to override a weak symbol in a shared object.
500 We prefer a non-weak definition in a shared library to a weak
501 definition in the executable. */
506 || (h
->root
.type
== bfd_link_hash_common
508 || ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
)))
509 && (h
->root
.type
!= bfd_link_hash_defweak
510 || bind
== STB_WEAK
))
514 newdyncommon
= false;
516 *psec
= sec
= bfd_und_section_ptr
;
517 *size_change_ok
= true;
519 /* If we get here when the old symbol is a common symbol, then
520 we are explicitly letting it override a weak symbol or
521 function in a dynamic object, and we don't want to warn about
522 a type change. If the old symbol is a defined symbol, a type
523 change warning may still be appropriate. */
525 if (h
->root
.type
== bfd_link_hash_common
)
526 *type_change_ok
= true;
529 /* Handle the special case of an old common symbol merging with a
530 new symbol which looks like a common symbol in a shared object.
531 We change *PSEC and *PVALUE to make the new symbol look like a
532 common symbol, and let _bfd_generic_link_add_one_symbol will do
536 && h
->root
.type
== bfd_link_hash_common
)
540 newdyncommon
= false;
541 *pvalue
= sym
->st_size
;
542 *psec
= sec
= bfd_com_section_ptr
;
543 *size_change_ok
= true;
546 /* If the old symbol is from a dynamic object, and the new symbol is
547 a definition which is not from a dynamic object, then the new
548 symbol overrides the old symbol. Symbols from regular files
549 always take precedence over symbols from dynamic objects, even if
550 they are defined after the dynamic object in the link.
552 As above, we again permit a common symbol in a regular object to
553 override a definition in a shared object if the shared object
554 symbol is a function or is weak.
556 As above, we permit a non-weak definition in a shared object to
557 override a weak definition in a regular object. */
561 || (bfd_is_com_section (sec
)
562 && (h
->root
.type
== bfd_link_hash_defweak
563 || h
->type
== STT_FUNC
)))
566 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
568 || h
->root
.type
== bfd_link_hash_defweak
))
570 /* Change the hash table entry to undefined, and let
571 _bfd_generic_link_add_one_symbol do the right thing with the
574 h
->root
.type
= bfd_link_hash_undefined
;
575 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
576 *size_change_ok
= true;
579 olddyncommon
= false;
581 /* We again permit a type change when a common symbol may be
582 overriding a function. */
584 if (bfd_is_com_section (sec
))
585 *type_change_ok
= true;
587 /* This union may have been set to be non-NULL when this symbol
588 was seen in a dynamic object. We must force the union to be
589 NULL, so that it is correct for a regular symbol. */
591 h
->verinfo
.vertree
= NULL
;
593 /* In this special case, if H is the target of an indirection,
594 we want the caller to frob with H rather than with the
595 indirect symbol. That will permit the caller to redefine the
596 target of the indirection, rather than the indirect symbol
597 itself. FIXME: This will break the -y option if we store a
598 symbol with a different name. */
602 /* Handle the special case of a new common symbol merging with an
603 old symbol that looks like it might be a common symbol defined in
604 a shared object. Note that we have already handled the case in
605 which a new common symbol should simply override the definition
606 in the shared library. */
609 && bfd_is_com_section (sec
)
612 /* It would be best if we could set the hash table entry to a
613 common symbol, but we don't know what to use for the section
615 if (! ((*info
->callbacks
->multiple_common
)
616 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
617 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
620 /* If the predumed common symbol in the dynamic object is
621 larger, pretend that the new symbol has its size. */
623 if (h
->size
> *pvalue
)
626 /* FIXME: We no longer know the alignment required by the symbol
627 in the dynamic object, so we just wind up using the one from
628 the regular object. */
631 olddyncommon
= false;
633 h
->root
.type
= bfd_link_hash_undefined
;
634 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
636 *size_change_ok
= true;
637 *type_change_ok
= true;
639 h
->verinfo
.vertree
= NULL
;
642 /* Handle the special case of a weak definition in a regular object
643 followed by a non-weak definition in a shared object. In this
644 case, we prefer the definition in the shared object. */
646 && h
->root
.type
== bfd_link_hash_defweak
651 /* To make this work we have to frob the flags so that the rest
652 of the code does not think we are using the regular
654 h
->elf_link_hash_flags
&= ~ ELF_LINK_HASH_DEF_REGULAR
;
655 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
657 /* If H is the target of an indirection, we want the caller to
658 use H rather than the indirect symbol. Otherwise if we are
659 defining a new indirect symbol we will wind up attaching it
660 to the entry we are overriding. */
664 /* Handle the special case of a non-weak definition in a shared
665 object followed by a weak definition in a regular object. In
666 this case we prefer to definition in the shared object. To make
667 this work we have to tell the caller to not treat the new symbol
671 && h
->root
.type
!= bfd_link_hash_defweak
680 /* Add symbols from an ELF object file to the linker hash table. */
683 elf_link_add_object_symbols (abfd
, info
)
685 struct bfd_link_info
*info
;
687 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
688 const Elf_Internal_Sym
*,
689 const char **, flagword
*,
690 asection
**, bfd_vma
*));
691 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
692 asection
*, const Elf_Internal_Rela
*));
694 Elf_Internal_Shdr
*hdr
;
698 Elf_External_Sym
*buf
= NULL
;
699 struct elf_link_hash_entry
**sym_hash
;
701 bfd_byte
*dynver
= NULL
;
702 Elf_External_Versym
*extversym
= NULL
;
703 Elf_External_Versym
*ever
;
704 Elf_External_Dyn
*dynbuf
= NULL
;
705 struct elf_link_hash_entry
*weaks
;
706 Elf_External_Sym
*esym
;
707 Elf_External_Sym
*esymend
;
709 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
710 collect
= get_elf_backend_data (abfd
)->collect
;
712 if ((abfd
->flags
& DYNAMIC
) == 0)
718 /* You can't use -r against a dynamic object. Also, there's no
719 hope of using a dynamic object which does not exactly match
720 the format of the output file. */
721 if (info
->relocateable
|| info
->hash
->creator
!= abfd
->xvec
)
723 bfd_set_error (bfd_error_invalid_operation
);
728 /* As a GNU extension, any input sections which are named
729 .gnu.warning.SYMBOL are treated as warning symbols for the given
730 symbol. This differs from .gnu.warning sections, which generate
731 warnings when they are included in an output file. */
736 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
740 name
= bfd_get_section_name (abfd
, s
);
741 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
746 name
+= sizeof ".gnu.warning." - 1;
748 /* If this is a shared object, then look up the symbol
749 in the hash table. If it is there, and it is already
750 been defined, then we will not be using the entry
751 from this shared object, so we don't need to warn.
752 FIXME: If we see the definition in a regular object
753 later on, we will warn, but we shouldn't. The only
754 fix is to keep track of what warnings we are supposed
755 to emit, and then handle them all at the end of the
757 if (dynamic
&& abfd
->xvec
== info
->hash
->creator
)
759 struct elf_link_hash_entry
*h
;
761 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
764 /* FIXME: What about bfd_link_hash_common? */
766 && (h
->root
.type
== bfd_link_hash_defined
767 || h
->root
.type
== bfd_link_hash_defweak
))
769 /* We don't want to issue this warning. Clobber
770 the section size so that the warning does not
771 get copied into the output file. */
777 sz
= bfd_section_size (abfd
, s
);
778 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
782 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
787 if (! (_bfd_generic_link_add_one_symbol
788 (info
, abfd
, name
, BSF_WARNING
, s
, (bfd_vma
) 0, msg
,
789 false, collect
, (struct bfd_link_hash_entry
**) NULL
)))
792 if (! info
->relocateable
)
794 /* Clobber the section size so that the warning does
795 not get copied into the output file. */
802 /* If this is a dynamic object, we always link against the .dynsym
803 symbol table, not the .symtab symbol table. The dynamic linker
804 will only see the .dynsym symbol table, so there is no reason to
805 look at .symtab for a dynamic object. */
807 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
808 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
810 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
814 /* Read in any version definitions. */
816 if (! _bfd_elf_slurp_version_tables (abfd
))
819 /* Read in the symbol versions, but don't bother to convert them
820 to internal format. */
821 if (elf_dynversym (abfd
) != 0)
823 Elf_Internal_Shdr
*versymhdr
;
825 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
826 extversym
= (Elf_External_Versym
*) bfd_malloc (hdr
->sh_size
);
827 if (extversym
== NULL
)
829 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
830 || (bfd_read ((PTR
) extversym
, 1, versymhdr
->sh_size
, abfd
)
831 != versymhdr
->sh_size
))
836 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
838 /* The sh_info field of the symtab header tells us where the
839 external symbols start. We don't care about the local symbols at
841 if (elf_bad_symtab (abfd
))
843 extsymcount
= symcount
;
848 extsymcount
= symcount
- hdr
->sh_info
;
849 extsymoff
= hdr
->sh_info
;
852 buf
= ((Elf_External_Sym
*)
853 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
854 if (buf
== NULL
&& extsymcount
!= 0)
857 /* We store a pointer to the hash table entry for each external
859 sym_hash
= ((struct elf_link_hash_entry
**)
861 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
862 if (sym_hash
== NULL
)
864 elf_sym_hashes (abfd
) = sym_hash
;
868 /* If we are creating a shared library, create all the dynamic
869 sections immediately. We need to attach them to something,
870 so we attach them to this BFD, provided it is the right
871 format. FIXME: If there are no input BFD's of the same
872 format as the output, we can't make a shared library. */
874 && ! elf_hash_table (info
)->dynamic_sections_created
875 && abfd
->xvec
== info
->hash
->creator
)
877 if (! elf_link_create_dynamic_sections (abfd
, info
))
886 bfd_size_type oldsize
;
887 bfd_size_type strindex
;
889 /* Find the name to use in a DT_NEEDED entry that refers to this
890 object. If the object has a DT_SONAME entry, we use it.
891 Otherwise, if the generic linker stuck something in
892 elf_dt_name, we use that. Otherwise, we just use the file
893 name. If the generic linker put a null string into
894 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
895 there is a DT_SONAME entry. */
897 name
= bfd_get_filename (abfd
);
898 if (elf_dt_name (abfd
) != NULL
)
900 name
= elf_dt_name (abfd
);
904 s
= bfd_get_section_by_name (abfd
, ".dynamic");
907 Elf_External_Dyn
*extdyn
;
908 Elf_External_Dyn
*extdynend
;
912 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
916 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
917 (file_ptr
) 0, s
->_raw_size
))
920 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
923 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
926 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
927 for (; extdyn
< extdynend
; extdyn
++)
929 Elf_Internal_Dyn dyn
;
931 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
932 if (dyn
.d_tag
== DT_SONAME
)
934 name
= bfd_elf_string_from_elf_section (abfd
, link
,
939 if (dyn
.d_tag
== DT_NEEDED
)
941 struct bfd_link_needed_list
*n
, **pn
;
944 n
= ((struct bfd_link_needed_list
*)
945 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
946 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
948 if (n
== NULL
|| fnm
== NULL
)
950 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
957 for (pn
= &elf_hash_table (info
)->needed
;
969 /* We do not want to include any of the sections in a dynamic
970 object in the output file. We hack by simply clobbering the
971 list of sections in the BFD. This could be handled more
972 cleanly by, say, a new section flag; the existing
973 SEC_NEVER_LOAD flag is not the one we want, because that one
974 still implies that the section takes up space in the output
976 abfd
->sections
= NULL
;
977 abfd
->section_count
= 0;
979 /* If this is the first dynamic object found in the link, create
980 the special sections required for dynamic linking. */
981 if (! elf_hash_table (info
)->dynamic_sections_created
)
983 if (! elf_link_create_dynamic_sections (abfd
, info
))
989 /* Add a DT_NEEDED entry for this dynamic object. */
990 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
991 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
993 if (strindex
== (bfd_size_type
) -1)
996 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
999 Elf_External_Dyn
*dyncon
, *dynconend
;
1001 /* The hash table size did not change, which means that
1002 the dynamic object name was already entered. If we
1003 have already included this dynamic object in the
1004 link, just ignore it. There is no reason to include
1005 a particular dynamic object more than once. */
1006 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
1008 BFD_ASSERT (sdyn
!= NULL
);
1010 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
1011 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
1013 for (; dyncon
< dynconend
; dyncon
++)
1015 Elf_Internal_Dyn dyn
;
1017 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
1019 if (dyn
.d_tag
== DT_NEEDED
1020 && dyn
.d_un
.d_val
== strindex
)
1024 if (extversym
!= NULL
)
1031 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
1035 /* Save the SONAME, if there is one, because sometimes the
1036 linker emulation code will need to know it. */
1038 name
= bfd_get_filename (abfd
);
1039 elf_dt_name (abfd
) = name
;
1043 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
1045 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
1046 != extsymcount
* sizeof (Elf_External_Sym
)))
1051 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
1052 esymend
= buf
+ extsymcount
;
1055 esym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
1057 Elf_Internal_Sym sym
;
1063 struct elf_link_hash_entry
*h
;
1065 boolean size_change_ok
, type_change_ok
;
1066 boolean new_weakdef
;
1067 unsigned int old_alignment
;
1069 elf_swap_symbol_in (abfd
, esym
, &sym
);
1071 flags
= BSF_NO_FLAGS
;
1073 value
= sym
.st_value
;
1076 bind
= ELF_ST_BIND (sym
.st_info
);
1077 if (bind
== STB_LOCAL
)
1079 /* This should be impossible, since ELF requires that all
1080 global symbols follow all local symbols, and that sh_info
1081 point to the first global symbol. Unfortunatealy, Irix 5
1085 else if (bind
== STB_GLOBAL
)
1087 if (sym
.st_shndx
!= SHN_UNDEF
1088 && sym
.st_shndx
!= SHN_COMMON
)
1093 else if (bind
== STB_WEAK
)
1097 /* Leave it up to the processor backend. */
1100 if (sym
.st_shndx
== SHN_UNDEF
)
1101 sec
= bfd_und_section_ptr
;
1102 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
1104 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
1106 sec
= bfd_abs_section_ptr
;
1107 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1110 else if (sym
.st_shndx
== SHN_ABS
)
1111 sec
= bfd_abs_section_ptr
;
1112 else if (sym
.st_shndx
== SHN_COMMON
)
1114 sec
= bfd_com_section_ptr
;
1115 /* What ELF calls the size we call the value. What ELF
1116 calls the value we call the alignment. */
1117 value
= sym
.st_size
;
1121 /* Leave it up to the processor backend. */
1124 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
1125 if (name
== (const char *) NULL
)
1128 if (add_symbol_hook
)
1130 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
1134 /* The hook function sets the name to NULL if this symbol
1135 should be skipped for some reason. */
1136 if (name
== (const char *) NULL
)
1140 /* Sanity check that all possibilities were handled. */
1141 if (sec
== (asection
*) NULL
)
1143 bfd_set_error (bfd_error_bad_value
);
1147 if (bfd_is_und_section (sec
)
1148 || bfd_is_com_section (sec
))
1153 size_change_ok
= false;
1154 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
1156 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1158 Elf_Internal_Versym iver
;
1159 unsigned int vernum
= 0;
1164 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
1165 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
1167 /* If this is a hidden symbol, or if it is not version
1168 1, we append the version name to the symbol name.
1169 However, we do not modify a non-hidden absolute
1170 symbol, because it might be the version symbol
1171 itself. FIXME: What if it isn't? */
1172 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
1173 || (vernum
> 1 && ! bfd_is_abs_section (sec
)))
1176 int namelen
, newlen
;
1179 if (sym
.st_shndx
!= SHN_UNDEF
)
1181 if (vernum
> elf_tdata (abfd
)->dynverdef_hdr
.sh_info
)
1183 (*_bfd_error_handler
)
1184 (_("%s: %s: invalid version %u (max %d)"),
1185 bfd_get_filename (abfd
), name
, vernum
,
1186 elf_tdata (abfd
)->dynverdef_hdr
.sh_info
);
1187 bfd_set_error (bfd_error_bad_value
);
1190 else if (vernum
> 1)
1192 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1198 /* We cannot simply test for the number of
1199 entries in the VERNEED section since the
1200 numbers for the needed versions do not start
1202 Elf_Internal_Verneed
*t
;
1205 for (t
= elf_tdata (abfd
)->verref
;
1209 Elf_Internal_Vernaux
*a
;
1211 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1213 if (a
->vna_other
== vernum
)
1215 verstr
= a
->vna_nodename
;
1224 (*_bfd_error_handler
)
1225 (_("%s: %s: invalid needed version %d"),
1226 bfd_get_filename (abfd
), name
, vernum
);
1227 bfd_set_error (bfd_error_bad_value
);
1232 namelen
= strlen (name
);
1233 newlen
= namelen
+ strlen (verstr
) + 2;
1234 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
1237 newname
= (char *) bfd_alloc (abfd
, newlen
);
1238 if (newname
== NULL
)
1240 strcpy (newname
, name
);
1241 p
= newname
+ namelen
;
1243 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
1251 if (! elf_merge_symbol (abfd
, info
, name
, &sym
, &sec
, &value
,
1252 sym_hash
, &override
, &type_change_ok
,
1260 while (h
->root
.type
== bfd_link_hash_indirect
1261 || h
->root
.type
== bfd_link_hash_warning
)
1262 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1264 /* Remember the old alignment if this is a common symbol, so
1265 that we don't reduce the alignment later on. We can't
1266 check later, because _bfd_generic_link_add_one_symbol
1267 will set a default for the alignment which we want to
1269 if (h
->root
.type
== bfd_link_hash_common
)
1270 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
1272 if (elf_tdata (abfd
)->verdef
!= NULL
1276 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
1279 if (! (_bfd_generic_link_add_one_symbol
1280 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
1281 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
1285 while (h
->root
.type
== bfd_link_hash_indirect
1286 || h
->root
.type
== bfd_link_hash_warning
)
1287 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1290 new_weakdef
= false;
1293 && (flags
& BSF_WEAK
) != 0
1294 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
1295 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1296 && h
->weakdef
== NULL
)
1298 /* Keep a list of all weak defined non function symbols from
1299 a dynamic object, using the weakdef field. Later in this
1300 function we will set the weakdef field to the correct
1301 value. We only put non-function symbols from dynamic
1302 objects on this list, because that happens to be the only
1303 time we need to know the normal symbol corresponding to a
1304 weak symbol, and the information is time consuming to
1305 figure out. If the weakdef field is not already NULL,
1306 then this symbol was already defined by some previous
1307 dynamic object, and we will be using that previous
1308 definition anyhow. */
1315 /* Set the alignment of a common symbol. */
1316 if (sym
.st_shndx
== SHN_COMMON
1317 && h
->root
.type
== bfd_link_hash_common
)
1321 align
= bfd_log2 (sym
.st_value
);
1322 if (align
> old_alignment
)
1323 h
->root
.u
.c
.p
->alignment_power
= align
;
1326 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1332 /* Remember the symbol size and type. */
1333 if (sym
.st_size
!= 0
1334 && (definition
|| h
->size
== 0))
1336 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
1337 (*_bfd_error_handler
)
1338 (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
1339 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
1340 bfd_get_filename (abfd
));
1342 h
->size
= sym
.st_size
;
1345 /* If this is a common symbol, then we always want H->SIZE
1346 to be the size of the common symbol. The code just above
1347 won't fix the size if a common symbol becomes larger. We
1348 don't warn about a size change here, because that is
1349 covered by --warn-common. */
1350 if (h
->root
.type
== bfd_link_hash_common
)
1351 h
->size
= h
->root
.u
.c
.size
;
1353 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
1354 && (definition
|| h
->type
== STT_NOTYPE
))
1356 if (h
->type
!= STT_NOTYPE
1357 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
1358 && ! type_change_ok
)
1359 (*_bfd_error_handler
)
1360 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
1361 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
1362 bfd_get_filename (abfd
));
1364 h
->type
= ELF_ST_TYPE (sym
.st_info
);
1367 if (sym
.st_other
!= 0
1368 && (definition
|| h
->other
== 0))
1369 h
->other
= sym
.st_other
;
1371 /* Set a flag in the hash table entry indicating the type of
1372 reference or definition we just found. Keep a count of
1373 the number of dynamic symbols we find. A dynamic symbol
1374 is one which is referenced or defined by both a regular
1375 object and a shared object. */
1376 old_flags
= h
->elf_link_hash_flags
;
1382 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
1383 if (bind
!= STB_WEAK
)
1384 new_flag
|= ELF_LINK_HASH_REF_REGULAR_NONWEAK
;
1387 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
1389 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1390 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
1396 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
1398 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
1399 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
1400 | ELF_LINK_HASH_REF_REGULAR
)) != 0
1401 || (h
->weakdef
!= NULL
1403 && h
->weakdef
->dynindx
!= -1))
1407 h
->elf_link_hash_flags
|= new_flag
;
1409 /* If this symbol has a version, and it is the default
1410 version, we create an indirect symbol from the default
1411 name to the fully decorated name. This will cause
1412 external references which do not specify a version to be
1413 bound to this version of the symbol. */
1418 p
= strchr (name
, ELF_VER_CHR
);
1419 if (p
!= NULL
&& p
[1] == ELF_VER_CHR
)
1422 struct elf_link_hash_entry
*hi
;
1425 shortname
= bfd_hash_allocate (&info
->hash
->table
,
1427 if (shortname
== NULL
)
1429 strncpy (shortname
, name
, p
- name
);
1430 shortname
[p
- name
] = '\0';
1432 /* We are going to create a new symbol. Merge it
1433 with any existing symbol with this name. For the
1434 purposes of the merge, act as though we were
1435 defining the symbol we just defined, although we
1436 actually going to define an indirect symbol. */
1437 type_change_ok
= false;
1438 size_change_ok
= false;
1439 if (! elf_merge_symbol (abfd
, info
, shortname
, &sym
, &sec
,
1440 &value
, &hi
, &override
,
1441 &type_change_ok
, &size_change_ok
))
1446 if (! (_bfd_generic_link_add_one_symbol
1447 (info
, abfd
, shortname
, BSF_INDIRECT
,
1448 bfd_ind_section_ptr
, (bfd_vma
) 0, name
, false,
1449 collect
, (struct bfd_link_hash_entry
**) &hi
)))
1454 /* In this case the symbol named SHORTNAME is
1455 overriding the indirect symbol we want to
1456 add. We were planning on making SHORTNAME an
1457 indirect symbol referring to NAME. SHORTNAME
1458 is the name without a version. NAME is the
1459 fully versioned name, and it is the default
1462 Overriding means that we already saw a
1463 definition for the symbol SHORTNAME in a
1464 regular object, and it is overriding the
1465 symbol defined in the dynamic object.
1467 When this happens, we actually want to change
1468 NAME, the symbol we just added, to refer to
1469 SHORTNAME. This will cause references to
1470 NAME in the shared object to become
1471 references to SHORTNAME in the regular
1472 object. This is what we expect when we
1473 override a function in a shared object: that
1474 the references in the shared object will be
1475 mapped to the definition in the regular
1478 while (hi
->root
.type
== bfd_link_hash_indirect
1479 || hi
->root
.type
== bfd_link_hash_warning
)
1480 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1482 h
->root
.type
= bfd_link_hash_indirect
;
1483 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1484 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
1486 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEF_DYNAMIC
;
1487 hi
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1488 if (hi
->elf_link_hash_flags
1489 & (ELF_LINK_HASH_REF_REGULAR
1490 | ELF_LINK_HASH_DEF_REGULAR
))
1492 if (! _bfd_elf_link_record_dynamic_symbol (info
,
1498 /* Now set HI to H, so that the following code
1499 will set the other fields correctly. */
1503 /* If there is a duplicate definition somewhere,
1504 then HI may not point to an indirect symbol. We
1505 will have reported an error to the user in that
1508 if (hi
->root
.type
== bfd_link_hash_indirect
)
1510 struct elf_link_hash_entry
*ht
;
1512 /* If the symbol became indirect, then we assume
1513 that we have not seen a definition before. */
1514 BFD_ASSERT ((hi
->elf_link_hash_flags
1515 & (ELF_LINK_HASH_DEF_DYNAMIC
1516 | ELF_LINK_HASH_DEF_REGULAR
))
1519 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1521 /* Copy down any references that we may have
1522 already seen to the symbol which just became
1524 ht
->elf_link_hash_flags
|=
1525 (hi
->elf_link_hash_flags
1526 & (ELF_LINK_HASH_REF_DYNAMIC
1527 | ELF_LINK_HASH_REF_REGULAR
1528 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1530 /* Copy over the global and procedure linkage table
1531 offset entries. These may have been already set
1532 up by a check_relocs routine. */
1533 if (ht
->got
.offset
== (bfd_vma
) -1)
1535 ht
->got
.offset
= hi
->got
.offset
;
1536 hi
->got
.offset
= (bfd_vma
) -1;
1538 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1540 if (ht
->plt
.offset
== (bfd_vma
) -1)
1542 ht
->plt
.offset
= hi
->plt
.offset
;
1543 hi
->plt
.offset
= (bfd_vma
) -1;
1545 BFD_ASSERT (hi
->plt
.offset
== (bfd_vma
) -1);
1547 if (ht
->dynindx
== -1)
1549 ht
->dynindx
= hi
->dynindx
;
1550 ht
->dynstr_index
= hi
->dynstr_index
;
1552 hi
->dynstr_index
= 0;
1554 BFD_ASSERT (hi
->dynindx
== -1);
1556 /* FIXME: There may be other information to copy
1557 over for particular targets. */
1559 /* See if the new flags lead us to realize that
1560 the symbol must be dynamic. */
1566 || ((hi
->elf_link_hash_flags
1567 & ELF_LINK_HASH_REF_DYNAMIC
)
1573 if ((hi
->elf_link_hash_flags
1574 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1580 /* We also need to define an indirection from the
1581 nondefault version of the symbol. */
1583 shortname
= bfd_hash_allocate (&info
->hash
->table
,
1585 if (shortname
== NULL
)
1587 strncpy (shortname
, name
, p
- name
);
1588 strcpy (shortname
+ (p
- name
), p
+ 1);
1590 /* Once again, merge with any existing symbol. */
1591 type_change_ok
= false;
1592 size_change_ok
= false;
1593 if (! elf_merge_symbol (abfd
, info
, shortname
, &sym
, &sec
,
1594 &value
, &hi
, &override
,
1595 &type_change_ok
, &size_change_ok
))
1600 /* Here SHORTNAME is a versioned name, so we
1601 don't expect to see the type of override we
1602 do in the case above. */
1603 (*_bfd_error_handler
)
1604 (_("%s: warning: unexpected redefinition of `%s'"),
1605 bfd_get_filename (abfd
), shortname
);
1609 if (! (_bfd_generic_link_add_one_symbol
1610 (info
, abfd
, shortname
, BSF_INDIRECT
,
1611 bfd_ind_section_ptr
, (bfd_vma
) 0, name
, false,
1612 collect
, (struct bfd_link_hash_entry
**) &hi
)))
1615 /* If there is a duplicate definition somewhere,
1616 then HI may not point to an indirect symbol.
1617 We will have reported an error to the user in
1620 if (hi
->root
.type
== bfd_link_hash_indirect
)
1622 /* If the symbol became indirect, then we
1623 assume that we have not seen a definition
1625 BFD_ASSERT ((hi
->elf_link_hash_flags
1626 & (ELF_LINK_HASH_DEF_DYNAMIC
1627 | ELF_LINK_HASH_DEF_REGULAR
))
1630 /* Copy down any references that we may have
1631 already seen to the symbol which just
1633 h
->elf_link_hash_flags
|=
1634 (hi
->elf_link_hash_flags
1635 & (ELF_LINK_HASH_REF_DYNAMIC
1636 | ELF_LINK_HASH_REF_REGULAR
1637 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1639 /* Copy over the global and procedure linkage
1640 table offset entries. These may have been
1641 already set up by a check_relocs routine. */
1642 if (h
->got
.offset
== (bfd_vma
) -1)
1644 h
->got
.offset
= hi
->got
.offset
;
1645 hi
->got
.offset
= (bfd_vma
) -1;
1647 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1649 if (h
->plt
.offset
== (bfd_vma
) -1)
1651 h
->plt
.offset
= hi
->plt
.offset
;
1652 hi
->plt
.offset
= (bfd_vma
) -1;
1654 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1656 if (h
->dynindx
== -1)
1658 h
->dynindx
= hi
->dynindx
;
1659 h
->dynstr_index
= hi
->dynstr_index
;
1661 hi
->dynstr_index
= 0;
1663 BFD_ASSERT (hi
->dynindx
== -1);
1665 /* FIXME: There may be other information to
1666 copy over for particular targets. */
1668 /* See if the new flags lead us to realize
1669 that the symbol must be dynamic. */
1675 || ((hi
->elf_link_hash_flags
1676 & ELF_LINK_HASH_REF_DYNAMIC
)
1682 if ((hi
->elf_link_hash_flags
1683 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1692 if (dynsym
&& h
->dynindx
== -1)
1694 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1696 if (h
->weakdef
!= NULL
1698 && h
->weakdef
->dynindx
== -1)
1700 if (! _bfd_elf_link_record_dynamic_symbol (info
,
1708 /* Now set the weakdefs field correctly for all the weak defined
1709 symbols we found. The only way to do this is to search all the
1710 symbols. Since we only need the information for non functions in
1711 dynamic objects, that's the only time we actually put anything on
1712 the list WEAKS. We need this information so that if a regular
1713 object refers to a symbol defined weakly in a dynamic object, the
1714 real symbol in the dynamic object is also put in the dynamic
1715 symbols; we also must arrange for both symbols to point to the
1716 same memory location. We could handle the general case of symbol
1717 aliasing, but a general symbol alias can only be generated in
1718 assembler code, handling it correctly would be very time
1719 consuming, and other ELF linkers don't handle general aliasing
1721 while (weaks
!= NULL
)
1723 struct elf_link_hash_entry
*hlook
;
1726 struct elf_link_hash_entry
**hpp
;
1727 struct elf_link_hash_entry
**hppend
;
1730 weaks
= hlook
->weakdef
;
1731 hlook
->weakdef
= NULL
;
1733 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
1734 || hlook
->root
.type
== bfd_link_hash_defweak
1735 || hlook
->root
.type
== bfd_link_hash_common
1736 || hlook
->root
.type
== bfd_link_hash_indirect
);
1737 slook
= hlook
->root
.u
.def
.section
;
1738 vlook
= hlook
->root
.u
.def
.value
;
1740 hpp
= elf_sym_hashes (abfd
);
1741 hppend
= hpp
+ extsymcount
;
1742 for (; hpp
< hppend
; hpp
++)
1744 struct elf_link_hash_entry
*h
;
1747 if (h
!= NULL
&& h
!= hlook
1748 && h
->root
.type
== bfd_link_hash_defined
1749 && h
->root
.u
.def
.section
== slook
1750 && h
->root
.u
.def
.value
== vlook
)
1754 /* If the weak definition is in the list of dynamic
1755 symbols, make sure the real definition is put there
1757 if (hlook
->dynindx
!= -1
1758 && h
->dynindx
== -1)
1760 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1764 /* If the real definition is in the list of dynamic
1765 symbols, make sure the weak definition is put there
1766 as well. If we don't do this, then the dynamic
1767 loader might not merge the entries for the real
1768 definition and the weak definition. */
1769 if (h
->dynindx
!= -1
1770 && hlook
->dynindx
== -1)
1772 if (! _bfd_elf_link_record_dynamic_symbol (info
, hlook
))
1787 if (extversym
!= NULL
)
1793 /* If this object is the same format as the output object, and it is
1794 not a shared library, then let the backend look through the
1797 This is required to build global offset table entries and to
1798 arrange for dynamic relocs. It is not required for the
1799 particular common case of linking non PIC code, even when linking
1800 against shared libraries, but unfortunately there is no way of
1801 knowing whether an object file has been compiled PIC or not.
1802 Looking through the relocs is not particularly time consuming.
1803 The problem is that we must either (1) keep the relocs in memory,
1804 which causes the linker to require additional runtime memory or
1805 (2) read the relocs twice from the input file, which wastes time.
1806 This would be a good case for using mmap.
1808 I have no idea how to handle linking PIC code into a file of a
1809 different format. It probably can't be done. */
1810 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
1812 && abfd
->xvec
== info
->hash
->creator
1813 && check_relocs
!= NULL
)
1817 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1819 Elf_Internal_Rela
*internal_relocs
;
1822 if ((o
->flags
& SEC_RELOC
) == 0
1823 || o
->reloc_count
== 0
1824 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
1825 && (o
->flags
& SEC_DEBUGGING
) != 0)
1826 || bfd_is_abs_section (o
->output_section
))
1829 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
1830 (abfd
, o
, (PTR
) NULL
,
1831 (Elf_Internal_Rela
*) NULL
,
1832 info
->keep_memory
));
1833 if (internal_relocs
== NULL
)
1836 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
1838 if (! info
->keep_memory
)
1839 free (internal_relocs
);
1846 /* If this is a non-traditional, non-relocateable link, try to
1847 optimize the handling of the .stab/.stabstr sections. */
1849 && ! info
->relocateable
1850 && ! info
->traditional_format
1851 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1852 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
1854 asection
*stab
, *stabstr
;
1856 stab
= bfd_get_section_by_name (abfd
, ".stab");
1859 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
1861 if (stabstr
!= NULL
)
1863 struct bfd_elf_section_data
*secdata
;
1865 secdata
= elf_section_data (stab
);
1866 if (! _bfd_link_section_stabs (abfd
,
1867 &elf_hash_table (info
)->stab_info
,
1869 &secdata
->stab_info
))
1884 if (extversym
!= NULL
)
1889 /* Create some sections which will be filled in with dynamic linking
1890 information. ABFD is an input file which requires dynamic sections
1891 to be created. The dynamic sections take up virtual memory space
1892 when the final executable is run, so we need to create them before
1893 addresses are assigned to the output sections. We work out the
1894 actual contents and size of these sections later. */
1897 elf_link_create_dynamic_sections (abfd
, info
)
1899 struct bfd_link_info
*info
;
1902 register asection
*s
;
1903 struct elf_link_hash_entry
*h
;
1904 struct elf_backend_data
*bed
;
1906 if (elf_hash_table (info
)->dynamic_sections_created
)
1909 /* Make sure that all dynamic sections use the same input BFD. */
1910 if (elf_hash_table (info
)->dynobj
== NULL
)
1911 elf_hash_table (info
)->dynobj
= abfd
;
1913 abfd
= elf_hash_table (info
)->dynobj
;
1915 /* Note that we set the SEC_IN_MEMORY flag for all of these
1917 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1918 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1920 /* A dynamically linked executable has a .interp section, but a
1921 shared library does not. */
1924 s
= bfd_make_section (abfd
, ".interp");
1926 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1930 /* Create sections to hold version informations. These are removed
1931 if they are not needed. */
1932 s
= bfd_make_section (abfd
, ".gnu.version_d");
1934 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1935 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1938 s
= bfd_make_section (abfd
, ".gnu.version");
1940 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1941 || ! bfd_set_section_alignment (abfd
, s
, 1))
1944 s
= bfd_make_section (abfd
, ".gnu.version_r");
1946 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1947 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1950 s
= bfd_make_section (abfd
, ".dynsym");
1952 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1953 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1956 s
= bfd_make_section (abfd
, ".dynstr");
1958 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1961 /* Create a strtab to hold the dynamic symbol names. */
1962 if (elf_hash_table (info
)->dynstr
== NULL
)
1964 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1965 if (elf_hash_table (info
)->dynstr
== NULL
)
1969 s
= bfd_make_section (abfd
, ".dynamic");
1971 || ! bfd_set_section_flags (abfd
, s
, flags
)
1972 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1975 /* The special symbol _DYNAMIC is always set to the start of the
1976 .dynamic section. This call occurs before we have processed the
1977 symbols for any dynamic object, so we don't have to worry about
1978 overriding a dynamic definition. We could set _DYNAMIC in a
1979 linker script, but we only want to define it if we are, in fact,
1980 creating a .dynamic section. We don't want to define it if there
1981 is no .dynamic section, since on some ELF platforms the start up
1982 code examines it to decide how to initialize the process. */
1984 if (! (_bfd_generic_link_add_one_symbol
1985 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1986 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1987 (struct bfd_link_hash_entry
**) &h
)))
1989 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1990 h
->type
= STT_OBJECT
;
1993 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1996 bed
= get_elf_backend_data (abfd
);
1998 s
= bfd_make_section (abfd
, ".hash");
2000 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
2001 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
2003 elf_section_data (s
)->this_hdr
.sh_entsize
= bed
->s
->sizeof_hash_entry
;
2005 /* Let the backend create the rest of the sections. This lets the
2006 backend set the right flags. The backend will normally create
2007 the .got and .plt sections. */
2008 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
2011 elf_hash_table (info
)->dynamic_sections_created
= true;
2016 /* Add an entry to the .dynamic table. */
2019 elf_add_dynamic_entry (info
, tag
, val
)
2020 struct bfd_link_info
*info
;
2024 Elf_Internal_Dyn dyn
;
2028 bfd_byte
*newcontents
;
2030 dynobj
= elf_hash_table (info
)->dynobj
;
2032 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
2033 BFD_ASSERT (s
!= NULL
);
2035 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
2036 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
2037 if (newcontents
== NULL
)
2041 dyn
.d_un
.d_val
= val
;
2042 elf_swap_dyn_out (dynobj
, &dyn
,
2043 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
2045 s
->_raw_size
= newsize
;
2046 s
->contents
= newcontents
;
2051 /* Record a new local dynamic symbol. */
2054 elf_link_record_local_dynamic_symbol (info
, input_bfd
, input_indx
)
2055 struct bfd_link_info
*info
;
2059 struct elf_link_local_dynamic_entry
*entry
;
2060 struct elf_link_hash_table
*eht
;
2061 struct bfd_strtab_hash
*dynstr
;
2062 Elf_External_Sym esym
;
2063 unsigned long dynstr_index
;
2066 /* See if the entry exists already. */
2067 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
2068 if (entry
->input_bfd
== input_bfd
&& entry
->input_indx
== input_indx
)
2071 entry
= (struct elf_link_local_dynamic_entry
*)
2072 bfd_alloc (input_bfd
, sizeof (*entry
));
2076 /* Go find the symbol, so that we can find it's name. */
2077 if (bfd_seek (input_bfd
,
2078 (elf_tdata (input_bfd
)->symtab_hdr
.sh_offset
2079 + input_indx
* sizeof (Elf_External_Sym
)),
2081 || (bfd_read (&esym
, sizeof (Elf_External_Sym
), 1, input_bfd
)
2082 != sizeof (Elf_External_Sym
)))
2084 elf_swap_symbol_in (input_bfd
, &esym
, &entry
->isym
);
2086 name
= (bfd_elf_string_from_elf_section
2087 (input_bfd
, elf_tdata (input_bfd
)->symtab_hdr
.sh_link
,
2088 entry
->isym
.st_name
));
2090 dynstr
= elf_hash_table (info
)->dynstr
;
2093 /* Create a strtab to hold the dynamic symbol names. */
2094 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_stringtab_init ();
2099 dynstr_index
= _bfd_stringtab_add (dynstr
, name
, true, false);
2100 if (dynstr_index
== (unsigned long) -1)
2102 entry
->isym
.st_name
= dynstr_index
;
2104 eht
= elf_hash_table (info
);
2106 entry
->next
= eht
->dynlocal
;
2107 eht
->dynlocal
= entry
;
2108 entry
->input_bfd
= input_bfd
;
2109 entry
->input_indx
= input_indx
;
2112 /* The dynindx will be set at the end of size_dynamic_sections. */
2118 /* Read and swap the relocs from the section indicated by SHDR. This
2119 may be either a REL or a RELA section. The relocations are
2120 translated into RELA relocations and stored in INTERNAL_RELOCS,
2121 which should have already been allocated to contain enough space.
2122 The EXTERNAL_RELOCS are a buffer where the external form of the
2123 relocations should be stored.
2125 Returns false if something goes wrong. */
2128 elf_link_read_relocs_from_section (abfd
, shdr
, external_relocs
,
2131 Elf_Internal_Shdr
*shdr
;
2132 PTR external_relocs
;
2133 Elf_Internal_Rela
*internal_relocs
;
2135 struct elf_backend_data
*bed
;
2137 /* If there aren't any relocations, that's OK. */
2141 /* Position ourselves at the start of the section. */
2142 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0)
2145 /* Read the relocations. */
2146 if (bfd_read (external_relocs
, 1, shdr
->sh_size
, abfd
)
2150 bed
= get_elf_backend_data (abfd
);
2152 /* Convert the external relocations to the internal format. */
2153 if (shdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2155 Elf_External_Rel
*erel
;
2156 Elf_External_Rel
*erelend
;
2157 Elf_Internal_Rela
*irela
;
2158 Elf_Internal_Rel
*irel
;
2160 erel
= (Elf_External_Rel
*) external_relocs
;
2161 erelend
= erel
+ shdr
->sh_size
/ shdr
->sh_entsize
;
2162 irela
= internal_relocs
;
2163 irel
= bfd_alloc (abfd
, (bed
->s
->int_rels_per_ext_rel
2164 * sizeof (Elf_Internal_Rel
)));
2165 for (; erel
< erelend
; erel
++, irela
+= bed
->s
->int_rels_per_ext_rel
)
2169 if (bed
->s
->swap_reloc_in
)
2170 (*bed
->s
->swap_reloc_in
) (abfd
, (bfd_byte
*) erel
, irel
);
2172 elf_swap_reloc_in (abfd
, erel
, irel
);
2174 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; ++i
)
2176 irela
[i
].r_offset
= irel
[i
].r_offset
;
2177 irela
[i
].r_info
= irel
[i
].r_info
;
2178 irela
[i
].r_addend
= 0;
2184 Elf_External_Rela
*erela
;
2185 Elf_External_Rela
*erelaend
;
2186 Elf_Internal_Rela
*irela
;
2188 BFD_ASSERT (shdr
->sh_entsize
== sizeof (Elf_External_Rela
));
2190 erela
= (Elf_External_Rela
*) external_relocs
;
2191 erelaend
= erela
+ shdr
->sh_size
/ shdr
->sh_entsize
;
2192 irela
= internal_relocs
;
2193 for (; erela
< erelaend
; erela
++, irela
+= bed
->s
->int_rels_per_ext_rel
)
2195 if (bed
->s
->swap_reloca_in
)
2196 (*bed
->s
->swap_reloca_in
) (abfd
, (bfd_byte
*) erela
, irela
);
2198 elf_swap_reloca_in (abfd
, erela
, irela
);
2205 /* Read and swap the relocs for a section O. They may have been
2206 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2207 not NULL, they are used as buffers to read into. They are known to
2208 be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2209 the return value is allocated using either malloc or bfd_alloc,
2210 according to the KEEP_MEMORY argument. If O has two relocation
2211 sections (both REL and RELA relocations), then the REL_HDR
2212 relocations will appear first in INTERNAL_RELOCS, followed by the
2213 REL_HDR2 relocations. */
2216 NAME(_bfd_elf
,link_read_relocs
) (abfd
, o
, external_relocs
, internal_relocs
,
2220 PTR external_relocs
;
2221 Elf_Internal_Rela
*internal_relocs
;
2222 boolean keep_memory
;
2224 Elf_Internal_Shdr
*rel_hdr
;
2226 Elf_Internal_Rela
*alloc2
= NULL
;
2227 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2229 if (elf_section_data (o
)->relocs
!= NULL
)
2230 return elf_section_data (o
)->relocs
;
2232 if (o
->reloc_count
== 0)
2235 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2237 if (internal_relocs
== NULL
)
2241 size
= (o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
2242 * sizeof (Elf_Internal_Rela
));
2244 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2246 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2247 if (internal_relocs
== NULL
)
2251 if (external_relocs
== NULL
)
2253 size_t size
= (size_t) rel_hdr
->sh_size
;
2255 if (elf_section_data (o
)->rel_hdr2
)
2256 size
+= (size_t) elf_section_data (o
)->rel_hdr2
->sh_size
;
2257 alloc1
= (PTR
) bfd_malloc (size
);
2260 external_relocs
= alloc1
;
2263 if (!elf_link_read_relocs_from_section (abfd
, rel_hdr
,
2267 if (!elf_link_read_relocs_from_section
2269 elf_section_data (o
)->rel_hdr2
,
2270 ((bfd_byte
*) external_relocs
) + rel_hdr
->sh_size
,
2271 internal_relocs
+ (rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
2272 * bed
->s
->int_rels_per_ext_rel
)))
2275 /* Cache the results for next time, if we can. */
2277 elf_section_data (o
)->relocs
= internal_relocs
;
2282 /* Don't free alloc2, since if it was allocated we are passing it
2283 back (under the name of internal_relocs). */
2285 return internal_relocs
;
2296 /* Record an assignment to a symbol made by a linker script. We need
2297 this in case some dynamic object refers to this symbol. */
2301 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
2302 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2303 struct bfd_link_info
*info
;
2307 struct elf_link_hash_entry
*h
;
2309 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
2312 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
2316 if (h
->root
.type
== bfd_link_hash_new
)
2317 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
2319 /* If this symbol is being provided by the linker script, and it is
2320 currently defined by a dynamic object, but not by a regular
2321 object, then mark it as undefined so that the generic linker will
2322 force the correct value. */
2324 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2325 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2326 h
->root
.type
= bfd_link_hash_undefined
;
2328 /* If this symbol is not being provided by the linker script, and it is
2329 currently defined by a dynamic object, but not by a regular object,
2330 then clear out any version information because the symbol will not be
2331 associated with the dynamic object any more. */
2333 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2334 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2335 h
->verinfo
.verdef
= NULL
;
2337 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2338 h
->type
= STT_OBJECT
;
2340 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
2341 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
2343 && h
->dynindx
== -1)
2345 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2348 /* If this is a weak defined symbol, and we know a corresponding
2349 real symbol from the same dynamic object, make sure the real
2350 symbol is also made into a dynamic symbol. */
2351 if (h
->weakdef
!= NULL
2352 && h
->weakdef
->dynindx
== -1)
2354 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
2362 /* This structure is used to pass information to
2363 elf_link_assign_sym_version. */
2365 struct elf_assign_sym_version_info
2369 /* General link information. */
2370 struct bfd_link_info
*info
;
2372 struct bfd_elf_version_tree
*verdefs
;
2373 /* Whether we are exporting all dynamic symbols. */
2374 boolean export_dynamic
;
2375 /* Whether we had a failure. */
2379 /* This structure is used to pass information to
2380 elf_link_find_version_dependencies. */
2382 struct elf_find_verdep_info
2386 /* General link information. */
2387 struct bfd_link_info
*info
;
2388 /* The number of dependencies. */
2390 /* Whether we had a failure. */
2394 /* Array used to determine the number of hash table buckets to use
2395 based on the number of symbols there are. If there are fewer than
2396 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
2397 fewer than 37 we use 17 buckets, and so forth. We never use more
2398 than 32771 buckets. */
2400 static const size_t elf_buckets
[] =
2402 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
2406 /* Compute bucket count for hashing table. We do not use a static set
2407 of possible tables sizes anymore. Instead we determine for all
2408 possible reasonable sizes of the table the outcome (i.e., the
2409 number of collisions etc) and choose the best solution. The
2410 weighting functions are not too simple to allow the table to grow
2411 without bounds. Instead one of the weighting factors is the size.
2412 Therefore the result is always a good payoff between few collisions
2413 (= short chain lengths) and table size. */
2415 compute_bucket_count (info
)
2416 struct bfd_link_info
*info
;
2418 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
2419 size_t best_size
= 0;
2420 unsigned long int *hashcodes
;
2421 unsigned long int *hashcodesp
;
2422 unsigned long int i
;
2424 /* Compute the hash values for all exported symbols. At the same
2425 time store the values in an array so that we could use them for
2427 hashcodes
= (unsigned long int *) bfd_malloc (dynsymcount
2428 * sizeof (unsigned long int));
2429 if (hashcodes
== NULL
)
2431 hashcodesp
= hashcodes
;
2433 /* Put all hash values in HASHCODES. */
2434 elf_link_hash_traverse (elf_hash_table (info
),
2435 elf_collect_hash_codes
, &hashcodesp
);
2437 /* We have a problem here. The following code to optimize the table
2438 size requires an integer type with more the 32 bits. If
2439 BFD_HOST_U_64_BIT is set we know about such a type. */
2440 #ifdef BFD_HOST_U_64_BIT
2441 if (info
->optimize
== true)
2443 unsigned long int nsyms
= hashcodesp
- hashcodes
;
2446 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
2447 unsigned long int *counts
;
2449 /* Possible optimization parameters: if we have NSYMS symbols we say
2450 that the hashing table must at least have NSYMS/4 and at most
2452 minsize
= nsyms
/ 4;
2455 best_size
= maxsize
= nsyms
* 2;
2457 /* Create array where we count the collisions in. We must use bfd_malloc
2458 since the size could be large. */
2459 counts
= (unsigned long int *) bfd_malloc (maxsize
2460 * sizeof (unsigned long int));
2467 /* Compute the "optimal" size for the hash table. The criteria is a
2468 minimal chain length. The minor criteria is (of course) the size
2470 for (i
= minsize
; i
< maxsize
; ++i
)
2472 /* Walk through the array of hashcodes and count the collisions. */
2473 BFD_HOST_U_64_BIT max
;
2474 unsigned long int j
;
2475 unsigned long int fact
;
2477 memset (counts
, '\0', i
* sizeof (unsigned long int));
2479 /* Determine how often each hash bucket is used. */
2480 for (j
= 0; j
< nsyms
; ++j
)
2481 ++counts
[hashcodes
[j
] % i
];
2483 /* For the weight function we need some information about the
2484 pagesize on the target. This is information need not be 100%
2485 accurate. Since this information is not available (so far) we
2486 define it here to a reasonable default value. If it is crucial
2487 to have a better value some day simply define this value. */
2488 # ifndef BFD_TARGET_PAGESIZE
2489 # define BFD_TARGET_PAGESIZE (4096)
2492 /* We in any case need 2 + NSYMS entries for the size values and
2494 max
= (2 + nsyms
) * (ARCH_SIZE
/ 8);
2497 /* Variant 1: optimize for short chains. We add the squares
2498 of all the chain lengths (which favous many small chain
2499 over a few long chains). */
2500 for (j
= 0; j
< i
; ++j
)
2501 max
+= counts
[j
] * counts
[j
];
2503 /* This adds penalties for the overall size of the table. */
2504 fact
= i
/ (BFD_TARGET_PAGESIZE
/ (ARCH_SIZE
/ 8)) + 1;
2507 /* Variant 2: Optimize a lot more for small table. Here we
2508 also add squares of the size but we also add penalties for
2509 empty slots (the +1 term). */
2510 for (j
= 0; j
< i
; ++j
)
2511 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
2513 /* The overall size of the table is considered, but not as
2514 strong as in variant 1, where it is squared. */
2515 fact
= i
/ (BFD_TARGET_PAGESIZE
/ (ARCH_SIZE
/ 8)) + 1;
2519 /* Compare with current best results. */
2520 if (max
< best_chlen
)
2530 #endif /* defined (BFD_HOST_U_64_BIT) */
2532 /* This is the fallback solution if no 64bit type is available or if we
2533 are not supposed to spend much time on optimizations. We select the
2534 bucket count using a fixed set of numbers. */
2535 for (i
= 0; elf_buckets
[i
] != 0; i
++)
2537 best_size
= elf_buckets
[i
];
2538 if (dynsymcount
< elf_buckets
[i
+ 1])
2543 /* Free the arrays we needed. */
2549 /* Set up the sizes and contents of the ELF dynamic sections. This is
2550 called by the ELF linker emulation before_allocation routine. We
2551 must set the sizes of the sections before the linker sets the
2552 addresses of the various sections. */
2555 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
2556 export_dynamic
, filter_shlib
,
2557 auxiliary_filters
, info
, sinterpptr
,
2562 boolean export_dynamic
;
2563 const char *filter_shlib
;
2564 const char * const *auxiliary_filters
;
2565 struct bfd_link_info
*info
;
2566 asection
**sinterpptr
;
2567 struct bfd_elf_version_tree
*verdefs
;
2569 bfd_size_type soname_indx
;
2571 struct elf_backend_data
*bed
;
2572 struct elf_assign_sym_version_info asvinfo
;
2576 soname_indx
= (bfd_size_type
) -1;
2578 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
2581 /* The backend may have to create some sections regardless of whether
2582 we're dynamic or not. */
2583 bed
= get_elf_backend_data (output_bfd
);
2584 if (bed
->elf_backend_always_size_sections
2585 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
2588 dynobj
= elf_hash_table (info
)->dynobj
;
2590 /* If there were no dynamic objects in the link, there is nothing to
2595 /* If we are supposed to export all symbols into the dynamic symbol
2596 table (this is not the normal case), then do so. */
2599 struct elf_info_failed eif
;
2603 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
2609 if (elf_hash_table (info
)->dynamic_sections_created
)
2611 struct elf_info_failed eif
;
2612 struct elf_link_hash_entry
*h
;
2613 bfd_size_type strsize
;
2615 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
2616 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
2620 soname_indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2621 soname
, true, true);
2622 if (soname_indx
== (bfd_size_type
) -1
2623 || ! elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
2629 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
2637 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
2639 if (indx
== (bfd_size_type
) -1
2640 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
2644 if (filter_shlib
!= NULL
)
2648 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2649 filter_shlib
, true, true);
2650 if (indx
== (bfd_size_type
) -1
2651 || ! elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
2655 if (auxiliary_filters
!= NULL
)
2657 const char * const *p
;
2659 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
2663 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2665 if (indx
== (bfd_size_type
) -1
2666 || ! elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
2671 /* Attach all the symbols to their version information. */
2672 asvinfo
.output_bfd
= output_bfd
;
2673 asvinfo
.info
= info
;
2674 asvinfo
.verdefs
= verdefs
;
2675 asvinfo
.export_dynamic
= export_dynamic
;
2676 asvinfo
.failed
= false;
2678 elf_link_hash_traverse (elf_hash_table (info
),
2679 elf_link_assign_sym_version
,
2684 /* Find all symbols which were defined in a dynamic object and make
2685 the backend pick a reasonable value for them. */
2688 elf_link_hash_traverse (elf_hash_table (info
),
2689 elf_adjust_dynamic_symbol
,
2694 /* Add some entries to the .dynamic section. We fill in some of the
2695 values later, in elf_bfd_final_link, but we must add the entries
2696 now so that we know the final size of the .dynamic section. */
2698 /* If there are initialization and/or finalization functions to
2699 call then add the corresponding DT_INIT/DT_FINI entries. */
2700 h
= (info
->init_function
2701 ? elf_link_hash_lookup (elf_hash_table (info
),
2702 info
->init_function
, false,
2706 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2707 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2709 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
2712 h
= (info
->fini_function
2713 ? elf_link_hash_lookup (elf_hash_table (info
),
2714 info
->fini_function
, false,
2718 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2719 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2721 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
2725 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
2726 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
2727 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
2728 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
2729 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
2730 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
2731 sizeof (Elf_External_Sym
)))
2735 /* The backend must work out the sizes of all the other dynamic
2737 if (bed
->elf_backend_size_dynamic_sections
2738 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
2741 if (elf_hash_table (info
)->dynamic_sections_created
)
2745 size_t bucketcount
= 0;
2746 Elf_Internal_Sym isym
;
2747 size_t hash_entry_size
;
2749 /* Set up the version definition section. */
2750 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
2751 BFD_ASSERT (s
!= NULL
);
2753 /* We may have created additional version definitions if we are
2754 just linking a regular application. */
2755 verdefs
= asvinfo
.verdefs
;
2757 if (verdefs
== NULL
)
2758 _bfd_strip_section_from_output (s
);
2763 struct bfd_elf_version_tree
*t
;
2765 Elf_Internal_Verdef def
;
2766 Elf_Internal_Verdaux defaux
;
2771 /* Make space for the base version. */
2772 size
+= sizeof (Elf_External_Verdef
);
2773 size
+= sizeof (Elf_External_Verdaux
);
2776 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2778 struct bfd_elf_version_deps
*n
;
2780 size
+= sizeof (Elf_External_Verdef
);
2781 size
+= sizeof (Elf_External_Verdaux
);
2784 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2785 size
+= sizeof (Elf_External_Verdaux
);
2788 s
->_raw_size
= size
;
2789 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
2790 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2793 /* Fill in the version definition section. */
2797 def
.vd_version
= VER_DEF_CURRENT
;
2798 def
.vd_flags
= VER_FLG_BASE
;
2801 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2802 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2803 + sizeof (Elf_External_Verdaux
));
2805 if (soname_indx
!= (bfd_size_type
) -1)
2807 def
.vd_hash
= bfd_elf_hash (soname
);
2808 defaux
.vda_name
= soname_indx
;
2815 name
= output_bfd
->filename
;
2816 def
.vd_hash
= bfd_elf_hash (name
);
2817 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2819 if (indx
== (bfd_size_type
) -1)
2821 defaux
.vda_name
= indx
;
2823 defaux
.vda_next
= 0;
2825 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2826 (Elf_External_Verdef
*)p
);
2827 p
+= sizeof (Elf_External_Verdef
);
2828 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2829 (Elf_External_Verdaux
*) p
);
2830 p
+= sizeof (Elf_External_Verdaux
);
2832 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2835 struct bfd_elf_version_deps
*n
;
2836 struct elf_link_hash_entry
*h
;
2839 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2842 /* Add a symbol representing this version. */
2844 if (! (_bfd_generic_link_add_one_symbol
2845 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
2846 (bfd_vma
) 0, (const char *) NULL
, false,
2847 get_elf_backend_data (dynobj
)->collect
,
2848 (struct bfd_link_hash_entry
**) &h
)))
2850 h
->elf_link_hash_flags
&= ~ ELF_LINK_NON_ELF
;
2851 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2852 h
->type
= STT_OBJECT
;
2853 h
->verinfo
.vertree
= t
;
2855 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2858 def
.vd_version
= VER_DEF_CURRENT
;
2860 if (t
->globals
== NULL
&& t
->locals
== NULL
&& ! t
->used
)
2861 def
.vd_flags
|= VER_FLG_WEAK
;
2862 def
.vd_ndx
= t
->vernum
+ 1;
2863 def
.vd_cnt
= cdeps
+ 1;
2864 def
.vd_hash
= bfd_elf_hash (t
->name
);
2865 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2866 if (t
->next
!= NULL
)
2867 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2868 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
2872 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2873 (Elf_External_Verdef
*) p
);
2874 p
+= sizeof (Elf_External_Verdef
);
2876 defaux
.vda_name
= h
->dynstr_index
;
2877 if (t
->deps
== NULL
)
2878 defaux
.vda_next
= 0;
2880 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2881 t
->name_indx
= defaux
.vda_name
;
2883 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2884 (Elf_External_Verdaux
*) p
);
2885 p
+= sizeof (Elf_External_Verdaux
);
2887 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2889 if (n
->version_needed
== NULL
)
2891 /* This can happen if there was an error in the
2893 defaux
.vda_name
= 0;
2896 defaux
.vda_name
= n
->version_needed
->name_indx
;
2897 if (n
->next
== NULL
)
2898 defaux
.vda_next
= 0;
2900 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2902 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2903 (Elf_External_Verdaux
*) p
);
2904 p
+= sizeof (Elf_External_Verdaux
);
2908 if (! elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
2909 || ! elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
2912 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
2915 /* Work out the size of the version reference section. */
2917 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
2918 BFD_ASSERT (s
!= NULL
);
2920 struct elf_find_verdep_info sinfo
;
2922 sinfo
.output_bfd
= output_bfd
;
2924 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
2925 if (sinfo
.vers
== 0)
2927 sinfo
.failed
= false;
2929 elf_link_hash_traverse (elf_hash_table (info
),
2930 elf_link_find_version_dependencies
,
2933 if (elf_tdata (output_bfd
)->verref
== NULL
)
2934 _bfd_strip_section_from_output (s
);
2937 Elf_Internal_Verneed
*t
;
2942 /* Build the version definition section. */
2945 for (t
= elf_tdata (output_bfd
)->verref
;
2949 Elf_Internal_Vernaux
*a
;
2951 size
+= sizeof (Elf_External_Verneed
);
2953 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2954 size
+= sizeof (Elf_External_Vernaux
);
2957 s
->_raw_size
= size
;
2958 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, size
);
2959 if (s
->contents
== NULL
)
2963 for (t
= elf_tdata (output_bfd
)->verref
;
2968 Elf_Internal_Vernaux
*a
;
2972 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2975 t
->vn_version
= VER_NEED_CURRENT
;
2977 if (elf_dt_name (t
->vn_bfd
) != NULL
)
2978 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2979 elf_dt_name (t
->vn_bfd
),
2982 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2983 t
->vn_bfd
->filename
, true, false);
2984 if (indx
== (bfd_size_type
) -1)
2987 t
->vn_aux
= sizeof (Elf_External_Verneed
);
2988 if (t
->vn_nextref
== NULL
)
2991 t
->vn_next
= (sizeof (Elf_External_Verneed
)
2992 + caux
* sizeof (Elf_External_Vernaux
));
2994 _bfd_elf_swap_verneed_out (output_bfd
, t
,
2995 (Elf_External_Verneed
*) p
);
2996 p
+= sizeof (Elf_External_Verneed
);
2998 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
3000 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
3001 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
3002 a
->vna_nodename
, true, false);
3003 if (indx
== (bfd_size_type
) -1)
3006 if (a
->vna_nextptr
== NULL
)
3009 a
->vna_next
= sizeof (Elf_External_Vernaux
);
3011 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
3012 (Elf_External_Vernaux
*) p
);
3013 p
+= sizeof (Elf_External_Vernaux
);
3017 if (! elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
3018 || ! elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
3021 elf_tdata (output_bfd
)->cverrefs
= crefs
;
3025 /* Assign dynsym indicies. In a shared library we generate a
3026 section symbol for each output section, which come first.
3027 Next come all of the back-end allocated local dynamic syms,
3028 followed by the rest of the global symbols. */
3030 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
);
3032 /* Work out the size of the symbol version section. */
3033 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3034 BFD_ASSERT (s
!= NULL
);
3035 if (dynsymcount
== 0
3036 || (verdefs
== NULL
&& elf_tdata (output_bfd
)->verref
== NULL
))
3038 _bfd_strip_section_from_output (s
);
3039 /* The DYNSYMCOUNT might have changed if we were going to
3040 output a dynamic symbol table entry for S. */
3041 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
);
3045 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Versym
);
3046 s
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, s
->_raw_size
);
3047 if (s
->contents
== NULL
)
3050 if (! elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
3054 /* Set the size of the .dynsym and .hash sections. We counted
3055 the number of dynamic symbols in elf_link_add_object_symbols.
3056 We will build the contents of .dynsym and .hash when we build
3057 the final symbol table, because until then we do not know the
3058 correct value to give the symbols. We built the .dynstr
3059 section as we went along in elf_link_add_object_symbols. */
3060 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
3061 BFD_ASSERT (s
!= NULL
);
3062 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
3063 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
3064 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3067 /* The first entry in .dynsym is a dummy symbol. */
3074 elf_swap_symbol_out (output_bfd
, &isym
,
3075 (PTR
) (Elf_External_Sym
*) s
->contents
);
3077 /* Compute the size of the hashing table. As a side effect this
3078 computes the hash values for all the names we export. */
3079 bucketcount
= compute_bucket_count (info
);
3081 s
= bfd_get_section_by_name (dynobj
, ".hash");
3082 BFD_ASSERT (s
!= NULL
);
3083 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
3084 s
->_raw_size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
3085 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
3086 if (s
->contents
== NULL
)
3088 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
3090 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
3091 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
3092 s
->contents
+ hash_entry_size
);
3094 elf_hash_table (info
)->bucketcount
= bucketcount
;
3096 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
3097 BFD_ASSERT (s
!= NULL
);
3098 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
3100 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
3107 /* Fix up the flags for a symbol. This handles various cases which
3108 can only be fixed after all the input files are seen. This is
3109 currently called by both adjust_dynamic_symbol and
3110 assign_sym_version, which is unnecessary but perhaps more robust in
3111 the face of future changes. */
3114 elf_fix_symbol_flags (h
, eif
)
3115 struct elf_link_hash_entry
*h
;
3116 struct elf_info_failed
*eif
;
3118 /* If this symbol was mentioned in a non-ELF file, try to set
3119 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
3120 permit a non-ELF file to correctly refer to a symbol defined in
3121 an ELF dynamic object. */
3122 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
3124 if (h
->root
.type
!= bfd_link_hash_defined
3125 && h
->root
.type
!= bfd_link_hash_defweak
)
3126 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
3127 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
3130 if (h
->root
.u
.def
.section
->owner
!= NULL
3131 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
3132 == bfd_target_elf_flavour
))
3133 h
->elf_link_hash_flags
|= (ELF_LINK_HASH_REF_REGULAR
3134 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
);
3136 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3139 if (h
->dynindx
== -1
3140 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3141 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0))
3143 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3152 /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
3153 was first seen in a non-ELF file. Fortunately, if the symbol
3154 was first seen in an ELF file, we're probably OK unless the
3155 symbol was defined in a non-ELF file. Catch that case here.
3156 FIXME: We're still in trouble if the symbol was first seen in
3157 a dynamic object, and then later in a non-ELF regular object. */
3158 if ((h
->root
.type
== bfd_link_hash_defined
3159 || h
->root
.type
== bfd_link_hash_defweak
)
3160 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3161 && (h
->root
.u
.def
.section
->owner
!= NULL
3162 ? (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
3163 != bfd_target_elf_flavour
)
3164 : (bfd_is_abs_section (h
->root
.u
.def
.section
)
3165 && (h
->elf_link_hash_flags
3166 & ELF_LINK_HASH_DEF_DYNAMIC
) == 0)))
3167 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3170 /* If this is a final link, and the symbol was defined as a common
3171 symbol in a regular object file, and there was no definition in
3172 any dynamic object, then the linker will have allocated space for
3173 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
3174 flag will not have been set. */
3175 if (h
->root
.type
== bfd_link_hash_defined
3176 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3177 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
3178 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3179 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
3180 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3182 /* If -Bsymbolic was used (which means to bind references to global
3183 symbols to the definition within the shared object), and this
3184 symbol was defined in a regular object, then it actually doesn't
3185 need a PLT entry. */
3186 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
3187 && eif
->info
->shared
3188 && eif
->info
->symbolic
3189 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
3191 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3192 h
->plt
.offset
= (bfd_vma
) -1;
3198 /* Make the backend pick a good value for a dynamic symbol. This is
3199 called via elf_link_hash_traverse, and also calls itself
3203 elf_adjust_dynamic_symbol (h
, data
)
3204 struct elf_link_hash_entry
*h
;
3207 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
3209 struct elf_backend_data
*bed
;
3211 /* Ignore indirect symbols. These are added by the versioning code. */
3212 if (h
->root
.type
== bfd_link_hash_indirect
)
3215 /* Fix the symbol flags. */
3216 if (! elf_fix_symbol_flags (h
, eif
))
3219 /* If this symbol does not require a PLT entry, and it is not
3220 defined by a dynamic object, or is not referenced by a regular
3221 object, ignore it. We do have to handle a weak defined symbol,
3222 even if no regular object refers to it, if we decided to add it
3223 to the dynamic symbol table. FIXME: Do we normally need to worry
3224 about symbols which are defined by one dynamic object and
3225 referenced by another one? */
3226 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
3227 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
3228 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3229 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
3230 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
3232 h
->plt
.offset
= (bfd_vma
) -1;
3236 /* If we've already adjusted this symbol, don't do it again. This
3237 can happen via a recursive call. */
3238 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
3241 /* Don't look at this symbol again. Note that we must set this
3242 after checking the above conditions, because we may look at a
3243 symbol once, decide not to do anything, and then get called
3244 recursively later after REF_REGULAR is set below. */
3245 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
3247 /* If this is a weak definition, and we know a real definition, and
3248 the real symbol is not itself defined by a regular object file,
3249 then get a good value for the real definition. We handle the
3250 real symbol first, for the convenience of the backend routine.
3252 Note that there is a confusing case here. If the real definition
3253 is defined by a regular object file, we don't get the real symbol
3254 from the dynamic object, but we do get the weak symbol. If the
3255 processor backend uses a COPY reloc, then if some routine in the
3256 dynamic object changes the real symbol, we will not see that
3257 change in the corresponding weak symbol. This is the way other
3258 ELF linkers work as well, and seems to be a result of the shared
3261 I will clarify this issue. Most SVR4 shared libraries define the
3262 variable _timezone and define timezone as a weak synonym. The
3263 tzset call changes _timezone. If you write
3264 extern int timezone;
3266 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
3267 you might expect that, since timezone is a synonym for _timezone,
3268 the same number will print both times. However, if the processor
3269 backend uses a COPY reloc, then actually timezone will be copied
3270 into your process image, and, since you define _timezone
3271 yourself, _timezone will not. Thus timezone and _timezone will
3272 wind up at different memory locations. The tzset call will set
3273 _timezone, leaving timezone unchanged. */
3275 if (h
->weakdef
!= NULL
)
3277 struct elf_link_hash_entry
*weakdef
;
3279 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
3280 || h
->root
.type
== bfd_link_hash_defweak
);
3281 weakdef
= h
->weakdef
;
3282 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
3283 || weakdef
->root
.type
== bfd_link_hash_defweak
);
3284 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
3285 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
3287 /* This symbol is defined by a regular object file, so we
3288 will not do anything special. Clear weakdef for the
3289 convenience of the processor backend. */
3294 /* There is an implicit reference by a regular object file
3295 via the weak symbol. */
3296 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
3297 if (h
->weakdef
->elf_link_hash_flags
3298 & ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3299 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR_NONWEAK
;
3300 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
3305 /* If a symbol has no type and no size and does not require a PLT
3306 entry, then we are probably about to do the wrong thing here: we
3307 are probably going to create a COPY reloc for an empty object.
3308 This case can arise when a shared object is built with assembly
3309 code, and the assembly code fails to set the symbol type. */
3311 && h
->type
== STT_NOTYPE
3312 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
3313 (*_bfd_error_handler
)
3314 (_("warning: type and size of dynamic symbol `%s' are not defined"),
3315 h
->root
.root
.string
);
3317 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
3318 bed
= get_elf_backend_data (dynobj
);
3319 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
3328 /* This routine is used to export all defined symbols into the dynamic
3329 symbol table. It is called via elf_link_hash_traverse. */
3332 elf_export_symbol (h
, data
)
3333 struct elf_link_hash_entry
*h
;
3336 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
3338 /* Ignore indirect symbols. These are added by the versioning code. */
3339 if (h
->root
.type
== bfd_link_hash_indirect
)
3342 if (h
->dynindx
== -1
3343 && (h
->elf_link_hash_flags
3344 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
3346 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3356 /* Look through the symbols which are defined in other shared
3357 libraries and referenced here. Update the list of version
3358 dependencies. This will be put into the .gnu.version_r section.
3359 This function is called via elf_link_hash_traverse. */
3362 elf_link_find_version_dependencies (h
, data
)
3363 struct elf_link_hash_entry
*h
;
3366 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
3367 Elf_Internal_Verneed
*t
;
3368 Elf_Internal_Vernaux
*a
;
3370 /* We only care about symbols defined in shared objects with version
3372 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3373 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
3375 || h
->verinfo
.verdef
== NULL
)
3378 /* See if we already know about this version. */
3379 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
3381 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
3384 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
3385 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
3391 /* This is a new version. Add it to tree we are building. */
3395 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *t
);
3398 rinfo
->failed
= true;
3402 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
3403 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
3404 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
3407 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *a
);
3409 /* Note that we are copying a string pointer here, and testing it
3410 above. If bfd_elf_string_from_elf_section is ever changed to
3411 discard the string data when low in memory, this will have to be
3413 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
3415 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
3416 a
->vna_nextptr
= t
->vn_auxptr
;
3418 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
3421 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
3428 /* Figure out appropriate versions for all the symbols. We may not
3429 have the version number script until we have read all of the input
3430 files, so until that point we don't know which symbols should be
3431 local. This function is called via elf_link_hash_traverse. */
3434 elf_link_assign_sym_version (h
, data
)
3435 struct elf_link_hash_entry
*h
;
3438 struct elf_assign_sym_version_info
*sinfo
=
3439 (struct elf_assign_sym_version_info
*) data
;
3440 struct bfd_link_info
*info
= sinfo
->info
;
3441 struct elf_info_failed eif
;
3444 /* Fix the symbol flags. */
3447 if (! elf_fix_symbol_flags (h
, &eif
))
3450 sinfo
->failed
= true;
3454 /* We only need version numbers for symbols defined in regular
3456 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3459 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
3460 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3462 struct bfd_elf_version_tree
*t
;
3467 /* There are two consecutive ELF_VER_CHR characters if this is
3468 not a hidden symbol. */
3470 if (*p
== ELF_VER_CHR
)
3476 /* If there is no version string, we can just return out. */
3480 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3484 /* Look for the version. If we find it, it is no longer weak. */
3485 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3487 if (strcmp (t
->name
, p
) == 0)
3491 struct bfd_elf_version_expr
*d
;
3493 len
= p
- h
->root
.root
.string
;
3494 alc
= bfd_alloc (sinfo
->output_bfd
, len
);
3497 strncpy (alc
, h
->root
.root
.string
, len
- 1);
3498 alc
[len
- 1] = '\0';
3499 if (alc
[len
- 2] == ELF_VER_CHR
)
3500 alc
[len
- 2] = '\0';
3502 h
->verinfo
.vertree
= t
;
3506 if (t
->globals
!= NULL
)
3508 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3509 if ((*d
->match
) (d
, alc
))
3513 /* See if there is anything to force this symbol to
3515 if (d
== NULL
&& t
->locals
!= NULL
)
3517 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3519 if ((*d
->match
) (d
, alc
))
3521 if (h
->dynindx
!= -1
3523 && ! sinfo
->export_dynamic
)
3525 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3526 h
->elf_link_hash_flags
&=~
3527 ELF_LINK_HASH_NEEDS_PLT
;
3529 h
->plt
.offset
= (bfd_vma
) -1;
3530 /* FIXME: The name of the symbol has
3531 already been recorded in the dynamic
3532 string table section. */
3540 bfd_release (sinfo
->output_bfd
, alc
);
3545 /* If we are building an application, we need to create a
3546 version node for this version. */
3547 if (t
== NULL
&& ! info
->shared
)
3549 struct bfd_elf_version_tree
**pp
;
3552 /* If we aren't going to export this symbol, we don't need
3553 to worry about it. */
3554 if (h
->dynindx
== -1)
3557 t
= ((struct bfd_elf_version_tree
*)
3558 bfd_alloc (sinfo
->output_bfd
, sizeof *t
));
3561 sinfo
->failed
= true;
3570 t
->name_indx
= (unsigned int) -1;
3574 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3576 t
->vernum
= version_index
;
3580 h
->verinfo
.vertree
= t
;
3584 /* We could not find the version for a symbol when
3585 generating a shared archive. Return an error. */
3586 (*_bfd_error_handler
)
3587 (_("%s: undefined versioned symbol name %s"),
3588 bfd_get_filename (sinfo
->output_bfd
), h
->root
.root
.string
);
3589 bfd_set_error (bfd_error_bad_value
);
3590 sinfo
->failed
= true;
3595 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3598 /* If we don't have a version for this symbol, see if we can find
3600 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
3602 struct bfd_elf_version_tree
*t
;
3603 struct bfd_elf_version_tree
*deflt
;
3604 struct bfd_elf_version_expr
*d
;
3606 /* See if can find what version this symbol is in. If the
3607 symbol is supposed to be local, then don't actually register
3610 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3612 if (t
->globals
!= NULL
)
3614 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3616 if ((*d
->match
) (d
, h
->root
.root
.string
))
3618 h
->verinfo
.vertree
= t
;
3627 if (t
->locals
!= NULL
)
3629 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3631 if (d
->pattern
[0] == '*' && d
->pattern
[1] == '\0')
3633 else if ((*d
->match
) (d
, h
->root
.root
.string
))
3635 h
->verinfo
.vertree
= t
;
3636 if (h
->dynindx
!= -1
3638 && ! sinfo
->export_dynamic
)
3640 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3641 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3643 h
->plt
.offset
= (bfd_vma
) -1;
3644 /* FIXME: The name of the symbol has already
3645 been recorded in the dynamic string table
3657 if (deflt
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3659 h
->verinfo
.vertree
= deflt
;
3660 if (h
->dynindx
!= -1
3662 && ! sinfo
->export_dynamic
)
3664 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3665 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3667 h
->plt
.offset
= (bfd_vma
) -1;
3668 /* FIXME: The name of the symbol has already been
3669 recorded in the dynamic string table section. */
3677 /* Final phase of ELF linker. */
3679 /* A structure we use to avoid passing large numbers of arguments. */
3681 struct elf_final_link_info
3683 /* General link information. */
3684 struct bfd_link_info
*info
;
3687 /* Symbol string table. */
3688 struct bfd_strtab_hash
*symstrtab
;
3689 /* .dynsym section. */
3690 asection
*dynsym_sec
;
3691 /* .hash section. */
3693 /* symbol version section (.gnu.version). */
3694 asection
*symver_sec
;
3695 /* Buffer large enough to hold contents of any section. */
3697 /* Buffer large enough to hold external relocs of any section. */
3698 PTR external_relocs
;
3699 /* Buffer large enough to hold internal relocs of any section. */
3700 Elf_Internal_Rela
*internal_relocs
;
3701 /* Buffer large enough to hold external local symbols of any input
3703 Elf_External_Sym
*external_syms
;
3704 /* Buffer large enough to hold internal local symbols of any input
3706 Elf_Internal_Sym
*internal_syms
;
3707 /* Array large enough to hold a symbol index for each local symbol
3708 of any input BFD. */
3710 /* Array large enough to hold a section pointer for each local
3711 symbol of any input BFD. */
3712 asection
**sections
;
3713 /* Buffer to hold swapped out symbols. */
3714 Elf_External_Sym
*symbuf
;
3715 /* Number of swapped out symbols in buffer. */
3716 size_t symbuf_count
;
3717 /* Number of symbols which fit in symbuf. */
3721 static boolean elf_link_output_sym
3722 PARAMS ((struct elf_final_link_info
*, const char *,
3723 Elf_Internal_Sym
*, asection
*));
3724 static boolean elf_link_flush_output_syms
3725 PARAMS ((struct elf_final_link_info
*));
3726 static boolean elf_link_output_extsym
3727 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3728 static boolean elf_link_input_bfd
3729 PARAMS ((struct elf_final_link_info
*, bfd
*));
3730 static boolean elf_reloc_link_order
3731 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
3732 struct bfd_link_order
*));
3734 /* This struct is used to pass information to elf_link_output_extsym. */
3736 struct elf_outext_info
3740 struct elf_final_link_info
*finfo
;
3743 /* Compute the size of, and allocate space for, REL_HDR which is the
3744 section header for a section containing relocations for O. */
3747 elf_link_size_reloc_section (abfd
, rel_hdr
, o
)
3749 Elf_Internal_Shdr
*rel_hdr
;
3752 register struct elf_link_hash_entry
**p
, **pend
;
3754 /* We are overestimating the size required for the relocation
3755 sections, in the case that we are using both REL and RELA
3756 relocations for a single section. In that case, RELOC_COUNT will
3757 be the total number of relocations required, and we allocate
3758 space for that many REL relocations as well as that many RELA
3759 relocations. This approximation is wasteful of disk space.
3760 However, until we keep track of how many of each kind of
3761 relocation is required, it's difficult to calculate the right
3763 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
3765 /* The contents field must last into write_object_contents, so we
3766 allocate it with bfd_alloc rather than malloc. */
3767 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
3768 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
3771 p
= ((struct elf_link_hash_entry
**)
3772 bfd_malloc (o
->reloc_count
3773 * sizeof (struct elf_link_hash_entry
*)));
3774 if (p
== NULL
&& o
->reloc_count
!= 0)
3777 elf_section_data (o
)->rel_hashes
= p
;
3778 pend
= p
+ o
->reloc_count
;
3779 for (; p
< pend
; p
++)
3785 /* Do the final step of an ELF link. */
3788 elf_bfd_final_link (abfd
, info
)
3790 struct bfd_link_info
*info
;
3794 struct elf_final_link_info finfo
;
3795 register asection
*o
;
3796 register struct bfd_link_order
*p
;
3798 size_t max_contents_size
;
3799 size_t max_external_reloc_size
;
3800 size_t max_internal_reloc_count
;
3801 size_t max_sym_count
;
3803 Elf_Internal_Sym elfsym
;
3805 Elf_Internal_Shdr
*symtab_hdr
;
3806 Elf_Internal_Shdr
*symstrtab_hdr
;
3807 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3808 struct elf_outext_info eoinfo
;
3811 abfd
->flags
|= DYNAMIC
;
3813 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
3814 dynobj
= elf_hash_table (info
)->dynobj
;
3817 finfo
.output_bfd
= abfd
;
3818 finfo
.symstrtab
= elf_stringtab_init ();
3819 if (finfo
.symstrtab
== NULL
)
3824 finfo
.dynsym_sec
= NULL
;
3825 finfo
.hash_sec
= NULL
;
3826 finfo
.symver_sec
= NULL
;
3830 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
3831 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
3832 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
3833 finfo
.symver_sec
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3834 /* Note that it is OK if symver_sec is NULL. */
3837 finfo
.contents
= NULL
;
3838 finfo
.external_relocs
= NULL
;
3839 finfo
.internal_relocs
= NULL
;
3840 finfo
.external_syms
= NULL
;
3841 finfo
.internal_syms
= NULL
;
3842 finfo
.indices
= NULL
;
3843 finfo
.sections
= NULL
;
3844 finfo
.symbuf
= NULL
;
3845 finfo
.symbuf_count
= 0;
3847 /* Count up the number of relocations we will output for each output
3848 section, so that we know the sizes of the reloc sections. We
3849 also figure out some maximum sizes. */
3850 max_contents_size
= 0;
3851 max_external_reloc_size
= 0;
3852 max_internal_reloc_count
= 0;
3854 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3858 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3860 if (p
->type
== bfd_section_reloc_link_order
3861 || p
->type
== bfd_symbol_reloc_link_order
)
3863 else if (p
->type
== bfd_indirect_link_order
)
3867 sec
= p
->u
.indirect
.section
;
3869 /* Mark all sections which are to be included in the
3870 link. This will normally be every section. We need
3871 to do this so that we can identify any sections which
3872 the linker has decided to not include. */
3873 sec
->linker_mark
= true;
3875 if (info
->relocateable
)
3876 o
->reloc_count
+= sec
->reloc_count
;
3878 if (sec
->_raw_size
> max_contents_size
)
3879 max_contents_size
= sec
->_raw_size
;
3880 if (sec
->_cooked_size
> max_contents_size
)
3881 max_contents_size
= sec
->_cooked_size
;
3883 /* We are interested in just local symbols, not all
3885 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
3886 && (sec
->owner
->flags
& DYNAMIC
) == 0)
3890 if (elf_bad_symtab (sec
->owner
))
3891 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
3892 / sizeof (Elf_External_Sym
));
3894 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
3896 if (sym_count
> max_sym_count
)
3897 max_sym_count
= sym_count
;
3899 if ((sec
->flags
& SEC_RELOC
) != 0)
3903 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
3904 if (ext_size
> max_external_reloc_size
)
3905 max_external_reloc_size
= ext_size
;
3906 if (sec
->reloc_count
> max_internal_reloc_count
)
3907 max_internal_reloc_count
= sec
->reloc_count
;
3913 if (o
->reloc_count
> 0)
3914 o
->flags
|= SEC_RELOC
;
3917 /* Explicitly clear the SEC_RELOC flag. The linker tends to
3918 set it (this is probably a bug) and if it is set
3919 assign_section_numbers will create a reloc section. */
3920 o
->flags
&=~ SEC_RELOC
;
3923 /* If the SEC_ALLOC flag is not set, force the section VMA to
3924 zero. This is done in elf_fake_sections as well, but forcing
3925 the VMA to 0 here will ensure that relocs against these
3926 sections are handled correctly. */
3927 if ((o
->flags
& SEC_ALLOC
) == 0
3928 && ! o
->user_set_vma
)
3932 /* Figure out the file positions for everything but the symbol table
3933 and the relocs. We set symcount to force assign_section_numbers
3934 to create a symbol table. */
3935 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
3936 BFD_ASSERT (! abfd
->output_has_begun
);
3937 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
3940 /* That created the reloc sections. Set their sizes, and assign
3941 them file positions, and allocate some buffers. */
3942 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3944 if ((o
->flags
& SEC_RELOC
) != 0)
3946 if (!elf_link_size_reloc_section (abfd
,
3947 &elf_section_data (o
)->rel_hdr
,
3951 if (elf_section_data (o
)->rel_hdr2
3952 && !elf_link_size_reloc_section (abfd
,
3953 elf_section_data (o
)->rel_hdr2
,
3959 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3961 /* We have now assigned file positions for all the sections except
3962 .symtab and .strtab. We start the .symtab section at the current
3963 file position, and write directly to it. We build the .strtab
3964 section in memory. */
3965 bfd_get_symcount (abfd
) = 0;
3966 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3967 /* sh_name is set in prep_headers. */
3968 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3969 symtab_hdr
->sh_flags
= 0;
3970 symtab_hdr
->sh_addr
= 0;
3971 symtab_hdr
->sh_size
= 0;
3972 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
3973 /* sh_link is set in assign_section_numbers. */
3974 /* sh_info is set below. */
3975 /* sh_offset is set just below. */
3976 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
3978 off
= elf_tdata (abfd
)->next_file_pos
;
3979 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
3981 /* Note that at this point elf_tdata (abfd)->next_file_pos is
3982 incorrect. We do not yet know the size of the .symtab section.
3983 We correct next_file_pos below, after we do know the size. */
3985 /* Allocate a buffer to hold swapped out symbols. This is to avoid
3986 continuously seeking to the right position in the file. */
3987 if (! info
->keep_memory
|| max_sym_count
< 20)
3988 finfo
.symbuf_size
= 20;
3990 finfo
.symbuf_size
= max_sym_count
;
3991 finfo
.symbuf
= ((Elf_External_Sym
*)
3992 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
3993 if (finfo
.symbuf
== NULL
)
3996 /* Start writing out the symbol table. The first symbol is always a
3998 if (info
->strip
!= strip_all
|| info
->relocateable
)
4000 elfsym
.st_value
= 0;
4003 elfsym
.st_other
= 0;
4004 elfsym
.st_shndx
= SHN_UNDEF
;
4005 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
4006 &elfsym
, bfd_und_section_ptr
))
4011 /* Some standard ELF linkers do this, but we don't because it causes
4012 bootstrap comparison failures. */
4013 /* Output a file symbol for the output file as the second symbol.
4014 We output this even if we are discarding local symbols, although
4015 I'm not sure if this is correct. */
4016 elfsym
.st_value
= 0;
4018 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
4019 elfsym
.st_other
= 0;
4020 elfsym
.st_shndx
= SHN_ABS
;
4021 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
4022 &elfsym
, bfd_abs_section_ptr
))
4026 /* Output a symbol for each section. We output these even if we are
4027 discarding local symbols, since they are used for relocs. These
4028 symbols have no names. We store the index of each one in the
4029 index field of the section, so that we can find it again when
4030 outputting relocs. */
4031 if (info
->strip
!= strip_all
|| info
->relocateable
)
4034 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4035 elfsym
.st_other
= 0;
4036 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
4038 o
= section_from_elf_index (abfd
, i
);
4040 o
->target_index
= bfd_get_symcount (abfd
);
4041 elfsym
.st_shndx
= i
;
4042 if (info
->relocateable
|| o
== NULL
)
4043 elfsym
.st_value
= 0;
4045 elfsym
.st_value
= o
->vma
;
4046 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
4052 /* Allocate some memory to hold information read in from the input
4054 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
4055 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
4056 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
4057 bfd_malloc (max_internal_reloc_count
4058 * sizeof (Elf_Internal_Rela
)
4059 * bed
->s
->int_rels_per_ext_rel
));
4060 finfo
.external_syms
= ((Elf_External_Sym
*)
4061 bfd_malloc (max_sym_count
4062 * sizeof (Elf_External_Sym
)));
4063 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
4064 bfd_malloc (max_sym_count
4065 * sizeof (Elf_Internal_Sym
)));
4066 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
4067 finfo
.sections
= ((asection
**)
4068 bfd_malloc (max_sym_count
* sizeof (asection
*)));
4069 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
4070 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
4071 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
4072 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
4073 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
4074 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
4075 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
4078 /* Since ELF permits relocations to be against local symbols, we
4079 must have the local symbols available when we do the relocations.
4080 Since we would rather only read the local symbols once, and we
4081 would rather not keep them in memory, we handle all the
4082 relocations for a single input file at the same time.
4084 Unfortunately, there is no way to know the total number of local
4085 symbols until we have seen all of them, and the local symbol
4086 indices precede the global symbol indices. This means that when
4087 we are generating relocateable output, and we see a reloc against
4088 a global symbol, we can not know the symbol index until we have
4089 finished examining all the local symbols to see which ones we are
4090 going to output. To deal with this, we keep the relocations in
4091 memory, and don't output them until the end of the link. This is
4092 an unfortunate waste of memory, but I don't see a good way around
4093 it. Fortunately, it only happens when performing a relocateable
4094 link, which is not the common case. FIXME: If keep_memory is set
4095 we could write the relocs out and then read them again; I don't
4096 know how bad the memory loss will be. */
4098 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
4099 sub
->output_has_begun
= false;
4100 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4102 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
4104 if (p
->type
== bfd_indirect_link_order
4105 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
4106 == bfd_target_elf_flavour
))
4108 sub
= p
->u
.indirect
.section
->owner
;
4109 if (! sub
->output_has_begun
)
4111 if (! elf_link_input_bfd (&finfo
, sub
))
4113 sub
->output_has_begun
= true;
4116 else if (p
->type
== bfd_section_reloc_link_order
4117 || p
->type
== bfd_symbol_reloc_link_order
)
4119 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
4124 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
4130 /* That wrote out all the local symbols. Finish up the symbol table
4131 with the global symbols. */
4133 if (info
->strip
!= strip_all
&& info
->shared
)
4135 /* Output any global symbols that got converted to local in a
4136 version script. We do this in a separate step since ELF
4137 requires all local symbols to appear prior to any global
4138 symbols. FIXME: We should only do this if some global
4139 symbols were, in fact, converted to become local. FIXME:
4140 Will this work correctly with the Irix 5 linker? */
4141 eoinfo
.failed
= false;
4142 eoinfo
.finfo
= &finfo
;
4143 eoinfo
.localsyms
= true;
4144 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
4150 /* The sh_info field records the index of the first non local symbol. */
4151 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
4155 Elf_Internal_Sym sym
;
4156 Elf_External_Sym
*dynsym
=
4157 (Elf_External_Sym
*)finfo
.dynsym_sec
->contents
;
4158 unsigned long last_local
= 0;
4160 /* Write out the section symbols for the output sections. */
4167 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4170 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4173 indx
= elf_section_data (s
)->this_idx
;
4174 BFD_ASSERT (indx
> 0);
4175 sym
.st_shndx
= indx
;
4176 sym
.st_value
= s
->vma
;
4178 elf_swap_symbol_out (abfd
, &sym
,
4179 dynsym
+ elf_section_data (s
)->dynindx
);
4182 last_local
= bfd_count_sections (abfd
);
4185 /* Write out the local dynsyms. */
4186 if (elf_hash_table (info
)->dynlocal
)
4188 struct elf_link_local_dynamic_entry
*e
;
4189 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
4193 sym
.st_size
= e
->isym
.st_size
;
4194 sym
.st_other
= e
->isym
.st_other
;
4196 /* Note that we saved a word of storage and overwrote
4197 the original st_name with the dynstr_index. */
4198 sym
.st_name
= e
->isym
.st_name
;
4200 /* Whatever binding the symbol had before, it's now local. */
4201 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
,
4202 ELF_ST_TYPE (e
->isym
.st_info
));
4204 s
= bfd_section_from_elf_index (e
->input_bfd
, e
->isym
.st_shndx
);
4206 sym
.st_shndx
= elf_section_data (s
->output_section
)->this_idx
;
4207 sym
.st_value
= (s
->output_section
->vma
4209 + e
->isym
.st_value
);
4211 if (last_local
< e
->dynindx
)
4212 last_local
= e
->dynindx
;
4214 elf_swap_symbol_out (abfd
, &sym
, dynsym
+ e
->dynindx
);
4218 elf_section_data (finfo
.dynsym_sec
->output_section
)
4219 ->this_hdr
.sh_info
= last_local
;
4222 /* We get the global symbols from the hash table. */
4223 eoinfo
.failed
= false;
4224 eoinfo
.localsyms
= false;
4225 eoinfo
.finfo
= &finfo
;
4226 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
4231 /* Flush all symbols to the file. */
4232 if (! elf_link_flush_output_syms (&finfo
))
4235 /* Now we know the size of the symtab section. */
4236 off
+= symtab_hdr
->sh_size
;
4238 /* Finish up and write out the symbol string table (.strtab)
4240 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4241 /* sh_name was set in prep_headers. */
4242 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4243 symstrtab_hdr
->sh_flags
= 0;
4244 symstrtab_hdr
->sh_addr
= 0;
4245 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
4246 symstrtab_hdr
->sh_entsize
= 0;
4247 symstrtab_hdr
->sh_link
= 0;
4248 symstrtab_hdr
->sh_info
= 0;
4249 /* sh_offset is set just below. */
4250 symstrtab_hdr
->sh_addralign
= 1;
4252 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
4253 elf_tdata (abfd
)->next_file_pos
= off
;
4255 if (bfd_get_symcount (abfd
) > 0)
4257 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
4258 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
4262 /* Adjust the relocs to have the correct symbol indices. */
4263 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4265 struct elf_link_hash_entry
**rel_hash
;
4266 Elf_Internal_Shdr
*rel_hdr
;
4268 if ((o
->flags
& SEC_RELOC
) == 0)
4271 rel_hash
= elf_section_data (o
)->rel_hashes
;
4272 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4273 BFD_ASSERT (elf_section_data (o
)->rel_count
== o
->reloc_count
);
4274 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
4276 if (*rel_hash
== NULL
)
4279 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
4281 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4283 Elf_External_Rel
*erel
;
4284 Elf_Internal_Rel irel
;
4286 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
4287 elf_swap_reloc_in (abfd
, erel
, &irel
);
4288 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
4289 ELF_R_TYPE (irel
.r_info
));
4290 elf_swap_reloc_out (abfd
, &irel
, erel
);
4294 Elf_External_Rela
*erela
;
4295 Elf_Internal_Rela irela
;
4297 BFD_ASSERT (rel_hdr
->sh_entsize
4298 == sizeof (Elf_External_Rela
));
4300 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
4301 elf_swap_reloca_in (abfd
, erela
, &irela
);
4302 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
4303 ELF_R_TYPE (irela
.r_info
));
4304 elf_swap_reloca_out (abfd
, &irela
, erela
);
4308 /* Set the reloc_count field to 0 to prevent write_relocs from
4309 trying to swap the relocs out itself. */
4313 /* If we are linking against a dynamic object, or generating a
4314 shared library, finish up the dynamic linking information. */
4317 Elf_External_Dyn
*dyncon
, *dynconend
;
4319 /* Fix up .dynamic entries. */
4320 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
4321 BFD_ASSERT (o
!= NULL
);
4323 dyncon
= (Elf_External_Dyn
*) o
->contents
;
4324 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
4325 for (; dyncon
< dynconend
; dyncon
++)
4327 Elf_Internal_Dyn dyn
;
4331 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4338 name
= info
->init_function
;
4341 name
= info
->fini_function
;
4344 struct elf_link_hash_entry
*h
;
4346 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4347 false, false, true);
4349 && (h
->root
.type
== bfd_link_hash_defined
4350 || h
->root
.type
== bfd_link_hash_defweak
))
4352 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
4353 o
= h
->root
.u
.def
.section
;
4354 if (o
->output_section
!= NULL
)
4355 dyn
.d_un
.d_val
+= (o
->output_section
->vma
4356 + o
->output_offset
);
4359 /* The symbol is imported from another shared
4360 library and does not apply to this one. */
4364 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4379 name
= ".gnu.version_d";
4382 name
= ".gnu.version_r";
4385 name
= ".gnu.version";
4387 o
= bfd_get_section_by_name (abfd
, name
);
4388 BFD_ASSERT (o
!= NULL
);
4389 dyn
.d_un
.d_ptr
= o
->vma
;
4390 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4397 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
4402 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
4404 Elf_Internal_Shdr
*hdr
;
4406 hdr
= elf_elfsections (abfd
)[i
];
4407 if (hdr
->sh_type
== type
4408 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
4410 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
4411 dyn
.d_un
.d_val
+= hdr
->sh_size
;
4414 if (dyn
.d_un
.d_val
== 0
4415 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
4416 dyn
.d_un
.d_val
= hdr
->sh_addr
;
4420 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4426 /* If we have created any dynamic sections, then output them. */
4429 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
4432 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
4434 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4435 || o
->_raw_size
== 0)
4437 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
4439 /* At this point, we are only interested in sections
4440 created by elf_link_create_dynamic_sections. */
4443 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
4445 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
4447 if (! bfd_set_section_contents (abfd
, o
->output_section
,
4448 o
->contents
, o
->output_offset
,
4456 /* The contents of the .dynstr section are actually in a
4458 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
4459 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4460 || ! _bfd_stringtab_emit (abfd
,
4461 elf_hash_table (info
)->dynstr
))
4467 /* If we have optimized stabs strings, output them. */
4468 if (elf_hash_table (info
)->stab_info
!= NULL
)
4470 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
4474 if (finfo
.symstrtab
!= NULL
)
4475 _bfd_stringtab_free (finfo
.symstrtab
);
4476 if (finfo
.contents
!= NULL
)
4477 free (finfo
.contents
);
4478 if (finfo
.external_relocs
!= NULL
)
4479 free (finfo
.external_relocs
);
4480 if (finfo
.internal_relocs
!= NULL
)
4481 free (finfo
.internal_relocs
);
4482 if (finfo
.external_syms
!= NULL
)
4483 free (finfo
.external_syms
);
4484 if (finfo
.internal_syms
!= NULL
)
4485 free (finfo
.internal_syms
);
4486 if (finfo
.indices
!= NULL
)
4487 free (finfo
.indices
);
4488 if (finfo
.sections
!= NULL
)
4489 free (finfo
.sections
);
4490 if (finfo
.symbuf
!= NULL
)
4491 free (finfo
.symbuf
);
4492 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4494 if ((o
->flags
& SEC_RELOC
) != 0
4495 && elf_section_data (o
)->rel_hashes
!= NULL
)
4496 free (elf_section_data (o
)->rel_hashes
);
4499 elf_tdata (abfd
)->linker
= true;
4504 if (finfo
.symstrtab
!= NULL
)
4505 _bfd_stringtab_free (finfo
.symstrtab
);
4506 if (finfo
.contents
!= NULL
)
4507 free (finfo
.contents
);
4508 if (finfo
.external_relocs
!= NULL
)
4509 free (finfo
.external_relocs
);
4510 if (finfo
.internal_relocs
!= NULL
)
4511 free (finfo
.internal_relocs
);
4512 if (finfo
.external_syms
!= NULL
)
4513 free (finfo
.external_syms
);
4514 if (finfo
.internal_syms
!= NULL
)
4515 free (finfo
.internal_syms
);
4516 if (finfo
.indices
!= NULL
)
4517 free (finfo
.indices
);
4518 if (finfo
.sections
!= NULL
)
4519 free (finfo
.sections
);
4520 if (finfo
.symbuf
!= NULL
)
4521 free (finfo
.symbuf
);
4522 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4524 if ((o
->flags
& SEC_RELOC
) != 0
4525 && elf_section_data (o
)->rel_hashes
!= NULL
)
4526 free (elf_section_data (o
)->rel_hashes
);
4532 /* Add a symbol to the output symbol table. */
4535 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
4536 struct elf_final_link_info
*finfo
;
4538 Elf_Internal_Sym
*elfsym
;
4539 asection
*input_sec
;
4541 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
4542 struct bfd_link_info
*info
,
4547 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
4548 elf_backend_link_output_symbol_hook
;
4549 if (output_symbol_hook
!= NULL
)
4551 if (! ((*output_symbol_hook
)
4552 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
4556 if (name
== (const char *) NULL
|| *name
== '\0')
4557 elfsym
->st_name
= 0;
4558 else if (input_sec
->flags
& SEC_EXCLUDE
)
4559 elfsym
->st_name
= 0;
4562 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
4565 if (elfsym
->st_name
== (unsigned long) -1)
4569 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
4571 if (! elf_link_flush_output_syms (finfo
))
4575 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
4576 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
4577 ++finfo
->symbuf_count
;
4579 ++ bfd_get_symcount (finfo
->output_bfd
);
4584 /* Flush the output symbols to the file. */
4587 elf_link_flush_output_syms (finfo
)
4588 struct elf_final_link_info
*finfo
;
4590 if (finfo
->symbuf_count
> 0)
4592 Elf_Internal_Shdr
*symtab
;
4594 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
4596 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
4598 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
4599 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
4600 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
4603 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
4605 finfo
->symbuf_count
= 0;
4611 /* Add an external symbol to the symbol table. This is called from
4612 the hash table traversal routine. When generating a shared object,
4613 we go through the symbol table twice. The first time we output
4614 anything that might have been forced to local scope in a version
4615 script. The second time we output the symbols that are still
4619 elf_link_output_extsym (h
, data
)
4620 struct elf_link_hash_entry
*h
;
4623 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
4624 struct elf_final_link_info
*finfo
= eoinfo
->finfo
;
4626 Elf_Internal_Sym sym
;
4627 asection
*input_sec
;
4629 /* Decide whether to output this symbol in this pass. */
4630 if (eoinfo
->localsyms
)
4632 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
4637 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4641 /* If we are not creating a shared library, and this symbol is
4642 referenced by a shared library but is not defined anywhere, then
4643 warn that it is undefined. If we do not do this, the runtime
4644 linker will complain that the symbol is undefined when the
4645 program is run. We don't have to worry about symbols that are
4646 referenced by regular files, because we will already have issued
4647 warnings for them. */
4648 if (! finfo
->info
->relocateable
4649 && ! (finfo
->info
->shared
4650 && !finfo
->info
->no_undefined
)
4651 && h
->root
.type
== bfd_link_hash_undefined
4652 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
4653 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4655 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4656 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
4657 (asection
*) NULL
, 0)))
4659 eoinfo
->failed
= true;
4664 /* We don't want to output symbols that have never been mentioned by
4665 a regular file, or that we have been told to strip. However, if
4666 h->indx is set to -2, the symbol is used by a reloc and we must
4670 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4671 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
4672 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
4673 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4675 else if (finfo
->info
->strip
== strip_all
4676 || (finfo
->info
->strip
== strip_some
4677 && bfd_hash_lookup (finfo
->info
->keep_hash
,
4678 h
->root
.root
.string
,
4679 false, false) == NULL
))
4684 /* If we're stripping it, and it's not a dynamic symbol, there's
4685 nothing else to do. */
4686 if (strip
&& h
->dynindx
== -1)
4690 sym
.st_size
= h
->size
;
4691 sym
.st_other
= h
->other
;
4692 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4693 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
4694 else if (h
->root
.type
== bfd_link_hash_undefweak
4695 || h
->root
.type
== bfd_link_hash_defweak
)
4696 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4698 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
4700 switch (h
->root
.type
)
4703 case bfd_link_hash_new
:
4707 case bfd_link_hash_undefined
:
4708 input_sec
= bfd_und_section_ptr
;
4709 sym
.st_shndx
= SHN_UNDEF
;
4712 case bfd_link_hash_undefweak
:
4713 input_sec
= bfd_und_section_ptr
;
4714 sym
.st_shndx
= SHN_UNDEF
;
4717 case bfd_link_hash_defined
:
4718 case bfd_link_hash_defweak
:
4720 input_sec
= h
->root
.u
.def
.section
;
4721 if (input_sec
->output_section
!= NULL
)
4724 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
4725 input_sec
->output_section
);
4726 if (sym
.st_shndx
== (unsigned short) -1)
4728 (*_bfd_error_handler
)
4729 (_("%s: could not find output section %s for input section %s"),
4730 bfd_get_filename (finfo
->output_bfd
),
4731 input_sec
->output_section
->name
,
4733 eoinfo
->failed
= true;
4737 /* ELF symbols in relocateable files are section relative,
4738 but in nonrelocateable files they are virtual
4740 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
4741 if (! finfo
->info
->relocateable
)
4742 sym
.st_value
+= input_sec
->output_section
->vma
;
4746 BFD_ASSERT (input_sec
->owner
== NULL
4747 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
4748 sym
.st_shndx
= SHN_UNDEF
;
4749 input_sec
= bfd_und_section_ptr
;
4754 case bfd_link_hash_common
:
4755 input_sec
= h
->root
.u
.c
.p
->section
;
4756 sym
.st_shndx
= SHN_COMMON
;
4757 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
4760 case bfd_link_hash_indirect
:
4761 /* These symbols are created by symbol versioning. They point
4762 to the decorated version of the name. For example, if the
4763 symbol foo@@GNU_1.2 is the default, which should be used when
4764 foo is used with no version, then we add an indirect symbol
4765 foo which points to foo@@GNU_1.2. We ignore these symbols,
4766 since the indirected symbol is already in the hash table. If
4767 the indirect symbol is non-ELF, fall through and output it. */
4768 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) == 0)
4772 case bfd_link_hash_warning
:
4773 /* We can't represent these symbols in ELF, although a warning
4774 symbol may have come from a .gnu.warning.SYMBOL section. We
4775 just put the target symbol in the hash table. If the target
4776 symbol does not really exist, don't do anything. */
4777 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
4779 return (elf_link_output_extsym
4780 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
4783 /* Give the processor backend a chance to tweak the symbol value,
4784 and also to finish up anything that needs to be done for this
4786 if ((h
->dynindx
!= -1
4787 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4788 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4790 struct elf_backend_data
*bed
;
4792 bed
= get_elf_backend_data (finfo
->output_bfd
);
4793 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
4794 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
4796 eoinfo
->failed
= true;
4801 /* If we are marking the symbol as undefined, and there are no
4802 non-weak references to this symbol from a regular object, then
4803 mark the symbol as weak undefined. We can't do this earlier,
4804 because it might not be marked as undefined until the
4805 finish_dynamic_symbol routine gets through with it. */
4806 if (sym
.st_shndx
== SHN_UNDEF
4807 && sym
.st_info
== ELF_ST_INFO (STB_GLOBAL
, h
->type
)
4808 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
4809 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
) == 0)
4810 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4812 /* If this symbol should be put in the .dynsym section, then put it
4813 there now. We have already know the symbol index. We also fill
4814 in the entry in the .hash section. */
4815 if (h
->dynindx
!= -1
4816 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4820 size_t hash_entry_size
;
4821 bfd_byte
*bucketpos
;
4824 sym
.st_name
= h
->dynstr_index
;
4826 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
4827 (PTR
) (((Elf_External_Sym
*)
4828 finfo
->dynsym_sec
->contents
)
4831 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
4832 bucket
= h
->elf_hash_value
% bucketcount
;
4834 = elf_section_data (finfo
->hash_sec
)->this_hdr
.sh_entsize
;
4835 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
4836 + (bucket
+ 2) * hash_entry_size
);
4837 chain
= bfd_get (8 * hash_entry_size
, finfo
->output_bfd
, bucketpos
);
4838 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, h
->dynindx
, bucketpos
);
4839 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, chain
,
4840 ((bfd_byte
*) finfo
->hash_sec
->contents
4841 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
4843 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
4845 Elf_Internal_Versym iversym
;
4847 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4849 if (h
->verinfo
.verdef
== NULL
)
4850 iversym
.vs_vers
= 0;
4852 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
4856 if (h
->verinfo
.vertree
== NULL
)
4857 iversym
.vs_vers
= 1;
4859 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
4862 if ((h
->elf_link_hash_flags
& ELF_LINK_HIDDEN
) != 0)
4863 iversym
.vs_vers
|= VERSYM_HIDDEN
;
4865 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
,
4866 (((Elf_External_Versym
*)
4867 finfo
->symver_sec
->contents
)
4872 /* If we're stripping it, then it was just a dynamic symbol, and
4873 there's nothing else to do. */
4877 h
->indx
= bfd_get_symcount (finfo
->output_bfd
);
4879 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
4881 eoinfo
->failed
= true;
4888 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
4889 originated from the section given by INPUT_REL_HDR) to the
4893 elf_link_output_relocs (output_bfd
, input_section
, input_rel_hdr
,
4896 asection
*input_section
;
4897 Elf_Internal_Shdr
*input_rel_hdr
;
4898 Elf_Internal_Rela
*internal_relocs
;
4900 Elf_Internal_Rela
*irela
;
4901 Elf_Internal_Rela
*irelaend
;
4902 Elf_Internal_Shdr
*output_rel_hdr
;
4903 asection
*output_section
;
4904 unsigned int *rel_countp
= NULL
;
4906 output_section
= input_section
->output_section
;
4907 output_rel_hdr
= NULL
;
4909 if (elf_section_data (output_section
)->rel_hdr
.sh_entsize
4910 == input_rel_hdr
->sh_entsize
)
4912 output_rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
4913 rel_countp
= &elf_section_data (output_section
)->rel_count
;
4915 else if (elf_section_data (output_section
)->rel_hdr2
4916 && (elf_section_data (output_section
)->rel_hdr2
->sh_entsize
4917 == input_rel_hdr
->sh_entsize
))
4919 output_rel_hdr
= elf_section_data (output_section
)->rel_hdr2
;
4920 rel_countp
= &elf_section_data (output_section
)->rel_count2
;
4923 BFD_ASSERT (output_rel_hdr
!= NULL
);
4925 irela
= internal_relocs
;
4926 irelaend
= irela
+ input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
4927 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4929 Elf_External_Rel
*erel
;
4931 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
+ *rel_countp
);
4932 for (; irela
< irelaend
; irela
++, erel
++)
4934 Elf_Internal_Rel irel
;
4936 irel
.r_offset
= irela
->r_offset
;
4937 irel
.r_info
= irela
->r_info
;
4938 BFD_ASSERT (irela
->r_addend
== 0);
4939 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
4944 Elf_External_Rela
*erela
;
4946 BFD_ASSERT (input_rel_hdr
->sh_entsize
4947 == sizeof (Elf_External_Rela
));
4948 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
+ *rel_countp
);
4949 for (; irela
< irelaend
; irela
++, erela
++)
4950 elf_swap_reloca_out (output_bfd
, irela
, erela
);
4953 /* Bump the counter, so that we know where to add the next set of
4955 *rel_countp
+= input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
4958 /* Link an input file into the linker output file. This function
4959 handles all the sections and relocations of the input file at once.
4960 This is so that we only have to read the local symbols once, and
4961 don't have to keep them in memory. */
4964 elf_link_input_bfd (finfo
, input_bfd
)
4965 struct elf_final_link_info
*finfo
;
4968 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
4969 bfd
*, asection
*, bfd_byte
*,
4970 Elf_Internal_Rela
*,
4971 Elf_Internal_Sym
*, asection
**));
4973 Elf_Internal_Shdr
*symtab_hdr
;
4976 Elf_External_Sym
*external_syms
;
4977 Elf_External_Sym
*esym
;
4978 Elf_External_Sym
*esymend
;
4979 Elf_Internal_Sym
*isym
;
4981 asection
**ppsection
;
4983 struct elf_backend_data
*bed
;
4985 output_bfd
= finfo
->output_bfd
;
4986 bed
= get_elf_backend_data (output_bfd
);
4987 relocate_section
= bed
->elf_backend_relocate_section
;
4989 /* If this is a dynamic object, we don't want to do anything here:
4990 we don't want the local symbols, and we don't want the section
4992 if ((input_bfd
->flags
& DYNAMIC
) != 0)
4995 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4996 if (elf_bad_symtab (input_bfd
))
4998 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5003 locsymcount
= symtab_hdr
->sh_info
;
5004 extsymoff
= symtab_hdr
->sh_info
;
5007 /* Read the local symbols. */
5008 if (symtab_hdr
->contents
!= NULL
)
5009 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
5010 else if (locsymcount
== 0)
5011 external_syms
= NULL
;
5014 external_syms
= finfo
->external_syms
;
5015 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5016 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
5017 locsymcount
, input_bfd
)
5018 != locsymcount
* sizeof (Elf_External_Sym
)))
5022 /* Swap in the local symbols and write out the ones which we know
5023 are going into the output file. */
5024 esym
= external_syms
;
5025 esymend
= esym
+ locsymcount
;
5026 isym
= finfo
->internal_syms
;
5027 pindex
= finfo
->indices
;
5028 ppsection
= finfo
->sections
;
5029 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
5033 Elf_Internal_Sym osym
;
5035 elf_swap_symbol_in (input_bfd
, esym
, isym
);
5038 if (elf_bad_symtab (input_bfd
))
5040 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
5047 if (isym
->st_shndx
== SHN_UNDEF
)
5048 isec
= bfd_und_section_ptr
;
5049 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
5050 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
5051 else if (isym
->st_shndx
== SHN_ABS
)
5052 isec
= bfd_abs_section_ptr
;
5053 else if (isym
->st_shndx
== SHN_COMMON
)
5054 isec
= bfd_com_section_ptr
;
5063 /* Don't output the first, undefined, symbol. */
5064 if (esym
== external_syms
)
5067 /* If we are stripping all symbols, we don't want to output this
5069 if (finfo
->info
->strip
== strip_all
)
5072 /* We never output section symbols. Instead, we use the section
5073 symbol of the corresponding section in the output file. */
5074 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5077 /* If we are discarding all local symbols, we don't want to
5078 output this one. If we are generating a relocateable output
5079 file, then some of the local symbols may be required by
5080 relocs; we output them below as we discover that they are
5082 if (finfo
->info
->discard
== discard_all
)
5085 /* If this symbol is defined in a section which we are
5086 discarding, we don't need to keep it, but note that
5087 linker_mark is only reliable for sections that have contents.
5088 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
5089 as well as linker_mark. */
5090 if (isym
->st_shndx
> 0
5091 && isym
->st_shndx
< SHN_LORESERVE
5093 && ((! isec
->linker_mark
&& (isec
->flags
& SEC_HAS_CONTENTS
) != 0)
5094 || (! finfo
->info
->relocateable
5095 && (isec
->flags
& SEC_EXCLUDE
) != 0)))
5098 /* Get the name of the symbol. */
5099 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
5104 /* See if we are discarding symbols with this name. */
5105 if ((finfo
->info
->strip
== strip_some
5106 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
5108 || (finfo
->info
->discard
== discard_l
5109 && bfd_is_local_label_name (input_bfd
, name
)))
5112 /* If we get here, we are going to output this symbol. */
5116 /* Adjust the section index for the output file. */
5117 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
5118 isec
->output_section
);
5119 if (osym
.st_shndx
== (unsigned short) -1)
5122 *pindex
= bfd_get_symcount (output_bfd
);
5124 /* ELF symbols in relocateable files are section relative, but
5125 in executable files they are virtual addresses. Note that
5126 this code assumes that all ELF sections have an associated
5127 BFD section with a reasonable value for output_offset; below
5128 we assume that they also have a reasonable value for
5129 output_section. Any special sections must be set up to meet
5130 these requirements. */
5131 osym
.st_value
+= isec
->output_offset
;
5132 if (! finfo
->info
->relocateable
)
5133 osym
.st_value
+= isec
->output_section
->vma
;
5135 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
5139 /* Relocate the contents of each section. */
5140 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5144 if (! o
->linker_mark
)
5146 /* This section was omitted from the link. */
5150 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
5151 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
5154 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
5156 /* Section was created by elf_link_create_dynamic_sections
5161 /* Get the contents of the section. They have been cached by a
5162 relaxation routine. Note that o is a section in an input
5163 file, so the contents field will not have been set by any of
5164 the routines which work on output files. */
5165 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
5166 contents
= elf_section_data (o
)->this_hdr
.contents
;
5169 contents
= finfo
->contents
;
5170 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
5171 (file_ptr
) 0, o
->_raw_size
))
5175 if ((o
->flags
& SEC_RELOC
) != 0)
5177 Elf_Internal_Rela
*internal_relocs
;
5179 /* Get the swapped relocs. */
5180 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
5181 (input_bfd
, o
, finfo
->external_relocs
,
5182 finfo
->internal_relocs
, false));
5183 if (internal_relocs
== NULL
5184 && o
->reloc_count
> 0)
5187 /* Relocate the section by invoking a back end routine.
5189 The back end routine is responsible for adjusting the
5190 section contents as necessary, and (if using Rela relocs
5191 and generating a relocateable output file) adjusting the
5192 reloc addend as necessary.
5194 The back end routine does not have to worry about setting
5195 the reloc address or the reloc symbol index.
5197 The back end routine is given a pointer to the swapped in
5198 internal symbols, and can access the hash table entries
5199 for the external symbols via elf_sym_hashes (input_bfd).
5201 When generating relocateable output, the back end routine
5202 must handle STB_LOCAL/STT_SECTION symbols specially. The
5203 output symbol is going to be a section symbol
5204 corresponding to the output section, which will require
5205 the addend to be adjusted. */
5207 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
5208 input_bfd
, o
, contents
,
5210 finfo
->internal_syms
,
5214 if (finfo
->info
->relocateable
)
5216 Elf_Internal_Rela
*irela
;
5217 Elf_Internal_Rela
*irelaend
;
5218 struct elf_link_hash_entry
**rel_hash
;
5219 Elf_Internal_Shdr
*input_rel_hdr
;
5221 /* Adjust the reloc addresses and symbol indices. */
5223 irela
= internal_relocs
;
5225 irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5226 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
5227 + elf_section_data (o
->output_section
)->rel_count
);
5228 for (; irela
< irelaend
; irela
++, rel_hash
++)
5230 unsigned long r_symndx
;
5231 Elf_Internal_Sym
*isym
;
5234 irela
->r_offset
+= o
->output_offset
;
5236 r_symndx
= ELF_R_SYM (irela
->r_info
);
5241 if (r_symndx
>= locsymcount
5242 || (elf_bad_symtab (input_bfd
)
5243 && finfo
->sections
[r_symndx
] == NULL
))
5245 struct elf_link_hash_entry
*rh
;
5248 /* This is a reloc against a global symbol. We
5249 have not yet output all the local symbols, so
5250 we do not know the symbol index of any global
5251 symbol. We set the rel_hash entry for this
5252 reloc to point to the global hash table entry
5253 for this symbol. The symbol index is then
5254 set at the end of elf_bfd_final_link. */
5255 indx
= r_symndx
- extsymoff
;
5256 rh
= elf_sym_hashes (input_bfd
)[indx
];
5257 while (rh
->root
.type
== bfd_link_hash_indirect
5258 || rh
->root
.type
== bfd_link_hash_warning
)
5259 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
5261 /* Setting the index to -2 tells
5262 elf_link_output_extsym that this symbol is
5264 BFD_ASSERT (rh
->indx
< 0);
5272 /* This is a reloc against a local symbol. */
5275 isym
= finfo
->internal_syms
+ r_symndx
;
5276 sec
= finfo
->sections
[r_symndx
];
5277 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
5279 /* I suppose the backend ought to fill in the
5280 section of any STT_SECTION symbol against a
5281 processor specific section. If we have
5282 discarded a section, the output_section will
5283 be the absolute section. */
5285 && (bfd_is_abs_section (sec
)
5286 || (sec
->output_section
!= NULL
5287 && bfd_is_abs_section (sec
->output_section
))))
5289 else if (sec
== NULL
|| sec
->owner
== NULL
)
5291 bfd_set_error (bfd_error_bad_value
);
5296 r_symndx
= sec
->output_section
->target_index
;
5297 BFD_ASSERT (r_symndx
!= 0);
5302 if (finfo
->indices
[r_symndx
] == -1)
5308 if (finfo
->info
->strip
== strip_all
)
5310 /* You can't do ld -r -s. */
5311 bfd_set_error (bfd_error_invalid_operation
);
5315 /* This symbol was skipped earlier, but
5316 since it is needed by a reloc, we
5317 must output it now. */
5318 link
= symtab_hdr
->sh_link
;
5319 name
= bfd_elf_string_from_elf_section (input_bfd
,
5325 osec
= sec
->output_section
;
5327 _bfd_elf_section_from_bfd_section (output_bfd
,
5329 if (isym
->st_shndx
== (unsigned short) -1)
5332 isym
->st_value
+= sec
->output_offset
;
5333 if (! finfo
->info
->relocateable
)
5334 isym
->st_value
+= osec
->vma
;
5336 finfo
->indices
[r_symndx
] = bfd_get_symcount (output_bfd
);
5338 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
5342 r_symndx
= finfo
->indices
[r_symndx
];
5345 irela
->r_info
= ELF_R_INFO (r_symndx
,
5346 ELF_R_TYPE (irela
->r_info
));
5349 /* Swap out the relocs. */
5350 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5351 elf_link_output_relocs (output_bfd
, o
,
5355 += input_rel_hdr
->sh_size
/ input_rel_hdr
->sh_entsize
;
5356 input_rel_hdr
= elf_section_data (o
)->rel_hdr2
;
5358 elf_link_output_relocs (output_bfd
, o
,
5364 /* Write out the modified section contents. */
5365 if (elf_section_data (o
)->stab_info
== NULL
)
5367 if (! (o
->flags
& SEC_EXCLUDE
) &&
5368 ! bfd_set_section_contents (output_bfd
, o
->output_section
,
5369 contents
, o
->output_offset
,
5370 (o
->_cooked_size
!= 0
5377 if (! (_bfd_write_section_stabs
5378 (output_bfd
, &elf_hash_table (finfo
->info
)->stab_info
,
5379 o
, &elf_section_data (o
)->stab_info
, contents
)))
5387 /* Generate a reloc when linking an ELF file. This is a reloc
5388 requested by the linker, and does come from any input file. This
5389 is used to build constructor and destructor tables when linking
5393 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
5395 struct bfd_link_info
*info
;
5396 asection
*output_section
;
5397 struct bfd_link_order
*link_order
;
5399 reloc_howto_type
*howto
;
5403 struct elf_link_hash_entry
**rel_hash_ptr
;
5404 Elf_Internal_Shdr
*rel_hdr
;
5406 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5409 bfd_set_error (bfd_error_bad_value
);
5413 addend
= link_order
->u
.reloc
.p
->addend
;
5415 /* Figure out the symbol index. */
5416 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
5417 + elf_section_data (output_section
)->rel_count
);
5418 if (link_order
->type
== bfd_section_reloc_link_order
)
5420 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
5421 BFD_ASSERT (indx
!= 0);
5422 *rel_hash_ptr
= NULL
;
5426 struct elf_link_hash_entry
*h
;
5428 /* Treat a reloc against a defined symbol as though it were
5429 actually against the section. */
5430 h
= ((struct elf_link_hash_entry
*)
5431 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
5432 link_order
->u
.reloc
.p
->u
.name
,
5433 false, false, true));
5435 && (h
->root
.type
== bfd_link_hash_defined
5436 || h
->root
.type
== bfd_link_hash_defweak
))
5440 section
= h
->root
.u
.def
.section
;
5441 indx
= section
->output_section
->target_index
;
5442 *rel_hash_ptr
= NULL
;
5443 /* It seems that we ought to add the symbol value to the
5444 addend here, but in practice it has already been added
5445 because it was passed to constructor_callback. */
5446 addend
+= section
->output_section
->vma
+ section
->output_offset
;
5450 /* Setting the index to -2 tells elf_link_output_extsym that
5451 this symbol is used by a reloc. */
5458 if (! ((*info
->callbacks
->unattached_reloc
)
5459 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5460 (asection
*) NULL
, (bfd_vma
) 0)))
5466 /* If this is an inplace reloc, we must write the addend into the
5468 if (howto
->partial_inplace
&& addend
!= 0)
5471 bfd_reloc_status_type rstat
;
5475 size
= bfd_get_reloc_size (howto
);
5476 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5477 if (buf
== (bfd_byte
*) NULL
)
5479 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5485 case bfd_reloc_outofrange
:
5487 case bfd_reloc_overflow
:
5488 if (! ((*info
->callbacks
->reloc_overflow
)
5490 (link_order
->type
== bfd_section_reloc_link_order
5491 ? bfd_section_name (output_bfd
,
5492 link_order
->u
.reloc
.p
->u
.section
)
5493 : link_order
->u
.reloc
.p
->u
.name
),
5494 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
5502 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
5503 (file_ptr
) link_order
->offset
, size
);
5509 /* The address of a reloc is relative to the section in a
5510 relocateable file, and is a virtual address in an executable
5512 offset
= link_order
->offset
;
5513 if (! info
->relocateable
)
5514 offset
+= output_section
->vma
;
5516 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
5518 if (rel_hdr
->sh_type
== SHT_REL
)
5520 Elf_Internal_Rel irel
;
5521 Elf_External_Rel
*erel
;
5523 irel
.r_offset
= offset
;
5524 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5525 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
5526 + elf_section_data (output_section
)->rel_count
);
5527 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
5531 Elf_Internal_Rela irela
;
5532 Elf_External_Rela
*erela
;
5534 irela
.r_offset
= offset
;
5535 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5536 irela
.r_addend
= addend
;
5537 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
5538 + elf_section_data (output_section
)->rel_count
);
5539 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
5542 ++elf_section_data (output_section
)->rel_count
;
5548 /* Allocate a pointer to live in a linker created section. */
5551 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
5553 struct bfd_link_info
*info
;
5554 elf_linker_section_t
*lsect
;
5555 struct elf_link_hash_entry
*h
;
5556 const Elf_Internal_Rela
*rel
;
5558 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
5559 elf_linker_section_pointers_t
*linker_section_ptr
;
5560 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
5562 BFD_ASSERT (lsect
!= NULL
);
5564 /* Is this a global symbol? */
5567 /* Has this symbol already been allocated, if so, our work is done */
5568 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5573 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
5574 /* Make sure this symbol is output as a dynamic symbol. */
5575 if (h
->dynindx
== -1)
5577 if (! elf_link_record_dynamic_symbol (info
, h
))
5581 if (lsect
->rel_section
)
5582 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5585 else /* Allocation of a pointer to a local symbol */
5587 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
5589 /* Allocate a table to hold the local symbols if first time */
5592 unsigned int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
5593 register unsigned int i
;
5595 ptr
= (elf_linker_section_pointers_t
**)
5596 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
5601 elf_local_ptr_offsets (abfd
) = ptr
;
5602 for (i
= 0; i
< num_symbols
; i
++)
5603 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
5606 /* Has this symbol already been allocated, if so, our work is done */
5607 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
5612 ptr_linker_section_ptr
= &ptr
[r_symndx
];
5616 /* If we are generating a shared object, we need to
5617 output a R_<xxx>_RELATIVE reloc so that the
5618 dynamic linker can adjust this GOT entry. */
5619 BFD_ASSERT (lsect
->rel_section
!= NULL
);
5620 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5624 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
5625 from internal memory. */
5626 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
5627 linker_section_ptr
= (elf_linker_section_pointers_t
*)
5628 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
5630 if (!linker_section_ptr
)
5633 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
5634 linker_section_ptr
->addend
= rel
->r_addend
;
5635 linker_section_ptr
->which
= lsect
->which
;
5636 linker_section_ptr
->written_address_p
= false;
5637 *ptr_linker_section_ptr
= linker_section_ptr
;
5640 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
5642 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
5643 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
5644 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
5645 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
5647 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
5649 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
5650 lsect
->sym_hash
->root
.root
.string
,
5651 (long)ARCH_SIZE
/ 8,
5652 (long)lsect
->sym_hash
->root
.u
.def
.value
);
5658 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
5660 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
5663 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
5664 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
5672 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
5675 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
5678 /* Fill in the address for a pointer generated in alinker section. */
5681 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
5684 struct bfd_link_info
*info
;
5685 elf_linker_section_t
*lsect
;
5686 struct elf_link_hash_entry
*h
;
5688 const Elf_Internal_Rela
*rel
;
5691 elf_linker_section_pointers_t
*linker_section_ptr
;
5693 BFD_ASSERT (lsect
!= NULL
);
5695 if (h
!= NULL
) /* global symbol */
5697 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5701 BFD_ASSERT (linker_section_ptr
!= NULL
);
5703 if (! elf_hash_table (info
)->dynamic_sections_created
5706 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
5708 /* This is actually a static link, or it is a
5709 -Bsymbolic link and the symbol is defined
5710 locally. We must initialize this entry in the
5713 When doing a dynamic link, we create a .rela.<xxx>
5714 relocation entry to initialize the value. This
5715 is done in the finish_dynamic_symbol routine. */
5716 if (!linker_section_ptr
->written_address_p
)
5718 linker_section_ptr
->written_address_p
= true;
5719 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5720 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5724 else /* local symbol */
5726 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
5727 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
5728 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
5729 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
5733 BFD_ASSERT (linker_section_ptr
!= NULL
);
5735 /* Write out pointer if it hasn't been rewritten out before */
5736 if (!linker_section_ptr
->written_address_p
)
5738 linker_section_ptr
->written_address_p
= true;
5739 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5740 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5744 asection
*srel
= lsect
->rel_section
;
5745 Elf_Internal_Rela outrel
;
5747 /* We need to generate a relative reloc for the dynamic linker. */
5749 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
5752 BFD_ASSERT (srel
!= NULL
);
5754 outrel
.r_offset
= (lsect
->section
->output_section
->vma
5755 + lsect
->section
->output_offset
5756 + linker_section_ptr
->offset
);
5757 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
5758 outrel
.r_addend
= 0;
5759 elf_swap_reloca_out (output_bfd
, &outrel
,
5760 (((Elf_External_Rela
*)
5761 lsect
->section
->contents
)
5762 + elf_section_data (lsect
->section
)->rel_count
));
5763 ++elf_section_data (lsect
->section
)->rel_count
;
5768 relocation
= (lsect
->section
->output_offset
5769 + linker_section_ptr
->offset
5770 - lsect
->hole_offset
5771 - lsect
->sym_offset
);
5774 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
5775 lsect
->name
, (long)relocation
, (long)relocation
);
5778 /* Subtract out the addend, because it will get added back in by the normal
5780 return relocation
- linker_section_ptr
->addend
;
5783 /* Garbage collect unused sections. */
5785 static boolean elf_gc_mark
5786 PARAMS ((struct bfd_link_info
*info
, asection
*sec
,
5787 asection
* (*gc_mark_hook
)
5788 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5789 struct elf_link_hash_entry
*, Elf_Internal_Sym
*))));
5791 static boolean elf_gc_sweep
5792 PARAMS ((struct bfd_link_info
*info
,
5793 boolean (*gc_sweep_hook
)
5794 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5795 const Elf_Internal_Rela
*relocs
))));
5797 static boolean elf_gc_sweep_symbol
5798 PARAMS ((struct elf_link_hash_entry
*h
, PTR idxptr
));
5800 static boolean elf_gc_allocate_got_offsets
5801 PARAMS ((struct elf_link_hash_entry
*h
, PTR offarg
));
5803 static boolean elf_gc_propagate_vtable_entries_used
5804 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5806 static boolean elf_gc_smash_unused_vtentry_relocs
5807 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5809 /* The mark phase of garbage collection. For a given section, mark
5810 it, and all the sections which define symbols to which it refers. */
5813 elf_gc_mark (info
, sec
, gc_mark_hook
)
5814 struct bfd_link_info
*info
;
5816 asection
* (*gc_mark_hook
)
5817 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5818 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
5824 /* Look through the section relocs. */
5826 if ((sec
->flags
& SEC_RELOC
) != 0 && sec
->reloc_count
> 0)
5828 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
5829 Elf_Internal_Shdr
*symtab_hdr
;
5830 struct elf_link_hash_entry
**sym_hashes
;
5833 Elf_External_Sym
*locsyms
, *freesyms
= NULL
;
5834 bfd
*input_bfd
= sec
->owner
;
5835 struct elf_backend_data
*bed
= get_elf_backend_data (input_bfd
);
5837 /* GCFIXME: how to arrange so that relocs and symbols are not
5838 reread continually? */
5840 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5841 sym_hashes
= elf_sym_hashes (input_bfd
);
5843 /* Read the local symbols. */
5844 if (elf_bad_symtab (input_bfd
))
5846 nlocsyms
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5850 extsymoff
= nlocsyms
= symtab_hdr
->sh_info
;
5851 if (symtab_hdr
->contents
)
5852 locsyms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
5853 else if (nlocsyms
== 0)
5857 locsyms
= freesyms
=
5858 bfd_malloc (nlocsyms
* sizeof (Elf_External_Sym
));
5859 if (freesyms
== NULL
5860 || bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5861 || (bfd_read (locsyms
, sizeof (Elf_External_Sym
),
5862 nlocsyms
, input_bfd
)
5863 != nlocsyms
* sizeof (Elf_External_Sym
)))
5870 /* Read the relocations. */
5871 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
5872 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5873 info
->keep_memory
));
5874 if (relstart
== NULL
)
5879 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5881 for (rel
= relstart
; rel
< relend
; rel
++)
5883 unsigned long r_symndx
;
5885 struct elf_link_hash_entry
*h
;
5888 r_symndx
= ELF_R_SYM (rel
->r_info
);
5892 if (elf_bad_symtab (sec
->owner
))
5894 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5895 if (ELF_ST_BIND (s
.st_info
) == STB_LOCAL
)
5896 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5899 h
= sym_hashes
[r_symndx
- extsymoff
];
5900 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5903 else if (r_symndx
>= nlocsyms
)
5905 h
= sym_hashes
[r_symndx
- extsymoff
];
5906 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5910 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5911 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5914 if (rsec
&& !rsec
->gc_mark
)
5915 if (!elf_gc_mark (info
, rsec
, gc_mark_hook
))
5923 if (!info
->keep_memory
)
5933 /* The sweep phase of garbage collection. Remove all garbage sections. */
5936 elf_gc_sweep (info
, gc_sweep_hook
)
5937 struct bfd_link_info
*info
;
5938 boolean (*gc_sweep_hook
)
5939 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5940 const Elf_Internal_Rela
*relocs
));
5944 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5948 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5950 /* Keep special sections. Keep .debug sections. */
5951 if ((o
->flags
& SEC_LINKER_CREATED
)
5952 || (o
->flags
& SEC_DEBUGGING
))
5958 /* Skip sweeping sections already excluded. */
5959 if (o
->flags
& SEC_EXCLUDE
)
5962 /* Since this is early in the link process, it is simple
5963 to remove a section from the output. */
5964 o
->flags
|= SEC_EXCLUDE
;
5966 /* But we also have to update some of the relocation
5967 info we collected before. */
5969 && (o
->flags
& SEC_RELOC
) && o
->reloc_count
> 0)
5971 Elf_Internal_Rela
*internal_relocs
;
5974 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
5975 (o
->owner
, o
, NULL
, NULL
, info
->keep_memory
));
5976 if (internal_relocs
== NULL
)
5979 r
= (*gc_sweep_hook
)(o
->owner
, info
, o
, internal_relocs
);
5981 if (!info
->keep_memory
)
5982 free (internal_relocs
);
5990 /* Remove the symbols that were in the swept sections from the dynamic
5991 symbol table. GCFIXME: Anyone know how to get them out of the
5992 static symbol table as well? */
5996 elf_link_hash_traverse (elf_hash_table (info
),
5997 elf_gc_sweep_symbol
,
6000 elf_hash_table (info
)->dynsymcount
= i
;
6006 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
6009 elf_gc_sweep_symbol (h
, idxptr
)
6010 struct elf_link_hash_entry
*h
;
6013 int *idx
= (int *) idxptr
;
6015 if (h
->dynindx
!= -1
6016 && ((h
->root
.type
!= bfd_link_hash_defined
6017 && h
->root
.type
!= bfd_link_hash_defweak
)
6018 || h
->root
.u
.def
.section
->gc_mark
))
6019 h
->dynindx
= (*idx
)++;
6024 /* Propogate collected vtable information. This is called through
6025 elf_link_hash_traverse. */
6028 elf_gc_propagate_vtable_entries_used (h
, okp
)
6029 struct elf_link_hash_entry
*h
;
6032 /* Those that are not vtables. */
6033 if (h
->vtable_parent
== NULL
)
6036 /* Those vtables that do not have parents, we cannot merge. */
6037 if (h
->vtable_parent
== (struct elf_link_hash_entry
*) -1)
6040 /* If we've already been done, exit. */
6041 if (h
->vtable_entries_used
&& h
->vtable_entries_used
[-1])
6044 /* Make sure the parent's table is up to date. */
6045 elf_gc_propagate_vtable_entries_used (h
->vtable_parent
, okp
);
6047 if (h
->vtable_entries_used
== NULL
)
6049 /* None of this table's entries were referenced. Re-use the
6051 h
->vtable_entries_used
= h
->vtable_parent
->vtable_entries_used
;
6052 h
->vtable_entries_size
= h
->vtable_parent
->vtable_entries_size
;
6059 /* Or the parent's entries into ours. */
6060 cu
= h
->vtable_entries_used
;
6062 pu
= h
->vtable_parent
->vtable_entries_used
;
6065 n
= h
->vtable_parent
->vtable_entries_size
/ FILE_ALIGN
;
6068 if (*pu
) *cu
= true;
6078 elf_gc_smash_unused_vtentry_relocs (h
, okp
)
6079 struct elf_link_hash_entry
*h
;
6083 bfd_vma hstart
, hend
;
6084 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
6085 struct elf_backend_data
*bed
;
6087 /* Take care of both those symbols that do not describe vtables as
6088 well as those that are not loaded. */
6089 if (h
->vtable_parent
== NULL
)
6092 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
6093 || h
->root
.type
== bfd_link_hash_defweak
);
6095 sec
= h
->root
.u
.def
.section
;
6096 hstart
= h
->root
.u
.def
.value
;
6097 hend
= hstart
+ h
->size
;
6099 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
6100 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
, true));
6102 return *(boolean
*)okp
= false;
6103 bed
= get_elf_backend_data (sec
->owner
);
6104 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6106 for (rel
= relstart
; rel
< relend
; ++rel
)
6107 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
6109 /* If the entry is in use, do nothing. */
6110 if (h
->vtable_entries_used
6111 && (rel
->r_offset
- hstart
) < h
->vtable_entries_size
)
6113 bfd_vma entry
= (rel
->r_offset
- hstart
) / FILE_ALIGN
;
6114 if (h
->vtable_entries_used
[entry
])
6117 /* Otherwise, kill it. */
6118 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
6124 /* Do mark and sweep of unused sections. */
6127 elf_gc_sections (abfd
, info
)
6129 struct bfd_link_info
*info
;
6133 asection
* (*gc_mark_hook
)
6134 PARAMS ((bfd
*abfd
, struct bfd_link_info
*, Elf_Internal_Rela
*,
6135 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*));
6137 if (!get_elf_backend_data (abfd
)->can_gc_sections
6138 || info
->relocateable
6139 || elf_hash_table (info
)->dynamic_sections_created
)
6142 /* Apply transitive closure to the vtable entry usage info. */
6143 elf_link_hash_traverse (elf_hash_table (info
),
6144 elf_gc_propagate_vtable_entries_used
,
6149 /* Kill the vtable relocations that were not used. */
6150 elf_link_hash_traverse (elf_hash_table (info
),
6151 elf_gc_smash_unused_vtentry_relocs
,
6156 /* Grovel through relocs to find out who stays ... */
6158 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
6159 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
6162 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
6164 if (o
->flags
& SEC_KEEP
)
6165 if (!elf_gc_mark (info
, o
, gc_mark_hook
))
6170 /* ... and mark SEC_EXCLUDE for those that go. */
6171 if (!elf_gc_sweep(info
, get_elf_backend_data (abfd
)->gc_sweep_hook
))
6177 /* Called from check_relocs to record the existance of a VTINHERIT reloc. */
6180 elf_gc_record_vtinherit (abfd
, sec
, h
, offset
)
6183 struct elf_link_hash_entry
*h
;
6186 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
6187 struct elf_link_hash_entry
**search
, *child
;
6188 bfd_size_type extsymcount
;
6190 /* The sh_info field of the symtab header tells us where the
6191 external symbols start. We don't care about the local symbols at
6193 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/sizeof (Elf_External_Sym
);
6194 if (!elf_bad_symtab (abfd
))
6195 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
6197 sym_hashes
= elf_sym_hashes (abfd
);
6198 sym_hashes_end
= sym_hashes
+ extsymcount
;
6200 /* Hunt down the child symbol, which is in this section at the same
6201 offset as the relocation. */
6202 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
6204 if ((child
= *search
) != NULL
6205 && (child
->root
.type
== bfd_link_hash_defined
6206 || child
->root
.type
== bfd_link_hash_defweak
)
6207 && child
->root
.u
.def
.section
== sec
6208 && child
->root
.u
.def
.value
== offset
)
6212 (*_bfd_error_handler
) ("%s: %s+%lu: No symbol found for INHERIT",
6213 bfd_get_filename (abfd
), sec
->name
,
6214 (unsigned long)offset
);
6215 bfd_set_error (bfd_error_invalid_operation
);
6221 /* This *should* only be the absolute section. It could potentially
6222 be that someone has defined a non-global vtable though, which
6223 would be bad. It isn't worth paging in the local symbols to be
6224 sure though; that case should simply be handled by the assembler. */
6226 child
->vtable_parent
= (struct elf_link_hash_entry
*) -1;
6229 child
->vtable_parent
= h
;
6234 /* Called from check_relocs to record the existance of a VTENTRY reloc. */
6237 elf_gc_record_vtentry (abfd
, sec
, h
, addend
)
6238 bfd
*abfd ATTRIBUTE_UNUSED
;
6239 asection
*sec ATTRIBUTE_UNUSED
;
6240 struct elf_link_hash_entry
*h
;
6243 if (addend
>= h
->vtable_entries_size
)
6246 boolean
*ptr
= h
->vtable_entries_used
;
6248 /* While the symbol is undefined, we have to be prepared to handle
6250 if (h
->root
.type
== bfd_link_hash_undefined
)
6257 /* Oops! We've got a reference past the defined end of
6258 the table. This is probably a bug -- shall we warn? */
6263 /* Allocate one extra entry for use as a "done" flag for the
6264 consolidation pass. */
6265 bytes
= (size
/ FILE_ALIGN
+ 1) * sizeof(boolean
);
6271 ptr
= realloc (ptr
-1, bytes
);
6275 oldbytes
= (h
->vtable_entries_size
/FILE_ALIGN
+ 1) * sizeof(boolean
);
6276 memset (ptr
+ oldbytes
, 0, bytes
- oldbytes
);
6280 ptr
= calloc (1, bytes
);
6285 /* And arrange for that done flag to be at index -1. */
6286 h
->vtable_entries_used
= ptr
+1;
6287 h
->vtable_entries_size
= size
;
6289 h
->vtable_entries_used
[addend
/ FILE_ALIGN
] = true;
6294 /* And an accompanying bit to work out final got entry offsets once
6295 we're done. Should be called from final_link. */
6298 elf_gc_common_finalize_got_offsets (abfd
, info
)
6300 struct bfd_link_info
*info
;
6303 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6306 /* The GOT offset is relative to the .got section, but the GOT header is
6307 put into the .got.plt section, if the backend uses it. */
6308 if (bed
->want_got_plt
)
6311 gotoff
= bed
->got_header_size
;
6313 /* Do the local .got entries first. */
6314 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
6316 bfd_signed_vma
*local_got
= elf_local_got_refcounts (i
);
6317 bfd_size_type j
, locsymcount
;
6318 Elf_Internal_Shdr
*symtab_hdr
;
6323 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
6324 if (elf_bad_symtab (i
))
6325 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6327 locsymcount
= symtab_hdr
->sh_info
;
6329 for (j
= 0; j
< locsymcount
; ++j
)
6331 if (local_got
[j
] > 0)
6333 local_got
[j
] = gotoff
;
6334 gotoff
+= ARCH_SIZE
/ 8;
6337 local_got
[j
] = (bfd_vma
) -1;
6341 /* Then the global .got and .plt entries. */
6342 elf_link_hash_traverse (elf_hash_table (info
),
6343 elf_gc_allocate_got_offsets
,
6348 /* We need a special top-level link routine to convert got reference counts
6349 to real got offsets. */
6352 elf_gc_allocate_got_offsets (h
, offarg
)
6353 struct elf_link_hash_entry
*h
;
6356 bfd_vma
*off
= (bfd_vma
*) offarg
;
6358 if (h
->got
.refcount
> 0)
6360 h
->got
.offset
= off
[0];
6361 off
[0] += ARCH_SIZE
/ 8;
6364 h
->got
.offset
= (bfd_vma
) -1;
6369 /* Many folk need no more in the way of final link than this, once
6370 got entry reference counting is enabled. */
6373 elf_gc_common_final_link (abfd
, info
)
6375 struct bfd_link_info
*info
;
6377 if (!elf_gc_common_finalize_got_offsets (abfd
, info
))
6380 /* Invoke the regular ELF backend linker to do all the work. */
6381 return elf_bfd_final_link (abfd
, info
);
6384 /* This function will be called though elf_link_hash_traverse to store
6385 all hash value of the exported symbols in an array. */
6388 elf_collect_hash_codes (h
, data
)
6389 struct elf_link_hash_entry
*h
;
6392 unsigned long **valuep
= (unsigned long **) data
;
6398 /* Ignore indirect symbols. These are added by the versioning code. */
6399 if (h
->dynindx
== -1)
6402 name
= h
->root
.root
.string
;
6403 p
= strchr (name
, ELF_VER_CHR
);
6406 alc
= bfd_malloc (p
- name
+ 1);
6407 memcpy (alc
, name
, p
- name
);
6408 alc
[p
- name
] = '\0';
6412 /* Compute the hash value. */
6413 ha
= bfd_elf_hash (name
);
6415 /* Store the found hash value in the array given as the argument. */
6418 /* And store it in the struct so that we can put it in the hash table
6420 h
->elf_hash_value
= ha
;