2 Copyright 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 /* This struct is used to pass information to routines called via
23 elf_link_hash_traverse which must return failure. */
25 struct elf_info_failed
28 struct bfd_link_info
*info
;
31 static boolean elf_link_add_object_symbols
32 PARAMS ((bfd
*, struct bfd_link_info
*));
33 static boolean elf_link_add_archive_symbols
34 PARAMS ((bfd
*, struct bfd_link_info
*));
35 static boolean elf_merge_symbol
36 PARAMS ((bfd
*, struct bfd_link_info
*, const char *, Elf_Internal_Sym
*,
37 asection
**, bfd_vma
*, struct elf_link_hash_entry
**,
38 boolean
*, boolean
*, boolean
*));
39 static boolean elf_export_symbol
40 PARAMS ((struct elf_link_hash_entry
*, PTR
));
41 static boolean elf_fix_symbol_flags
42 PARAMS ((struct elf_link_hash_entry
*, struct elf_info_failed
*));
43 static boolean elf_adjust_dynamic_symbol
44 PARAMS ((struct elf_link_hash_entry
*, PTR
));
45 static boolean elf_link_find_version_dependencies
46 PARAMS ((struct elf_link_hash_entry
*, PTR
));
47 static boolean elf_link_find_version_dependencies
48 PARAMS ((struct elf_link_hash_entry
*, PTR
));
49 static boolean elf_link_assign_sym_version
50 PARAMS ((struct elf_link_hash_entry
*, PTR
));
51 static boolean elf_link_renumber_dynsyms
52 PARAMS ((struct elf_link_hash_entry
*, PTR
));
54 /* Given an ELF BFD, add symbols to the global hash table as
58 elf_bfd_link_add_symbols (abfd
, info
)
60 struct bfd_link_info
*info
;
62 switch (bfd_get_format (abfd
))
65 return elf_link_add_object_symbols (abfd
, info
);
67 return elf_link_add_archive_symbols (abfd
, info
);
69 bfd_set_error (bfd_error_wrong_format
);
75 /* Add symbols from an ELF archive file to the linker hash table. We
76 don't use _bfd_generic_link_add_archive_symbols because of a
77 problem which arises on UnixWare. The UnixWare libc.so is an
78 archive which includes an entry libc.so.1 which defines a bunch of
79 symbols. The libc.so archive also includes a number of other
80 object files, which also define symbols, some of which are the same
81 as those defined in libc.so.1. Correct linking requires that we
82 consider each object file in turn, and include it if it defines any
83 symbols we need. _bfd_generic_link_add_archive_symbols does not do
84 this; it looks through the list of undefined symbols, and includes
85 any object file which defines them. When this algorithm is used on
86 UnixWare, it winds up pulling in libc.so.1 early and defining a
87 bunch of symbols. This means that some of the other objects in the
88 archive are not included in the link, which is incorrect since they
89 precede libc.so.1 in the archive.
91 Fortunately, ELF archive handling is simpler than that done by
92 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
93 oddities. In ELF, if we find a symbol in the archive map, and the
94 symbol is currently undefined, we know that we must pull in that
97 Unfortunately, we do have to make multiple passes over the symbol
98 table until nothing further is resolved. */
101 elf_link_add_archive_symbols (abfd
, info
)
103 struct bfd_link_info
*info
;
106 boolean
*defined
= NULL
;
107 boolean
*included
= NULL
;
111 if (! bfd_has_map (abfd
))
113 /* An empty archive is a special case. */
114 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
116 bfd_set_error (bfd_error_no_armap
);
120 /* Keep track of all symbols we know to be already defined, and all
121 files we know to be already included. This is to speed up the
122 second and subsequent passes. */
123 c
= bfd_ardata (abfd
)->symdef_count
;
126 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
127 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
128 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
130 memset (defined
, 0, c
* sizeof (boolean
));
131 memset (included
, 0, c
* sizeof (boolean
));
133 symdefs
= bfd_ardata (abfd
)->symdefs
;
146 symdefend
= symdef
+ c
;
147 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
149 struct elf_link_hash_entry
*h
;
151 struct bfd_link_hash_entry
*undefs_tail
;
154 if (defined
[i
] || included
[i
])
156 if (symdef
->file_offset
== last
)
162 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
163 false, false, false);
169 /* If this is a default version (the name contains @@),
170 look up the symbol again without the version. The
171 effect is that references to the symbol without the
172 version will be matched by the default symbol in the
175 p
= strchr (symdef
->name
, ELF_VER_CHR
);
176 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
179 copy
= bfd_alloc (abfd
, p
- symdef
->name
+ 1);
182 memcpy (copy
, symdef
->name
, p
- symdef
->name
);
183 copy
[p
- symdef
->name
] = '\0';
185 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
186 false, false, false);
188 bfd_release (abfd
, copy
);
194 if (h
->root
.type
!= bfd_link_hash_undefined
)
196 if (h
->root
.type
!= bfd_link_hash_undefweak
)
201 /* We need to include this archive member. */
203 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
204 if (element
== (bfd
*) NULL
)
207 if (! bfd_check_format (element
, bfd_object
))
210 /* Doublecheck that we have not included this object
211 already--it should be impossible, but there may be
212 something wrong with the archive. */
213 if (element
->archive_pass
!= 0)
215 bfd_set_error (bfd_error_bad_value
);
218 element
->archive_pass
= 1;
220 undefs_tail
= info
->hash
->undefs_tail
;
222 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
225 if (! elf_link_add_object_symbols (element
, info
))
228 /* If there are any new undefined symbols, we need to make
229 another pass through the archive in order to see whether
230 they can be defined. FIXME: This isn't perfect, because
231 common symbols wind up on undefs_tail and because an
232 undefined symbol which is defined later on in this pass
233 does not require another pass. This isn't a bug, but it
234 does make the code less efficient than it could be. */
235 if (undefs_tail
!= info
->hash
->undefs_tail
)
238 /* Look backward to mark all symbols from this object file
239 which we have already seen in this pass. */
243 included
[mark
] = true;
248 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
250 /* We mark subsequent symbols from this object file as we go
251 on through the loop. */
252 last
= symdef
->file_offset
;
263 if (defined
!= (boolean
*) NULL
)
265 if (included
!= (boolean
*) NULL
)
270 /* This function is called when we want to define a new symbol. It
271 handles the various cases which arise when we find a definition in
272 a dynamic object, or when there is already a definition in a
273 dynamic object. The new symbol is described by NAME, SYM, PSEC,
274 and PVALUE. We set SYM_HASH to the hash table entry. We set
275 OVERRIDE if the old symbol is overriding a new definition. We set
276 TYPE_CHANGE_OK if it is OK for the type to change. We set
277 SIZE_CHANGE_OK if it is OK for the size to change. By OK to
278 change, we mean that we shouldn't warn if the type or size does
282 elf_merge_symbol (abfd
, info
, name
, sym
, psec
, pvalue
, sym_hash
,
283 override
, type_change_ok
, size_change_ok
)
285 struct bfd_link_info
*info
;
287 Elf_Internal_Sym
*sym
;
290 struct elf_link_hash_entry
**sym_hash
;
292 boolean
*type_change_ok
;
293 boolean
*size_change_ok
;
296 struct elf_link_hash_entry
*h
;
299 boolean newdyn
, olddyn
, olddef
, newdef
, newdyncommon
, olddyncommon
;
304 bind
= ELF_ST_BIND (sym
->st_info
);
306 if (! bfd_is_und_section (sec
))
307 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, false, false);
309 h
= ((struct elf_link_hash_entry
*)
310 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true, false, false));
315 /* This code is for coping with dynamic objects, and is only useful
316 if we are doing an ELF link. */
317 if (info
->hash
->creator
!= abfd
->xvec
)
320 /* For merging, we only care about real symbols. */
322 while (h
->root
.type
== bfd_link_hash_indirect
323 || h
->root
.type
== bfd_link_hash_warning
)
324 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
326 /* If we just created the symbol, mark it as being an ELF symbol.
327 Other than that, there is nothing to do--there is no merge issue
328 with a newly defined symbol--so we just return. */
330 if (h
->root
.type
== bfd_link_hash_new
)
332 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
336 /* OLDBFD is a BFD associated with the existing symbol. */
338 switch (h
->root
.type
)
344 case bfd_link_hash_undefined
:
345 case bfd_link_hash_undefweak
:
346 oldbfd
= h
->root
.u
.undef
.abfd
;
349 case bfd_link_hash_defined
:
350 case bfd_link_hash_defweak
:
351 oldbfd
= h
->root
.u
.def
.section
->owner
;
354 case bfd_link_hash_common
:
355 oldbfd
= h
->root
.u
.c
.p
->section
->owner
;
359 /* NEWDYN and OLDDYN indicate whether the new or old symbol,
360 respectively, is from a dynamic object. */
362 if ((abfd
->flags
& DYNAMIC
) != 0)
367 if (oldbfd
== NULL
|| (oldbfd
->flags
& DYNAMIC
) == 0)
372 /* NEWDEF and OLDDEF indicate whether the new or old symbol,
373 respectively, appear to be a definition rather than reference. */
375 if (bfd_is_und_section (sec
) || bfd_is_com_section (sec
))
380 if (h
->root
.type
== bfd_link_hash_undefined
381 || h
->root
.type
== bfd_link_hash_undefweak
382 || h
->root
.type
== bfd_link_hash_common
)
387 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
388 symbol, respectively, appears to be a common symbol in a dynamic
389 object. If a symbol appears in an uninitialized section, and is
390 not weak, and is not a function, then it may be a common symbol
391 which was resolved when the dynamic object was created. We want
392 to treat such symbols specially, because they raise special
393 considerations when setting the symbol size: if the symbol
394 appears as a common symbol in a regular object, and the size in
395 the regular object is larger, we must make sure that we use the
396 larger size. This problematic case can always be avoided in C,
397 but it must be handled correctly when using Fortran shared
400 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
401 likewise for OLDDYNCOMMON and OLDDEF.
403 Note that this test is just a heuristic, and that it is quite
404 possible to have an uninitialized symbol in a shared object which
405 is really a definition, rather than a common symbol. This could
406 lead to some minor confusion when the symbol really is a common
407 symbol in some regular object. However, I think it will be
412 && (sec
->flags
& SEC_ALLOC
) != 0
413 && (sec
->flags
& SEC_LOAD
) == 0
416 && ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
419 newdyncommon
= false;
423 && h
->root
.type
== bfd_link_hash_defined
424 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
425 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
426 && (h
->root
.u
.def
.section
->flags
& SEC_LOAD
) == 0
428 && h
->type
!= STT_FUNC
)
431 olddyncommon
= false;
433 /* It's OK to change the type if either the existing symbol or the
434 new symbol is weak. */
436 if (h
->root
.type
== bfd_link_hash_defweak
437 || h
->root
.type
== bfd_link_hash_undefweak
439 *type_change_ok
= true;
441 /* It's OK to change the size if either the existing symbol or the
442 new symbol is weak, or if the old symbol is undefined. */
445 || h
->root
.type
== bfd_link_hash_undefined
)
446 *size_change_ok
= true;
448 /* If both the old and the new symbols look like common symbols in a
449 dynamic object, set the size of the symbol to the larger of the
454 && sym
->st_size
!= h
->size
)
456 /* Since we think we have two common symbols, issue a multiple
457 common warning if desired. Note that we only warn if the
458 size is different. If the size is the same, we simply let
459 the old symbol override the new one as normally happens with
460 symbols defined in dynamic objects. */
462 if (! ((*info
->callbacks
->multiple_common
)
463 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
464 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
467 if (sym
->st_size
> h
->size
)
468 h
->size
= sym
->st_size
;
470 *size_change_ok
= true;
473 /* If we are looking at a dynamic object, and we have found a
474 definition, we need to see if the symbol was already defined by
475 some other object. If so, we want to use the existing
476 definition, and we do not want to report a multiple symbol
477 definition error; we do this by clobbering *PSEC to be
480 We treat a common symbol as a definition if the symbol in the
481 shared library is a function, since common symbols always
482 represent variables; this can cause confusion in principle, but
483 any such confusion would seem to indicate an erroneous program or
484 shared library. We also permit a common symbol in a regular
485 object to override a weak symbol in a shared object. */
490 || (h
->root
.type
== bfd_link_hash_common
492 || ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
))))
496 newdyncommon
= false;
498 *psec
= sec
= bfd_und_section_ptr
;
499 *size_change_ok
= true;
501 /* If we get here when the old symbol is a common symbol, then
502 we are explicitly letting it override a weak symbol or
503 function in a dynamic object, and we don't want to warn about
504 a type change. If the old symbol is a defined symbol, a type
505 change warning may still be appropriate. */
507 if (h
->root
.type
== bfd_link_hash_common
)
508 *type_change_ok
= true;
511 /* Handle the special case of an old common symbol merging with a
512 new symbol which looks like a common symbol in a shared object.
513 We change *PSEC and *PVALUE to make the new symbol look like a
514 common symbol, and let _bfd_generic_link_add_one_symbol will do
518 && h
->root
.type
== bfd_link_hash_common
)
522 newdyncommon
= false;
523 *pvalue
= sym
->st_size
;
524 *psec
= sec
= bfd_com_section_ptr
;
525 *size_change_ok
= true;
528 /* If the old symbol is from a dynamic object, and the new symbol is
529 a definition which is not from a dynamic object, then the new
530 symbol overrides the old symbol. Symbols from regular files
531 always take precedence over symbols from dynamic objects, even if
532 they are defined after the dynamic object in the link.
534 As above, we again permit a common symbol in a regular object to
535 override a definition in a shared object if the shared object
536 symbol is a function or is weak. */
540 || (bfd_is_com_section (sec
)
541 && (h
->root
.type
== bfd_link_hash_defweak
542 || h
->type
== STT_FUNC
)))
545 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
547 /* Change the hash table entry to undefined, and let
548 _bfd_generic_link_add_one_symbol do the right thing with the
551 h
->root
.type
= bfd_link_hash_undefined
;
552 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
553 *size_change_ok
= true;
556 olddyncommon
= false;
558 /* We again permit a type change when a common symbol may be
559 overriding a function. */
561 if (bfd_is_com_section (sec
))
562 *type_change_ok
= true;
564 /* This union may have been set to be non-NULL when this symbol
565 was seen in a dynamic object. We must force the union to be
566 NULL, so that it is correct for a regular symbol. */
568 h
->verinfo
.vertree
= NULL
;
570 /* In this special case, if H is the target of an indirection,
571 we want the caller to frob with H rather than with the
572 indirect symbol. That will permit the caller to redefine the
573 target of the indirection, rather than the indirect symbol
574 itself. FIXME: This will break the -y option if we store a
575 symbol with a different name. */
579 /* Handle the special case of a new common symbol merging with an
580 old symbol that looks like it might be a common symbol defined in
581 a shared object. Note that we have already handled the case in
582 which a new common symbol should simply override the definition
583 in the shared library. */
586 && bfd_is_com_section (sec
)
589 /* It would be best if we could set the hash table entry to a
590 common symbol, but we don't know what to use for the section
592 if (! ((*info
->callbacks
->multiple_common
)
593 (info
, h
->root
.root
.string
, oldbfd
, bfd_link_hash_common
,
594 h
->size
, abfd
, bfd_link_hash_common
, sym
->st_size
)))
597 /* If the predumed common symbol in the dynamic object is
598 larger, pretend that the new symbol has its size. */
600 if (h
->size
> *pvalue
)
603 /* FIXME: We no longer know the alignment required by the symbol
604 in the dynamic object, so we just wind up using the one from
605 the regular object. */
608 olddyncommon
= false;
610 h
->root
.type
= bfd_link_hash_undefined
;
611 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
613 *size_change_ok
= true;
614 *type_change_ok
= true;
616 h
->verinfo
.vertree
= NULL
;
622 /* Add symbols from an ELF object file to the linker hash table. */
625 elf_link_add_object_symbols (abfd
, info
)
627 struct bfd_link_info
*info
;
629 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
630 const Elf_Internal_Sym
*,
631 const char **, flagword
*,
632 asection
**, bfd_vma
*));
633 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
634 asection
*, const Elf_Internal_Rela
*));
636 Elf_Internal_Shdr
*hdr
;
640 Elf_External_Sym
*buf
= NULL
;
641 struct elf_link_hash_entry
**sym_hash
;
643 bfd_byte
*dynver
= NULL
;
644 Elf_External_Versym
*extversym
= NULL
;
645 Elf_External_Versym
*ever
;
646 Elf_External_Dyn
*dynbuf
= NULL
;
647 struct elf_link_hash_entry
*weaks
;
648 Elf_External_Sym
*esym
;
649 Elf_External_Sym
*esymend
;
651 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
652 collect
= get_elf_backend_data (abfd
)->collect
;
654 if ((abfd
->flags
& DYNAMIC
) == 0)
660 /* You can't use -r against a dynamic object. Also, there's no
661 hope of using a dynamic object which does not exactly match
662 the format of the output file. */
663 if (info
->relocateable
|| info
->hash
->creator
!= abfd
->xvec
)
665 bfd_set_error (bfd_error_invalid_operation
);
670 /* As a GNU extension, any input sections which are named
671 .gnu.warning.SYMBOL are treated as warning symbols for the given
672 symbol. This differs from .gnu.warning sections, which generate
673 warnings when they are included in an output file. */
678 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
682 name
= bfd_get_section_name (abfd
, s
);
683 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
688 name
+= sizeof ".gnu.warning." - 1;
690 /* If this is a shared object, then look up the symbol
691 in the hash table. If it is there, and it is already
692 been defined, then we will not be using the entry
693 from this shared object, so we don't need to warn.
694 FIXME: If we see the definition in a regular object
695 later on, we will warn, but we shouldn't. The only
696 fix is to keep track of what warnings we are supposed
697 to emit, and then handle them all at the end of the
699 if (dynamic
&& abfd
->xvec
== info
->hash
->creator
)
701 struct elf_link_hash_entry
*h
;
703 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
706 /* FIXME: What about bfd_link_hash_common? */
708 && (h
->root
.type
== bfd_link_hash_defined
709 || h
->root
.type
== bfd_link_hash_defweak
))
711 /* We don't want to issue this warning. Clobber
712 the section size so that the warning does not
713 get copied into the output file. */
719 sz
= bfd_section_size (abfd
, s
);
720 msg
= (char *) bfd_alloc (abfd
, sz
+ 1);
724 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
729 if (! (_bfd_generic_link_add_one_symbol
730 (info
, abfd
, name
, BSF_WARNING
, s
, (bfd_vma
) 0, msg
,
731 false, collect
, (struct bfd_link_hash_entry
**) NULL
)))
734 if (! info
->relocateable
)
736 /* Clobber the section size so that the warning does
737 not get copied into the output file. */
744 /* If this is a dynamic object, we always link against the .dynsym
745 symbol table, not the .symtab symbol table. The dynamic linker
746 will only see the .dynsym symbol table, so there is no reason to
747 look at .symtab for a dynamic object. */
749 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
750 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
752 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
756 /* Read in any version definitions. */
758 if (! _bfd_elf_slurp_version_tables (abfd
))
761 /* Read in the symbol versions, but don't bother to convert them
762 to internal format. */
763 if (elf_dynversym (abfd
) != 0)
765 Elf_Internal_Shdr
*versymhdr
;
767 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
768 extversym
= (Elf_External_Versym
*) bfd_malloc (hdr
->sh_size
);
769 if (extversym
== NULL
)
771 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
772 || (bfd_read ((PTR
) extversym
, 1, versymhdr
->sh_size
, abfd
)
773 != versymhdr
->sh_size
))
778 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
780 /* The sh_info field of the symtab header tells us where the
781 external symbols start. We don't care about the local symbols at
783 if (elf_bad_symtab (abfd
))
785 extsymcount
= symcount
;
790 extsymcount
= symcount
- hdr
->sh_info
;
791 extsymoff
= hdr
->sh_info
;
794 buf
= ((Elf_External_Sym
*)
795 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
796 if (buf
== NULL
&& extsymcount
!= 0)
799 /* We store a pointer to the hash table entry for each external
801 sym_hash
= ((struct elf_link_hash_entry
**)
803 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
804 if (sym_hash
== NULL
)
806 elf_sym_hashes (abfd
) = sym_hash
;
810 /* If we are creating a shared library, create all the dynamic
811 sections immediately. We need to attach them to something,
812 so we attach them to this BFD, provided it is the right
813 format. FIXME: If there are no input BFD's of the same
814 format as the output, we can't make a shared library. */
816 && ! elf_hash_table (info
)->dynamic_sections_created
817 && abfd
->xvec
== info
->hash
->creator
)
819 if (! elf_link_create_dynamic_sections (abfd
, info
))
828 bfd_size_type oldsize
;
829 bfd_size_type strindex
;
831 /* Find the name to use in a DT_NEEDED entry that refers to this
832 object. If the object has a DT_SONAME entry, we use it.
833 Otherwise, if the generic linker stuck something in
834 elf_dt_name, we use that. Otherwise, we just use the file
835 name. If the generic linker put a null string into
836 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
837 there is a DT_SONAME entry. */
839 name
= bfd_get_filename (abfd
);
840 if (elf_dt_name (abfd
) != NULL
)
842 name
= elf_dt_name (abfd
);
846 s
= bfd_get_section_by_name (abfd
, ".dynamic");
849 Elf_External_Dyn
*extdyn
;
850 Elf_External_Dyn
*extdynend
;
854 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
858 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
859 (file_ptr
) 0, s
->_raw_size
))
862 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
865 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
868 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
869 for (; extdyn
< extdynend
; extdyn
++)
871 Elf_Internal_Dyn dyn
;
873 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
874 if (dyn
.d_tag
== DT_SONAME
)
876 name
= bfd_elf_string_from_elf_section (abfd
, link
,
881 if (dyn
.d_tag
== DT_NEEDED
)
883 struct bfd_link_needed_list
*n
, **pn
;
886 n
= ((struct bfd_link_needed_list
*)
887 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
888 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
890 if (n
== NULL
|| fnm
== NULL
)
892 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
899 for (pn
= &elf_hash_table (info
)->needed
;
911 /* We do not want to include any of the sections in a dynamic
912 object in the output file. We hack by simply clobbering the
913 list of sections in the BFD. This could be handled more
914 cleanly by, say, a new section flag; the existing
915 SEC_NEVER_LOAD flag is not the one we want, because that one
916 still implies that the section takes up space in the output
918 abfd
->sections
= NULL
;
919 abfd
->section_count
= 0;
921 /* If this is the first dynamic object found in the link, create
922 the special sections required for dynamic linking. */
923 if (! elf_hash_table (info
)->dynamic_sections_created
)
925 if (! elf_link_create_dynamic_sections (abfd
, info
))
931 /* Add a DT_NEEDED entry for this dynamic object. */
932 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
933 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
935 if (strindex
== (bfd_size_type
) -1)
938 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
941 Elf_External_Dyn
*dyncon
, *dynconend
;
943 /* The hash table size did not change, which means that
944 the dynamic object name was already entered. If we
945 have already included this dynamic object in the
946 link, just ignore it. There is no reason to include
947 a particular dynamic object more than once. */
948 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
950 BFD_ASSERT (sdyn
!= NULL
);
952 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
953 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
955 for (; dyncon
< dynconend
; dyncon
++)
957 Elf_Internal_Dyn dyn
;
959 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
961 if (dyn
.d_tag
== DT_NEEDED
962 && dyn
.d_un
.d_val
== strindex
)
966 if (extversym
!= NULL
)
973 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
977 /* Save the SONAME, if there is one, because sometimes the
978 linker emulation code will need to know it. */
980 name
= bfd_get_filename (abfd
);
981 elf_dt_name (abfd
) = name
;
985 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
987 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
988 != extsymcount
* sizeof (Elf_External_Sym
)))
993 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
994 esymend
= buf
+ extsymcount
;
997 esym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
999 Elf_Internal_Sym sym
;
1005 struct elf_link_hash_entry
*h
;
1007 boolean size_change_ok
, type_change_ok
;
1008 boolean new_weakdef
;
1009 unsigned int old_alignment
;
1011 elf_swap_symbol_in (abfd
, esym
, &sym
);
1013 flags
= BSF_NO_FLAGS
;
1015 value
= sym
.st_value
;
1018 bind
= ELF_ST_BIND (sym
.st_info
);
1019 if (bind
== STB_LOCAL
)
1021 /* This should be impossible, since ELF requires that all
1022 global symbols follow all local symbols, and that sh_info
1023 point to the first global symbol. Unfortunatealy, Irix 5
1027 else if (bind
== STB_GLOBAL
)
1029 if (sym
.st_shndx
!= SHN_UNDEF
1030 && sym
.st_shndx
!= SHN_COMMON
)
1035 else if (bind
== STB_WEAK
)
1039 /* Leave it up to the processor backend. */
1042 if (sym
.st_shndx
== SHN_UNDEF
)
1043 sec
= bfd_und_section_ptr
;
1044 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
1046 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
1048 sec
= bfd_abs_section_ptr
;
1049 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1052 else if (sym
.st_shndx
== SHN_ABS
)
1053 sec
= bfd_abs_section_ptr
;
1054 else if (sym
.st_shndx
== SHN_COMMON
)
1056 sec
= bfd_com_section_ptr
;
1057 /* What ELF calls the size we call the value. What ELF
1058 calls the value we call the alignment. */
1059 value
= sym
.st_size
;
1063 /* Leave it up to the processor backend. */
1066 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
1067 if (name
== (const char *) NULL
)
1070 if (add_symbol_hook
)
1072 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
1076 /* The hook function sets the name to NULL if this symbol
1077 should be skipped for some reason. */
1078 if (name
== (const char *) NULL
)
1082 /* Sanity check that all possibilities were handled. */
1083 if (sec
== (asection
*) NULL
)
1085 bfd_set_error (bfd_error_bad_value
);
1089 if (bfd_is_und_section (sec
)
1090 || bfd_is_com_section (sec
))
1095 size_change_ok
= false;
1096 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
1098 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1100 Elf_Internal_Versym iver
;
1101 unsigned int vernum
= 0;
1106 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
1107 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
1109 /* If this is a hidden symbol, or if it is not version
1110 1, we append the version name to the symbol name.
1111 However, we do not modify a non-hidden absolute
1112 symbol, because it might be the version symbol
1113 itself. FIXME: What if it isn't? */
1114 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
1115 || (vernum
> 1 && ! bfd_is_abs_section (sec
)))
1118 int namelen
, newlen
;
1121 if (sym
.st_shndx
!= SHN_UNDEF
)
1123 if (vernum
> elf_tdata (abfd
)->dynverdef_hdr
.sh_info
)
1125 (*_bfd_error_handler
)
1126 (_("%s: %s: invalid version %u (max %d)"),
1127 abfd
->filename
, name
, vernum
,
1128 elf_tdata (abfd
)->dynverdef_hdr
.sh_info
);
1129 bfd_set_error (bfd_error_bad_value
);
1132 else if (vernum
> 1)
1134 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1140 /* We cannot simply test for the number of
1141 entries in the VERNEED section since the
1142 numbers for the needed versions do not start
1144 Elf_Internal_Verneed
*t
;
1147 for (t
= elf_tdata (abfd
)->verref
;
1151 Elf_Internal_Vernaux
*a
;
1153 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1155 if (a
->vna_other
== vernum
)
1157 verstr
= a
->vna_nodename
;
1166 (*_bfd_error_handler
)
1167 (_("%s: %s: invalid needed version %d"),
1168 abfd
->filename
, name
, vernum
);
1169 bfd_set_error (bfd_error_bad_value
);
1174 namelen
= strlen (name
);
1175 newlen
= namelen
+ strlen (verstr
) + 2;
1176 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
1179 newname
= (char *) bfd_alloc (abfd
, newlen
);
1180 if (newname
== NULL
)
1182 strcpy (newname
, name
);
1183 p
= newname
+ namelen
;
1185 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
1193 if (! elf_merge_symbol (abfd
, info
, name
, &sym
, &sec
, &value
,
1194 sym_hash
, &override
, &type_change_ok
,
1202 while (h
->root
.type
== bfd_link_hash_indirect
1203 || h
->root
.type
== bfd_link_hash_warning
)
1204 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1206 /* Remember the old alignment if this is a common symbol, so
1207 that we don't reduce the alignment later on. We can't
1208 check later, because _bfd_generic_link_add_one_symbol
1209 will set a default for the alignment which we want to
1211 if (h
->root
.type
== bfd_link_hash_common
)
1212 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
1214 if (elf_tdata (abfd
)->verdef
!= NULL
1218 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
1221 if (! (_bfd_generic_link_add_one_symbol
1222 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
1223 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
1227 while (h
->root
.type
== bfd_link_hash_indirect
1228 || h
->root
.type
== bfd_link_hash_warning
)
1229 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1232 new_weakdef
= false;
1235 && (flags
& BSF_WEAK
) != 0
1236 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
1237 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1238 && h
->weakdef
== NULL
)
1240 /* Keep a list of all weak defined non function symbols from
1241 a dynamic object, using the weakdef field. Later in this
1242 function we will set the weakdef field to the correct
1243 value. We only put non-function symbols from dynamic
1244 objects on this list, because that happens to be the only
1245 time we need to know the normal symbol corresponding to a
1246 weak symbol, and the information is time consuming to
1247 figure out. If the weakdef field is not already NULL,
1248 then this symbol was already defined by some previous
1249 dynamic object, and we will be using that previous
1250 definition anyhow. */
1257 /* Set the alignment of a common symbol. */
1258 if (sym
.st_shndx
== SHN_COMMON
1259 && h
->root
.type
== bfd_link_hash_common
)
1263 align
= bfd_log2 (sym
.st_value
);
1264 if (align
> old_alignment
)
1265 h
->root
.u
.c
.p
->alignment_power
= align
;
1268 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1274 /* Remember the symbol size and type. */
1275 if (sym
.st_size
!= 0
1276 && (definition
|| h
->size
== 0))
1278 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
1279 (*_bfd_error_handler
)
1280 (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
1281 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
1282 bfd_get_filename (abfd
));
1284 h
->size
= sym
.st_size
;
1287 /* If this is a common symbol, then we always want H->SIZE
1288 to be the size of the common symbol. The code just above
1289 won't fix the size if a common symbol becomes larger. We
1290 don't warn about a size change here, because that is
1291 covered by --warn-common. */
1292 if (h
->root
.type
== bfd_link_hash_common
)
1293 h
->size
= h
->root
.u
.c
.size
;
1295 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
1296 && (definition
|| h
->type
== STT_NOTYPE
))
1298 if (h
->type
!= STT_NOTYPE
1299 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
1300 && ! type_change_ok
)
1301 (*_bfd_error_handler
)
1302 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
1303 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
1304 bfd_get_filename (abfd
));
1306 h
->type
= ELF_ST_TYPE (sym
.st_info
);
1309 if (sym
.st_other
!= 0
1310 && (definition
|| h
->other
== 0))
1311 h
->other
= sym
.st_other
;
1313 /* Set a flag in the hash table entry indicating the type of
1314 reference or definition we just found. Keep a count of
1315 the number of dynamic symbols we find. A dynamic symbol
1316 is one which is referenced or defined by both a regular
1317 object and a shared object. */
1318 old_flags
= h
->elf_link_hash_flags
;
1323 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
1325 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
1327 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1328 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
1334 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
1336 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
1337 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
1338 | ELF_LINK_HASH_REF_REGULAR
)) != 0
1339 || (h
->weakdef
!= NULL
1341 && h
->weakdef
->dynindx
!= -1))
1345 h
->elf_link_hash_flags
|= new_flag
;
1347 /* If this symbol has a version, and it is the default
1348 version, we create an indirect symbol from the default
1349 name to the fully decorated name. This will cause
1350 external references which do not specify a version to be
1351 bound to this version of the symbol. */
1356 p
= strchr (name
, ELF_VER_CHR
);
1357 if (p
!= NULL
&& p
[1] == ELF_VER_CHR
)
1360 struct elf_link_hash_entry
*hi
;
1363 shortname
= bfd_hash_allocate (&info
->hash
->table
,
1365 if (shortname
== NULL
)
1367 strncpy (shortname
, name
, p
- name
);
1368 shortname
[p
- name
] = '\0';
1370 /* We are going to create a new symbol. Merge it
1371 with any existing symbol with this name. For the
1372 purposes of the merge, act as though we were
1373 defining the symbol we just defined, although we
1374 actually going to define an indirect symbol. */
1375 type_change_ok
= false;
1376 size_change_ok
= false;
1377 if (! elf_merge_symbol (abfd
, info
, shortname
, &sym
, &sec
,
1378 &value
, &hi
, &override
,
1379 &type_change_ok
, &size_change_ok
))
1384 if (! (_bfd_generic_link_add_one_symbol
1385 (info
, abfd
, shortname
, BSF_INDIRECT
,
1386 bfd_ind_section_ptr
, (bfd_vma
) 0, name
, false,
1387 collect
, (struct bfd_link_hash_entry
**) &hi
)))
1392 /* In this case the symbol named SHORTNAME is
1393 overriding the indirect symbol we want to
1394 add. We were planning on making SHORTNAME an
1395 indirect symbol referring to NAME. SHORTNAME
1396 is the name without a version. NAME is the
1397 fully versioned name, and it is the default
1400 Overriding means that we already saw a
1401 definition for the symbol SHORTNAME in a
1402 regular object, and it is overriding the
1403 symbol defined in the dynamic object.
1405 When this happens, we actually want to change
1406 NAME, the symbol we just added, to refer to
1407 SHORTNAME. This will cause references to
1408 NAME in the shared object to become
1409 references to SHORTNAME in the regular
1410 object. This is what we expect when we
1411 override a function in a shared object: that
1412 the references in the shared object will be
1413 mapped to the definition in the regular
1416 while (hi
->root
.type
== bfd_link_hash_indirect
1417 || hi
->root
.type
== bfd_link_hash_warning
)
1418 hi
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1420 h
->root
.type
= bfd_link_hash_indirect
;
1421 h
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) hi
;
1422 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
1424 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_DEF_DYNAMIC
;
1425 hi
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_DYNAMIC
;
1426 if (hi
->elf_link_hash_flags
1427 & (ELF_LINK_HASH_REF_REGULAR
1428 | ELF_LINK_HASH_DEF_REGULAR
))
1430 if (! _bfd_elf_link_record_dynamic_symbol (info
,
1436 /* Now set HI to H, so that the following code
1437 will set the other fields correctly. */
1441 /* If there is a duplicate definition somewhere,
1442 then HI may not point to an indirect symbol. We
1443 will have reported an error to the user in that
1446 if (hi
->root
.type
== bfd_link_hash_indirect
)
1448 struct elf_link_hash_entry
*ht
;
1450 /* If the symbol became indirect, then we assume
1451 that we have not seen a definition before. */
1452 BFD_ASSERT ((hi
->elf_link_hash_flags
1453 & (ELF_LINK_HASH_DEF_DYNAMIC
1454 | ELF_LINK_HASH_DEF_REGULAR
))
1457 ht
= (struct elf_link_hash_entry
*) hi
->root
.u
.i
.link
;
1459 /* Copy down any references that we may have
1460 already seen to the symbol which just became
1462 ht
->elf_link_hash_flags
|=
1463 (hi
->elf_link_hash_flags
1464 & (ELF_LINK_HASH_REF_DYNAMIC
1465 | ELF_LINK_HASH_REF_REGULAR
));
1467 /* Copy over the global and procedure linkage table
1468 offset entries. These may have been already set
1469 up by a check_relocs routine. */
1470 if (ht
->got
.offset
== (bfd_vma
) -1)
1472 ht
->got
.offset
= hi
->got
.offset
;
1473 hi
->got
.offset
= (bfd_vma
) -1;
1475 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1477 if (ht
->plt
.offset
== (bfd_vma
) -1)
1479 ht
->plt
.offset
= hi
->plt
.offset
;
1480 hi
->plt
.offset
= (bfd_vma
) -1;
1482 BFD_ASSERT (hi
->plt
.offset
== (bfd_vma
) -1);
1484 if (ht
->dynindx
== -1)
1486 ht
->dynindx
= hi
->dynindx
;
1487 ht
->dynstr_index
= hi
->dynstr_index
;
1489 hi
->dynstr_index
= 0;
1491 BFD_ASSERT (hi
->dynindx
== -1);
1493 /* FIXME: There may be other information to copy
1494 over for particular targets. */
1496 /* See if the new flags lead us to realize that
1497 the symbol must be dynamic. */
1503 || ((hi
->elf_link_hash_flags
1504 & ELF_LINK_HASH_REF_DYNAMIC
)
1510 if ((hi
->elf_link_hash_flags
1511 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1517 /* We also need to define an indirection from the
1518 nondefault version of the symbol. */
1520 shortname
= bfd_hash_allocate (&info
->hash
->table
,
1522 if (shortname
== NULL
)
1524 strncpy (shortname
, name
, p
- name
);
1525 strcpy (shortname
+ (p
- name
), p
+ 1);
1527 /* Once again, merge with any existing symbol. */
1528 type_change_ok
= false;
1529 size_change_ok
= false;
1530 if (! elf_merge_symbol (abfd
, info
, shortname
, &sym
, &sec
,
1531 &value
, &hi
, &override
,
1532 &type_change_ok
, &size_change_ok
))
1537 /* Here SHORTNAME is a versioned name, so we
1538 don't expect to see the type of override we
1539 do in the case above. */
1540 (*_bfd_error_handler
)
1541 (_("%s: warning: unexpected redefinition of `%s'"),
1542 bfd_get_filename (abfd
), shortname
);
1546 if (! (_bfd_generic_link_add_one_symbol
1547 (info
, abfd
, shortname
, BSF_INDIRECT
,
1548 bfd_ind_section_ptr
, (bfd_vma
) 0, name
, false,
1549 collect
, (struct bfd_link_hash_entry
**) &hi
)))
1552 /* If there is a duplicate definition somewhere,
1553 then HI may not point to an indirect symbol.
1554 We will have reported an error to the user in
1557 if (hi
->root
.type
== bfd_link_hash_indirect
)
1559 /* If the symbol became indirect, then we
1560 assume that we have not seen a definition
1562 BFD_ASSERT ((hi
->elf_link_hash_flags
1563 & (ELF_LINK_HASH_DEF_DYNAMIC
1564 | ELF_LINK_HASH_DEF_REGULAR
))
1567 /* Copy down any references that we may have
1568 already seen to the symbol which just
1570 h
->elf_link_hash_flags
|=
1571 (hi
->elf_link_hash_flags
1572 & (ELF_LINK_HASH_REF_DYNAMIC
1573 | ELF_LINK_HASH_REF_REGULAR
));
1575 /* Copy over the global and procedure linkage
1576 table offset entries. These may have been
1577 already set up by a check_relocs routine. */
1578 if (h
->got
.offset
== (bfd_vma
) -1)
1580 h
->got
.offset
= hi
->got
.offset
;
1581 hi
->got
.offset
= (bfd_vma
) -1;
1583 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1585 if (h
->plt
.offset
== (bfd_vma
) -1)
1587 h
->plt
.offset
= hi
->plt
.offset
;
1588 hi
->plt
.offset
= (bfd_vma
) -1;
1590 BFD_ASSERT (hi
->got
.offset
== (bfd_vma
) -1);
1592 if (h
->dynindx
== -1)
1594 h
->dynindx
= hi
->dynindx
;
1595 h
->dynstr_index
= hi
->dynstr_index
;
1597 hi
->dynstr_index
= 0;
1599 BFD_ASSERT (hi
->dynindx
== -1);
1601 /* FIXME: There may be other information to
1602 copy over for particular targets. */
1604 /* See if the new flags lead us to realize
1605 that the symbol must be dynamic. */
1611 || ((hi
->elf_link_hash_flags
1612 & ELF_LINK_HASH_REF_DYNAMIC
)
1618 if ((hi
->elf_link_hash_flags
1619 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1628 if (dynsym
&& h
->dynindx
== -1)
1630 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1632 if (h
->weakdef
!= NULL
1634 && h
->weakdef
->dynindx
== -1)
1636 if (! _bfd_elf_link_record_dynamic_symbol (info
,
1644 /* Now set the weakdefs field correctly for all the weak defined
1645 symbols we found. The only way to do this is to search all the
1646 symbols. Since we only need the information for non functions in
1647 dynamic objects, that's the only time we actually put anything on
1648 the list WEAKS. We need this information so that if a regular
1649 object refers to a symbol defined weakly in a dynamic object, the
1650 real symbol in the dynamic object is also put in the dynamic
1651 symbols; we also must arrange for both symbols to point to the
1652 same memory location. We could handle the general case of symbol
1653 aliasing, but a general symbol alias can only be generated in
1654 assembler code, handling it correctly would be very time
1655 consuming, and other ELF linkers don't handle general aliasing
1657 while (weaks
!= NULL
)
1659 struct elf_link_hash_entry
*hlook
;
1662 struct elf_link_hash_entry
**hpp
;
1663 struct elf_link_hash_entry
**hppend
;
1666 weaks
= hlook
->weakdef
;
1667 hlook
->weakdef
= NULL
;
1669 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
1670 || hlook
->root
.type
== bfd_link_hash_defweak
1671 || hlook
->root
.type
== bfd_link_hash_common
1672 || hlook
->root
.type
== bfd_link_hash_indirect
);
1673 slook
= hlook
->root
.u
.def
.section
;
1674 vlook
= hlook
->root
.u
.def
.value
;
1676 hpp
= elf_sym_hashes (abfd
);
1677 hppend
= hpp
+ extsymcount
;
1678 for (; hpp
< hppend
; hpp
++)
1680 struct elf_link_hash_entry
*h
;
1683 if (h
!= NULL
&& h
!= hlook
1684 && h
->root
.type
== bfd_link_hash_defined
1685 && h
->root
.u
.def
.section
== slook
1686 && h
->root
.u
.def
.value
== vlook
)
1690 /* If the weak definition is in the list of dynamic
1691 symbols, make sure the real definition is put there
1693 if (hlook
->dynindx
!= -1
1694 && h
->dynindx
== -1)
1696 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1700 /* If the real definition is in the list of dynamic
1701 symbols, make sure the weak definition is put there
1702 as well. If we don't do this, then the dynamic
1703 loader might not merge the entries for the real
1704 definition and the weak definition. */
1705 if (h
->dynindx
!= -1
1706 && hlook
->dynindx
== -1)
1708 if (! _bfd_elf_link_record_dynamic_symbol (info
, hlook
))
1723 if (extversym
!= NULL
)
1729 /* If this object is the same format as the output object, and it is
1730 not a shared library, then let the backend look through the
1733 This is required to build global offset table entries and to
1734 arrange for dynamic relocs. It is not required for the
1735 particular common case of linking non PIC code, even when linking
1736 against shared libraries, but unfortunately there is no way of
1737 knowing whether an object file has been compiled PIC or not.
1738 Looking through the relocs is not particularly time consuming.
1739 The problem is that we must either (1) keep the relocs in memory,
1740 which causes the linker to require additional runtime memory or
1741 (2) read the relocs twice from the input file, which wastes time.
1742 This would be a good case for using mmap.
1744 I have no idea how to handle linking PIC code into a file of a
1745 different format. It probably can't be done. */
1746 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
1748 && abfd
->xvec
== info
->hash
->creator
1749 && check_relocs
!= NULL
)
1753 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1755 Elf_Internal_Rela
*internal_relocs
;
1758 if ((o
->flags
& SEC_RELOC
) == 0
1759 || o
->reloc_count
== 0
1760 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
1761 && (o
->flags
& SEC_DEBUGGING
) != 0)
1762 || bfd_is_abs_section (o
->output_section
))
1765 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
1766 (abfd
, o
, (PTR
) NULL
,
1767 (Elf_Internal_Rela
*) NULL
,
1768 info
->keep_memory
));
1769 if (internal_relocs
== NULL
)
1772 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
1774 if (! info
->keep_memory
)
1775 free (internal_relocs
);
1782 /* If this is a non-traditional, non-relocateable link, try to
1783 optimize the handling of the .stab/.stabstr sections. */
1785 && ! info
->relocateable
1786 && ! info
->traditional_format
1787 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1788 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
1790 asection
*stab
, *stabstr
;
1792 stab
= bfd_get_section_by_name (abfd
, ".stab");
1795 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
1797 if (stabstr
!= NULL
)
1799 struct bfd_elf_section_data
*secdata
;
1801 secdata
= elf_section_data (stab
);
1802 if (! _bfd_link_section_stabs (abfd
,
1803 &elf_hash_table (info
)->stab_info
,
1805 &secdata
->stab_info
))
1820 if (extversym
!= NULL
)
1825 /* Create some sections which will be filled in with dynamic linking
1826 information. ABFD is an input file which requires dynamic sections
1827 to be created. The dynamic sections take up virtual memory space
1828 when the final executable is run, so we need to create them before
1829 addresses are assigned to the output sections. We work out the
1830 actual contents and size of these sections later. */
1833 elf_link_create_dynamic_sections (abfd
, info
)
1835 struct bfd_link_info
*info
;
1838 register asection
*s
;
1839 struct elf_link_hash_entry
*h
;
1840 struct elf_backend_data
*bed
;
1842 if (elf_hash_table (info
)->dynamic_sections_created
)
1845 /* Make sure that all dynamic sections use the same input BFD. */
1846 if (elf_hash_table (info
)->dynobj
== NULL
)
1847 elf_hash_table (info
)->dynobj
= abfd
;
1849 abfd
= elf_hash_table (info
)->dynobj
;
1851 /* Note that we set the SEC_IN_MEMORY flag for all of these
1853 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1854 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1856 /* A dynamically linked executable has a .interp section, but a
1857 shared library does not. */
1860 s
= bfd_make_section (abfd
, ".interp");
1862 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1866 /* Create sections to hold version informations. These are removed
1867 if they are not needed. */
1868 s
= bfd_make_section (abfd
, ".gnu.version_d");
1870 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1871 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1874 s
= bfd_make_section (abfd
, ".gnu.version");
1876 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1877 || ! bfd_set_section_alignment (abfd
, s
, 1))
1880 s
= bfd_make_section (abfd
, ".gnu.version_r");
1882 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1883 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1886 s
= bfd_make_section (abfd
, ".dynsym");
1888 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1889 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1892 s
= bfd_make_section (abfd
, ".dynstr");
1894 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1897 /* Create a strtab to hold the dynamic symbol names. */
1898 if (elf_hash_table (info
)->dynstr
== NULL
)
1900 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1901 if (elf_hash_table (info
)->dynstr
== NULL
)
1905 s
= bfd_make_section (abfd
, ".dynamic");
1907 || ! bfd_set_section_flags (abfd
, s
, flags
)
1908 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1911 /* The special symbol _DYNAMIC is always set to the start of the
1912 .dynamic section. This call occurs before we have processed the
1913 symbols for any dynamic object, so we don't have to worry about
1914 overriding a dynamic definition. We could set _DYNAMIC in a
1915 linker script, but we only want to define it if we are, in fact,
1916 creating a .dynamic section. We don't want to define it if there
1917 is no .dynamic section, since on some ELF platforms the start up
1918 code examines it to decide how to initialize the process. */
1920 if (! (_bfd_generic_link_add_one_symbol
1921 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1922 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1923 (struct bfd_link_hash_entry
**) &h
)))
1925 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1926 h
->type
= STT_OBJECT
;
1929 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1932 s
= bfd_make_section (abfd
, ".hash");
1934 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1935 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1938 /* Let the backend create the rest of the sections. This lets the
1939 backend set the right flags. The backend will normally create
1940 the .got and .plt sections. */
1941 bed
= get_elf_backend_data (abfd
);
1942 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1945 elf_hash_table (info
)->dynamic_sections_created
= true;
1950 /* Add an entry to the .dynamic table. */
1953 elf_add_dynamic_entry (info
, tag
, val
)
1954 struct bfd_link_info
*info
;
1958 Elf_Internal_Dyn dyn
;
1962 bfd_byte
*newcontents
;
1964 dynobj
= elf_hash_table (info
)->dynobj
;
1966 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1967 BFD_ASSERT (s
!= NULL
);
1969 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1970 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1971 if (newcontents
== NULL
)
1975 dyn
.d_un
.d_val
= val
;
1976 elf_swap_dyn_out (dynobj
, &dyn
,
1977 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1979 s
->_raw_size
= newsize
;
1980 s
->contents
= newcontents
;
1986 /* Read and swap the relocs for a section. They may have been cached.
1987 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1988 they are used as buffers to read into. They are known to be large
1989 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1990 value is allocated using either malloc or bfd_alloc, according to
1991 the KEEP_MEMORY argument. */
1994 NAME(_bfd_elf
,link_read_relocs
) (abfd
, o
, external_relocs
, internal_relocs
,
1998 PTR external_relocs
;
1999 Elf_Internal_Rela
*internal_relocs
;
2000 boolean keep_memory
;
2002 Elf_Internal_Shdr
*rel_hdr
;
2004 Elf_Internal_Rela
*alloc2
= NULL
;
2006 if (elf_section_data (o
)->relocs
!= NULL
)
2007 return elf_section_data (o
)->relocs
;
2009 if (o
->reloc_count
== 0)
2012 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2014 if (internal_relocs
== NULL
)
2018 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
2020 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
2022 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
2023 if (internal_relocs
== NULL
)
2027 if (external_relocs
== NULL
)
2029 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
2032 external_relocs
= alloc1
;
2035 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
2036 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
2037 != rel_hdr
->sh_size
))
2040 /* Swap in the relocs. For convenience, we always produce an
2041 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
2043 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2045 Elf_External_Rel
*erel
;
2046 Elf_External_Rel
*erelend
;
2047 Elf_Internal_Rela
*irela
;
2049 erel
= (Elf_External_Rel
*) external_relocs
;
2050 erelend
= erel
+ o
->reloc_count
;
2051 irela
= internal_relocs
;
2052 for (; erel
< erelend
; erel
++, irela
++)
2054 Elf_Internal_Rel irel
;
2056 elf_swap_reloc_in (abfd
, erel
, &irel
);
2057 irela
->r_offset
= irel
.r_offset
;
2058 irela
->r_info
= irel
.r_info
;
2059 irela
->r_addend
= 0;
2064 Elf_External_Rela
*erela
;
2065 Elf_External_Rela
*erelaend
;
2066 Elf_Internal_Rela
*irela
;
2068 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
2070 erela
= (Elf_External_Rela
*) external_relocs
;
2071 erelaend
= erela
+ o
->reloc_count
;
2072 irela
= internal_relocs
;
2073 for (; erela
< erelaend
; erela
++, irela
++)
2074 elf_swap_reloca_in (abfd
, erela
, irela
);
2077 /* Cache the results for next time, if we can. */
2079 elf_section_data (o
)->relocs
= internal_relocs
;
2084 /* Don't free alloc2, since if it was allocated we are passing it
2085 back (under the name of internal_relocs). */
2087 return internal_relocs
;
2098 /* Record an assignment to a symbol made by a linker script. We need
2099 this in case some dynamic object refers to this symbol. */
2103 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
2105 struct bfd_link_info
*info
;
2109 struct elf_link_hash_entry
*h
;
2111 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
2114 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
2118 if (h
->root
.type
== bfd_link_hash_new
)
2119 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
2121 /* If this symbol is being provided by the linker script, and it is
2122 currently defined by a dynamic object, but not by a regular
2123 object, then mark it as undefined so that the generic linker will
2124 force the correct value. */
2126 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2127 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2128 h
->root
.type
= bfd_link_hash_undefined
;
2130 /* If this symbol is not being provided by the linker script, and it is
2131 currently defined by a dynamic object, but not by a regular object,
2132 then clear out any version information because the symbol will not be
2133 associated with the dynamic object any more. */
2135 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2136 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2137 h
->verinfo
.verdef
= NULL
;
2139 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2140 h
->type
= STT_OBJECT
;
2142 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
2143 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
2145 && h
->dynindx
== -1)
2147 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2150 /* If this is a weak defined symbol, and we know a corresponding
2151 real symbol from the same dynamic object, make sure the real
2152 symbol is also made into a dynamic symbol. */
2153 if (h
->weakdef
!= NULL
2154 && h
->weakdef
->dynindx
== -1)
2156 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
2164 /* This structure is used to pass information to
2165 elf_link_assign_sym_version. */
2167 struct elf_assign_sym_version_info
2171 /* General link information. */
2172 struct bfd_link_info
*info
;
2174 struct bfd_elf_version_tree
*verdefs
;
2175 /* Whether we are exporting all dynamic symbols. */
2176 boolean export_dynamic
;
2177 /* Whether we removed any symbols from the dynamic symbol table. */
2178 boolean removed_dynamic
;
2179 /* Whether we had a failure. */
2183 /* This structure is used to pass information to
2184 elf_link_find_version_dependencies. */
2186 struct elf_find_verdep_info
2190 /* General link information. */
2191 struct bfd_link_info
*info
;
2192 /* The number of dependencies. */
2194 /* Whether we had a failure. */
2198 /* Array used to determine the number of hash table buckets to use
2199 based on the number of symbols there are. If there are fewer than
2200 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
2201 fewer than 37 we use 17 buckets, and so forth. We never use more
2202 than 32771 buckets. */
2204 static const size_t elf_buckets
[] =
2206 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
2210 /* Set up the sizes and contents of the ELF dynamic sections. This is
2211 called by the ELF linker emulation before_allocation routine. We
2212 must set the sizes of the sections before the linker sets the
2213 addresses of the various sections. */
2216 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
2217 export_dynamic
, filter_shlib
,
2218 auxiliary_filters
, info
, sinterpptr
,
2223 boolean export_dynamic
;
2224 const char *filter_shlib
;
2225 const char * const *auxiliary_filters
;
2226 struct bfd_link_info
*info
;
2227 asection
**sinterpptr
;
2228 struct bfd_elf_version_tree
*verdefs
;
2230 bfd_size_type soname_indx
;
2232 struct elf_backend_data
*bed
;
2233 bfd_size_type old_dynsymcount
;
2234 struct elf_assign_sym_version_info asvinfo
;
2238 soname_indx
= (bfd_size_type
) -1;
2240 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
2243 /* The backend may have to create some sections regardless of whether
2244 we're dynamic or not. */
2245 bed
= get_elf_backend_data (output_bfd
);
2246 if (bed
->elf_backend_always_size_sections
2247 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
2250 dynobj
= elf_hash_table (info
)->dynobj
;
2252 /* If there were no dynamic objects in the link, there is nothing to
2257 /* If we are supposed to export all symbols into the dynamic symbol
2258 table (this is not the normal case), then do so. */
2261 struct elf_info_failed eif
;
2265 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
2271 if (elf_hash_table (info
)->dynamic_sections_created
)
2273 struct elf_info_failed eif
;
2274 struct elf_link_hash_entry
*h
;
2275 bfd_size_type strsize
;
2277 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
2278 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
2282 soname_indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2283 soname
, true, true);
2284 if (soname_indx
== (bfd_size_type
) -1
2285 || ! elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
2291 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
2299 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
2301 if (indx
== (bfd_size_type
) -1
2302 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
2306 if (filter_shlib
!= NULL
)
2310 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2311 filter_shlib
, true, true);
2312 if (indx
== (bfd_size_type
) -1
2313 || ! elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
2317 if (auxiliary_filters
!= NULL
)
2319 const char * const *p
;
2321 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
2325 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2327 if (indx
== (bfd_size_type
) -1
2328 || ! elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
2333 /* Attach all the symbols to their version information. */
2334 asvinfo
.output_bfd
= output_bfd
;
2335 asvinfo
.info
= info
;
2336 asvinfo
.verdefs
= verdefs
;
2337 asvinfo
.export_dynamic
= export_dynamic
;
2338 asvinfo
.removed_dynamic
= false;
2339 asvinfo
.failed
= false;
2341 elf_link_hash_traverse (elf_hash_table (info
),
2342 elf_link_assign_sym_version
,
2347 /* Find all symbols which were defined in a dynamic object and make
2348 the backend pick a reasonable value for them. */
2351 elf_link_hash_traverse (elf_hash_table (info
),
2352 elf_adjust_dynamic_symbol
,
2357 /* Add some entries to the .dynamic section. We fill in some of the
2358 values later, in elf_bfd_final_link, but we must add the entries
2359 now so that we know the final size of the .dynamic section. */
2360 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
2363 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2364 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2366 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
2369 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
2372 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2373 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2375 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
2378 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
2379 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
2380 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
2381 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
2382 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
2383 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
2384 sizeof (Elf_External_Sym
)))
2388 /* The backend must work out the sizes of all the other dynamic
2390 old_dynsymcount
= elf_hash_table (info
)->dynsymcount
;
2391 if (bed
->elf_backend_size_dynamic_sections
2392 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
2395 if (elf_hash_table (info
)->dynamic_sections_created
)
2400 size_t bucketcount
= 0;
2401 Elf_Internal_Sym isym
;
2403 /* Set up the version definition section. */
2404 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
2405 BFD_ASSERT (s
!= NULL
);
2407 /* We may have created additional version definitions if we are
2408 just linking a regular application. */
2409 verdefs
= asvinfo
.verdefs
;
2411 if (verdefs
== NULL
)
2415 /* Don't include this section in the output file. */
2416 for (spp
= &output_bfd
->sections
;
2417 *spp
!= s
->output_section
;
2418 spp
= &(*spp
)->next
)
2420 *spp
= s
->output_section
->next
;
2421 --output_bfd
->section_count
;
2427 struct bfd_elf_version_tree
*t
;
2429 Elf_Internal_Verdef def
;
2430 Elf_Internal_Verdaux defaux
;
2432 if (asvinfo
.removed_dynamic
)
2434 /* Some dynamic symbols were changed to be local
2435 symbols. In this case, we renumber all of the
2436 dynamic symbols, so that we don't have a hole. If
2437 the backend changed dynsymcount, then assume that the
2438 new symbols are at the start. This is the case on
2439 the MIPS. FIXME: The names of the removed symbols
2440 will still be in the dynamic string table, wasting
2442 elf_hash_table (info
)->dynsymcount
=
2443 1 + (elf_hash_table (info
)->dynsymcount
- old_dynsymcount
);
2444 elf_link_hash_traverse (elf_hash_table (info
),
2445 elf_link_renumber_dynsyms
,
2452 /* Make space for the base version. */
2453 size
+= sizeof (Elf_External_Verdef
);
2454 size
+= sizeof (Elf_External_Verdaux
);
2457 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2459 struct bfd_elf_version_deps
*n
;
2461 size
+= sizeof (Elf_External_Verdef
);
2462 size
+= sizeof (Elf_External_Verdaux
);
2465 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2466 size
+= sizeof (Elf_External_Verdaux
);
2469 s
->_raw_size
= size
;
2470 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
2471 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2474 /* Fill in the version definition section. */
2478 def
.vd_version
= VER_DEF_CURRENT
;
2479 def
.vd_flags
= VER_FLG_BASE
;
2482 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2483 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2484 + sizeof (Elf_External_Verdaux
));
2486 if (soname_indx
!= (bfd_size_type
) -1)
2488 def
.vd_hash
= bfd_elf_hash ((const unsigned char *) soname
);
2489 defaux
.vda_name
= soname_indx
;
2496 name
= output_bfd
->filename
;
2497 def
.vd_hash
= bfd_elf_hash ((const unsigned char *) name
);
2498 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2500 if (indx
== (bfd_size_type
) -1)
2502 defaux
.vda_name
= indx
;
2504 defaux
.vda_next
= 0;
2506 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2507 (Elf_External_Verdef
*)p
);
2508 p
+= sizeof (Elf_External_Verdef
);
2509 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2510 (Elf_External_Verdaux
*) p
);
2511 p
+= sizeof (Elf_External_Verdaux
);
2513 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2516 struct bfd_elf_version_deps
*n
;
2517 struct elf_link_hash_entry
*h
;
2520 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2523 /* Add a symbol representing this version. */
2525 if (! (_bfd_generic_link_add_one_symbol
2526 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
2527 (bfd_vma
) 0, (const char *) NULL
, false,
2528 get_elf_backend_data (dynobj
)->collect
,
2529 (struct bfd_link_hash_entry
**) &h
)))
2531 h
->elf_link_hash_flags
&= ~ ELF_LINK_NON_ELF
;
2532 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2533 h
->type
= STT_OBJECT
;
2534 h
->verinfo
.vertree
= t
;
2536 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2539 def
.vd_version
= VER_DEF_CURRENT
;
2541 if (t
->globals
== NULL
&& t
->locals
== NULL
&& ! t
->used
)
2542 def
.vd_flags
|= VER_FLG_WEAK
;
2543 def
.vd_ndx
= t
->vernum
+ 1;
2544 def
.vd_cnt
= cdeps
+ 1;
2545 def
.vd_hash
= bfd_elf_hash ((const unsigned char *) t
->name
);
2546 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2547 if (t
->next
!= NULL
)
2548 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2549 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
2553 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2554 (Elf_External_Verdef
*) p
);
2555 p
+= sizeof (Elf_External_Verdef
);
2557 defaux
.vda_name
= h
->dynstr_index
;
2558 if (t
->deps
== NULL
)
2559 defaux
.vda_next
= 0;
2561 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2562 t
->name_indx
= defaux
.vda_name
;
2564 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2565 (Elf_External_Verdaux
*) p
);
2566 p
+= sizeof (Elf_External_Verdaux
);
2568 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2570 if (n
->version_needed
== NULL
)
2572 /* This can happen if there was an error in the
2574 defaux
.vda_name
= 0;
2577 defaux
.vda_name
= n
->version_needed
->name_indx
;
2578 if (n
->next
== NULL
)
2579 defaux
.vda_next
= 0;
2581 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2583 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2584 (Elf_External_Verdaux
*) p
);
2585 p
+= sizeof (Elf_External_Verdaux
);
2589 if (! elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
2590 || ! elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
2593 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
2596 /* Work out the size of the version reference section. */
2598 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
2599 BFD_ASSERT (s
!= NULL
);
2601 struct elf_find_verdep_info sinfo
;
2603 sinfo
.output_bfd
= output_bfd
;
2605 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
2606 if (sinfo
.vers
== 0)
2608 sinfo
.failed
= false;
2610 elf_link_hash_traverse (elf_hash_table (info
),
2611 elf_link_find_version_dependencies
,
2614 if (elf_tdata (output_bfd
)->verref
== NULL
)
2618 /* We don't have any version definitions, so we can just
2619 remove the section. */
2621 for (spp
= &output_bfd
->sections
;
2622 *spp
!= s
->output_section
;
2623 spp
= &(*spp
)->next
)
2625 *spp
= s
->output_section
->next
;
2626 --output_bfd
->section_count
;
2630 Elf_Internal_Verneed
*t
;
2635 /* Build the version definition section. */
2638 for (t
= elf_tdata (output_bfd
)->verref
;
2642 Elf_Internal_Vernaux
*a
;
2644 size
+= sizeof (Elf_External_Verneed
);
2646 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2647 size
+= sizeof (Elf_External_Vernaux
);
2650 s
->_raw_size
= size
;
2651 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, size
);
2652 if (s
->contents
== NULL
)
2656 for (t
= elf_tdata (output_bfd
)->verref
;
2661 Elf_Internal_Vernaux
*a
;
2665 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2668 t
->vn_version
= VER_NEED_CURRENT
;
2670 if (elf_dt_name (t
->vn_bfd
) != NULL
)
2671 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2672 elf_dt_name (t
->vn_bfd
),
2675 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2676 t
->vn_bfd
->filename
, true, false);
2677 if (indx
== (bfd_size_type
) -1)
2680 t
->vn_aux
= sizeof (Elf_External_Verneed
);
2681 if (t
->vn_nextref
== NULL
)
2684 t
->vn_next
= (sizeof (Elf_External_Verneed
)
2685 + caux
* sizeof (Elf_External_Vernaux
));
2687 _bfd_elf_swap_verneed_out (output_bfd
, t
,
2688 (Elf_External_Verneed
*) p
);
2689 p
+= sizeof (Elf_External_Verneed
);
2691 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2693 a
->vna_hash
= bfd_elf_hash ((const unsigned char *)
2695 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
2696 a
->vna_nodename
, true, false);
2697 if (indx
== (bfd_size_type
) -1)
2700 if (a
->vna_nextptr
== NULL
)
2703 a
->vna_next
= sizeof (Elf_External_Vernaux
);
2705 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
2706 (Elf_External_Vernaux
*) p
);
2707 p
+= sizeof (Elf_External_Vernaux
);
2711 if (! elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
2712 || ! elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
2715 elf_tdata (output_bfd
)->cverrefs
= crefs
;
2719 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
2721 /* Work out the size of the symbol version section. */
2722 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
2723 BFD_ASSERT (s
!= NULL
);
2724 if (dynsymcount
== 0
2725 || (verdefs
== NULL
&& elf_tdata (output_bfd
)->verref
== NULL
))
2729 /* We don't need any symbol versions; just discard the
2731 for (spp
= &output_bfd
->sections
;
2732 *spp
!= s
->output_section
;
2733 spp
= &(*spp
)->next
)
2735 *spp
= s
->output_section
->next
;
2736 --output_bfd
->section_count
;
2740 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Versym
);
2741 s
->contents
= (bfd_byte
*) bfd_zalloc (output_bfd
, s
->_raw_size
);
2742 if (s
->contents
== NULL
)
2745 if (! elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
2749 /* Set the size of the .dynsym and .hash sections. We counted
2750 the number of dynamic symbols in elf_link_add_object_symbols.
2751 We will build the contents of .dynsym and .hash when we build
2752 the final symbol table, because until then we do not know the
2753 correct value to give the symbols. We built the .dynstr
2754 section as we went along in elf_link_add_object_symbols. */
2755 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
2756 BFD_ASSERT (s
!= NULL
);
2757 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
2758 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
2759 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2762 /* The first entry in .dynsym is a dummy symbol. */
2769 elf_swap_symbol_out (output_bfd
, &isym
,
2770 (PTR
) (Elf_External_Sym
*) s
->contents
);
2772 for (i
= 0; elf_buckets
[i
] != 0; i
++)
2774 bucketcount
= elf_buckets
[i
];
2775 if (dynsymcount
< elf_buckets
[i
+ 1])
2779 s
= bfd_get_section_by_name (dynobj
, ".hash");
2780 BFD_ASSERT (s
!= NULL
);
2781 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
2782 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
2783 if (s
->contents
== NULL
)
2785 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
2787 put_word (output_bfd
, bucketcount
, s
->contents
);
2788 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
2790 elf_hash_table (info
)->bucketcount
= bucketcount
;
2792 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
2793 BFD_ASSERT (s
!= NULL
);
2794 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
2796 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
2803 /* Fix up the flags for a symbol. This handles various cases which
2804 can only be fixed after all the input files are seen. This is
2805 currently called by both adjust_dynamic_symbol and
2806 assign_sym_version, which is unnecessary but perhaps more robust in
2807 the face of future changes. */
2810 elf_fix_symbol_flags (h
, eif
)
2811 struct elf_link_hash_entry
*h
;
2812 struct elf_info_failed
*eif
;
2814 /* If this symbol was mentioned in a non-ELF file, try to set
2815 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2816 permit a non-ELF file to correctly refer to a symbol defined in
2817 an ELF dynamic object. */
2818 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
2820 if (h
->root
.type
!= bfd_link_hash_defined
2821 && h
->root
.type
!= bfd_link_hash_defweak
)
2822 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2825 if (h
->root
.u
.def
.section
->owner
!= NULL
2826 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
2827 == bfd_target_elf_flavour
))
2828 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2830 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2833 if (h
->dynindx
== -1
2834 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2835 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0))
2837 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
2845 /* If this is a final link, and the symbol was defined as a common
2846 symbol in a regular object file, and there was no definition in
2847 any dynamic object, then the linker will have allocated space for
2848 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
2849 flag will not have been set. */
2850 if (h
->root
.type
== bfd_link_hash_defined
2851 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2852 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
2853 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2854 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
2855 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2857 /* If -Bsymbolic was used (which means to bind references to global
2858 symbols to the definition within the shared object), and this
2859 symbol was defined in a regular object, then it actually doesn't
2860 need a PLT entry. */
2861 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
2862 && eif
->info
->shared
2863 && eif
->info
->symbolic
2864 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2866 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
2867 h
->plt
.offset
= (bfd_vma
) -1;
2873 /* Make the backend pick a good value for a dynamic symbol. This is
2874 called via elf_link_hash_traverse, and also calls itself
2878 elf_adjust_dynamic_symbol (h
, data
)
2879 struct elf_link_hash_entry
*h
;
2882 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2884 struct elf_backend_data
*bed
;
2886 /* Ignore indirect symbols. These are added by the versioning code. */
2887 if (h
->root
.type
== bfd_link_hash_indirect
)
2890 /* Fix the symbol flags. */
2891 if (! elf_fix_symbol_flags (h
, eif
))
2894 /* If this symbol does not require a PLT entry, and it is not
2895 defined by a dynamic object, or is not referenced by a regular
2896 object, ignore it. We do have to handle a weak defined symbol,
2897 even if no regular object refers to it, if we decided to add it
2898 to the dynamic symbol table. FIXME: Do we normally need to worry
2899 about symbols which are defined by one dynamic object and
2900 referenced by another one? */
2901 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
2902 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
2903 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2904 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
2905 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
2907 h
->plt
.offset
= (bfd_vma
) -1;
2911 /* If we've already adjusted this symbol, don't do it again. This
2912 can happen via a recursive call. */
2913 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
2916 /* Don't look at this symbol again. Note that we must set this
2917 after checking the above conditions, because we may look at a
2918 symbol once, decide not to do anything, and then get called
2919 recursively later after REF_REGULAR is set below. */
2920 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
2922 /* If this is a weak definition, and we know a real definition, and
2923 the real symbol is not itself defined by a regular object file,
2924 then get a good value for the real definition. We handle the
2925 real symbol first, for the convenience of the backend routine.
2927 Note that there is a confusing case here. If the real definition
2928 is defined by a regular object file, we don't get the real symbol
2929 from the dynamic object, but we do get the weak symbol. If the
2930 processor backend uses a COPY reloc, then if some routine in the
2931 dynamic object changes the real symbol, we will not see that
2932 change in the corresponding weak symbol. This is the way other
2933 ELF linkers work as well, and seems to be a result of the shared
2936 I will clarify this issue. Most SVR4 shared libraries define the
2937 variable _timezone and define timezone as a weak synonym. The
2938 tzset call changes _timezone. If you write
2939 extern int timezone;
2941 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2942 you might expect that, since timezone is a synonym for _timezone,
2943 the same number will print both times. However, if the processor
2944 backend uses a COPY reloc, then actually timezone will be copied
2945 into your process image, and, since you define _timezone
2946 yourself, _timezone will not. Thus timezone and _timezone will
2947 wind up at different memory locations. The tzset call will set
2948 _timezone, leaving timezone unchanged. */
2950 if (h
->weakdef
!= NULL
)
2952 struct elf_link_hash_entry
*weakdef
;
2954 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2955 || h
->root
.type
== bfd_link_hash_defweak
);
2956 weakdef
= h
->weakdef
;
2957 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
2958 || weakdef
->root
.type
== bfd_link_hash_defweak
);
2959 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
2960 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
2962 /* This symbol is defined by a regular object file, so we
2963 will not do anything special. Clear weakdef for the
2964 convenience of the processor backend. */
2969 /* There is an implicit reference by a regular object file
2970 via the weak symbol. */
2971 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2972 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
2977 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
2978 bed
= get_elf_backend_data (dynobj
);
2979 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
2988 /* This routine is used to export all defined symbols into the dynamic
2989 symbol table. It is called via elf_link_hash_traverse. */
2992 elf_export_symbol (h
, data
)
2993 struct elf_link_hash_entry
*h
;
2996 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
2998 /* Ignore indirect symbols. These are added by the versioning code. */
2999 if (h
->root
.type
== bfd_link_hash_indirect
)
3002 if (h
->dynindx
== -1
3003 && (h
->elf_link_hash_flags
3004 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
3006 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
3016 /* Look through the symbols which are defined in other shared
3017 libraries and referenced here. Update the list of version
3018 dependencies. This will be put into the .gnu.version_r section.
3019 This function is called via elf_link_hash_traverse. */
3022 elf_link_find_version_dependencies (h
, data
)
3023 struct elf_link_hash_entry
*h
;
3026 struct elf_find_verdep_info
*rinfo
= (struct elf_find_verdep_info
*) data
;
3027 Elf_Internal_Verneed
*t
;
3028 Elf_Internal_Vernaux
*a
;
3030 /* We only care about symbols defined in shared objects with version
3032 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
3033 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
3035 || h
->verinfo
.verdef
== NULL
)
3038 /* See if we already know about this version. */
3039 for (t
= elf_tdata (rinfo
->output_bfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
3041 if (t
->vn_bfd
!= h
->verinfo
.verdef
->vd_bfd
)
3044 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
3045 if (a
->vna_nodename
== h
->verinfo
.verdef
->vd_nodename
)
3051 /* This is a new version. Add it to tree we are building. */
3055 t
= (Elf_Internal_Verneed
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *t
);
3058 rinfo
->failed
= true;
3062 t
->vn_bfd
= h
->verinfo
.verdef
->vd_bfd
;
3063 t
->vn_nextref
= elf_tdata (rinfo
->output_bfd
)->verref
;
3064 elf_tdata (rinfo
->output_bfd
)->verref
= t
;
3067 a
= (Elf_Internal_Vernaux
*) bfd_zalloc (rinfo
->output_bfd
, sizeof *a
);
3069 /* Note that we are copying a string pointer here, and testing it
3070 above. If bfd_elf_string_from_elf_section is ever changed to
3071 discard the string data when low in memory, this will have to be
3073 a
->vna_nodename
= h
->verinfo
.verdef
->vd_nodename
;
3075 a
->vna_flags
= h
->verinfo
.verdef
->vd_flags
;
3076 a
->vna_nextptr
= t
->vn_auxptr
;
3078 h
->verinfo
.verdef
->vd_exp_refno
= rinfo
->vers
;
3081 a
->vna_other
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
3088 /* Figure out appropriate versions for all the symbols. We may not
3089 have the version number script until we have read all of the input
3090 files, so until that point we don't know which symbols should be
3091 local. This function is called via elf_link_hash_traverse. */
3094 elf_link_assign_sym_version (h
, data
)
3095 struct elf_link_hash_entry
*h
;
3098 struct elf_assign_sym_version_info
*sinfo
=
3099 (struct elf_assign_sym_version_info
*) data
;
3100 struct bfd_link_info
*info
= sinfo
->info
;
3101 struct elf_info_failed eif
;
3104 /* Fix the symbol flags. */
3107 if (! elf_fix_symbol_flags (h
, &eif
))
3110 sinfo
->failed
= true;
3114 /* We only need version numbers for symbols defined in regular
3116 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3119 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
3120 if (p
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3122 struct bfd_elf_version_tree
*t
;
3127 /* There are two consecutive ELF_VER_CHR characters if this is
3128 not a hidden symbol. */
3130 if (*p
== ELF_VER_CHR
)
3136 /* If there is no version string, we can just return out. */
3140 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3144 /* Look for the version. If we find it, it is no longer weak. */
3145 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3147 if (strcmp (t
->name
, p
) == 0)
3151 struct bfd_elf_version_expr
*d
;
3153 len
= p
- h
->root
.root
.string
;
3154 alc
= bfd_alloc (sinfo
->output_bfd
, len
);
3157 strncpy (alc
, h
->root
.root
.string
, len
- 1);
3158 alc
[len
- 1] = '\0';
3159 if (alc
[len
- 2] == ELF_VER_CHR
)
3160 alc
[len
- 2] = '\0';
3162 h
->verinfo
.vertree
= t
;
3166 if (t
->globals
!= NULL
)
3168 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3170 if ((d
->match
[0] == '*' && d
->match
[1] == '\0')
3171 || fnmatch (d
->match
, alc
, 0) == 0)
3176 /* See if there is anything to force this symbol to
3178 if (d
== NULL
&& t
->locals
!= NULL
)
3180 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3182 if ((d
->match
[0] == '*' && d
->match
[1] == '\0')
3183 || fnmatch (d
->match
, alc
, 0) == 0)
3185 if (h
->dynindx
!= -1
3187 && ! sinfo
->export_dynamic
)
3189 sinfo
->removed_dynamic
= true;
3190 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3191 h
->elf_link_hash_flags
&=~
3192 ELF_LINK_HASH_NEEDS_PLT
;
3194 h
->plt
.offset
= (bfd_vma
) -1;
3195 /* FIXME: The name of the symbol has
3196 already been recorded in the dynamic
3197 string table section. */
3205 bfd_release (sinfo
->output_bfd
, alc
);
3210 /* If we are building an application, we need to create a
3211 version node for this version. */
3212 if (t
== NULL
&& ! info
->shared
)
3214 struct bfd_elf_version_tree
**pp
;
3217 /* If we aren't going to export this symbol, we don't need
3218 to worry about it. */
3219 if (h
->dynindx
== -1)
3222 t
= ((struct bfd_elf_version_tree
*)
3223 bfd_alloc (sinfo
->output_bfd
, sizeof *t
));
3226 sinfo
->failed
= true;
3235 t
->name_indx
= (unsigned int) -1;
3239 for (pp
= &sinfo
->verdefs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3241 t
->vernum
= version_index
;
3245 h
->verinfo
.vertree
= t
;
3249 /* We could not find the version for a symbol when
3250 generating a shared archive. Return an error. */
3251 (*_bfd_error_handler
)
3252 (_("%s: undefined versioned symbol name %s"),
3253 bfd_get_filename (sinfo
->output_bfd
), h
->root
.root
.string
);
3254 bfd_set_error (bfd_error_bad_value
);
3255 sinfo
->failed
= true;
3260 h
->elf_link_hash_flags
|= ELF_LINK_HIDDEN
;
3263 /* If we don't have a version for this symbol, see if we can find
3265 if (h
->verinfo
.vertree
== NULL
&& sinfo
->verdefs
!= NULL
)
3267 struct bfd_elf_version_tree
*t
;
3268 struct bfd_elf_version_tree
*deflt
;
3269 struct bfd_elf_version_expr
*d
;
3271 /* See if can find what version this symbol is in. If the
3272 symbol is supposed to be local, then don't actually register
3275 for (t
= sinfo
->verdefs
; t
!= NULL
; t
= t
->next
)
3277 if (t
->globals
!= NULL
)
3279 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
3281 if (fnmatch (d
->match
, h
->root
.root
.string
, 0) == 0)
3283 h
->verinfo
.vertree
= t
;
3292 if (t
->locals
!= NULL
)
3294 for (d
= t
->locals
; d
!= NULL
; d
= d
->next
)
3296 if (d
->match
[0] == '*' && d
->match
[1] == '\0')
3298 else if (fnmatch (d
->match
, h
->root
.root
.string
, 0) == 0)
3300 h
->verinfo
.vertree
= t
;
3301 if (h
->dynindx
!= -1
3303 && ! sinfo
->export_dynamic
)
3305 sinfo
->removed_dynamic
= true;
3306 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3307 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3309 h
->plt
.offset
= (bfd_vma
) -1;
3310 /* FIXME: The name of the symbol has already
3311 been recorded in the dynamic string table
3323 if (deflt
!= NULL
&& h
->verinfo
.vertree
== NULL
)
3325 h
->verinfo
.vertree
= deflt
;
3326 if (h
->dynindx
!= -1
3328 && ! sinfo
->export_dynamic
)
3330 sinfo
->removed_dynamic
= true;
3331 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
3332 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
3334 h
->plt
.offset
= (bfd_vma
) -1;
3335 /* FIXME: The name of the symbol has already been
3336 recorded in the dynamic string table section. */
3344 /* This function is used to renumber the dynamic symbols, if some of
3345 them are removed because they are marked as local. This is called
3346 via elf_link_hash_traverse. */
3349 elf_link_renumber_dynsyms (h
, data
)
3350 struct elf_link_hash_entry
*h
;
3353 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
3355 if (h
->dynindx
!= -1)
3357 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
3358 ++elf_hash_table (info
)->dynsymcount
;
3364 /* Final phase of ELF linker. */
3366 /* A structure we use to avoid passing large numbers of arguments. */
3368 struct elf_final_link_info
3370 /* General link information. */
3371 struct bfd_link_info
*info
;
3374 /* Symbol string table. */
3375 struct bfd_strtab_hash
*symstrtab
;
3376 /* .dynsym section. */
3377 asection
*dynsym_sec
;
3378 /* .hash section. */
3380 /* symbol version section (.gnu.version). */
3381 asection
*symver_sec
;
3382 /* Buffer large enough to hold contents of any section. */
3384 /* Buffer large enough to hold external relocs of any section. */
3385 PTR external_relocs
;
3386 /* Buffer large enough to hold internal relocs of any section. */
3387 Elf_Internal_Rela
*internal_relocs
;
3388 /* Buffer large enough to hold external local symbols of any input
3390 Elf_External_Sym
*external_syms
;
3391 /* Buffer large enough to hold internal local symbols of any input
3393 Elf_Internal_Sym
*internal_syms
;
3394 /* Array large enough to hold a symbol index for each local symbol
3395 of any input BFD. */
3397 /* Array large enough to hold a section pointer for each local
3398 symbol of any input BFD. */
3399 asection
**sections
;
3400 /* Buffer to hold swapped out symbols. */
3401 Elf_External_Sym
*symbuf
;
3402 /* Number of swapped out symbols in buffer. */
3403 size_t symbuf_count
;
3404 /* Number of symbols which fit in symbuf. */
3408 static boolean elf_link_output_sym
3409 PARAMS ((struct elf_final_link_info
*, const char *,
3410 Elf_Internal_Sym
*, asection
*));
3411 static boolean elf_link_flush_output_syms
3412 PARAMS ((struct elf_final_link_info
*));
3413 static boolean elf_link_output_extsym
3414 PARAMS ((struct elf_link_hash_entry
*, PTR
));
3415 static boolean elf_link_input_bfd
3416 PARAMS ((struct elf_final_link_info
*, bfd
*));
3417 static boolean elf_reloc_link_order
3418 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
3419 struct bfd_link_order
*));
3421 /* This struct is used to pass information to elf_link_output_extsym. */
3423 struct elf_outext_info
3427 struct elf_final_link_info
*finfo
;
3430 /* Do the final step of an ELF link. */
3433 elf_bfd_final_link (abfd
, info
)
3435 struct bfd_link_info
*info
;
3439 struct elf_final_link_info finfo
;
3440 register asection
*o
;
3441 register struct bfd_link_order
*p
;
3443 size_t max_contents_size
;
3444 size_t max_external_reloc_size
;
3445 size_t max_internal_reloc_count
;
3446 size_t max_sym_count
;
3448 Elf_Internal_Sym elfsym
;
3450 Elf_Internal_Shdr
*symtab_hdr
;
3451 Elf_Internal_Shdr
*symstrtab_hdr
;
3452 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3453 struct elf_outext_info eoinfo
;
3456 abfd
->flags
|= DYNAMIC
;
3458 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
3459 dynobj
= elf_hash_table (info
)->dynobj
;
3462 finfo
.output_bfd
= abfd
;
3463 finfo
.symstrtab
= elf_stringtab_init ();
3464 if (finfo
.symstrtab
== NULL
)
3469 finfo
.dynsym_sec
= NULL
;
3470 finfo
.hash_sec
= NULL
;
3471 finfo
.symver_sec
= NULL
;
3475 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
3476 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
3477 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
3478 finfo
.symver_sec
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3479 /* Note that it is OK if symver_sec is NULL. */
3482 finfo
.contents
= NULL
;
3483 finfo
.external_relocs
= NULL
;
3484 finfo
.internal_relocs
= NULL
;
3485 finfo
.external_syms
= NULL
;
3486 finfo
.internal_syms
= NULL
;
3487 finfo
.indices
= NULL
;
3488 finfo
.sections
= NULL
;
3489 finfo
.symbuf
= NULL
;
3490 finfo
.symbuf_count
= 0;
3492 /* Count up the number of relocations we will output for each output
3493 section, so that we know the sizes of the reloc sections. We
3494 also figure out some maximum sizes. */
3495 max_contents_size
= 0;
3496 max_external_reloc_size
= 0;
3497 max_internal_reloc_count
= 0;
3499 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3503 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3505 if (p
->type
== bfd_section_reloc_link_order
3506 || p
->type
== bfd_symbol_reloc_link_order
)
3508 else if (p
->type
== bfd_indirect_link_order
)
3512 sec
= p
->u
.indirect
.section
;
3514 /* Mark all sections which are to be included in the
3515 link. This will normally be every section. We need
3516 to do this so that we can identify any sections which
3517 the linker has decided to not include. */
3518 sec
->linker_mark
= true;
3520 if (info
->relocateable
)
3521 o
->reloc_count
+= sec
->reloc_count
;
3523 if (sec
->_raw_size
> max_contents_size
)
3524 max_contents_size
= sec
->_raw_size
;
3525 if (sec
->_cooked_size
> max_contents_size
)
3526 max_contents_size
= sec
->_cooked_size
;
3528 /* We are interested in just local symbols, not all
3530 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
3531 && (sec
->owner
->flags
& DYNAMIC
) == 0)
3535 if (elf_bad_symtab (sec
->owner
))
3536 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
3537 / sizeof (Elf_External_Sym
));
3539 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
3541 if (sym_count
> max_sym_count
)
3542 max_sym_count
= sym_count
;
3544 if ((sec
->flags
& SEC_RELOC
) != 0)
3548 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
3549 if (ext_size
> max_external_reloc_size
)
3550 max_external_reloc_size
= ext_size
;
3551 if (sec
->reloc_count
> max_internal_reloc_count
)
3552 max_internal_reloc_count
= sec
->reloc_count
;
3558 if (o
->reloc_count
> 0)
3559 o
->flags
|= SEC_RELOC
;
3562 /* Explicitly clear the SEC_RELOC flag. The linker tends to
3563 set it (this is probably a bug) and if it is set
3564 assign_section_numbers will create a reloc section. */
3565 o
->flags
&=~ SEC_RELOC
;
3568 /* If the SEC_ALLOC flag is not set, force the section VMA to
3569 zero. This is done in elf_fake_sections as well, but forcing
3570 the VMA to 0 here will ensure that relocs against these
3571 sections are handled correctly. */
3572 if ((o
->flags
& SEC_ALLOC
) == 0
3573 && ! o
->user_set_vma
)
3577 /* Figure out the file positions for everything but the symbol table
3578 and the relocs. We set symcount to force assign_section_numbers
3579 to create a symbol table. */
3580 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
3581 BFD_ASSERT (! abfd
->output_has_begun
);
3582 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
3585 /* That created the reloc sections. Set their sizes, and assign
3586 them file positions, and allocate some buffers. */
3587 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3589 if ((o
->flags
& SEC_RELOC
) != 0)
3591 Elf_Internal_Shdr
*rel_hdr
;
3592 register struct elf_link_hash_entry
**p
, **pend
;
3594 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
3596 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
3598 /* The contents field must last into write_object_contents,
3599 so we allocate it with bfd_alloc rather than malloc. */
3600 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
3601 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
3604 p
= ((struct elf_link_hash_entry
**)
3605 bfd_malloc (o
->reloc_count
3606 * sizeof (struct elf_link_hash_entry
*)));
3607 if (p
== NULL
&& o
->reloc_count
!= 0)
3609 elf_section_data (o
)->rel_hashes
= p
;
3610 pend
= p
+ o
->reloc_count
;
3611 for (; p
< pend
; p
++)
3614 /* Use the reloc_count field as an index when outputting the
3620 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3622 /* We have now assigned file positions for all the sections except
3623 .symtab and .strtab. We start the .symtab section at the current
3624 file position, and write directly to it. We build the .strtab
3625 section in memory. */
3627 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3628 /* sh_name is set in prep_headers. */
3629 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3630 symtab_hdr
->sh_flags
= 0;
3631 symtab_hdr
->sh_addr
= 0;
3632 symtab_hdr
->sh_size
= 0;
3633 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
3634 /* sh_link is set in assign_section_numbers. */
3635 /* sh_info is set below. */
3636 /* sh_offset is set just below. */
3637 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
3639 off
= elf_tdata (abfd
)->next_file_pos
;
3640 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
3642 /* Note that at this point elf_tdata (abfd)->next_file_pos is
3643 incorrect. We do not yet know the size of the .symtab section.
3644 We correct next_file_pos below, after we do know the size. */
3646 /* Allocate a buffer to hold swapped out symbols. This is to avoid
3647 continuously seeking to the right position in the file. */
3648 if (! info
->keep_memory
|| max_sym_count
< 20)
3649 finfo
.symbuf_size
= 20;
3651 finfo
.symbuf_size
= max_sym_count
;
3652 finfo
.symbuf
= ((Elf_External_Sym
*)
3653 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
3654 if (finfo
.symbuf
== NULL
)
3657 /* Start writing out the symbol table. The first symbol is always a
3659 if (info
->strip
!= strip_all
|| info
->relocateable
)
3661 elfsym
.st_value
= 0;
3664 elfsym
.st_other
= 0;
3665 elfsym
.st_shndx
= SHN_UNDEF
;
3666 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
3667 &elfsym
, bfd_und_section_ptr
))
3672 /* Some standard ELF linkers do this, but we don't because it causes
3673 bootstrap comparison failures. */
3674 /* Output a file symbol for the output file as the second symbol.
3675 We output this even if we are discarding local symbols, although
3676 I'm not sure if this is correct. */
3677 elfsym
.st_value
= 0;
3679 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3680 elfsym
.st_other
= 0;
3681 elfsym
.st_shndx
= SHN_ABS
;
3682 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
3683 &elfsym
, bfd_abs_section_ptr
))
3687 /* Output a symbol for each section. We output these even if we are
3688 discarding local symbols, since they are used for relocs. These
3689 symbols have no names. We store the index of each one in the
3690 index field of the section, so that we can find it again when
3691 outputting relocs. */
3692 if (info
->strip
!= strip_all
|| info
->relocateable
)
3695 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3696 elfsym
.st_other
= 0;
3697 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
3699 o
= section_from_elf_index (abfd
, i
);
3701 o
->target_index
= abfd
->symcount
;
3702 elfsym
.st_shndx
= i
;
3703 if (info
->relocateable
|| o
== NULL
)
3704 elfsym
.st_value
= 0;
3706 elfsym
.st_value
= o
->vma
;
3707 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
3713 /* Allocate some memory to hold information read in from the input
3715 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
3716 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
3717 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
3718 bfd_malloc (max_internal_reloc_count
3719 * sizeof (Elf_Internal_Rela
)));
3720 finfo
.external_syms
= ((Elf_External_Sym
*)
3721 bfd_malloc (max_sym_count
3722 * sizeof (Elf_External_Sym
)));
3723 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
3724 bfd_malloc (max_sym_count
3725 * sizeof (Elf_Internal_Sym
)));
3726 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
3727 finfo
.sections
= ((asection
**)
3728 bfd_malloc (max_sym_count
* sizeof (asection
*)));
3729 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
3730 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
3731 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
3732 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
3733 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
3734 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
3735 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
3738 /* Since ELF permits relocations to be against local symbols, we
3739 must have the local symbols available when we do the relocations.
3740 Since we would rather only read the local symbols once, and we
3741 would rather not keep them in memory, we handle all the
3742 relocations for a single input file at the same time.
3744 Unfortunately, there is no way to know the total number of local
3745 symbols until we have seen all of them, and the local symbol
3746 indices precede the global symbol indices. This means that when
3747 we are generating relocateable output, and we see a reloc against
3748 a global symbol, we can not know the symbol index until we have
3749 finished examining all the local symbols to see which ones we are
3750 going to output. To deal with this, we keep the relocations in
3751 memory, and don't output them until the end of the link. This is
3752 an unfortunate waste of memory, but I don't see a good way around
3753 it. Fortunately, it only happens when performing a relocateable
3754 link, which is not the common case. FIXME: If keep_memory is set
3755 we could write the relocs out and then read them again; I don't
3756 know how bad the memory loss will be. */
3758 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3759 sub
->output_has_begun
= false;
3760 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3762 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3764 if (p
->type
== bfd_indirect_link_order
3765 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
3766 == bfd_target_elf_flavour
))
3768 sub
= p
->u
.indirect
.section
->owner
;
3769 if (! sub
->output_has_begun
)
3771 if (! elf_link_input_bfd (&finfo
, sub
))
3773 sub
->output_has_begun
= true;
3776 else if (p
->type
== bfd_section_reloc_link_order
3777 || p
->type
== bfd_symbol_reloc_link_order
)
3779 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
3784 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3790 /* That wrote out all the local symbols. Finish up the symbol table
3791 with the global symbols. */
3793 if (info
->strip
!= strip_all
&& info
->shared
)
3795 /* Output any global symbols that got converted to local in a
3796 version script. We do this in a separate step since ELF
3797 requires all local symbols to appear prior to any global
3798 symbols. FIXME: We should only do this if some global
3799 symbols were, in fact, converted to become local. FIXME:
3800 Will this work correctly with the Irix 5 linker? */
3801 eoinfo
.failed
= false;
3802 eoinfo
.finfo
= &finfo
;
3803 eoinfo
.localsyms
= true;
3804 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
3810 /* The sh_info field records the index of the first non local
3812 symtab_hdr
->sh_info
= abfd
->symcount
;
3814 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
3816 /* We get the global symbols from the hash table. */
3817 eoinfo
.failed
= false;
3818 eoinfo
.localsyms
= false;
3819 eoinfo
.finfo
= &finfo
;
3820 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
3825 /* Flush all symbols to the file. */
3826 if (! elf_link_flush_output_syms (&finfo
))
3829 /* Now we know the size of the symtab section. */
3830 off
+= symtab_hdr
->sh_size
;
3832 /* Finish up and write out the symbol string table (.strtab)
3834 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3835 /* sh_name was set in prep_headers. */
3836 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3837 symstrtab_hdr
->sh_flags
= 0;
3838 symstrtab_hdr
->sh_addr
= 0;
3839 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
3840 symstrtab_hdr
->sh_entsize
= 0;
3841 symstrtab_hdr
->sh_link
= 0;
3842 symstrtab_hdr
->sh_info
= 0;
3843 /* sh_offset is set just below. */
3844 symstrtab_hdr
->sh_addralign
= 1;
3846 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
3847 elf_tdata (abfd
)->next_file_pos
= off
;
3849 if (abfd
->symcount
> 0)
3851 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
3852 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
3856 /* Adjust the relocs to have the correct symbol indices. */
3857 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3859 struct elf_link_hash_entry
**rel_hash
;
3860 Elf_Internal_Shdr
*rel_hdr
;
3862 if ((o
->flags
& SEC_RELOC
) == 0)
3865 rel_hash
= elf_section_data (o
)->rel_hashes
;
3866 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
3867 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
3869 if (*rel_hash
== NULL
)
3872 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
3874 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
3876 Elf_External_Rel
*erel
;
3877 Elf_Internal_Rel irel
;
3879 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
3880 elf_swap_reloc_in (abfd
, erel
, &irel
);
3881 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
3882 ELF_R_TYPE (irel
.r_info
));
3883 elf_swap_reloc_out (abfd
, &irel
, erel
);
3887 Elf_External_Rela
*erela
;
3888 Elf_Internal_Rela irela
;
3890 BFD_ASSERT (rel_hdr
->sh_entsize
3891 == sizeof (Elf_External_Rela
));
3893 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
3894 elf_swap_reloca_in (abfd
, erela
, &irela
);
3895 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
3896 ELF_R_TYPE (irela
.r_info
));
3897 elf_swap_reloca_out (abfd
, &irela
, erela
);
3901 /* Set the reloc_count field to 0 to prevent write_relocs from
3902 trying to swap the relocs out itself. */
3906 /* If we are linking against a dynamic object, or generating a
3907 shared library, finish up the dynamic linking information. */
3910 Elf_External_Dyn
*dyncon
, *dynconend
;
3912 /* Fix up .dynamic entries. */
3913 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
3914 BFD_ASSERT (o
!= NULL
);
3916 dyncon
= (Elf_External_Dyn
*) o
->contents
;
3917 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
3918 for (; dyncon
< dynconend
; dyncon
++)
3920 Elf_Internal_Dyn dyn
;
3924 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3931 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
3932 magic _init and _fini symbols. This is pretty ugly,
3933 but we are compatible. */
3941 struct elf_link_hash_entry
*h
;
3943 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3944 false, false, true);
3946 && (h
->root
.type
== bfd_link_hash_defined
3947 || h
->root
.type
== bfd_link_hash_defweak
))
3949 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
3950 o
= h
->root
.u
.def
.section
;
3951 if (o
->output_section
!= NULL
)
3952 dyn
.d_un
.d_val
+= (o
->output_section
->vma
3953 + o
->output_offset
);
3956 /* The symbol is imported from another shared
3957 library and does not apply to this one. */
3961 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
3976 name
= ".gnu.version_d";
3979 name
= ".gnu.version_r";
3982 name
= ".gnu.version";
3984 o
= bfd_get_section_by_name (abfd
, name
);
3985 BFD_ASSERT (o
!= NULL
);
3986 dyn
.d_un
.d_ptr
= o
->vma
;
3987 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
3994 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
3999 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
4001 Elf_Internal_Shdr
*hdr
;
4003 hdr
= elf_elfsections (abfd
)[i
];
4004 if (hdr
->sh_type
== type
4005 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
4007 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
4008 dyn
.d_un
.d_val
+= hdr
->sh_size
;
4011 if (dyn
.d_un
.d_val
== 0
4012 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
4013 dyn
.d_un
.d_val
= hdr
->sh_addr
;
4017 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
4023 /* If we have created any dynamic sections, then output them. */
4026 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
4029 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
4031 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4032 || o
->_raw_size
== 0)
4034 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
4036 /* At this point, we are only interested in sections
4037 created by elf_link_create_dynamic_sections. */
4040 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
4042 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
4044 if (! bfd_set_section_contents (abfd
, o
->output_section
,
4045 o
->contents
, o
->output_offset
,
4053 /* The contents of the .dynstr section are actually in a
4055 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
4056 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4057 || ! _bfd_stringtab_emit (abfd
,
4058 elf_hash_table (info
)->dynstr
))
4064 /* If we have optimized stabs strings, output them. */
4065 if (elf_hash_table (info
)->stab_info
!= NULL
)
4067 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
4071 if (finfo
.symstrtab
!= NULL
)
4072 _bfd_stringtab_free (finfo
.symstrtab
);
4073 if (finfo
.contents
!= NULL
)
4074 free (finfo
.contents
);
4075 if (finfo
.external_relocs
!= NULL
)
4076 free (finfo
.external_relocs
);
4077 if (finfo
.internal_relocs
!= NULL
)
4078 free (finfo
.internal_relocs
);
4079 if (finfo
.external_syms
!= NULL
)
4080 free (finfo
.external_syms
);
4081 if (finfo
.internal_syms
!= NULL
)
4082 free (finfo
.internal_syms
);
4083 if (finfo
.indices
!= NULL
)
4084 free (finfo
.indices
);
4085 if (finfo
.sections
!= NULL
)
4086 free (finfo
.sections
);
4087 if (finfo
.symbuf
!= NULL
)
4088 free (finfo
.symbuf
);
4089 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4091 if ((o
->flags
& SEC_RELOC
) != 0
4092 && elf_section_data (o
)->rel_hashes
!= NULL
)
4093 free (elf_section_data (o
)->rel_hashes
);
4096 elf_tdata (abfd
)->linker
= true;
4101 if (finfo
.symstrtab
!= NULL
)
4102 _bfd_stringtab_free (finfo
.symstrtab
);
4103 if (finfo
.contents
!= NULL
)
4104 free (finfo
.contents
);
4105 if (finfo
.external_relocs
!= NULL
)
4106 free (finfo
.external_relocs
);
4107 if (finfo
.internal_relocs
!= NULL
)
4108 free (finfo
.internal_relocs
);
4109 if (finfo
.external_syms
!= NULL
)
4110 free (finfo
.external_syms
);
4111 if (finfo
.internal_syms
!= NULL
)
4112 free (finfo
.internal_syms
);
4113 if (finfo
.indices
!= NULL
)
4114 free (finfo
.indices
);
4115 if (finfo
.sections
!= NULL
)
4116 free (finfo
.sections
);
4117 if (finfo
.symbuf
!= NULL
)
4118 free (finfo
.symbuf
);
4119 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4121 if ((o
->flags
& SEC_RELOC
) != 0
4122 && elf_section_data (o
)->rel_hashes
!= NULL
)
4123 free (elf_section_data (o
)->rel_hashes
);
4129 /* Add a symbol to the output symbol table. */
4132 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
4133 struct elf_final_link_info
*finfo
;
4135 Elf_Internal_Sym
*elfsym
;
4136 asection
*input_sec
;
4138 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
4139 struct bfd_link_info
*info
,
4144 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
4145 elf_backend_link_output_symbol_hook
;
4146 if (output_symbol_hook
!= NULL
)
4148 if (! ((*output_symbol_hook
)
4149 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
4153 if (name
== (const char *) NULL
|| *name
== '\0')
4154 elfsym
->st_name
= 0;
4157 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
4160 if (elfsym
->st_name
== (unsigned long) -1)
4164 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
4166 if (! elf_link_flush_output_syms (finfo
))
4170 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
4171 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
4172 ++finfo
->symbuf_count
;
4174 ++finfo
->output_bfd
->symcount
;
4179 /* Flush the output symbols to the file. */
4182 elf_link_flush_output_syms (finfo
)
4183 struct elf_final_link_info
*finfo
;
4185 if (finfo
->symbuf_count
> 0)
4187 Elf_Internal_Shdr
*symtab
;
4189 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
4191 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
4193 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
4194 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
4195 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
4198 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
4200 finfo
->symbuf_count
= 0;
4206 /* Add an external symbol to the symbol table. This is called from
4207 the hash table traversal routine. When generating a shared object,
4208 we go through the symbol table twice. The first time we output
4209 anything that might have been forced to local scope in a version
4210 script. The second time we output the symbols that are still
4214 elf_link_output_extsym (h
, data
)
4215 struct elf_link_hash_entry
*h
;
4218 struct elf_outext_info
*eoinfo
= (struct elf_outext_info
*) data
;
4219 struct elf_final_link_info
*finfo
= eoinfo
->finfo
;
4221 Elf_Internal_Sym sym
;
4222 asection
*input_sec
;
4224 /* Decide whether to output this symbol in this pass. */
4225 if (eoinfo
->localsyms
)
4227 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
4232 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4236 /* If we are not creating a shared library, and this symbol is
4237 referenced by a shared library but is not defined anywhere, then
4238 warn that it is undefined. If we do not do this, the runtime
4239 linker will complain that the symbol is undefined when the
4240 program is run. We don't have to worry about symbols that are
4241 referenced by regular files, because we will already have issued
4242 warnings for them. */
4243 if (! finfo
->info
->relocateable
4244 && ! finfo
->info
->shared
4245 && h
->root
.type
== bfd_link_hash_undefined
4246 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
4247 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4249 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4250 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
4251 (asection
*) NULL
, 0)))
4253 eoinfo
->failed
= true;
4258 /* We don't want to output symbols that have never been mentioned by
4259 a regular file, or that we have been told to strip. However, if
4260 h->indx is set to -2, the symbol is used by a reloc and we must
4264 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4265 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
4266 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
4267 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4269 else if (finfo
->info
->strip
== strip_all
4270 || (finfo
->info
->strip
== strip_some
4271 && bfd_hash_lookup (finfo
->info
->keep_hash
,
4272 h
->root
.root
.string
,
4273 false, false) == NULL
))
4278 /* If we're stripping it, and it's not a dynamic symbol, there's
4279 nothing else to do. */
4280 if (strip
&& h
->dynindx
== -1)
4284 sym
.st_size
= h
->size
;
4285 sym
.st_other
= h
->other
;
4286 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4287 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
4288 else if (h
->root
.type
== bfd_link_hash_undefweak
4289 || h
->root
.type
== bfd_link_hash_defweak
)
4290 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4292 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
4294 switch (h
->root
.type
)
4297 case bfd_link_hash_new
:
4301 case bfd_link_hash_undefined
:
4302 input_sec
= bfd_und_section_ptr
;
4303 sym
.st_shndx
= SHN_UNDEF
;
4306 case bfd_link_hash_undefweak
:
4307 input_sec
= bfd_und_section_ptr
;
4308 sym
.st_shndx
= SHN_UNDEF
;
4311 case bfd_link_hash_defined
:
4312 case bfd_link_hash_defweak
:
4314 input_sec
= h
->root
.u
.def
.section
;
4315 if (input_sec
->output_section
!= NULL
)
4318 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
4319 input_sec
->output_section
);
4320 if (sym
.st_shndx
== (unsigned short) -1)
4322 (*_bfd_error_handler
)
4323 (_("%s: could not find output section %s for input section %s"),
4324 bfd_get_filename (finfo
->output_bfd
),
4325 input_sec
->output_section
->name
,
4327 eoinfo
->failed
= true;
4331 /* ELF symbols in relocateable files are section relative,
4332 but in nonrelocateable files they are virtual
4334 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
4335 if (! finfo
->info
->relocateable
)
4336 sym
.st_value
+= input_sec
->output_section
->vma
;
4340 BFD_ASSERT (input_sec
->owner
== NULL
4341 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
4342 sym
.st_shndx
= SHN_UNDEF
;
4343 input_sec
= bfd_und_section_ptr
;
4348 case bfd_link_hash_common
:
4349 input_sec
= h
->root
.u
.c
.p
->section
;
4350 sym
.st_shndx
= SHN_COMMON
;
4351 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
4354 case bfd_link_hash_indirect
:
4355 /* These symbols are created by symbol versioning. They point
4356 to the decorated version of the name. For example, if the
4357 symbol foo@@GNU_1.2 is the default, which should be used when
4358 foo is used with no version, then we add an indirect symbol
4359 foo which points to foo@@GNU_1.2. We ignore these symbols,
4360 since the indirected symbol is already in the hash table. If
4361 the indirect symbol is non-ELF, fall through and output it. */
4362 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) == 0)
4366 case bfd_link_hash_warning
:
4367 /* We can't represent these symbols in ELF, although a warning
4368 symbol may have come from a .gnu.warning.SYMBOL section. We
4369 just put the target symbol in the hash table. If the target
4370 symbol does not really exist, don't do anything. */
4371 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
4373 return (elf_link_output_extsym
4374 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
4377 /* Give the processor backend a chance to tweak the symbol value,
4378 and also to finish up anything that needs to be done for this
4380 if ((h
->dynindx
!= -1
4381 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4382 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4384 struct elf_backend_data
*bed
;
4386 bed
= get_elf_backend_data (finfo
->output_bfd
);
4387 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
4388 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
4390 eoinfo
->failed
= true;
4395 /* If this symbol should be put in the .dynsym section, then put it
4396 there now. We have already know the symbol index. We also fill
4397 in the entry in the .hash section. */
4398 if (h
->dynindx
!= -1
4399 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4405 bfd_byte
*bucketpos
;
4408 sym
.st_name
= h
->dynstr_index
;
4410 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
4411 (PTR
) (((Elf_External_Sym
*)
4412 finfo
->dynsym_sec
->contents
)
4415 /* We didn't include the version string in the dynamic string
4416 table, so we must not consider it in the hash table. */
4417 name
= h
->root
.root
.string
;
4418 p
= strchr (name
, ELF_VER_CHR
);
4423 copy
= bfd_alloc (finfo
->output_bfd
, p
- name
+ 1);
4424 strncpy (copy
, name
, p
- name
);
4425 copy
[p
- name
] = '\0';
4429 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
4430 bucket
= bfd_elf_hash ((const unsigned char *) name
) % bucketcount
;
4431 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
4432 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
4433 chain
= get_word (finfo
->output_bfd
, bucketpos
);
4434 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
4435 put_word (finfo
->output_bfd
, chain
,
4436 ((bfd_byte
*) finfo
->hash_sec
->contents
4437 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
4440 bfd_release (finfo
->output_bfd
, copy
);
4442 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
4444 Elf_Internal_Versym iversym
;
4446 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4448 if (h
->verinfo
.verdef
== NULL
)
4449 iversym
.vs_vers
= 0;
4451 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
4455 if (h
->verinfo
.vertree
== NULL
)
4456 iversym
.vs_vers
= 1;
4458 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
4461 if ((h
->elf_link_hash_flags
& ELF_LINK_HIDDEN
) != 0)
4462 iversym
.vs_vers
|= VERSYM_HIDDEN
;
4464 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
,
4465 (((Elf_External_Versym
*)
4466 finfo
->symver_sec
->contents
)
4471 /* If we're stripping it, then it was just a dynamic symbol, and
4472 there's nothing else to do. */
4476 h
->indx
= finfo
->output_bfd
->symcount
;
4478 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
4480 eoinfo
->failed
= true;
4487 /* Link an input file into the linker output file. This function
4488 handles all the sections and relocations of the input file at once.
4489 This is so that we only have to read the local symbols once, and
4490 don't have to keep them in memory. */
4493 elf_link_input_bfd (finfo
, input_bfd
)
4494 struct elf_final_link_info
*finfo
;
4497 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
4498 bfd
*, asection
*, bfd_byte
*,
4499 Elf_Internal_Rela
*,
4500 Elf_Internal_Sym
*, asection
**));
4502 Elf_Internal_Shdr
*symtab_hdr
;
4505 Elf_External_Sym
*external_syms
;
4506 Elf_External_Sym
*esym
;
4507 Elf_External_Sym
*esymend
;
4508 Elf_Internal_Sym
*isym
;
4510 asection
**ppsection
;
4513 output_bfd
= finfo
->output_bfd
;
4515 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
4517 /* If this is a dynamic object, we don't want to do anything here:
4518 we don't want the local symbols, and we don't want the section
4520 if ((input_bfd
->flags
& DYNAMIC
) != 0)
4523 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4524 if (elf_bad_symtab (input_bfd
))
4526 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4531 locsymcount
= symtab_hdr
->sh_info
;
4532 extsymoff
= symtab_hdr
->sh_info
;
4535 /* Read the local symbols. */
4536 if (symtab_hdr
->contents
!= NULL
)
4537 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
4538 else if (locsymcount
== 0)
4539 external_syms
= NULL
;
4542 external_syms
= finfo
->external_syms
;
4543 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
4544 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
4545 locsymcount
, input_bfd
)
4546 != locsymcount
* sizeof (Elf_External_Sym
)))
4550 /* Swap in the local symbols and write out the ones which we know
4551 are going into the output file. */
4552 esym
= external_syms
;
4553 esymend
= esym
+ locsymcount
;
4554 isym
= finfo
->internal_syms
;
4555 pindex
= finfo
->indices
;
4556 ppsection
= finfo
->sections
;
4557 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
4561 Elf_Internal_Sym osym
;
4563 elf_swap_symbol_in (input_bfd
, esym
, isym
);
4566 if (elf_bad_symtab (input_bfd
))
4568 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
4575 if (isym
->st_shndx
== SHN_UNDEF
)
4576 isec
= bfd_und_section_ptr
;
4577 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
4578 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
4579 else if (isym
->st_shndx
== SHN_ABS
)
4580 isec
= bfd_abs_section_ptr
;
4581 else if (isym
->st_shndx
== SHN_COMMON
)
4582 isec
= bfd_com_section_ptr
;
4591 /* Don't output the first, undefined, symbol. */
4592 if (esym
== external_syms
)
4595 /* If we are stripping all symbols, we don't want to output this
4597 if (finfo
->info
->strip
== strip_all
)
4600 /* We never output section symbols. Instead, we use the section
4601 symbol of the corresponding section in the output file. */
4602 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
4605 /* If we are discarding all local symbols, we don't want to
4606 output this one. If we are generating a relocateable output
4607 file, then some of the local symbols may be required by
4608 relocs; we output them below as we discover that they are
4610 if (finfo
->info
->discard
== discard_all
)
4613 /* If this symbol is defined in a section which we are
4614 discarding, we don't need to keep it, but note that
4615 linker_mark is only reliable for sections that have contents.
4616 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
4617 as well as linker_mark. */
4618 if (isym
->st_shndx
> 0
4619 && isym
->st_shndx
< SHN_LORESERVE
4621 && ((! isec
->linker_mark
&& (isec
->flags
& SEC_HAS_CONTENTS
) != 0)
4622 || (! finfo
->info
->relocateable
4623 && (isec
->flags
& SEC_EXCLUDE
) != 0)))
4626 /* Get the name of the symbol. */
4627 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
4632 /* See if we are discarding symbols with this name. */
4633 if ((finfo
->info
->strip
== strip_some
4634 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
4636 || (finfo
->info
->discard
== discard_l
4637 && bfd_is_local_label_name (input_bfd
, name
)))
4640 /* If we get here, we are going to output this symbol. */
4644 /* Adjust the section index for the output file. */
4645 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
4646 isec
->output_section
);
4647 if (osym
.st_shndx
== (unsigned short) -1)
4650 *pindex
= output_bfd
->symcount
;
4652 /* ELF symbols in relocateable files are section relative, but
4653 in executable files they are virtual addresses. Note that
4654 this code assumes that all ELF sections have an associated
4655 BFD section with a reasonable value for output_offset; below
4656 we assume that they also have a reasonable value for
4657 output_section. Any special sections must be set up to meet
4658 these requirements. */
4659 osym
.st_value
+= isec
->output_offset
;
4660 if (! finfo
->info
->relocateable
)
4661 osym
.st_value
+= isec
->output_section
->vma
;
4663 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
4667 /* Relocate the contents of each section. */
4668 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4672 if (! o
->linker_mark
)
4674 /* This section was omitted from the link. */
4678 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4679 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
4682 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
4684 /* Section was created by elf_link_create_dynamic_sections
4689 /* Get the contents of the section. They have been cached by a
4690 relaxation routine. Note that o is a section in an input
4691 file, so the contents field will not have been set by any of
4692 the routines which work on output files. */
4693 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
4694 contents
= elf_section_data (o
)->this_hdr
.contents
;
4697 contents
= finfo
->contents
;
4698 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
4699 (file_ptr
) 0, o
->_raw_size
))
4703 if ((o
->flags
& SEC_RELOC
) != 0)
4705 Elf_Internal_Rela
*internal_relocs
;
4707 /* Get the swapped relocs. */
4708 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
4709 (input_bfd
, o
, finfo
->external_relocs
,
4710 finfo
->internal_relocs
, false));
4711 if (internal_relocs
== NULL
4712 && o
->reloc_count
> 0)
4715 /* Relocate the section by invoking a back end routine.
4717 The back end routine is responsible for adjusting the
4718 section contents as necessary, and (if using Rela relocs
4719 and generating a relocateable output file) adjusting the
4720 reloc addend as necessary.
4722 The back end routine does not have to worry about setting
4723 the reloc address or the reloc symbol index.
4725 The back end routine is given a pointer to the swapped in
4726 internal symbols, and can access the hash table entries
4727 for the external symbols via elf_sym_hashes (input_bfd).
4729 When generating relocateable output, the back end routine
4730 must handle STB_LOCAL/STT_SECTION symbols specially. The
4731 output symbol is going to be a section symbol
4732 corresponding to the output section, which will require
4733 the addend to be adjusted. */
4735 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
4736 input_bfd
, o
, contents
,
4738 finfo
->internal_syms
,
4742 if (finfo
->info
->relocateable
)
4744 Elf_Internal_Rela
*irela
;
4745 Elf_Internal_Rela
*irelaend
;
4746 struct elf_link_hash_entry
**rel_hash
;
4747 Elf_Internal_Shdr
*input_rel_hdr
;
4748 Elf_Internal_Shdr
*output_rel_hdr
;
4750 /* Adjust the reloc addresses and symbol indices. */
4752 irela
= internal_relocs
;
4753 irelaend
= irela
+ o
->reloc_count
;
4754 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
4755 + o
->output_section
->reloc_count
);
4756 for (; irela
< irelaend
; irela
++, rel_hash
++)
4758 unsigned long r_symndx
;
4759 Elf_Internal_Sym
*isym
;
4762 irela
->r_offset
+= o
->output_offset
;
4764 r_symndx
= ELF_R_SYM (irela
->r_info
);
4769 if (r_symndx
>= locsymcount
4770 || (elf_bad_symtab (input_bfd
)
4771 && finfo
->sections
[r_symndx
] == NULL
))
4773 struct elf_link_hash_entry
*rh
;
4776 /* This is a reloc against a global symbol. We
4777 have not yet output all the local symbols, so
4778 we do not know the symbol index of any global
4779 symbol. We set the rel_hash entry for this
4780 reloc to point to the global hash table entry
4781 for this symbol. The symbol index is then
4782 set at the end of elf_bfd_final_link. */
4783 indx
= r_symndx
- extsymoff
;
4784 rh
= elf_sym_hashes (input_bfd
)[indx
];
4785 while (rh
->root
.type
== bfd_link_hash_indirect
4786 || rh
->root
.type
== bfd_link_hash_warning
)
4787 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
4789 /* Setting the index to -2 tells
4790 elf_link_output_extsym that this symbol is
4792 BFD_ASSERT (rh
->indx
< 0);
4800 /* This is a reloc against a local symbol. */
4803 isym
= finfo
->internal_syms
+ r_symndx
;
4804 sec
= finfo
->sections
[r_symndx
];
4805 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
4807 /* I suppose the backend ought to fill in the
4808 section of any STT_SECTION symbol against a
4809 processor specific section. If we have
4810 discarded a section, the output_section will
4811 be the absolute section. */
4813 && (bfd_is_abs_section (sec
)
4814 || (sec
->output_section
!= NULL
4815 && bfd_is_abs_section (sec
->output_section
))))
4817 else if (sec
== NULL
|| sec
->owner
== NULL
)
4819 bfd_set_error (bfd_error_bad_value
);
4824 r_symndx
= sec
->output_section
->target_index
;
4825 BFD_ASSERT (r_symndx
!= 0);
4830 if (finfo
->indices
[r_symndx
] == -1)
4836 if (finfo
->info
->strip
== strip_all
)
4838 /* You can't do ld -r -s. */
4839 bfd_set_error (bfd_error_invalid_operation
);
4843 /* This symbol was skipped earlier, but
4844 since it is needed by a reloc, we
4845 must output it now. */
4846 link
= symtab_hdr
->sh_link
;
4847 name
= bfd_elf_string_from_elf_section (input_bfd
,
4853 osec
= sec
->output_section
;
4855 _bfd_elf_section_from_bfd_section (output_bfd
,
4857 if (isym
->st_shndx
== (unsigned short) -1)
4860 isym
->st_value
+= sec
->output_offset
;
4861 if (! finfo
->info
->relocateable
)
4862 isym
->st_value
+= osec
->vma
;
4864 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
4866 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
4870 r_symndx
= finfo
->indices
[r_symndx
];
4873 irela
->r_info
= ELF_R_INFO (r_symndx
,
4874 ELF_R_TYPE (irela
->r_info
));
4877 /* Swap out the relocs. */
4878 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
4879 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
4880 BFD_ASSERT (output_rel_hdr
->sh_entsize
4881 == input_rel_hdr
->sh_entsize
);
4882 irela
= internal_relocs
;
4883 irelaend
= irela
+ o
->reloc_count
;
4884 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
4886 Elf_External_Rel
*erel
;
4888 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
4889 + o
->output_section
->reloc_count
);
4890 for (; irela
< irelaend
; irela
++, erel
++)
4892 Elf_Internal_Rel irel
;
4894 irel
.r_offset
= irela
->r_offset
;
4895 irel
.r_info
= irela
->r_info
;
4896 BFD_ASSERT (irela
->r_addend
== 0);
4897 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
4902 Elf_External_Rela
*erela
;
4904 BFD_ASSERT (input_rel_hdr
->sh_entsize
4905 == sizeof (Elf_External_Rela
));
4906 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
4907 + o
->output_section
->reloc_count
);
4908 for (; irela
< irelaend
; irela
++, erela
++)
4909 elf_swap_reloca_out (output_bfd
, irela
, erela
);
4912 o
->output_section
->reloc_count
+= o
->reloc_count
;
4916 /* Write out the modified section contents. */
4917 if (elf_section_data (o
)->stab_info
== NULL
)
4919 if (! (o
->flags
& SEC_EXCLUDE
) &&
4920 ! bfd_set_section_contents (output_bfd
, o
->output_section
,
4921 contents
, o
->output_offset
,
4922 (o
->_cooked_size
!= 0
4929 if (! (_bfd_write_section_stabs
4930 (output_bfd
, &elf_hash_table (finfo
->info
)->stab_info
,
4931 o
, &elf_section_data (o
)->stab_info
, contents
)))
4939 /* Generate a reloc when linking an ELF file. This is a reloc
4940 requested by the linker, and does come from any input file. This
4941 is used to build constructor and destructor tables when linking
4945 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
4947 struct bfd_link_info
*info
;
4948 asection
*output_section
;
4949 struct bfd_link_order
*link_order
;
4951 reloc_howto_type
*howto
;
4955 struct elf_link_hash_entry
**rel_hash_ptr
;
4956 Elf_Internal_Shdr
*rel_hdr
;
4958 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
4961 bfd_set_error (bfd_error_bad_value
);
4965 addend
= link_order
->u
.reloc
.p
->addend
;
4967 /* Figure out the symbol index. */
4968 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
4969 + output_section
->reloc_count
);
4970 if (link_order
->type
== bfd_section_reloc_link_order
)
4972 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
4973 BFD_ASSERT (indx
!= 0);
4974 *rel_hash_ptr
= NULL
;
4978 struct elf_link_hash_entry
*h
;
4980 /* Treat a reloc against a defined symbol as though it were
4981 actually against the section. */
4982 h
= ((struct elf_link_hash_entry
*)
4983 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
4984 link_order
->u
.reloc
.p
->u
.name
,
4985 false, false, true));
4987 && (h
->root
.type
== bfd_link_hash_defined
4988 || h
->root
.type
== bfd_link_hash_defweak
))
4992 section
= h
->root
.u
.def
.section
;
4993 indx
= section
->output_section
->target_index
;
4994 *rel_hash_ptr
= NULL
;
4995 /* It seems that we ought to add the symbol value to the
4996 addend here, but in practice it has already been added
4997 because it was passed to constructor_callback. */
4998 addend
+= section
->output_section
->vma
+ section
->output_offset
;
5002 /* Setting the index to -2 tells elf_link_output_extsym that
5003 this symbol is used by a reloc. */
5010 if (! ((*info
->callbacks
->unattached_reloc
)
5011 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
5012 (asection
*) NULL
, (bfd_vma
) 0)))
5018 /* If this is an inplace reloc, we must write the addend into the
5020 if (howto
->partial_inplace
&& addend
!= 0)
5023 bfd_reloc_status_type rstat
;
5027 size
= bfd_get_reloc_size (howto
);
5028 buf
= (bfd_byte
*) bfd_zmalloc (size
);
5029 if (buf
== (bfd_byte
*) NULL
)
5031 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5037 case bfd_reloc_outofrange
:
5039 case bfd_reloc_overflow
:
5040 if (! ((*info
->callbacks
->reloc_overflow
)
5042 (link_order
->type
== bfd_section_reloc_link_order
5043 ? bfd_section_name (output_bfd
,
5044 link_order
->u
.reloc
.p
->u
.section
)
5045 : link_order
->u
.reloc
.p
->u
.name
),
5046 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
5054 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
5055 (file_ptr
) link_order
->offset
, size
);
5061 /* The address of a reloc is relative to the section in a
5062 relocateable file, and is a virtual address in an executable
5064 offset
= link_order
->offset
;
5065 if (! info
->relocateable
)
5066 offset
+= output_section
->vma
;
5068 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
5070 if (rel_hdr
->sh_type
== SHT_REL
)
5072 Elf_Internal_Rel irel
;
5073 Elf_External_Rel
*erel
;
5075 irel
.r_offset
= offset
;
5076 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5077 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
5078 + output_section
->reloc_count
);
5079 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
5083 Elf_Internal_Rela irela
;
5084 Elf_External_Rela
*erela
;
5086 irela
.r_offset
= offset
;
5087 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
5088 irela
.r_addend
= addend
;
5089 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
5090 + output_section
->reloc_count
);
5091 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
5094 ++output_section
->reloc_count
;
5100 /* Allocate a pointer to live in a linker created section. */
5103 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
5105 struct bfd_link_info
*info
;
5106 elf_linker_section_t
*lsect
;
5107 struct elf_link_hash_entry
*h
;
5108 const Elf_Internal_Rela
*rel
;
5110 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
5111 elf_linker_section_pointers_t
*linker_section_ptr
;
5112 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
5114 BFD_ASSERT (lsect
!= NULL
);
5116 /* Is this a global symbol? */
5119 /* Has this symbol already been allocated, if so, our work is done */
5120 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5125 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
5126 /* Make sure this symbol is output as a dynamic symbol. */
5127 if (h
->dynindx
== -1)
5129 if (! elf_link_record_dynamic_symbol (info
, h
))
5133 if (lsect
->rel_section
)
5134 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5137 else /* Allocation of a pointer to a local symbol */
5139 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
5141 /* Allocate a table to hold the local symbols if first time */
5144 unsigned int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
5145 register unsigned int i
;
5147 ptr
= (elf_linker_section_pointers_t
**)
5148 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
5153 elf_local_ptr_offsets (abfd
) = ptr
;
5154 for (i
= 0; i
< num_symbols
; i
++)
5155 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
5158 /* Has this symbol already been allocated, if so, our work is done */
5159 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
5164 ptr_linker_section_ptr
= &ptr
[r_symndx
];
5168 /* If we are generating a shared object, we need to
5169 output a R_<xxx>_RELATIVE reloc so that the
5170 dynamic linker can adjust this GOT entry. */
5171 BFD_ASSERT (lsect
->rel_section
!= NULL
);
5172 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
5176 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
5177 from internal memory. */
5178 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
5179 linker_section_ptr
= (elf_linker_section_pointers_t
*)
5180 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
5182 if (!linker_section_ptr
)
5185 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
5186 linker_section_ptr
->addend
= rel
->r_addend
;
5187 linker_section_ptr
->which
= lsect
->which
;
5188 linker_section_ptr
->written_address_p
= false;
5189 *ptr_linker_section_ptr
= linker_section_ptr
;
5192 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
5194 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
5195 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
5196 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
5197 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
5199 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
5201 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
5202 lsect
->sym_hash
->root
.root
.string
,
5203 (long)ARCH_SIZE
/ 8,
5204 (long)lsect
->sym_hash
->root
.u
.def
.value
);
5210 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
5212 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
5215 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
5216 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
5224 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
5227 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
5230 /* Fill in the address for a pointer generated in alinker section. */
5233 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
5236 struct bfd_link_info
*info
;
5237 elf_linker_section_t
*lsect
;
5238 struct elf_link_hash_entry
*h
;
5240 const Elf_Internal_Rela
*rel
;
5243 elf_linker_section_pointers_t
*linker_section_ptr
;
5245 BFD_ASSERT (lsect
!= NULL
);
5247 if (h
!= NULL
) /* global symbol */
5249 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
5253 BFD_ASSERT (linker_section_ptr
!= NULL
);
5255 if (! elf_hash_table (info
)->dynamic_sections_created
5258 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
5260 /* This is actually a static link, or it is a
5261 -Bsymbolic link and the symbol is defined
5262 locally. We must initialize this entry in the
5265 When doing a dynamic link, we create a .rela.<xxx>
5266 relocation entry to initialize the value. This
5267 is done in the finish_dynamic_symbol routine. */
5268 if (!linker_section_ptr
->written_address_p
)
5270 linker_section_ptr
->written_address_p
= true;
5271 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5272 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5276 else /* local symbol */
5278 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
5279 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
5280 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
5281 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
5285 BFD_ASSERT (linker_section_ptr
!= NULL
);
5287 /* Write out pointer if it hasn't been rewritten out before */
5288 if (!linker_section_ptr
->written_address_p
)
5290 linker_section_ptr
->written_address_p
= true;
5291 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
5292 lsect
->section
->contents
+ linker_section_ptr
->offset
);
5296 asection
*srel
= lsect
->rel_section
;
5297 Elf_Internal_Rela outrel
;
5299 /* We need to generate a relative reloc for the dynamic linker. */
5301 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
5304 BFD_ASSERT (srel
!= NULL
);
5306 outrel
.r_offset
= (lsect
->section
->output_section
->vma
5307 + lsect
->section
->output_offset
5308 + linker_section_ptr
->offset
);
5309 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
5310 outrel
.r_addend
= 0;
5311 elf_swap_reloca_out (output_bfd
, &outrel
,
5312 (((Elf_External_Rela
*)
5313 lsect
->section
->contents
)
5314 + lsect
->section
->reloc_count
));
5315 ++lsect
->section
->reloc_count
;
5320 relocation
= (lsect
->section
->output_offset
5321 + linker_section_ptr
->offset
5322 - lsect
->hole_offset
5323 - lsect
->sym_offset
);
5326 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
5327 lsect
->name
, (long)relocation
, (long)relocation
);
5330 /* Subtract out the addend, because it will get added back in by the normal
5332 return relocation
- linker_section_ptr
->addend
;
5335 /* Garbage collect unused sections. */
5337 static boolean elf_gc_mark
5338 PARAMS ((struct bfd_link_info
*info
, asection
*sec
,
5339 asection
* (*gc_mark_hook
)
5340 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5341 struct elf_link_hash_entry
*, Elf_Internal_Sym
*))));
5343 static boolean elf_gc_sweep
5344 PARAMS ((struct bfd_link_info
*info
,
5345 boolean (*gc_sweep_hook
)
5346 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5347 const Elf_Internal_Rela
*relocs
))));
5349 static boolean elf_gc_sweep_symbol
5350 PARAMS ((struct elf_link_hash_entry
*h
, PTR idxptr
));
5352 static boolean elf_gc_allocate_got_offsets
5353 PARAMS ((struct elf_link_hash_entry
*h
, PTR offarg
));
5355 static boolean elf_gc_propagate_vtable_entries_used
5356 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5358 static boolean elf_gc_smash_unused_vtentry_relocs
5359 PARAMS ((struct elf_link_hash_entry
*h
, PTR dummy
));
5361 /* The mark phase of garbage collection. For a given section, mark
5362 it, and all the sections which define symbols to which it refers. */
5365 elf_gc_mark (info
, sec
, gc_mark_hook
)
5366 struct bfd_link_info
*info
;
5368 asection
* (*gc_mark_hook
)
5369 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5370 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
5376 /* Look through the section relocs. */
5378 if ((sec
->flags
& SEC_RELOC
) != 0 && sec
->reloc_count
> 0)
5380 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
5381 Elf_Internal_Shdr
*symtab_hdr
;
5382 struct elf_link_hash_entry
**sym_hashes
;
5385 Elf_External_Sym
*locsyms
, *freesyms
= NULL
;
5386 bfd
*input_bfd
= sec
->owner
;
5388 /* GCFIXME: how to arrange so that relocs and symbols are not
5389 reread continually? */
5391 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5392 sym_hashes
= elf_sym_hashes (input_bfd
);
5394 /* Read the local symbols. */
5395 if (elf_bad_symtab (input_bfd
))
5397 nlocsyms
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5401 extsymoff
= nlocsyms
= symtab_hdr
->sh_info
;
5402 if (symtab_hdr
->contents
)
5403 locsyms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
5404 else if (nlocsyms
== 0)
5408 locsyms
= freesyms
=
5409 bfd_malloc (nlocsyms
* sizeof (Elf_External_Sym
));
5410 if (freesyms
== NULL
5411 || bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
5412 || (bfd_read (locsyms
, sizeof (Elf_External_Sym
),
5413 nlocsyms
, input_bfd
)
5414 != nlocsyms
* sizeof (Elf_External_Sym
)))
5421 /* Read the relocations. */
5422 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
5423 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5424 info
->keep_memory
));
5425 if (relstart
== NULL
)
5430 relend
= relstart
+ sec
->reloc_count
;
5432 for (rel
= relstart
; rel
< relend
; rel
++)
5434 unsigned long r_symndx
;
5436 struct elf_link_hash_entry
*h
;
5439 r_symndx
= ELF_R_SYM (rel
->r_info
);
5443 if (elf_bad_symtab (sec
->owner
))
5445 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5446 if (ELF_ST_BIND (s
.st_info
) == STB_LOCAL
)
5447 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5450 h
= sym_hashes
[r_symndx
- extsymoff
];
5451 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5454 else if (r_symndx
>= nlocsyms
)
5456 h
= sym_hashes
[r_symndx
- extsymoff
];
5457 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, h
, NULL
);
5461 elf_swap_symbol_in (input_bfd
, &locsyms
[r_symndx
], &s
);
5462 rsec
= (*gc_mark_hook
)(sec
->owner
, info
, rel
, NULL
, &s
);
5465 if (rsec
&& !rsec
->gc_mark
)
5466 if (!elf_gc_mark (info
, rsec
, gc_mark_hook
))
5474 if (!info
->keep_memory
)
5484 /* The sweep phase of garbage collection. Remove all garbage sections. */
5487 elf_gc_sweep (info
, gc_sweep_hook
)
5488 struct bfd_link_info
*info
;
5489 boolean (*gc_sweep_hook
)
5490 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*o
,
5491 const Elf_Internal_Rela
*relocs
));
5495 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5499 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5501 /* Keep special sections. Keep .debug sections. */
5502 if ((o
->flags
& SEC_LINKER_CREATED
)
5503 || (o
->flags
& SEC_DEBUGGING
))
5509 /* Skip sweeping sections already excluded. */
5510 if (o
->flags
& SEC_EXCLUDE
)
5513 /* Since this is early in the link process, it is simple
5514 to remove a section from the output. */
5515 o
->flags
|= SEC_EXCLUDE
;
5517 /* But we also have to update some of the relocation
5518 info we collected before. */
5520 && (o
->flags
& SEC_RELOC
) && o
->reloc_count
> 0)
5522 Elf_Internal_Rela
*internal_relocs
;
5525 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
5526 (o
->owner
, o
, NULL
, NULL
, info
->keep_memory
));
5527 if (internal_relocs
== NULL
)
5530 r
= (*gc_sweep_hook
)(o
->owner
, info
, o
, internal_relocs
);
5532 if (!info
->keep_memory
)
5533 free (internal_relocs
);
5541 /* Remove the symbols that were in the swept sections from the dynamic
5542 symbol table. GCFIXME: Anyone know how to get them out of the
5543 static symbol table as well? */
5547 elf_link_hash_traverse (elf_hash_table (info
),
5548 elf_gc_sweep_symbol
,
5551 elf_hash_table (info
)->dynsymcount
= i
;
5557 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
5560 elf_gc_sweep_symbol (h
, idxptr
)
5561 struct elf_link_hash_entry
*h
;
5564 int *idx
= (int *) idxptr
;
5566 if (h
->dynindx
!= -1
5567 && ((h
->root
.type
!= bfd_link_hash_defined
5568 && h
->root
.type
!= bfd_link_hash_defweak
)
5569 || h
->root
.u
.def
.section
->gc_mark
))
5570 h
->dynindx
= (*idx
)++;
5575 /* Propogate collected vtable information. This is called through
5576 elf_link_hash_traverse. */
5579 elf_gc_propagate_vtable_entries_used (h
, okp
)
5580 struct elf_link_hash_entry
*h
;
5583 /* Those that are not vtables. */
5584 if (h
->vtable_parent
== NULL
)
5587 /* Those vtables that do not have parents, we cannot merge. */
5588 if (h
->vtable_parent
== (struct elf_link_hash_entry
*) -1)
5591 /* If we've already been done, exit. */
5592 if (h
->vtable_entries_used
&& h
->vtable_entries_used
[-1])
5595 /* Make sure the parent's table is up to date. */
5596 elf_gc_propagate_vtable_entries_used (h
->vtable_parent
, okp
);
5598 if (h
->vtable_entries_used
== NULL
)
5600 /* None of this table's entries were referenced. Re-use the
5602 h
->vtable_entries_used
= h
->vtable_parent
->vtable_entries_used
;
5609 /* Or the parent's entries into ours. */
5610 cu
= h
->vtable_entries_used
;
5612 pu
= h
->vtable_parent
->vtable_entries_used
;
5615 n
= h
->vtable_parent
->size
/ FILE_ALIGN
;
5618 if (*pu
) *cu
= true;
5628 elf_gc_smash_unused_vtentry_relocs (h
, okp
)
5629 struct elf_link_hash_entry
*h
;
5633 bfd_vma hstart
, hend
;
5634 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
5636 /* Take care of both those symbols that do not describe vtables as
5637 well as those that are not loaded. */
5638 if (h
->vtable_parent
== NULL
)
5641 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5642 || h
->root
.type
== bfd_link_hash_defweak
);
5644 sec
= h
->root
.u
.def
.section
;
5645 hstart
= h
->root
.u
.def
.value
;
5646 hend
= hstart
+ h
->size
;
5648 relstart
= (NAME(_bfd_elf
,link_read_relocs
)
5649 (sec
->owner
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
, true));
5651 return *(boolean
*)okp
= false;
5652 relend
= relstart
+ sec
->reloc_count
;
5654 for (rel
= relstart
; rel
< relend
; ++rel
)
5655 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
5657 /* If the entry is in use, do nothing. */
5658 if (h
->vtable_entries_used
)
5660 bfd_vma entry
= (rel
->r_offset
- hstart
) / FILE_ALIGN
;
5661 if (h
->vtable_entries_used
[entry
])
5664 /* Otherwise, kill it. */
5665 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
5671 /* Do mark and sweep of unused sections. */
5674 elf_gc_sections (abfd
, info
)
5676 struct bfd_link_info
*info
;
5680 asection
* (*gc_mark_hook
)
5681 PARAMS ((bfd
*abfd
, struct bfd_link_info
*, Elf_Internal_Rela
*,
5682 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*));
5684 if (!get_elf_backend_data (abfd
)->can_gc_sections
5685 || info
->relocateable
5686 || elf_hash_table (info
)->dynamic_sections_created
)
5689 /* Apply transitive closure to the vtable entry usage info. */
5690 elf_link_hash_traverse (elf_hash_table (info
),
5691 elf_gc_propagate_vtable_entries_used
,
5696 /* Kill the vtable relocations that were not used. */
5697 elf_link_hash_traverse (elf_hash_table (info
),
5698 elf_gc_smash_unused_vtentry_relocs
,
5703 /* Grovel through relocs to find out who stays ... */
5705 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
5706 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5709 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5711 if (o
->flags
& SEC_KEEP
)
5712 if (!elf_gc_mark (info
, o
, gc_mark_hook
))
5717 /* ... and mark SEC_EXCLUDE for those that go. */
5718 if (!elf_gc_sweep(info
, get_elf_backend_data (abfd
)->gc_sweep_hook
))
5724 /* Called from check_relocs to record the existance of a VTINHERIT reloc. */
5727 elf_gc_record_vtinherit (abfd
, sec
, h
, offset
)
5730 struct elf_link_hash_entry
*h
;
5733 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
5734 struct elf_link_hash_entry
**search
, *child
;
5735 bfd_size_type extsymcount
;
5737 /* The sh_info field of the symtab header tells us where the
5738 external symbols start. We don't care about the local symbols at
5740 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/sizeof (Elf_External_Sym
);
5741 if (!elf_bad_symtab (abfd
))
5742 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
5744 sym_hashes
= elf_sym_hashes (abfd
);
5745 sym_hashes_end
= sym_hashes
+ extsymcount
;
5747 /* Hunt down the child symbol, which is in this section at the same
5748 offset as the relocation. */
5749 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
5751 if ((child
= *search
) != NULL
5752 && (child
->root
.type
== bfd_link_hash_defined
5753 || child
->root
.type
== bfd_link_hash_defweak
)
5754 && child
->root
.u
.def
.section
== sec
5755 && child
->root
.u
.def
.value
== offset
)
5759 (*_bfd_error_handler
) ("%s: %s+%lu: No symbol found for INHERIT",
5760 bfd_get_filename (abfd
), sec
->name
,
5761 (unsigned long)offset
);
5762 bfd_set_error (bfd_error_invalid_operation
);
5768 /* This *should* only be the absolute section. It could potentially
5769 be that someone has defined a non-global vtable though, which
5770 would be bad. It isn't worth paging in the local symbols to be
5771 sure though; that case should simply be handled by the assembler. */
5773 child
->vtable_parent
= (struct elf_link_hash_entry
*) -1;
5776 child
->vtable_parent
= h
;
5781 /* Called from check_relocs to record the existance of a VTENTRY reloc. */
5784 elf_gc_record_vtentry (abfd
, sec
, h
, addend
)
5787 struct elf_link_hash_entry
*h
;
5790 if (h
->vtable_entries_used
== NULL
)
5792 /* Allocate one extra entry for use as a "done" flag for the
5793 consolidation pass. */
5794 size_t size
= (h
->size
/ FILE_ALIGN
+ 1) * sizeof(boolean
);
5795 h
->vtable_entries_used
= (boolean
*) bfd_alloc (abfd
, size
);
5796 if (h
->vtable_entries_used
== NULL
)
5799 /* And arrange for that done flag to be at index -1. */
5800 memset (h
->vtable_entries_used
++, 0, size
);
5802 h
->vtable_entries_used
[addend
/ FILE_ALIGN
] = true;
5807 /* And an accompanying bit to work out final got entry offsets once
5808 we're done. Should be called from final_link. */
5811 elf_gc_common_finalize_got_offsets (abfd
, info
)
5813 struct bfd_link_info
*info
;
5816 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5819 /* The GOT offset is relative to the .got section, but the GOT header is
5820 put into the .got.plt section, if the backend uses it. */
5821 if (bed
->want_got_plt
)
5824 gotoff
= bed
->got_header_size
;
5826 /* Do the local .got entries first. */
5827 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
5829 bfd_signed_vma
*local_got
= elf_local_got_refcounts (i
);
5830 bfd_size_type j
, locsymcount
;
5831 Elf_Internal_Shdr
*symtab_hdr
;
5836 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
5837 if (elf_bad_symtab (i
))
5838 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5840 locsymcount
= symtab_hdr
->sh_info
;
5842 for (j
= 0; j
< locsymcount
; ++j
)
5844 if (local_got
[j
] > 0)
5846 local_got
[j
] = gotoff
;
5847 gotoff
+= ARCH_SIZE
/ 8;
5850 local_got
[j
] = (bfd_vma
) -1;
5854 /* Then the global .got and .plt entries. */
5855 elf_link_hash_traverse (elf_hash_table (info
),
5856 elf_gc_allocate_got_offsets
,
5861 /* We need a special top-level link routine to convert got reference counts
5862 to real got offsets. */
5865 elf_gc_allocate_got_offsets (h
, offarg
)
5866 struct elf_link_hash_entry
*h
;
5869 bfd_vma
*off
= (bfd_vma
*) offarg
;
5871 if (h
->got
.refcount
> 0)
5873 h
->got
.offset
= off
[0];
5874 off
[0] += ARCH_SIZE
/ 8;
5877 h
->got
.offset
= (bfd_vma
) -1;
5882 /* Many folk need no more in the way of final link than this, once
5883 got entry reference counting is enabled. */
5886 elf_gc_common_final_link (abfd
, info
)
5888 struct bfd_link_info
*info
;
5890 if (!elf_gc_common_finalize_got_offsets (abfd
, info
))
5893 /* Invoke the regular ELF backend linker to do all the work. */
5894 return elf_bfd_final_link (abfd
, info
);