2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* ELF linker code. */
23 #include "safe-ctype.h"
25 static bfd_boolean
elf_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
26 static bfd_boolean
elf_link_add_archive_symbols (bfd
*,
27 struct bfd_link_info
*);
28 static bfd_boolean
elf_finalize_dynstr (bfd
*, struct bfd_link_info
*);
29 static bfd_boolean
elf_collect_hash_codes (struct elf_link_hash_entry
*,
31 static bfd_boolean
elf_section_ignore_discarded_relocs (asection
*);
33 /* Given an ELF BFD, add symbols to the global hash table as
37 elf_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
39 switch (bfd_get_format (abfd
))
42 return elf_link_add_object_symbols (abfd
, info
);
44 return elf_link_add_archive_symbols (abfd
, info
);
46 bfd_set_error (bfd_error_wrong_format
);
51 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */
53 is_global_data_symbol_definition (bfd
*abfd ATTRIBUTE_UNUSED
,
54 Elf_Internal_Sym
*sym
)
56 /* Local symbols do not count, but target specific ones might. */
57 if (ELF_ST_BIND (sym
->st_info
) != STB_GLOBAL
58 && ELF_ST_BIND (sym
->st_info
) < STB_LOOS
)
61 /* Function symbols do not count. */
62 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
)
65 /* If the section is undefined, then so is the symbol. */
66 if (sym
->st_shndx
== SHN_UNDEF
)
69 /* If the symbol is defined in the common section, then
70 it is a common definition and so does not count. */
71 if (sym
->st_shndx
== SHN_COMMON
)
74 /* If the symbol is in a target specific section then we
75 must rely upon the backend to tell us what it is. */
76 if (sym
->st_shndx
>= SHN_LORESERVE
&& sym
->st_shndx
< SHN_ABS
)
77 /* FIXME - this function is not coded yet:
79 return _bfd_is_global_symbol_definition (abfd, sym);
81 Instead for now assume that the definition is not global,
82 Even if this is wrong, at least the linker will behave
83 in the same way that it used to do. */
89 /* Search the symbol table of the archive element of the archive ABFD
90 whose archive map contains a mention of SYMDEF, and determine if
91 the symbol is defined in this element. */
93 elf_link_is_defined_archive_symbol (bfd
* abfd
, carsym
* symdef
)
95 Elf_Internal_Shdr
* hdr
;
96 bfd_size_type symcount
;
97 bfd_size_type extsymcount
;
98 bfd_size_type extsymoff
;
99 Elf_Internal_Sym
*isymbuf
;
100 Elf_Internal_Sym
*isym
;
101 Elf_Internal_Sym
*isymend
;
104 abfd
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
108 if (! bfd_check_format (abfd
, bfd_object
))
111 /* If we have already included the element containing this symbol in the
112 link then we do not need to include it again. Just claim that any symbol
113 it contains is not a definition, so that our caller will not decide to
114 (re)include this element. */
115 if (abfd
->archive_pass
)
118 /* Select the appropriate symbol table. */
119 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dynsymtab (abfd
) == 0)
120 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
122 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
124 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
126 /* The sh_info field of the symtab header tells us where the
127 external symbols start. We don't care about the local symbols. */
128 if (elf_bad_symtab (abfd
))
130 extsymcount
= symcount
;
135 extsymcount
= symcount
- hdr
->sh_info
;
136 extsymoff
= hdr
->sh_info
;
139 if (extsymcount
== 0)
142 /* Read in the symbol table. */
143 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
148 /* Scan the symbol table looking for SYMDEF. */
150 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
; isym
< isymend
; isym
++)
154 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
159 if (strcmp (name
, symdef
->name
) == 0)
161 result
= is_global_data_symbol_definition (abfd
, isym
);
171 /* Add symbols from an ELF archive file to the linker hash table. We
172 don't use _bfd_generic_link_add_archive_symbols because of a
173 problem which arises on UnixWare. The UnixWare libc.so is an
174 archive which includes an entry libc.so.1 which defines a bunch of
175 symbols. The libc.so archive also includes a number of other
176 object files, which also define symbols, some of which are the same
177 as those defined in libc.so.1. Correct linking requires that we
178 consider each object file in turn, and include it if it defines any
179 symbols we need. _bfd_generic_link_add_archive_symbols does not do
180 this; it looks through the list of undefined symbols, and includes
181 any object file which defines them. When this algorithm is used on
182 UnixWare, it winds up pulling in libc.so.1 early and defining a
183 bunch of symbols. This means that some of the other objects in the
184 archive are not included in the link, which is incorrect since they
185 precede libc.so.1 in the archive.
187 Fortunately, ELF archive handling is simpler than that done by
188 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
189 oddities. In ELF, if we find a symbol in the archive map, and the
190 symbol is currently undefined, we know that we must pull in that
193 Unfortunately, we do have to make multiple passes over the symbol
194 table until nothing further is resolved. */
197 elf_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
200 bfd_boolean
*defined
= NULL
;
201 bfd_boolean
*included
= NULL
;
206 if (! bfd_has_map (abfd
))
208 /* An empty archive is a special case. */
209 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
211 bfd_set_error (bfd_error_no_armap
);
215 /* Keep track of all symbols we know to be already defined, and all
216 files we know to be already included. This is to speed up the
217 second and subsequent passes. */
218 c
= bfd_ardata (abfd
)->symdef_count
;
222 amt
*= sizeof (bfd_boolean
);
223 defined
= bfd_zmalloc (amt
);
224 included
= bfd_zmalloc (amt
);
225 if (defined
== NULL
|| included
== NULL
)
228 symdefs
= bfd_ardata (abfd
)->symdefs
;
241 symdefend
= symdef
+ c
;
242 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
244 struct elf_link_hash_entry
*h
;
246 struct bfd_link_hash_entry
*undefs_tail
;
249 if (defined
[i
] || included
[i
])
251 if (symdef
->file_offset
== last
)
257 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
258 FALSE
, FALSE
, FALSE
);
265 /* If this is a default version (the name contains @@),
266 look up the symbol again with only one `@' as well
267 as without the version. The effect is that references
268 to the symbol with and without the version will be
269 matched by the default symbol in the archive. */
271 p
= strchr (symdef
->name
, ELF_VER_CHR
);
272 if (p
== NULL
|| p
[1] != ELF_VER_CHR
)
275 /* First check with only one `@'. */
276 len
= strlen (symdef
->name
);
277 copy
= bfd_alloc (abfd
, len
);
280 first
= p
- symdef
->name
+ 1;
281 memcpy (copy
, symdef
->name
, first
);
282 memcpy (copy
+ first
, symdef
->name
+ first
+ 1, len
- first
);
284 h
= elf_link_hash_lookup (elf_hash_table (info
), copy
,
285 FALSE
, FALSE
, FALSE
);
289 /* We also need to check references to the symbol
290 without the version. */
292 copy
[first
- 1] = '\0';
293 h
= elf_link_hash_lookup (elf_hash_table (info
),
294 copy
, FALSE
, FALSE
, FALSE
);
297 bfd_release (abfd
, copy
);
303 if (h
->root
.type
== bfd_link_hash_common
)
305 /* We currently have a common symbol. The archive map contains
306 a reference to this symbol, so we may want to include it. We
307 only want to include it however, if this archive element
308 contains a definition of the symbol, not just another common
311 Unfortunately some archivers (including GNU ar) will put
312 declarations of common symbols into their archive maps, as
313 well as real definitions, so we cannot just go by the archive
314 map alone. Instead we must read in the element's symbol
315 table and check that to see what kind of symbol definition
317 if (! elf_link_is_defined_archive_symbol (abfd
, symdef
))
320 else if (h
->root
.type
!= bfd_link_hash_undefined
)
322 if (h
->root
.type
!= bfd_link_hash_undefweak
)
327 /* We need to include this archive member. */
328 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
332 if (! bfd_check_format (element
, bfd_object
))
335 /* Doublecheck that we have not included this object
336 already--it should be impossible, but there may be
337 something wrong with the archive. */
338 if (element
->archive_pass
!= 0)
340 bfd_set_error (bfd_error_bad_value
);
343 element
->archive_pass
= 1;
345 undefs_tail
= info
->hash
->undefs_tail
;
347 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
350 if (! elf_link_add_object_symbols (element
, info
))
353 /* If there are any new undefined symbols, we need to make
354 another pass through the archive in order to see whether
355 they can be defined. FIXME: This isn't perfect, because
356 common symbols wind up on undefs_tail and because an
357 undefined symbol which is defined later on in this pass
358 does not require another pass. This isn't a bug, but it
359 does make the code less efficient than it could be. */
360 if (undefs_tail
!= info
->hash
->undefs_tail
)
363 /* Look backward to mark all symbols from this object file
364 which we have already seen in this pass. */
368 included
[mark
] = TRUE
;
373 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
375 /* We mark subsequent symbols from this object file as we go
376 on through the loop. */
377 last
= symdef
->file_offset
;
390 if (included
!= NULL
)
395 /* Add symbols from an ELF object file to the linker hash table. */
398 elf_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
400 bfd_boolean (*add_symbol_hook
)
401 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
402 const char **, flagword
*, asection
**, bfd_vma
*);
403 bfd_boolean (*check_relocs
)
404 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
406 Elf_Internal_Shdr
*hdr
;
407 bfd_size_type symcount
;
408 bfd_size_type extsymcount
;
409 bfd_size_type extsymoff
;
410 struct elf_link_hash_entry
**sym_hash
;
412 Elf_External_Versym
*extversym
= NULL
;
413 Elf_External_Versym
*ever
;
414 struct elf_link_hash_entry
*weaks
;
415 struct elf_link_hash_entry
**nondeflt_vers
= NULL
;
416 bfd_size_type nondeflt_vers_cnt
= 0;
417 Elf_Internal_Sym
*isymbuf
= NULL
;
418 Elf_Internal_Sym
*isym
;
419 Elf_Internal_Sym
*isymend
;
420 const struct elf_backend_data
*bed
;
421 bfd_boolean dt_needed
;
422 struct elf_link_hash_table
* hash_table
;
425 hash_table
= elf_hash_table (info
);
427 bed
= get_elf_backend_data (abfd
);
428 add_symbol_hook
= bed
->elf_add_symbol_hook
;
429 collect
= bed
->collect
;
431 if ((abfd
->flags
& DYNAMIC
) == 0)
437 /* You can't use -r against a dynamic object. Also, there's no
438 hope of using a dynamic object which does not exactly match
439 the format of the output file. */
440 if (info
->relocatable
|| info
->hash
->creator
!= abfd
->xvec
)
442 bfd_set_error (bfd_error_invalid_operation
);
447 /* As a GNU extension, any input sections which are named
448 .gnu.warning.SYMBOL are treated as warning symbols for the given
449 symbol. This differs from .gnu.warning sections, which generate
450 warnings when they are included in an output file. */
451 if (info
->executable
)
455 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
459 name
= bfd_get_section_name (abfd
, s
);
460 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
464 bfd_size_type prefix_len
;
465 const char * gnu_warning_prefix
= _("warning: ");
467 name
+= sizeof ".gnu.warning." - 1;
469 /* If this is a shared object, then look up the symbol
470 in the hash table. If it is there, and it is already
471 been defined, then we will not be using the entry
472 from this shared object, so we don't need to warn.
473 FIXME: If we see the definition in a regular object
474 later on, we will warn, but we shouldn't. The only
475 fix is to keep track of what warnings we are supposed
476 to emit, and then handle them all at the end of the
478 if (dynamic
&& abfd
->xvec
== info
->hash
->creator
)
480 struct elf_link_hash_entry
*h
;
482 h
= elf_link_hash_lookup (hash_table
, name
,
485 /* FIXME: What about bfd_link_hash_common? */
487 && (h
->root
.type
== bfd_link_hash_defined
488 || h
->root
.type
== bfd_link_hash_defweak
))
490 /* We don't want to issue this warning. Clobber
491 the section size so that the warning does not
492 get copied into the output file. */
498 sz
= bfd_section_size (abfd
, s
);
499 prefix_len
= strlen (gnu_warning_prefix
);
500 msg
= bfd_alloc (abfd
, prefix_len
+ sz
+ 1);
504 strcpy (msg
, gnu_warning_prefix
);
505 if (! bfd_get_section_contents (abfd
, s
, msg
+ prefix_len
, 0, sz
))
508 msg
[prefix_len
+ sz
] = '\0';
510 if (! (_bfd_generic_link_add_one_symbol
511 (info
, abfd
, name
, BSF_WARNING
, s
, 0, msg
,
512 FALSE
, collect
, NULL
)))
515 if (! info
->relocatable
)
517 /* Clobber the section size so that the warning does
518 not get copied into the output file. */
528 /* If we are creating a shared library, create all the dynamic
529 sections immediately. We need to attach them to something,
530 so we attach them to this BFD, provided it is the right
531 format. FIXME: If there are no input BFD's of the same
532 format as the output, we can't make a shared library. */
534 && is_elf_hash_table (info
)
535 && ! hash_table
->dynamic_sections_created
536 && abfd
->xvec
== info
->hash
->creator
)
538 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
542 else if (! is_elf_hash_table (info
))
547 bfd_boolean add_needed
;
549 bfd_size_type oldsize
;
550 bfd_size_type strindex
;
551 struct bfd_link_needed_list
*rpath
= NULL
, *runpath
= NULL
;
553 /* ld --just-symbols and dynamic objects don't mix very well.
554 Test for --just-symbols by looking at info set up by
555 _bfd_elf_link_just_syms. */
556 if ((s
= abfd
->sections
) != NULL
557 && s
->sec_info_type
== ELF_INFO_TYPE_JUST_SYMS
)
560 /* Find the name to use in a DT_NEEDED entry that refers to this
561 object. If the object has a DT_SONAME entry, we use it.
562 Otherwise, if the generic linker stuck something in
563 elf_dt_name, we use that. Otherwise, we just use the file
564 name. If the generic linker put a null string into
565 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
566 there is a DT_SONAME entry. */
568 name
= bfd_get_filename (abfd
);
569 if (elf_dt_name (abfd
) != NULL
)
571 name
= elf_dt_name (abfd
);
574 if (elf_dt_soname (abfd
) != NULL
)
580 s
= bfd_get_section_by_name (abfd
, ".dynamic");
583 Elf_External_Dyn
*dynbuf
= NULL
;
584 Elf_External_Dyn
*extdyn
;
585 Elf_External_Dyn
*extdynend
;
587 unsigned long shlink
;
589 dynbuf
= bfd_malloc (s
->_raw_size
);
593 if (! bfd_get_section_contents (abfd
, s
, dynbuf
, 0, s
->_raw_size
))
596 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
599 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
602 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
603 for (; extdyn
< extdynend
; extdyn
++)
605 Elf_Internal_Dyn dyn
;
607 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
608 if (dyn
.d_tag
== DT_SONAME
)
610 unsigned int tagv
= dyn
.d_un
.d_val
;
611 name
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
615 if (dyn
.d_tag
== DT_NEEDED
)
617 struct bfd_link_needed_list
*n
, **pn
;
619 unsigned int tagv
= dyn
.d_un
.d_val
;
621 amt
= sizeof (struct bfd_link_needed_list
);
622 n
= bfd_alloc (abfd
, amt
);
623 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
624 if (n
== NULL
|| fnm
== NULL
)
626 amt
= strlen (fnm
) + 1;
627 anm
= bfd_alloc (abfd
, amt
);
630 memcpy (anm
, fnm
, amt
);
634 for (pn
= & hash_table
->needed
;
640 if (dyn
.d_tag
== DT_RUNPATH
)
642 struct bfd_link_needed_list
*n
, **pn
;
644 unsigned int tagv
= dyn
.d_un
.d_val
;
646 amt
= sizeof (struct bfd_link_needed_list
);
647 n
= bfd_alloc (abfd
, amt
);
648 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
649 if (n
== NULL
|| fnm
== NULL
)
651 amt
= strlen (fnm
) + 1;
652 anm
= bfd_alloc (abfd
, amt
);
655 memcpy (anm
, fnm
, amt
);
665 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */
666 if (!runpath
&& dyn
.d_tag
== DT_RPATH
)
668 struct bfd_link_needed_list
*n
, **pn
;
670 unsigned int tagv
= dyn
.d_un
.d_val
;
672 amt
= sizeof (struct bfd_link_needed_list
);
673 n
= bfd_alloc (abfd
, amt
);
674 fnm
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
675 if (n
== NULL
|| fnm
== NULL
)
677 amt
= strlen (fnm
) + 1;
678 anm
= bfd_alloc (abfd
, amt
);
685 memcpy (anm
, fnm
, amt
);
700 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
701 frees all more recently bfd_alloc'd blocks as well. */
707 struct bfd_link_needed_list
**pn
;
708 for (pn
= & hash_table
->runpath
;
715 /* We do not want to include any of the sections in a dynamic
716 object in the output file. We hack by simply clobbering the
717 list of sections in the BFD. This could be handled more
718 cleanly by, say, a new section flag; the existing
719 SEC_NEVER_LOAD flag is not the one we want, because that one
720 still implies that the section takes up space in the output
722 bfd_section_list_clear (abfd
);
724 /* If this is the first dynamic object found in the link, create
725 the special sections required for dynamic linking. */
726 if (! hash_table
->dynamic_sections_created
)
727 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
732 /* Add a DT_NEEDED entry for this dynamic object. */
733 oldsize
= _bfd_elf_strtab_size (hash_table
->dynstr
);
734 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
, name
, FALSE
);
735 if (strindex
== (bfd_size_type
) -1)
738 if (oldsize
== _bfd_elf_strtab_size (hash_table
->dynstr
))
741 Elf_External_Dyn
*dyncon
, *dynconend
;
743 /* The hash table size did not change, which means that
744 the dynamic object name was already entered. If we
745 have already included this dynamic object in the
746 link, just ignore it. There is no reason to include
747 a particular dynamic object more than once. */
748 sdyn
= bfd_get_section_by_name (hash_table
->dynobj
, ".dynamic");
749 BFD_ASSERT (sdyn
!= NULL
);
751 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
752 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
754 for (; dyncon
< dynconend
; dyncon
++)
756 Elf_Internal_Dyn dyn
;
758 elf_swap_dyn_in (hash_table
->dynobj
, dyncon
, & dyn
);
759 if (dyn
.d_tag
== DT_NEEDED
760 && dyn
.d_un
.d_val
== strindex
)
762 _bfd_elf_strtab_delref (hash_table
->dynstr
, strindex
);
768 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
772 /* Save the SONAME, if there is one, because sometimes the
773 linker emulation code will need to know it. */
775 name
= basename (bfd_get_filename (abfd
));
776 elf_dt_name (abfd
) = name
;
779 /* If this is a dynamic object, we always link against the .dynsym
780 symbol table, not the .symtab symbol table. The dynamic linker
781 will only see the .dynsym symbol table, so there is no reason to
782 look at .symtab for a dynamic object. */
784 if (! dynamic
|| elf_dynsymtab (abfd
) == 0)
785 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
787 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
789 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
791 /* The sh_info field of the symtab header tells us where the
792 external symbols start. We don't care about the local symbols at
794 if (elf_bad_symtab (abfd
))
796 extsymcount
= symcount
;
801 extsymcount
= symcount
- hdr
->sh_info
;
802 extsymoff
= hdr
->sh_info
;
806 if (extsymcount
!= 0)
808 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
813 /* We store a pointer to the hash table entry for each external
815 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
816 sym_hash
= bfd_alloc (abfd
, amt
);
817 if (sym_hash
== NULL
)
819 elf_sym_hashes (abfd
) = sym_hash
;
824 /* Read in any version definitions. */
825 if (! _bfd_elf_slurp_version_tables (abfd
))
828 /* Read in the symbol versions, but don't bother to convert them
829 to internal format. */
830 if (elf_dynversym (abfd
) != 0)
832 Elf_Internal_Shdr
*versymhdr
;
834 versymhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
835 extversym
= bfd_malloc (versymhdr
->sh_size
);
836 if (extversym
== NULL
)
838 amt
= versymhdr
->sh_size
;
839 if (bfd_seek (abfd
, versymhdr
->sh_offset
, SEEK_SET
) != 0
840 || bfd_bread (extversym
, amt
, abfd
) != amt
)
841 goto error_free_vers
;
847 ever
= extversym
!= NULL
? extversym
+ extsymoff
: NULL
;
848 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
850 isym
++, sym_hash
++, ever
= (ever
!= NULL
? ever
+ 1 : NULL
))
857 struct elf_link_hash_entry
*h
;
858 bfd_boolean definition
;
859 bfd_boolean size_change_ok
;
860 bfd_boolean type_change_ok
;
861 bfd_boolean new_weakdef
;
862 bfd_boolean override
;
863 unsigned int old_alignment
;
868 flags
= BSF_NO_FLAGS
;
870 value
= isym
->st_value
;
873 bind
= ELF_ST_BIND (isym
->st_info
);
874 if (bind
== STB_LOCAL
)
876 /* This should be impossible, since ELF requires that all
877 global symbols follow all local symbols, and that sh_info
878 point to the first global symbol. Unfortunatealy, Irix 5
882 else if (bind
== STB_GLOBAL
)
884 if (isym
->st_shndx
!= SHN_UNDEF
885 && isym
->st_shndx
!= SHN_COMMON
)
888 else if (bind
== STB_WEAK
)
892 /* Leave it up to the processor backend. */
895 if (isym
->st_shndx
== SHN_UNDEF
)
896 sec
= bfd_und_section_ptr
;
897 else if (isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
899 sec
= section_from_elf_index (abfd
, isym
->st_shndx
);
901 sec
= bfd_abs_section_ptr
;
902 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
905 else if (isym
->st_shndx
== SHN_ABS
)
906 sec
= bfd_abs_section_ptr
;
907 else if (isym
->st_shndx
== SHN_COMMON
)
909 sec
= bfd_com_section_ptr
;
910 /* What ELF calls the size we call the value. What ELF
911 calls the value we call the alignment. */
912 value
= isym
->st_size
;
916 /* Leave it up to the processor backend. */
919 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
922 goto error_free_vers
;
924 if (isym
->st_shndx
== SHN_COMMON
925 && ELF_ST_TYPE (isym
->st_info
) == STT_TLS
)
927 asection
*tcomm
= bfd_get_section_by_name (abfd
, ".tcommon");
931 tcomm
= bfd_make_section (abfd
, ".tcommon");
933 || !bfd_set_section_flags (abfd
, tcomm
, (SEC_ALLOC
936 | SEC_THREAD_LOCAL
)))
937 goto error_free_vers
;
941 else if (add_symbol_hook
)
943 if (! (*add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
, &sec
,
945 goto error_free_vers
;
947 /* The hook function sets the name to NULL if this symbol
948 should be skipped for some reason. */
953 /* Sanity check that all possibilities were handled. */
956 bfd_set_error (bfd_error_bad_value
);
957 goto error_free_vers
;
960 if (bfd_is_und_section (sec
)
961 || bfd_is_com_section (sec
))
966 size_change_ok
= FALSE
;
967 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
971 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
973 Elf_Internal_Versym iver
;
974 unsigned int vernum
= 0;
979 _bfd_elf_swap_versym_in (abfd
, ever
, &iver
);
980 vernum
= iver
.vs_vers
& VERSYM_VERSION
;
982 /* If this is a hidden symbol, or if it is not version
983 1, we append the version name to the symbol name.
984 However, we do not modify a non-hidden absolute
985 symbol, because it might be the version symbol
986 itself. FIXME: What if it isn't? */
987 if ((iver
.vs_vers
& VERSYM_HIDDEN
) != 0
988 || (vernum
> 1 && ! bfd_is_abs_section (sec
)))
991 size_t namelen
, verlen
, newlen
;
994 if (isym
->st_shndx
!= SHN_UNDEF
)
996 if (vernum
> elf_tdata (abfd
)->dynverdef_hdr
.sh_info
)
998 (*_bfd_error_handler
)
999 (_("%s: %s: invalid version %u (max %d)"),
1000 bfd_archive_filename (abfd
), name
, vernum
,
1001 elf_tdata (abfd
)->dynverdef_hdr
.sh_info
);
1002 bfd_set_error (bfd_error_bad_value
);
1003 goto error_free_vers
;
1005 else if (vernum
> 1)
1007 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1013 /* We cannot simply test for the number of
1014 entries in the VERNEED section since the
1015 numbers for the needed versions do not start
1017 Elf_Internal_Verneed
*t
;
1020 for (t
= elf_tdata (abfd
)->verref
;
1024 Elf_Internal_Vernaux
*a
;
1026 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1028 if (a
->vna_other
== vernum
)
1030 verstr
= a
->vna_nodename
;
1039 (*_bfd_error_handler
)
1040 (_("%s: %s: invalid needed version %d"),
1041 bfd_archive_filename (abfd
), name
, vernum
);
1042 bfd_set_error (bfd_error_bad_value
);
1043 goto error_free_vers
;
1047 namelen
= strlen (name
);
1048 verlen
= strlen (verstr
);
1049 newlen
= namelen
+ verlen
+ 2;
1050 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
1051 && isym
->st_shndx
!= SHN_UNDEF
)
1054 newname
= bfd_alloc (abfd
, newlen
);
1055 if (newname
== NULL
)
1056 goto error_free_vers
;
1057 memcpy (newname
, name
, namelen
);
1058 p
= newname
+ namelen
;
1060 /* If this is a defined non-hidden version symbol,
1061 we add another @ to the name. This indicates the
1062 default version of the symbol. */
1063 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0
1064 && isym
->st_shndx
!= SHN_UNDEF
)
1066 memcpy (p
, verstr
, verlen
+ 1);
1072 if (!_bfd_elf_merge_symbol (abfd
, info
, name
, isym
, &sec
, &value
,
1073 sym_hash
, &skip
, &override
,
1074 &type_change_ok
, &size_change_ok
,
1076 goto error_free_vers
;
1085 while (h
->root
.type
== bfd_link_hash_indirect
1086 || h
->root
.type
== bfd_link_hash_warning
)
1087 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1089 /* Remember the old alignment if this is a common symbol, so
1090 that we don't reduce the alignment later on. We can't
1091 check later, because _bfd_generic_link_add_one_symbol
1092 will set a default for the alignment which we want to
1093 override. We also remember the old bfd where the existing
1094 definition comes from. */
1095 switch (h
->root
.type
)
1100 case bfd_link_hash_defined
:
1101 case bfd_link_hash_defweak
:
1102 old_bfd
= h
->root
.u
.def
.section
->owner
;
1105 case bfd_link_hash_common
:
1106 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
1107 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
1111 if (elf_tdata (abfd
)->verdef
!= NULL
1115 h
->verinfo
.verdef
= &elf_tdata (abfd
)->verdef
[vernum
- 1];
1118 if (! (_bfd_generic_link_add_one_symbol
1119 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, collect
,
1120 (struct bfd_link_hash_entry
**) sym_hash
)))
1121 goto error_free_vers
;
1124 while (h
->root
.type
== bfd_link_hash_indirect
1125 || h
->root
.type
== bfd_link_hash_warning
)
1126 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1129 new_weakdef
= FALSE
;
1132 && (flags
& BSF_WEAK
) != 0
1133 && ELF_ST_TYPE (isym
->st_info
) != STT_FUNC
1134 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1135 && h
->weakdef
== NULL
)
1137 /* Keep a list of all weak defined non function symbols from
1138 a dynamic object, using the weakdef field. Later in this
1139 function we will set the weakdef field to the correct
1140 value. We only put non-function symbols from dynamic
1141 objects on this list, because that happens to be the only
1142 time we need to know the normal symbol corresponding to a
1143 weak symbol, and the information is time consuming to
1144 figure out. If the weakdef field is not already NULL,
1145 then this symbol was already defined by some previous
1146 dynamic object, and we will be using that previous
1147 definition anyhow. */
1154 /* Set the alignment of a common symbol. */
1155 if (isym
->st_shndx
== SHN_COMMON
1156 && h
->root
.type
== bfd_link_hash_common
)
1160 align
= bfd_log2 (isym
->st_value
);
1161 if (align
> old_alignment
1162 /* Permit an alignment power of zero if an alignment of one
1163 is specified and no other alignments have been specified. */
1164 || (isym
->st_value
== 1 && old_alignment
== 0))
1165 h
->root
.u
.c
.p
->alignment_power
= align
;
1167 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
1170 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
1176 /* Check the alignment when a common symbol is involved. This
1177 can change when a common symbol is overriden by a normal
1178 definition or a common symbol is ignored due to the old
1179 normal definition. We need to make sure the maximum
1180 alignment is maintained. */
1181 if ((old_alignment
|| isym
->st_shndx
== SHN_COMMON
)
1182 && h
->root
.type
!= bfd_link_hash_common
)
1184 unsigned int common_align
;
1185 unsigned int normal_align
;
1186 unsigned int symbol_align
;
1190 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
1191 if (h
->root
.u
.def
.section
->owner
!= NULL
1192 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
1194 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
1195 if (normal_align
> symbol_align
)
1196 normal_align
= symbol_align
;
1199 normal_align
= symbol_align
;
1203 common_align
= old_alignment
;
1204 common_bfd
= old_bfd
;
1209 common_align
= bfd_log2 (isym
->st_value
);
1211 normal_bfd
= old_bfd
;
1214 if (normal_align
< common_align
)
1215 (*_bfd_error_handler
)
1216 (_("Warning: alignment %u of symbol `%s' in %s is smaller than %u in %s"),
1219 bfd_archive_filename (normal_bfd
),
1221 bfd_archive_filename (common_bfd
));
1224 /* Remember the symbol size and type. */
1225 if (isym
->st_size
!= 0
1226 && (definition
|| h
->size
== 0))
1228 if (h
->size
!= 0 && h
->size
!= isym
->st_size
&& ! size_change_ok
)
1229 (*_bfd_error_handler
)
1230 (_("Warning: size of symbol `%s' changed from %lu in %s to %lu in %s"),
1231 name
, (unsigned long) h
->size
,
1232 bfd_archive_filename (old_bfd
),
1233 (unsigned long) isym
->st_size
,
1234 bfd_archive_filename (abfd
));
1236 h
->size
= isym
->st_size
;
1239 /* If this is a common symbol, then we always want H->SIZE
1240 to be the size of the common symbol. The code just above
1241 won't fix the size if a common symbol becomes larger. We
1242 don't warn about a size change here, because that is
1243 covered by --warn-common. */
1244 if (h
->root
.type
== bfd_link_hash_common
)
1245 h
->size
= h
->root
.u
.c
.size
;
1247 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
1248 && (definition
|| h
->type
== STT_NOTYPE
))
1250 if (h
->type
!= STT_NOTYPE
1251 && h
->type
!= ELF_ST_TYPE (isym
->st_info
)
1252 && ! type_change_ok
)
1253 (*_bfd_error_handler
)
1254 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
1255 name
, h
->type
, ELF_ST_TYPE (isym
->st_info
),
1256 bfd_archive_filename (abfd
));
1258 h
->type
= ELF_ST_TYPE (isym
->st_info
);
1261 /* If st_other has a processor-specific meaning, specific
1262 code might be needed here. We never merge the visibility
1263 attribute with the one from a dynamic object. */
1264 if (isym
->st_other
!= 0 && !dynamic
)
1266 unsigned char hvis
, symvis
, other
, nvis
;
1268 /* Take the balance of OTHER from the definition. */
1269 other
= (definition
? isym
->st_other
: h
->other
);
1270 other
&= ~ ELF_ST_VISIBILITY (-1);
1272 /* Combine visibilities, using the most constraining one. */
1273 hvis
= ELF_ST_VISIBILITY (h
->other
);
1274 symvis
= ELF_ST_VISIBILITY (isym
->st_other
);
1280 nvis
= hvis
< symvis
? hvis
: symvis
;
1282 h
->other
= other
| nvis
;
1285 /* Set a flag in the hash table entry indicating the type of
1286 reference or definition we just found. Keep a count of
1287 the number of dynamic symbols we find. A dynamic symbol
1288 is one which is referenced or defined by both a regular
1289 object and a shared object. */
1290 old_flags
= h
->elf_link_hash_flags
;
1296 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
1297 if (bind
!= STB_WEAK
)
1298 new_flag
|= ELF_LINK_HASH_REF_REGULAR_NONWEAK
;
1301 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
1302 if (! info
->executable
1303 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1304 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
1310 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
1312 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
1313 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
1314 | ELF_LINK_HASH_REF_REGULAR
)) != 0
1315 || (h
->weakdef
!= NULL
1317 && h
->weakdef
->dynindx
!= -1))
1321 h
->elf_link_hash_flags
|= new_flag
;
1323 /* Check to see if we need to add an indirect symbol for
1324 the default name. */
1325 if (definition
|| h
->root
.type
== bfd_link_hash_common
)
1326 if (!_bfd_elf_add_default_symbol (abfd
, info
, h
, name
, isym
,
1327 &sec
, &value
, &dynsym
,
1328 override
, dt_needed
))
1329 goto error_free_vers
;
1331 if (definition
&& !dynamic
)
1333 char *p
= strchr (name
, ELF_VER_CHR
);
1334 if (p
!= NULL
&& p
[1] != ELF_VER_CHR
)
1336 /* Queue non-default versions so that .symver x, x@FOO
1337 aliases can be checked. */
1338 if (! nondeflt_vers
)
1340 amt
= (isymend
- isym
+ 1)
1341 * sizeof (struct elf_link_hash_entry
*);
1342 nondeflt_vers
= bfd_malloc (amt
);
1344 nondeflt_vers
[nondeflt_vers_cnt
++] = h
;
1348 if (dynsym
&& h
->dynindx
== -1)
1350 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1351 goto error_free_vers
;
1352 if (h
->weakdef
!= NULL
1354 && h
->weakdef
->dynindx
== -1)
1356 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1357 goto error_free_vers
;
1360 else if (dynsym
&& h
->dynindx
!= -1)
1361 /* If the symbol already has a dynamic index, but
1362 visibility says it should not be visible, turn it into
1364 switch (ELF_ST_VISIBILITY (h
->other
))
1368 (*bed
->elf_backend_hide_symbol
) (info
, h
, TRUE
);
1372 if (dt_needed
&& definition
1373 && (h
->elf_link_hash_flags
1374 & ELF_LINK_HASH_REF_REGULAR
) != 0)
1376 bfd_size_type oldsize
;
1377 bfd_size_type strindex
;
1379 if (! is_elf_hash_table (info
))
1380 goto error_free_vers
;
1382 /* The symbol from a DT_NEEDED object is referenced from
1383 the regular object to create a dynamic executable. We
1384 have to make sure there is a DT_NEEDED entry for it. */
1387 oldsize
= _bfd_elf_strtab_size (hash_table
->dynstr
);
1388 strindex
= _bfd_elf_strtab_add (hash_table
->dynstr
,
1389 elf_dt_soname (abfd
), FALSE
);
1390 if (strindex
== (bfd_size_type
) -1)
1391 goto error_free_vers
;
1393 if (oldsize
== _bfd_elf_strtab_size (hash_table
->dynstr
))
1396 Elf_External_Dyn
*dyncon
, *dynconend
;
1398 sdyn
= bfd_get_section_by_name (hash_table
->dynobj
,
1400 BFD_ASSERT (sdyn
!= NULL
);
1402 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
1403 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
1405 for (; dyncon
< dynconend
; dyncon
++)
1407 Elf_Internal_Dyn dyn
;
1409 elf_swap_dyn_in (hash_table
->dynobj
,
1411 BFD_ASSERT (dyn
.d_tag
!= DT_NEEDED
||
1412 dyn
.d_un
.d_val
!= strindex
);
1416 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
1417 goto error_free_vers
;
1422 /* Now that all the symbols from this input file are created, handle
1423 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
1424 if (nondeflt_vers
!= NULL
)
1426 bfd_size_type cnt
, symidx
;
1428 for (cnt
= 0; cnt
< nondeflt_vers_cnt
; ++cnt
)
1430 struct elf_link_hash_entry
*h
= nondeflt_vers
[cnt
], *hi
;
1431 char *shortname
, *p
;
1433 p
= strchr (h
->root
.root
.string
, ELF_VER_CHR
);
1435 || (h
->root
.type
!= bfd_link_hash_defined
1436 && h
->root
.type
!= bfd_link_hash_defweak
))
1439 amt
= p
- h
->root
.root
.string
;
1440 shortname
= bfd_malloc (amt
+ 1);
1441 memcpy (shortname
, h
->root
.root
.string
, amt
);
1442 shortname
[amt
] = '\0';
1444 hi
= (struct elf_link_hash_entry
*)
1445 bfd_link_hash_lookup (info
->hash
, shortname
,
1446 FALSE
, FALSE
, FALSE
);
1448 && hi
->root
.type
== h
->root
.type
1449 && hi
->root
.u
.def
.value
== h
->root
.u
.def
.value
1450 && hi
->root
.u
.def
.section
== h
->root
.u
.def
.section
)
1452 (*bed
->elf_backend_hide_symbol
) (info
, hi
, TRUE
);
1453 hi
->root
.type
= bfd_link_hash_indirect
;
1454 hi
->root
.u
.i
.link
= (struct bfd_link_hash_entry
*) h
;
1455 (*bed
->elf_backend_copy_indirect_symbol
) (bed
, h
, hi
);
1456 sym_hash
= elf_sym_hashes (abfd
);
1458 for (symidx
= 0; symidx
< extsymcount
; ++symidx
)
1459 if (sym_hash
[symidx
] == hi
)
1461 sym_hash
[symidx
] = h
;
1467 free (nondeflt_vers
);
1468 nondeflt_vers
= NULL
;
1471 if (extversym
!= NULL
)
1477 if (isymbuf
!= NULL
)
1481 /* Now set the weakdefs field correctly for all the weak defined
1482 symbols we found. The only way to do this is to search all the
1483 symbols. Since we only need the information for non functions in
1484 dynamic objects, that's the only time we actually put anything on
1485 the list WEAKS. We need this information so that if a regular
1486 object refers to a symbol defined weakly in a dynamic object, the
1487 real symbol in the dynamic object is also put in the dynamic
1488 symbols; we also must arrange for both symbols to point to the
1489 same memory location. We could handle the general case of symbol
1490 aliasing, but a general symbol alias can only be generated in
1491 assembler code, handling it correctly would be very time
1492 consuming, and other ELF linkers don't handle general aliasing
1494 while (weaks
!= NULL
)
1496 struct elf_link_hash_entry
*hlook
;
1499 struct elf_link_hash_entry
**hpp
;
1500 struct elf_link_hash_entry
**hppend
;
1503 weaks
= hlook
->weakdef
;
1504 hlook
->weakdef
= NULL
;
1506 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
1507 || hlook
->root
.type
== bfd_link_hash_defweak
1508 || hlook
->root
.type
== bfd_link_hash_common
1509 || hlook
->root
.type
== bfd_link_hash_indirect
);
1510 slook
= hlook
->root
.u
.def
.section
;
1511 vlook
= hlook
->root
.u
.def
.value
;
1513 hpp
= elf_sym_hashes (abfd
);
1514 hppend
= hpp
+ extsymcount
;
1515 for (; hpp
< hppend
; hpp
++)
1517 struct elf_link_hash_entry
*h
;
1520 if (h
!= NULL
&& h
!= hlook
1521 && h
->root
.type
== bfd_link_hash_defined
1522 && h
->root
.u
.def
.section
== slook
1523 && h
->root
.u
.def
.value
== vlook
)
1527 /* If the weak definition is in the list of dynamic
1528 symbols, make sure the real definition is put there
1530 if (hlook
->dynindx
!= -1
1531 && h
->dynindx
== -1)
1533 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1537 /* If the real definition is in the list of dynamic
1538 symbols, make sure the weak definition is put there
1539 as well. If we don't do this, then the dynamic
1540 loader might not merge the entries for the real
1541 definition and the weak definition. */
1542 if (h
->dynindx
!= -1
1543 && hlook
->dynindx
== -1)
1545 if (! _bfd_elf_link_record_dynamic_symbol (info
, hlook
))
1553 /* If this object is the same format as the output object, and it is
1554 not a shared library, then let the backend look through the
1557 This is required to build global offset table entries and to
1558 arrange for dynamic relocs. It is not required for the
1559 particular common case of linking non PIC code, even when linking
1560 against shared libraries, but unfortunately there is no way of
1561 knowing whether an object file has been compiled PIC or not.
1562 Looking through the relocs is not particularly time consuming.
1563 The problem is that we must either (1) keep the relocs in memory,
1564 which causes the linker to require additional runtime memory or
1565 (2) read the relocs twice from the input file, which wastes time.
1566 This would be a good case for using mmap.
1568 I have no idea how to handle linking PIC code into a file of a
1569 different format. It probably can't be done. */
1570 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
1572 && abfd
->xvec
== info
->hash
->creator
1573 && check_relocs
!= NULL
)
1577 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1579 Elf_Internal_Rela
*internal_relocs
;
1582 if ((o
->flags
& SEC_RELOC
) == 0
1583 || o
->reloc_count
== 0
1584 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
1585 && (o
->flags
& SEC_DEBUGGING
) != 0)
1586 || bfd_is_abs_section (o
->output_section
))
1589 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
1591 if (internal_relocs
== NULL
)
1594 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
1596 if (elf_section_data (o
)->relocs
!= internal_relocs
)
1597 free (internal_relocs
);
1604 /* If this is a non-traditional link, try to optimize the handling
1605 of the .stab/.stabstr sections. */
1607 && ! info
->traditional_format
1608 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1609 && is_elf_hash_table (info
)
1610 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
1614 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
1615 if (stabstr
!= NULL
)
1617 bfd_size_type string_offset
= 0;
1620 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
1621 if (strncmp (".stab", stab
->name
, 5) == 0
1622 && (!stab
->name
[5] ||
1623 (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6])))
1624 && (stab
->flags
& SEC_MERGE
) == 0
1625 && !bfd_is_abs_section (stab
->output_section
))
1627 struct bfd_elf_section_data
*secdata
;
1629 secdata
= elf_section_data (stab
);
1630 if (! _bfd_link_section_stabs (abfd
,
1631 & hash_table
->stab_info
,
1636 if (secdata
->sec_info
)
1637 stab
->sec_info_type
= ELF_INFO_TYPE_STABS
;
1642 if (! info
->relocatable
&& ! dynamic
1643 && is_elf_hash_table (info
))
1647 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1648 if ((s
->flags
& SEC_MERGE
) != 0
1649 && !bfd_is_abs_section (s
->output_section
))
1651 struct bfd_elf_section_data
*secdata
;
1653 secdata
= elf_section_data (s
);
1654 if (! _bfd_merge_section (abfd
,
1655 & hash_table
->merge_info
,
1656 s
, &secdata
->sec_info
))
1658 else if (secdata
->sec_info
)
1659 s
->sec_info_type
= ELF_INFO_TYPE_MERGE
;
1663 if (is_elf_hash_table (info
))
1665 /* Add this bfd to the loaded list. */
1666 struct elf_link_loaded_list
*n
;
1668 n
= bfd_alloc (abfd
, sizeof (struct elf_link_loaded_list
));
1672 n
->next
= hash_table
->loaded
;
1673 hash_table
->loaded
= n
;
1679 if (nondeflt_vers
!= NULL
)
1680 free (nondeflt_vers
);
1681 if (extversym
!= NULL
)
1684 if (isymbuf
!= NULL
)
1690 /* Add an entry to the .dynamic table. */
1693 elf_add_dynamic_entry (struct bfd_link_info
*info
, bfd_vma tag
, bfd_vma val
)
1695 Elf_Internal_Dyn dyn
;
1698 bfd_size_type newsize
;
1699 bfd_byte
*newcontents
;
1701 if (! is_elf_hash_table (info
))
1704 dynobj
= elf_hash_table (info
)->dynobj
;
1706 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1707 BFD_ASSERT (s
!= NULL
);
1709 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1710 newcontents
= bfd_realloc (s
->contents
, newsize
);
1711 if (newcontents
== NULL
)
1715 dyn
.d_un
.d_val
= val
;
1716 elf_swap_dyn_out (dynobj
, &dyn
,
1717 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1719 s
->_raw_size
= newsize
;
1720 s
->contents
= newcontents
;
1725 /* Array used to determine the number of hash table buckets to use
1726 based on the number of symbols there are. If there are fewer than
1727 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1728 fewer than 37 we use 17 buckets, and so forth. We never use more
1729 than 32771 buckets. */
1731 static const size_t elf_buckets
[] =
1733 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
1737 /* Compute bucket count for hashing table. We do not use a static set
1738 of possible tables sizes anymore. Instead we determine for all
1739 possible reasonable sizes of the table the outcome (i.e., the
1740 number of collisions etc) and choose the best solution. The
1741 weighting functions are not too simple to allow the table to grow
1742 without bounds. Instead one of the weighting factors is the size.
1743 Therefore the result is always a good payoff between few collisions
1744 (= short chain lengths) and table size. */
1746 compute_bucket_count (struct bfd_link_info
*info
)
1748 size_t dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1749 size_t best_size
= 0;
1750 unsigned long int *hashcodes
;
1751 unsigned long int *hashcodesp
;
1752 unsigned long int i
;
1755 /* Compute the hash values for all exported symbols. At the same
1756 time store the values in an array so that we could use them for
1759 amt
*= sizeof (unsigned long int);
1760 hashcodes
= bfd_malloc (amt
);
1761 if (hashcodes
== NULL
)
1763 hashcodesp
= hashcodes
;
1765 /* Put all hash values in HASHCODES. */
1766 elf_link_hash_traverse (elf_hash_table (info
),
1767 elf_collect_hash_codes
, &hashcodesp
);
1769 /* We have a problem here. The following code to optimize the table
1770 size requires an integer type with more the 32 bits. If
1771 BFD_HOST_U_64_BIT is set we know about such a type. */
1772 #ifdef BFD_HOST_U_64_BIT
1775 unsigned long int nsyms
= hashcodesp
- hashcodes
;
1778 BFD_HOST_U_64_BIT best_chlen
= ~((BFD_HOST_U_64_BIT
) 0);
1779 unsigned long int *counts
;
1781 /* Possible optimization parameters: if we have NSYMS symbols we say
1782 that the hashing table must at least have NSYMS/4 and at most
1784 minsize
= nsyms
/ 4;
1787 best_size
= maxsize
= nsyms
* 2;
1789 /* Create array where we count the collisions in. We must use bfd_malloc
1790 since the size could be large. */
1792 amt
*= sizeof (unsigned long int);
1793 counts
= bfd_malloc (amt
);
1800 /* Compute the "optimal" size for the hash table. The criteria is a
1801 minimal chain length. The minor criteria is (of course) the size
1803 for (i
= minsize
; i
< maxsize
; ++i
)
1805 /* Walk through the array of hashcodes and count the collisions. */
1806 BFD_HOST_U_64_BIT max
;
1807 unsigned long int j
;
1808 unsigned long int fact
;
1810 memset (counts
, '\0', i
* sizeof (unsigned long int));
1812 /* Determine how often each hash bucket is used. */
1813 for (j
= 0; j
< nsyms
; ++j
)
1814 ++counts
[hashcodes
[j
] % i
];
1816 /* For the weight function we need some information about the
1817 pagesize on the target. This is information need not be 100%
1818 accurate. Since this information is not available (so far) we
1819 define it here to a reasonable default value. If it is crucial
1820 to have a better value some day simply define this value. */
1821 # ifndef BFD_TARGET_PAGESIZE
1822 # define BFD_TARGET_PAGESIZE (4096)
1825 /* We in any case need 2 + NSYMS entries for the size values and
1827 max
= (2 + nsyms
) * (ARCH_SIZE
/ 8);
1830 /* Variant 1: optimize for short chains. We add the squares
1831 of all the chain lengths (which favous many small chain
1832 over a few long chains). */
1833 for (j
= 0; j
< i
; ++j
)
1834 max
+= counts
[j
] * counts
[j
];
1836 /* This adds penalties for the overall size of the table. */
1837 fact
= i
/ (BFD_TARGET_PAGESIZE
/ (ARCH_SIZE
/ 8)) + 1;
1840 /* Variant 2: Optimize a lot more for small table. Here we
1841 also add squares of the size but we also add penalties for
1842 empty slots (the +1 term). */
1843 for (j
= 0; j
< i
; ++j
)
1844 max
+= (1 + counts
[j
]) * (1 + counts
[j
]);
1846 /* The overall size of the table is considered, but not as
1847 strong as in variant 1, where it is squared. */
1848 fact
= i
/ (BFD_TARGET_PAGESIZE
/ (ARCH_SIZE
/ 8)) + 1;
1852 /* Compare with current best results. */
1853 if (max
< best_chlen
)
1863 #endif /* defined (BFD_HOST_U_64_BIT) */
1865 /* This is the fallback solution if no 64bit type is available or if we
1866 are not supposed to spend much time on optimizations. We select the
1867 bucket count using a fixed set of numbers. */
1868 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1870 best_size
= elf_buckets
[i
];
1871 if (dynsymcount
< elf_buckets
[i
+ 1])
1876 /* Free the arrays we needed. */
1882 /* Set up the sizes and contents of the ELF dynamic sections. This is
1883 called by the ELF linker emulation before_allocation routine. We
1884 must set the sizes of the sections before the linker sets the
1885 addresses of the various sections. */
1888 NAME(bfd_elf
,size_dynamic_sections
) (bfd
*output_bfd
,
1891 const char *filter_shlib
,
1892 const char * const *auxiliary_filters
,
1893 struct bfd_link_info
*info
,
1894 asection
**sinterpptr
,
1895 struct bfd_elf_version_tree
*verdefs
)
1897 bfd_size_type soname_indx
;
1899 const struct elf_backend_data
*bed
;
1900 struct elf_assign_sym_version_info asvinfo
;
1904 soname_indx
= (bfd_size_type
) -1;
1906 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1909 if (! is_elf_hash_table (info
))
1912 if (info
->execstack
)
1913 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
1914 else if (info
->noexecstack
)
1915 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
;
1919 asection
*notesec
= NULL
;
1922 for (inputobj
= info
->input_bfds
;
1924 inputobj
= inputobj
->link_next
)
1928 if (inputobj
->flags
& DYNAMIC
)
1930 s
= bfd_get_section_by_name (inputobj
, ".note.GNU-stack");
1933 if (s
->flags
& SEC_CODE
)
1942 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| exec
;
1943 if (exec
&& info
->relocatable
1944 && notesec
->output_section
!= bfd_abs_section_ptr
)
1945 notesec
->output_section
->flags
|= SEC_CODE
;
1949 /* Any syms created from now on start with -1 in
1950 got.refcount/offset and plt.refcount/offset. */
1951 elf_hash_table (info
)->init_refcount
= elf_hash_table (info
)->init_offset
;
1953 /* The backend may have to create some sections regardless of whether
1954 we're dynamic or not. */
1955 bed
= get_elf_backend_data (output_bfd
);
1956 if (bed
->elf_backend_always_size_sections
1957 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
1960 dynobj
= elf_hash_table (info
)->dynobj
;
1962 /* If there were no dynamic objects in the link, there is nothing to
1967 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info
))
1970 if (elf_hash_table (info
)->dynamic_sections_created
)
1972 struct elf_info_failed eif
;
1973 struct elf_link_hash_entry
*h
;
1975 struct bfd_elf_version_tree
*t
;
1976 struct bfd_elf_version_expr
*d
;
1977 bfd_boolean all_defined
;
1979 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1980 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1984 soname_indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
1986 if (soname_indx
== (bfd_size_type
) -1
1987 || ! elf_add_dynamic_entry (info
, DT_SONAME
, soname_indx
))
1993 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1995 info
->flags
|= DF_SYMBOLIC
;
2002 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
, rpath
,
2004 if (info
->new_dtags
)
2005 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
, indx
);
2006 if (indx
== (bfd_size_type
) -1
2007 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
)
2009 && ! elf_add_dynamic_entry (info
, DT_RUNPATH
, indx
)))
2013 if (filter_shlib
!= NULL
)
2017 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
2018 filter_shlib
, TRUE
);
2019 if (indx
== (bfd_size_type
) -1
2020 || ! elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
2024 if (auxiliary_filters
!= NULL
)
2026 const char * const *p
;
2028 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
2032 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
2034 if (indx
== (bfd_size_type
) -1
2035 || ! elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
2041 eif
.verdefs
= verdefs
;
2044 /* If we are supposed to export all symbols into the dynamic symbol
2045 table (this is not the normal case), then do so. */
2046 if (info
->export_dynamic
)
2048 elf_link_hash_traverse (elf_hash_table (info
),
2049 _bfd_elf_export_symbol
,
2055 /* Make all global versions with definiton. */
2056 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2057 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
2058 if (!d
->symver
&& strchr (d
->pattern
, '*') == NULL
)
2060 const char *verstr
, *name
;
2061 size_t namelen
, verlen
, newlen
;
2063 struct elf_link_hash_entry
*newh
;
2066 namelen
= strlen (name
);
2068 verlen
= strlen (verstr
);
2069 newlen
= namelen
+ verlen
+ 3;
2071 newname
= bfd_malloc (newlen
);
2072 if (newname
== NULL
)
2074 memcpy (newname
, name
, namelen
);
2076 /* Check the hidden versioned definition. */
2077 p
= newname
+ namelen
;
2079 memcpy (p
, verstr
, verlen
+ 1);
2080 newh
= elf_link_hash_lookup (elf_hash_table (info
),
2081 newname
, FALSE
, FALSE
,
2084 || (newh
->root
.type
!= bfd_link_hash_defined
2085 && newh
->root
.type
!= bfd_link_hash_defweak
))
2087 /* Check the default versioned definition. */
2089 memcpy (p
, verstr
, verlen
+ 1);
2090 newh
= elf_link_hash_lookup (elf_hash_table (info
),
2091 newname
, FALSE
, FALSE
,
2096 /* Mark this version if there is a definition and it is
2097 not defined in a shared object. */
2099 && ((newh
->elf_link_hash_flags
2100 & ELF_LINK_HASH_DEF_DYNAMIC
) == 0)
2101 && (newh
->root
.type
== bfd_link_hash_defined
2102 || newh
->root
.type
== bfd_link_hash_defweak
))
2106 /* Attach all the symbols to their version information. */
2107 asvinfo
.output_bfd
= output_bfd
;
2108 asvinfo
.info
= info
;
2109 asvinfo
.verdefs
= verdefs
;
2110 asvinfo
.failed
= FALSE
;
2112 elf_link_hash_traverse (elf_hash_table (info
),
2113 _bfd_elf_link_assign_sym_version
,
2118 if (!info
->allow_undefined_version
)
2120 /* Check if all global versions have a definiton. */
2122 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2123 for (d
= t
->globals
; d
!= NULL
; d
= d
->next
)
2124 if (!d
->symver
&& !d
->script
2125 && strchr (d
->pattern
, '*') == NULL
)
2127 (*_bfd_error_handler
)
2128 (_("%s: undefined version: %s"),
2129 d
->pattern
, t
->name
);
2130 all_defined
= FALSE
;
2135 bfd_set_error (bfd_error_bad_value
);
2140 /* Find all symbols which were defined in a dynamic object and make
2141 the backend pick a reasonable value for them. */
2142 elf_link_hash_traverse (elf_hash_table (info
),
2143 _bfd_elf_adjust_dynamic_symbol
,
2148 /* Add some entries to the .dynamic section. We fill in some of the
2149 values later, in elf_bfd_final_link, but we must add the entries
2150 now so that we know the final size of the .dynamic section. */
2152 /* If there are initialization and/or finalization functions to
2153 call then add the corresponding DT_INIT/DT_FINI entries. */
2154 h
= (info
->init_function
2155 ? elf_link_hash_lookup (elf_hash_table (info
),
2156 info
->init_function
, FALSE
,
2160 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2161 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2163 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
2166 h
= (info
->fini_function
2167 ? elf_link_hash_lookup (elf_hash_table (info
),
2168 info
->fini_function
, FALSE
,
2172 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2173 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2175 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
2179 if (bfd_get_section_by_name (output_bfd
, ".preinit_array") != NULL
)
2181 /* DT_PREINIT_ARRAY is not allowed in shared library. */
2182 if (! info
->executable
)
2187 for (sub
= info
->input_bfds
; sub
!= NULL
;
2188 sub
= sub
->link_next
)
2189 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2190 if (elf_section_data (o
)->this_hdr
.sh_type
2191 == SHT_PREINIT_ARRAY
)
2193 (*_bfd_error_handler
)
2194 (_("%s: .preinit_array section is not allowed in DSO"),
2195 bfd_archive_filename (sub
));
2199 bfd_set_error (bfd_error_nonrepresentable_section
);
2203 if (!elf_add_dynamic_entry (info
, DT_PREINIT_ARRAY
, 0)
2204 || !elf_add_dynamic_entry (info
, DT_PREINIT_ARRAYSZ
, 0))
2207 if (bfd_get_section_by_name (output_bfd
, ".init_array") != NULL
)
2209 if (!elf_add_dynamic_entry (info
, DT_INIT_ARRAY
, 0)
2210 || !elf_add_dynamic_entry (info
, DT_INIT_ARRAYSZ
, 0))
2213 if (bfd_get_section_by_name (output_bfd
, ".fini_array") != NULL
)
2215 if (!elf_add_dynamic_entry (info
, DT_FINI_ARRAY
, 0)
2216 || !elf_add_dynamic_entry (info
, DT_FINI_ARRAYSZ
, 0))
2220 dynstr
= bfd_get_section_by_name (dynobj
, ".dynstr");
2221 /* If .dynstr is excluded from the link, we don't want any of
2222 these tags. Strictly, we should be checking each section
2223 individually; This quick check covers for the case where
2224 someone does a /DISCARD/ : { *(*) }. */
2225 if (dynstr
!= NULL
&& dynstr
->output_section
!= bfd_abs_section_ptr
)
2227 bfd_size_type strsize
;
2229 strsize
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
2230 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
2231 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
2232 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
2233 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
2234 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
2235 sizeof (Elf_External_Sym
)))
2240 /* The backend must work out the sizes of all the other dynamic
2242 if (bed
->elf_backend_size_dynamic_sections
2243 && ! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
2246 if (elf_hash_table (info
)->dynamic_sections_created
)
2248 bfd_size_type dynsymcount
;
2250 size_t bucketcount
= 0;
2251 size_t hash_entry_size
;
2252 unsigned int dtagcount
;
2254 /* Set up the version definition section. */
2255 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
2256 BFD_ASSERT (s
!= NULL
);
2258 /* We may have created additional version definitions if we are
2259 just linking a regular application. */
2260 verdefs
= asvinfo
.verdefs
;
2262 /* Skip anonymous version tag. */
2263 if (verdefs
!= NULL
&& verdefs
->vernum
== 0)
2264 verdefs
= verdefs
->next
;
2266 if (verdefs
== NULL
)
2267 _bfd_strip_section_from_output (info
, s
);
2272 struct bfd_elf_version_tree
*t
;
2274 Elf_Internal_Verdef def
;
2275 Elf_Internal_Verdaux defaux
;
2280 /* Make space for the base version. */
2281 size
+= sizeof (Elf_External_Verdef
);
2282 size
+= sizeof (Elf_External_Verdaux
);
2285 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2287 struct bfd_elf_version_deps
*n
;
2289 size
+= sizeof (Elf_External_Verdef
);
2290 size
+= sizeof (Elf_External_Verdaux
);
2293 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2294 size
+= sizeof (Elf_External_Verdaux
);
2297 s
->_raw_size
= size
;
2298 s
->contents
= bfd_alloc (output_bfd
, s
->_raw_size
);
2299 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2302 /* Fill in the version definition section. */
2306 def
.vd_version
= VER_DEF_CURRENT
;
2307 def
.vd_flags
= VER_FLG_BASE
;
2310 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2311 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2312 + sizeof (Elf_External_Verdaux
));
2314 if (soname_indx
!= (bfd_size_type
) -1)
2316 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
2318 def
.vd_hash
= bfd_elf_hash (soname
);
2319 defaux
.vda_name
= soname_indx
;
2326 name
= basename (output_bfd
->filename
);
2327 def
.vd_hash
= bfd_elf_hash (name
);
2328 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
2330 if (indx
== (bfd_size_type
) -1)
2332 defaux
.vda_name
= indx
;
2334 defaux
.vda_next
= 0;
2336 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2337 (Elf_External_Verdef
*) p
);
2338 p
+= sizeof (Elf_External_Verdef
);
2339 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2340 (Elf_External_Verdaux
*) p
);
2341 p
+= sizeof (Elf_External_Verdaux
);
2343 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
2346 struct bfd_elf_version_deps
*n
;
2347 struct elf_link_hash_entry
*h
;
2348 struct bfd_link_hash_entry
*bh
;
2351 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2354 /* Add a symbol representing this version. */
2356 if (! (_bfd_generic_link_add_one_symbol
2357 (info
, dynobj
, t
->name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
2359 get_elf_backend_data (dynobj
)->collect
, &bh
)))
2361 h
= (struct elf_link_hash_entry
*) bh
;
2362 h
->elf_link_hash_flags
&= ~ ELF_LINK_NON_ELF
;
2363 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2364 h
->type
= STT_OBJECT
;
2365 h
->verinfo
.vertree
= t
;
2367 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2370 def
.vd_version
= VER_DEF_CURRENT
;
2372 if (t
->globals
== NULL
&& t
->locals
== NULL
&& ! t
->used
)
2373 def
.vd_flags
|= VER_FLG_WEAK
;
2374 def
.vd_ndx
= t
->vernum
+ 1;
2375 def
.vd_cnt
= cdeps
+ 1;
2376 def
.vd_hash
= bfd_elf_hash (t
->name
);
2377 def
.vd_aux
= sizeof (Elf_External_Verdef
);
2378 if (t
->next
!= NULL
)
2379 def
.vd_next
= (sizeof (Elf_External_Verdef
)
2380 + (cdeps
+ 1) * sizeof (Elf_External_Verdaux
));
2384 _bfd_elf_swap_verdef_out (output_bfd
, &def
,
2385 (Elf_External_Verdef
*) p
);
2386 p
+= sizeof (Elf_External_Verdef
);
2388 defaux
.vda_name
= h
->dynstr_index
;
2389 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
2391 if (t
->deps
== NULL
)
2392 defaux
.vda_next
= 0;
2394 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2395 t
->name_indx
= defaux
.vda_name
;
2397 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2398 (Elf_External_Verdaux
*) p
);
2399 p
+= sizeof (Elf_External_Verdaux
);
2401 for (n
= t
->deps
; n
!= NULL
; n
= n
->next
)
2403 if (n
->version_needed
== NULL
)
2405 /* This can happen if there was an error in the
2407 defaux
.vda_name
= 0;
2411 defaux
.vda_name
= n
->version_needed
->name_indx
;
2412 _bfd_elf_strtab_addref (elf_hash_table (info
)->dynstr
,
2415 if (n
->next
== NULL
)
2416 defaux
.vda_next
= 0;
2418 defaux
.vda_next
= sizeof (Elf_External_Verdaux
);
2420 _bfd_elf_swap_verdaux_out (output_bfd
, &defaux
,
2421 (Elf_External_Verdaux
*) p
);
2422 p
+= sizeof (Elf_External_Verdaux
);
2426 if (! elf_add_dynamic_entry (info
, DT_VERDEF
, 0)
2427 || ! elf_add_dynamic_entry (info
, DT_VERDEFNUM
, cdefs
))
2430 elf_tdata (output_bfd
)->cverdefs
= cdefs
;
2433 if ((info
->new_dtags
&& info
->flags
) || (info
->flags
& DF_STATIC_TLS
))
2435 if (! elf_add_dynamic_entry (info
, DT_FLAGS
, info
->flags
))
2441 if (info
->executable
)
2442 info
->flags_1
&= ~ (DF_1_INITFIRST
2445 if (! elf_add_dynamic_entry (info
, DT_FLAGS_1
, info
->flags_1
))
2449 /* Work out the size of the version reference section. */
2451 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
2452 BFD_ASSERT (s
!= NULL
);
2454 struct elf_find_verdep_info sinfo
;
2456 sinfo
.output_bfd
= output_bfd
;
2458 sinfo
.vers
= elf_tdata (output_bfd
)->cverdefs
;
2459 if (sinfo
.vers
== 0)
2461 sinfo
.failed
= FALSE
;
2463 elf_link_hash_traverse (elf_hash_table (info
),
2464 _bfd_elf_link_find_version_dependencies
,
2467 if (elf_tdata (output_bfd
)->verref
== NULL
)
2468 _bfd_strip_section_from_output (info
, s
);
2471 Elf_Internal_Verneed
*t
;
2476 /* Build the version definition section. */
2479 for (t
= elf_tdata (output_bfd
)->verref
;
2483 Elf_Internal_Vernaux
*a
;
2485 size
+= sizeof (Elf_External_Verneed
);
2487 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2488 size
+= sizeof (Elf_External_Vernaux
);
2491 s
->_raw_size
= size
;
2492 s
->contents
= bfd_alloc (output_bfd
, s
->_raw_size
);
2493 if (s
->contents
== NULL
)
2497 for (t
= elf_tdata (output_bfd
)->verref
;
2502 Elf_Internal_Vernaux
*a
;
2506 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2509 t
->vn_version
= VER_NEED_CURRENT
;
2511 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
2512 elf_dt_name (t
->vn_bfd
) != NULL
2513 ? elf_dt_name (t
->vn_bfd
)
2514 : basename (t
->vn_bfd
->filename
),
2516 if (indx
== (bfd_size_type
) -1)
2519 t
->vn_aux
= sizeof (Elf_External_Verneed
);
2520 if (t
->vn_nextref
== NULL
)
2523 t
->vn_next
= (sizeof (Elf_External_Verneed
)
2524 + caux
* sizeof (Elf_External_Vernaux
));
2526 _bfd_elf_swap_verneed_out (output_bfd
, t
,
2527 (Elf_External_Verneed
*) p
);
2528 p
+= sizeof (Elf_External_Verneed
);
2530 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
2532 a
->vna_hash
= bfd_elf_hash (a
->vna_nodename
);
2533 indx
= _bfd_elf_strtab_add (elf_hash_table (info
)->dynstr
,
2534 a
->vna_nodename
, FALSE
);
2535 if (indx
== (bfd_size_type
) -1)
2538 if (a
->vna_nextptr
== NULL
)
2541 a
->vna_next
= sizeof (Elf_External_Vernaux
);
2543 _bfd_elf_swap_vernaux_out (output_bfd
, a
,
2544 (Elf_External_Vernaux
*) p
);
2545 p
+= sizeof (Elf_External_Vernaux
);
2549 if (! elf_add_dynamic_entry (info
, DT_VERNEED
, 0)
2550 || ! elf_add_dynamic_entry (info
, DT_VERNEEDNUM
, crefs
))
2553 elf_tdata (output_bfd
)->cverrefs
= crefs
;
2557 /* Assign dynsym indicies. In a shared library we generate a
2558 section symbol for each output section, which come first.
2559 Next come all of the back-end allocated local dynamic syms,
2560 followed by the rest of the global symbols. */
2562 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
);
2564 /* Work out the size of the symbol version section. */
2565 s
= bfd_get_section_by_name (dynobj
, ".gnu.version");
2566 BFD_ASSERT (s
!= NULL
);
2567 if (dynsymcount
== 0
2568 || (verdefs
== NULL
&& elf_tdata (output_bfd
)->verref
== NULL
))
2570 _bfd_strip_section_from_output (info
, s
);
2571 /* The DYNSYMCOUNT might have changed if we were going to
2572 output a dynamic symbol table entry for S. */
2573 dynsymcount
= _bfd_elf_link_renumber_dynsyms (output_bfd
, info
);
2577 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Versym
);
2578 s
->contents
= bfd_zalloc (output_bfd
, s
->_raw_size
);
2579 if (s
->contents
== NULL
)
2582 if (! elf_add_dynamic_entry (info
, DT_VERSYM
, 0))
2586 /* Set the size of the .dynsym and .hash sections. We counted
2587 the number of dynamic symbols in elf_link_add_object_symbols.
2588 We will build the contents of .dynsym and .hash when we build
2589 the final symbol table, because until then we do not know the
2590 correct value to give the symbols. We built the .dynstr
2591 section as we went along in elf_link_add_object_symbols. */
2592 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
2593 BFD_ASSERT (s
!= NULL
);
2594 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
2595 s
->contents
= bfd_alloc (output_bfd
, s
->_raw_size
);
2596 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2599 if (dynsymcount
!= 0)
2601 Elf_Internal_Sym isym
;
2603 /* The first entry in .dynsym is a dummy symbol. */
2610 elf_swap_symbol_out (output_bfd
, &isym
, s
->contents
, 0);
2613 /* Compute the size of the hashing table. As a side effect this
2614 computes the hash values for all the names we export. */
2615 bucketcount
= compute_bucket_count (info
);
2617 s
= bfd_get_section_by_name (dynobj
, ".hash");
2618 BFD_ASSERT (s
!= NULL
);
2619 hash_entry_size
= elf_section_data (s
)->this_hdr
.sh_entsize
;
2620 s
->_raw_size
= ((2 + bucketcount
+ dynsymcount
) * hash_entry_size
);
2621 s
->contents
= bfd_zalloc (output_bfd
, s
->_raw_size
);
2622 if (s
->contents
== NULL
)
2625 bfd_put (8 * hash_entry_size
, output_bfd
, bucketcount
, s
->contents
);
2626 bfd_put (8 * hash_entry_size
, output_bfd
, dynsymcount
,
2627 s
->contents
+ hash_entry_size
);
2629 elf_hash_table (info
)->bucketcount
= bucketcount
;
2631 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
2632 BFD_ASSERT (s
!= NULL
);
2634 elf_finalize_dynstr (output_bfd
, info
);
2636 s
->_raw_size
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
2638 for (dtagcount
= 0; dtagcount
<= info
->spare_dynamic_tags
; ++dtagcount
)
2639 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
2646 /* This function is used to adjust offsets into .dynstr for
2647 dynamic symbols. This is called via elf_link_hash_traverse. */
2650 elf_adjust_dynstr_offsets (struct elf_link_hash_entry
*h
, void *data
)
2652 struct elf_strtab_hash
*dynstr
= data
;
2654 if (h
->root
.type
== bfd_link_hash_warning
)
2655 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2657 if (h
->dynindx
!= -1)
2658 h
->dynstr_index
= _bfd_elf_strtab_offset (dynstr
, h
->dynstr_index
);
2662 /* Assign string offsets in .dynstr, update all structures referencing
2666 elf_finalize_dynstr (bfd
*output_bfd
, struct bfd_link_info
*info
)
2668 struct elf_link_local_dynamic_entry
*entry
;
2669 struct elf_strtab_hash
*dynstr
= elf_hash_table (info
)->dynstr
;
2670 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
2673 Elf_External_Dyn
*dyncon
, *dynconend
;
2675 _bfd_elf_strtab_finalize (dynstr
);
2676 size
= _bfd_elf_strtab_size (dynstr
);
2678 /* Update all .dynamic entries referencing .dynstr strings. */
2679 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2680 BFD_ASSERT (sdyn
!= NULL
);
2682 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
2683 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
2685 for (; dyncon
< dynconend
; dyncon
++)
2687 Elf_Internal_Dyn dyn
;
2689 elf_swap_dyn_in (dynobj
, dyncon
, & dyn
);
2693 dyn
.d_un
.d_val
= size
;
2694 elf_swap_dyn_out (dynobj
, & dyn
, dyncon
);
2702 dyn
.d_un
.d_val
= _bfd_elf_strtab_offset (dynstr
, dyn
.d_un
.d_val
);
2703 elf_swap_dyn_out (dynobj
, & dyn
, dyncon
);
2710 /* Now update local dynamic symbols. */
2711 for (entry
= elf_hash_table (info
)->dynlocal
; entry
; entry
= entry
->next
)
2712 entry
->isym
.st_name
= _bfd_elf_strtab_offset (dynstr
,
2713 entry
->isym
.st_name
);
2715 /* And the rest of dynamic symbols. */
2716 elf_link_hash_traverse (elf_hash_table (info
),
2717 elf_adjust_dynstr_offsets
, dynstr
);
2719 /* Adjust version definitions. */
2720 if (elf_tdata (output_bfd
)->cverdefs
)
2725 Elf_Internal_Verdef def
;
2726 Elf_Internal_Verdaux defaux
;
2728 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_d");
2729 p
= (bfd_byte
*) s
->contents
;
2732 _bfd_elf_swap_verdef_in (output_bfd
, (Elf_External_Verdef
*) p
,
2734 p
+= sizeof (Elf_External_Verdef
);
2735 for (i
= 0; i
< def
.vd_cnt
; ++i
)
2737 _bfd_elf_swap_verdaux_in (output_bfd
,
2738 (Elf_External_Verdaux
*) p
, &defaux
);
2739 defaux
.vda_name
= _bfd_elf_strtab_offset (dynstr
,
2741 _bfd_elf_swap_verdaux_out (output_bfd
,
2742 &defaux
, (Elf_External_Verdaux
*) p
);
2743 p
+= sizeof (Elf_External_Verdaux
);
2746 while (def
.vd_next
);
2749 /* Adjust version references. */
2750 if (elf_tdata (output_bfd
)->verref
)
2755 Elf_Internal_Verneed need
;
2756 Elf_Internal_Vernaux needaux
;
2758 s
= bfd_get_section_by_name (dynobj
, ".gnu.version_r");
2759 p
= (bfd_byte
*) s
->contents
;
2762 _bfd_elf_swap_verneed_in (output_bfd
, (Elf_External_Verneed
*) p
,
2764 need
.vn_file
= _bfd_elf_strtab_offset (dynstr
, need
.vn_file
);
2765 _bfd_elf_swap_verneed_out (output_bfd
, &need
,
2766 (Elf_External_Verneed
*) p
);
2767 p
+= sizeof (Elf_External_Verneed
);
2768 for (i
= 0; i
< need
.vn_cnt
; ++i
)
2770 _bfd_elf_swap_vernaux_in (output_bfd
,
2771 (Elf_External_Vernaux
*) p
, &needaux
);
2772 needaux
.vna_name
= _bfd_elf_strtab_offset (dynstr
,
2774 _bfd_elf_swap_vernaux_out (output_bfd
,
2776 (Elf_External_Vernaux
*) p
);
2777 p
+= sizeof (Elf_External_Vernaux
);
2780 while (need
.vn_next
);
2786 /* Final phase of ELF linker. */
2788 /* A structure we use to avoid passing large numbers of arguments. */
2790 struct elf_final_link_info
2792 /* General link information. */
2793 struct bfd_link_info
*info
;
2796 /* Symbol string table. */
2797 struct bfd_strtab_hash
*symstrtab
;
2798 /* .dynsym section. */
2799 asection
*dynsym_sec
;
2800 /* .hash section. */
2802 /* symbol version section (.gnu.version). */
2803 asection
*symver_sec
;
2804 /* first SHF_TLS section (if any). */
2805 asection
*first_tls_sec
;
2806 /* Buffer large enough to hold contents of any section. */
2808 /* Buffer large enough to hold external relocs of any section. */
2809 void *external_relocs
;
2810 /* Buffer large enough to hold internal relocs of any section. */
2811 Elf_Internal_Rela
*internal_relocs
;
2812 /* Buffer large enough to hold external local symbols of any input
2814 Elf_External_Sym
*external_syms
;
2815 /* And a buffer for symbol section indices. */
2816 Elf_External_Sym_Shndx
*locsym_shndx
;
2817 /* Buffer large enough to hold internal local symbols of any input
2819 Elf_Internal_Sym
*internal_syms
;
2820 /* Array large enough to hold a symbol index for each local symbol
2821 of any input BFD. */
2823 /* Array large enough to hold a section pointer for each local
2824 symbol of any input BFD. */
2825 asection
**sections
;
2826 /* Buffer to hold swapped out symbols. */
2827 Elf_External_Sym
*symbuf
;
2828 /* And one for symbol section indices. */
2829 Elf_External_Sym_Shndx
*symshndxbuf
;
2830 /* Number of swapped out symbols in buffer. */
2831 size_t symbuf_count
;
2832 /* Number of symbols which fit in symbuf. */
2834 /* And same for symshndxbuf. */
2835 size_t shndxbuf_size
;
2838 static bfd_boolean elf_link_output_sym
2839 (struct elf_final_link_info
*, const char *, Elf_Internal_Sym
*, asection
*);
2840 static bfd_boolean elf_link_flush_output_syms
2841 (struct elf_final_link_info
*);
2842 static bfd_boolean elf_link_output_extsym
2843 (struct elf_link_hash_entry
*, void *);
2844 static bfd_boolean elf_link_input_bfd
2845 (struct elf_final_link_info
*, bfd
*);
2846 static bfd_boolean elf_reloc_link_order
2847 (bfd
*, struct bfd_link_info
*, asection
*, struct bfd_link_order
*);
2849 /* This struct is used to pass information to elf_link_output_extsym. */
2851 struct elf_outext_info
2854 bfd_boolean localsyms
;
2855 struct elf_final_link_info
*finfo
;
2858 /* When performing a relocatable link, the input relocations are
2859 preserved. But, if they reference global symbols, the indices
2860 referenced must be updated. Update all the relocations in
2861 REL_HDR (there are COUNT of them), using the data in REL_HASH. */
2864 elf_link_adjust_relocs (bfd
*abfd
,
2865 Elf_Internal_Shdr
*rel_hdr
,
2867 struct elf_link_hash_entry
**rel_hash
)
2870 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2872 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2873 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2875 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2877 swap_in
= bed
->s
->swap_reloc_in
;
2878 swap_out
= bed
->s
->swap_reloc_out
;
2880 else if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
))
2882 swap_in
= bed
->s
->swap_reloca_in
;
2883 swap_out
= bed
->s
->swap_reloca_out
;
2888 if (bed
->s
->int_rels_per_ext_rel
> MAX_INT_RELS_PER_EXT_REL
)
2891 erela
= rel_hdr
->contents
;
2892 for (i
= 0; i
< count
; i
++, rel_hash
++, erela
+= rel_hdr
->sh_entsize
)
2894 Elf_Internal_Rela irela
[MAX_INT_RELS_PER_EXT_REL
];
2897 if (*rel_hash
== NULL
)
2900 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2902 (*swap_in
) (abfd
, erela
, irela
);
2903 for (j
= 0; j
< bed
->s
->int_rels_per_ext_rel
; j
++)
2904 irela
[j
].r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2905 ELF_R_TYPE (irela
[j
].r_info
));
2906 (*swap_out
) (abfd
, irela
, erela
);
2910 struct elf_link_sort_rela
2913 enum elf_reloc_type_class type
;
2914 /* We use this as an array of size int_rels_per_ext_rel. */
2915 Elf_Internal_Rela rela
[1];
2919 elf_link_sort_cmp1 (const void *A
, const void *B
)
2921 const struct elf_link_sort_rela
*a
= A
;
2922 const struct elf_link_sort_rela
*b
= B
;
2923 int relativea
, relativeb
;
2925 relativea
= a
->type
== reloc_class_relative
;
2926 relativeb
= b
->type
== reloc_class_relative
;
2928 if (relativea
< relativeb
)
2930 if (relativea
> relativeb
)
2932 if (ELF_R_SYM (a
->rela
->r_info
) < ELF_R_SYM (b
->rela
->r_info
))
2934 if (ELF_R_SYM (a
->rela
->r_info
) > ELF_R_SYM (b
->rela
->r_info
))
2936 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
2938 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
2944 elf_link_sort_cmp2 (const void *A
, const void *B
)
2946 const struct elf_link_sort_rela
*a
= A
;
2947 const struct elf_link_sort_rela
*b
= B
;
2950 if (a
->offset
< b
->offset
)
2952 if (a
->offset
> b
->offset
)
2954 copya
= (a
->type
== reloc_class_copy
) * 2 + (a
->type
== reloc_class_plt
);
2955 copyb
= (b
->type
== reloc_class_copy
) * 2 + (b
->type
== reloc_class_plt
);
2960 if (a
->rela
->r_offset
< b
->rela
->r_offset
)
2962 if (a
->rela
->r_offset
> b
->rela
->r_offset
)
2968 elf_link_sort_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
**psec
)
2971 bfd_size_type count
, size
;
2972 size_t i
, ret
, sort_elt
, ext_size
;
2973 bfd_byte
*sort
, *s_non_relative
, *p
;
2974 struct elf_link_sort_rela
*sq
;
2975 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2976 int i2e
= bed
->s
->int_rels_per_ext_rel
;
2977 void (*swap_in
) (bfd
*, const bfd_byte
*, Elf_Internal_Rela
*);
2978 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
2979 struct bfd_link_order
*lo
;
2981 reldyn
= bfd_get_section_by_name (abfd
, ".rela.dyn");
2982 if (reldyn
== NULL
|| reldyn
->_raw_size
== 0)
2984 reldyn
= bfd_get_section_by_name (abfd
, ".rel.dyn");
2985 if (reldyn
== NULL
|| reldyn
->_raw_size
== 0)
2987 ext_size
= sizeof (Elf_External_Rel
);
2988 swap_in
= bed
->s
->swap_reloc_in
;
2989 swap_out
= bed
->s
->swap_reloc_out
;
2993 ext_size
= sizeof (Elf_External_Rela
);
2994 swap_in
= bed
->s
->swap_reloca_in
;
2995 swap_out
= bed
->s
->swap_reloca_out
;
2997 count
= reldyn
->_raw_size
/ ext_size
;
3000 for (lo
= reldyn
->link_order_head
; lo
!= NULL
; lo
= lo
->next
)
3001 if (lo
->type
== bfd_indirect_link_order
)
3003 asection
*o
= lo
->u
.indirect
.section
;
3004 size
+= o
->_raw_size
;
3007 if (size
!= reldyn
->_raw_size
)
3010 sort_elt
= (sizeof (struct elf_link_sort_rela
)
3011 + (i2e
- 1) * sizeof (Elf_Internal_Rela
));
3012 sort
= bfd_zmalloc (sort_elt
* count
);
3015 (*info
->callbacks
->warning
)
3016 (info
, _("Not enough memory to sort relocations"), 0, abfd
, 0, 0);
3020 for (lo
= reldyn
->link_order_head
; lo
!= NULL
; lo
= lo
->next
)
3021 if (lo
->type
== bfd_indirect_link_order
)
3023 bfd_byte
*erel
, *erelend
;
3024 asection
*o
= lo
->u
.indirect
.section
;
3027 erelend
= o
->contents
+ o
->_raw_size
;
3028 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
3029 while (erel
< erelend
)
3031 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
3032 (*swap_in
) (abfd
, erel
, s
->rela
);
3033 s
->type
= (*bed
->elf_backend_reloc_type_class
) (s
->rela
);
3039 qsort (sort
, count
, sort_elt
, elf_link_sort_cmp1
);
3041 for (i
= 0, p
= sort
; i
< count
; i
++, p
+= sort_elt
)
3043 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
3044 if (s
->type
!= reloc_class_relative
)
3050 sq
= (struct elf_link_sort_rela
*) s_non_relative
;
3051 for (; i
< count
; i
++, p
+= sort_elt
)
3053 struct elf_link_sort_rela
*sp
= (struct elf_link_sort_rela
*) p
;
3054 if (ELF_R_SYM (sp
->rela
->r_info
) != ELF_R_SYM (sq
->rela
->r_info
))
3056 sp
->offset
= sq
->rela
->r_offset
;
3059 qsort (s_non_relative
, count
- ret
, sort_elt
, elf_link_sort_cmp2
);
3061 for (lo
= reldyn
->link_order_head
; lo
!= NULL
; lo
= lo
->next
)
3062 if (lo
->type
== bfd_indirect_link_order
)
3064 bfd_byte
*erel
, *erelend
;
3065 asection
*o
= lo
->u
.indirect
.section
;
3068 erelend
= o
->contents
+ o
->_raw_size
;
3069 p
= sort
+ o
->output_offset
/ ext_size
* sort_elt
;
3070 while (erel
< erelend
)
3072 struct elf_link_sort_rela
*s
= (struct elf_link_sort_rela
*) p
;
3073 (*swap_out
) (abfd
, s
->rela
, erel
);
3084 /* Do the final step of an ELF link. */
3087 elf_bfd_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3089 bfd_boolean dynamic
;
3090 bfd_boolean emit_relocs
;
3092 struct elf_final_link_info finfo
;
3093 register asection
*o
;
3094 register struct bfd_link_order
*p
;
3096 bfd_size_type max_contents_size
;
3097 bfd_size_type max_external_reloc_size
;
3098 bfd_size_type max_internal_reloc_count
;
3099 bfd_size_type max_sym_count
;
3100 bfd_size_type max_sym_shndx_count
;
3102 Elf_Internal_Sym elfsym
;
3104 Elf_Internal_Shdr
*symtab_hdr
;
3105 Elf_Internal_Shdr
*symtab_shndx_hdr
;
3106 Elf_Internal_Shdr
*symstrtab_hdr
;
3107 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3108 struct elf_outext_info eoinfo
;
3110 size_t relativecount
= 0;
3111 asection
*reldyn
= 0;
3114 if (! is_elf_hash_table (info
))
3118 abfd
->flags
|= DYNAMIC
;
3120 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
3121 dynobj
= elf_hash_table (info
)->dynobj
;
3123 emit_relocs
= (info
->relocatable
3124 || info
->emitrelocations
3125 || bed
->elf_backend_emit_relocs
);
3128 finfo
.output_bfd
= abfd
;
3129 finfo
.symstrtab
= elf_stringtab_init ();
3130 if (finfo
.symstrtab
== NULL
)
3135 finfo
.dynsym_sec
= NULL
;
3136 finfo
.hash_sec
= NULL
;
3137 finfo
.symver_sec
= NULL
;
3141 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
3142 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
3143 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
3144 finfo
.symver_sec
= bfd_get_section_by_name (dynobj
, ".gnu.version");
3145 /* Note that it is OK if symver_sec is NULL. */
3148 finfo
.contents
= NULL
;
3149 finfo
.external_relocs
= NULL
;
3150 finfo
.internal_relocs
= NULL
;
3151 finfo
.external_syms
= NULL
;
3152 finfo
.locsym_shndx
= NULL
;
3153 finfo
.internal_syms
= NULL
;
3154 finfo
.indices
= NULL
;
3155 finfo
.sections
= NULL
;
3156 finfo
.symbuf
= NULL
;
3157 finfo
.symshndxbuf
= NULL
;
3158 finfo
.symbuf_count
= 0;
3159 finfo
.shndxbuf_size
= 0;
3160 finfo
.first_tls_sec
= NULL
;
3161 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3162 if ((o
->flags
& SEC_THREAD_LOCAL
) != 0
3163 && (o
->flags
& SEC_LOAD
) != 0)
3165 finfo
.first_tls_sec
= o
;
3169 /* Count up the number of relocations we will output for each output
3170 section, so that we know the sizes of the reloc sections. We
3171 also figure out some maximum sizes. */
3172 max_contents_size
= 0;
3173 max_external_reloc_size
= 0;
3174 max_internal_reloc_count
= 0;
3176 max_sym_shndx_count
= 0;
3178 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3180 struct bfd_elf_section_data
*esdo
= elf_section_data (o
);
3183 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3185 unsigned int reloc_count
= 0;
3186 struct bfd_elf_section_data
*esdi
= NULL
;
3187 unsigned int *rel_count1
;
3189 if (p
->type
== bfd_section_reloc_link_order
3190 || p
->type
== bfd_symbol_reloc_link_order
)
3192 else if (p
->type
== bfd_indirect_link_order
)
3196 sec
= p
->u
.indirect
.section
;
3197 esdi
= elf_section_data (sec
);
3199 /* Mark all sections which are to be included in the
3200 link. This will normally be every section. We need
3201 to do this so that we can identify any sections which
3202 the linker has decided to not include. */
3203 sec
->linker_mark
= TRUE
;
3205 if (sec
->flags
& SEC_MERGE
)
3208 if (info
->relocatable
|| info
->emitrelocations
)
3209 reloc_count
= sec
->reloc_count
;
3210 else if (bed
->elf_backend_count_relocs
)
3212 Elf_Internal_Rela
* relocs
;
3214 relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
3217 reloc_count
= (*bed
->elf_backend_count_relocs
) (sec
, relocs
);
3219 if (elf_section_data (o
)->relocs
!= relocs
)
3223 if (sec
->_raw_size
> max_contents_size
)
3224 max_contents_size
= sec
->_raw_size
;
3225 if (sec
->_cooked_size
> max_contents_size
)
3226 max_contents_size
= sec
->_cooked_size
;
3228 /* We are interested in just local symbols, not all
3230 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
3231 && (sec
->owner
->flags
& DYNAMIC
) == 0)
3235 if (elf_bad_symtab (sec
->owner
))
3236 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
3237 / sizeof (Elf_External_Sym
));
3239 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
3241 if (sym_count
> max_sym_count
)
3242 max_sym_count
= sym_count
;
3244 if (sym_count
> max_sym_shndx_count
3245 && elf_symtab_shndx (sec
->owner
) != 0)
3246 max_sym_shndx_count
= sym_count
;
3248 if ((sec
->flags
& SEC_RELOC
) != 0)
3252 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
3253 if (ext_size
> max_external_reloc_size
)
3254 max_external_reloc_size
= ext_size
;
3255 if (sec
->reloc_count
> max_internal_reloc_count
)
3256 max_internal_reloc_count
= sec
->reloc_count
;
3261 if (reloc_count
== 0)
3264 o
->reloc_count
+= reloc_count
;
3266 /* MIPS may have a mix of REL and RELA relocs on sections.
3267 To support this curious ABI we keep reloc counts in
3268 elf_section_data too. We must be careful to add the
3269 relocations from the input section to the right output
3270 count. FIXME: Get rid of one count. We have
3271 o->reloc_count == esdo->rel_count + esdo->rel_count2. */
3272 rel_count1
= &esdo
->rel_count
;
3275 bfd_boolean same_size
;
3276 bfd_size_type entsize1
;
3278 entsize1
= esdi
->rel_hdr
.sh_entsize
;
3279 BFD_ASSERT (entsize1
== sizeof (Elf_External_Rel
)
3280 || entsize1
== sizeof (Elf_External_Rela
));
3281 same_size
= (!o
->use_rela_p
3282 == (entsize1
== sizeof (Elf_External_Rel
)));
3285 rel_count1
= &esdo
->rel_count2
;
3287 if (esdi
->rel_hdr2
!= NULL
)
3289 bfd_size_type entsize2
= esdi
->rel_hdr2
->sh_entsize
;
3290 unsigned int alt_count
;
3291 unsigned int *rel_count2
;
3293 BFD_ASSERT (entsize2
!= entsize1
3294 && (entsize2
== sizeof (Elf_External_Rel
)
3295 || entsize2
== sizeof (Elf_External_Rela
)));
3297 rel_count2
= &esdo
->rel_count2
;
3299 rel_count2
= &esdo
->rel_count
;
3301 /* The following is probably too simplistic if the
3302 backend counts output relocs unusually. */
3303 BFD_ASSERT (bed
->elf_backend_count_relocs
== NULL
);
3304 alt_count
= NUM_SHDR_ENTRIES (esdi
->rel_hdr2
);
3305 *rel_count2
+= alt_count
;
3306 reloc_count
-= alt_count
;
3309 *rel_count1
+= reloc_count
;
3312 if (o
->reloc_count
> 0)
3313 o
->flags
|= SEC_RELOC
;
3316 /* Explicitly clear the SEC_RELOC flag. The linker tends to
3317 set it (this is probably a bug) and if it is set
3318 assign_section_numbers will create a reloc section. */
3319 o
->flags
&=~ SEC_RELOC
;
3322 /* If the SEC_ALLOC flag is not set, force the section VMA to
3323 zero. This is done in elf_fake_sections as well, but forcing
3324 the VMA to 0 here will ensure that relocs against these
3325 sections are handled correctly. */
3326 if ((o
->flags
& SEC_ALLOC
) == 0
3327 && ! o
->user_set_vma
)
3331 if (! info
->relocatable
&& merged
)
3332 elf_link_hash_traverse (elf_hash_table (info
),
3333 _bfd_elf_link_sec_merge_syms
, abfd
);
3335 /* Figure out the file positions for everything but the symbol table
3336 and the relocs. We set symcount to force assign_section_numbers
3337 to create a symbol table. */
3338 bfd_get_symcount (abfd
) = info
->strip
== strip_all
? 0 : 1;
3339 BFD_ASSERT (! abfd
->output_has_begun
);
3340 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
3343 /* That created the reloc sections. Set their sizes, and assign
3344 them file positions, and allocate some buffers. */
3345 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3347 if ((o
->flags
& SEC_RELOC
) != 0)
3349 if (!(_bfd_elf_link_size_reloc_section
3350 (abfd
, &elf_section_data (o
)->rel_hdr
, o
)))
3353 if (elf_section_data (o
)->rel_hdr2
3354 && !(_bfd_elf_link_size_reloc_section
3355 (abfd
, elf_section_data (o
)->rel_hdr2
, o
)))
3359 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
3360 to count upwards while actually outputting the relocations. */
3361 elf_section_data (o
)->rel_count
= 0;
3362 elf_section_data (o
)->rel_count2
= 0;
3365 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3367 /* We have now assigned file positions for all the sections except
3368 .symtab and .strtab. We start the .symtab section at the current
3369 file position, and write directly to it. We build the .strtab
3370 section in memory. */
3371 bfd_get_symcount (abfd
) = 0;
3372 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3373 /* sh_name is set in prep_headers. */
3374 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3375 /* sh_flags, sh_addr and sh_size all start off zero. */
3376 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
3377 /* sh_link is set in assign_section_numbers. */
3378 /* sh_info is set below. */
3379 /* sh_offset is set just below. */
3380 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
3382 off
= elf_tdata (abfd
)->next_file_pos
;
3383 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, TRUE
);
3385 /* Note that at this point elf_tdata (abfd)->next_file_pos is
3386 incorrect. We do not yet know the size of the .symtab section.
3387 We correct next_file_pos below, after we do know the size. */
3389 /* Allocate a buffer to hold swapped out symbols. This is to avoid
3390 continuously seeking to the right position in the file. */
3391 if (! info
->keep_memory
|| max_sym_count
< 20)
3392 finfo
.symbuf_size
= 20;
3394 finfo
.symbuf_size
= max_sym_count
;
3395 amt
= finfo
.symbuf_size
;
3396 amt
*= sizeof (Elf_External_Sym
);
3397 finfo
.symbuf
= bfd_malloc (amt
);
3398 if (finfo
.symbuf
== NULL
)
3400 if (elf_numsections (abfd
) > SHN_LORESERVE
)
3402 /* Wild guess at number of output symbols. realloc'd as needed. */
3403 amt
= 2 * max_sym_count
+ elf_numsections (abfd
) + 1000;
3404 finfo
.shndxbuf_size
= amt
;
3405 amt
*= sizeof (Elf_External_Sym_Shndx
);
3406 finfo
.symshndxbuf
= bfd_zmalloc (amt
);
3407 if (finfo
.symshndxbuf
== NULL
)
3411 /* Start writing out the symbol table. The first symbol is always a
3413 if (info
->strip
!= strip_all
3416 elfsym
.st_value
= 0;
3419 elfsym
.st_other
= 0;
3420 elfsym
.st_shndx
= SHN_UNDEF
;
3421 if (! elf_link_output_sym (&finfo
, NULL
, &elfsym
, bfd_und_section_ptr
))
3426 /* Some standard ELF linkers do this, but we don't because it causes
3427 bootstrap comparison failures. */
3428 /* Output a file symbol for the output file as the second symbol.
3429 We output this even if we are discarding local symbols, although
3430 I'm not sure if this is correct. */
3431 elfsym
.st_value
= 0;
3433 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3434 elfsym
.st_other
= 0;
3435 elfsym
.st_shndx
= SHN_ABS
;
3436 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
3437 &elfsym
, bfd_abs_section_ptr
))
3441 /* Output a symbol for each section. We output these even if we are
3442 discarding local symbols, since they are used for relocs. These
3443 symbols have no names. We store the index of each one in the
3444 index field of the section, so that we can find it again when
3445 outputting relocs. */
3446 if (info
->strip
!= strip_all
3450 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3451 elfsym
.st_other
= 0;
3452 for (i
= 1; i
< elf_numsections (abfd
); i
++)
3454 o
= section_from_elf_index (abfd
, i
);
3456 o
->target_index
= bfd_get_symcount (abfd
);
3457 elfsym
.st_shndx
= i
;
3458 if (info
->relocatable
|| o
== NULL
)
3459 elfsym
.st_value
= 0;
3461 elfsym
.st_value
= o
->vma
;
3462 if (! elf_link_output_sym (&finfo
, NULL
, &elfsym
, o
))
3464 if (i
== SHN_LORESERVE
- 1)
3465 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3469 /* Allocate some memory to hold information read in from the input
3471 if (max_contents_size
!= 0)
3473 finfo
.contents
= bfd_malloc (max_contents_size
);
3474 if (finfo
.contents
== NULL
)
3478 if (max_external_reloc_size
!= 0)
3480 finfo
.external_relocs
= bfd_malloc (max_external_reloc_size
);
3481 if (finfo
.external_relocs
== NULL
)
3485 if (max_internal_reloc_count
!= 0)
3487 amt
= max_internal_reloc_count
* bed
->s
->int_rels_per_ext_rel
;
3488 amt
*= sizeof (Elf_Internal_Rela
);
3489 finfo
.internal_relocs
= bfd_malloc (amt
);
3490 if (finfo
.internal_relocs
== NULL
)
3494 if (max_sym_count
!= 0)
3496 amt
= max_sym_count
* sizeof (Elf_External_Sym
);
3497 finfo
.external_syms
= bfd_malloc (amt
);
3498 if (finfo
.external_syms
== NULL
)
3501 amt
= max_sym_count
* sizeof (Elf_Internal_Sym
);
3502 finfo
.internal_syms
= bfd_malloc (amt
);
3503 if (finfo
.internal_syms
== NULL
)
3506 amt
= max_sym_count
* sizeof (long);
3507 finfo
.indices
= bfd_malloc (amt
);
3508 if (finfo
.indices
== NULL
)
3511 amt
= max_sym_count
* sizeof (asection
*);
3512 finfo
.sections
= bfd_malloc (amt
);
3513 if (finfo
.sections
== NULL
)
3517 if (max_sym_shndx_count
!= 0)
3519 amt
= max_sym_shndx_count
* sizeof (Elf_External_Sym_Shndx
);
3520 finfo
.locsym_shndx
= bfd_malloc (amt
);
3521 if (finfo
.locsym_shndx
== NULL
)
3525 if (finfo
.first_tls_sec
)
3527 unsigned int align
= 0;
3528 bfd_vma base
= finfo
.first_tls_sec
->vma
, end
= 0;
3531 for (sec
= finfo
.first_tls_sec
;
3532 sec
&& (sec
->flags
& SEC_THREAD_LOCAL
);
3535 bfd_vma size
= sec
->_raw_size
;
3537 if (bfd_get_section_alignment (abfd
, sec
) > align
)
3538 align
= bfd_get_section_alignment (abfd
, sec
);
3539 if (sec
->_raw_size
== 0 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
3541 struct bfd_link_order
*o
;
3544 for (o
= sec
->link_order_head
; o
!= NULL
; o
= o
->next
)
3545 if (size
< o
->offset
+ o
->size
)
3546 size
= o
->offset
+ o
->size
;
3548 end
= sec
->vma
+ size
;
3550 elf_hash_table (info
)->tls_segment
3551 = bfd_zalloc (abfd
, sizeof (struct elf_link_tls_segment
));
3552 if (elf_hash_table (info
)->tls_segment
== NULL
)
3554 elf_hash_table (info
)->tls_segment
->start
= base
;
3555 elf_hash_table (info
)->tls_segment
->size
= end
- base
;
3556 elf_hash_table (info
)->tls_segment
->align
= align
;
3559 /* Since ELF permits relocations to be against local symbols, we
3560 must have the local symbols available when we do the relocations.
3561 Since we would rather only read the local symbols once, and we
3562 would rather not keep them in memory, we handle all the
3563 relocations for a single input file at the same time.
3565 Unfortunately, there is no way to know the total number of local
3566 symbols until we have seen all of them, and the local symbol
3567 indices precede the global symbol indices. This means that when
3568 we are generating relocatable output, and we see a reloc against
3569 a global symbol, we can not know the symbol index until we have
3570 finished examining all the local symbols to see which ones we are
3571 going to output. To deal with this, we keep the relocations in
3572 memory, and don't output them until the end of the link. This is
3573 an unfortunate waste of memory, but I don't see a good way around
3574 it. Fortunately, it only happens when performing a relocatable
3575 link, which is not the common case. FIXME: If keep_memory is set
3576 we could write the relocs out and then read them again; I don't
3577 know how bad the memory loss will be. */
3579 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
3580 sub
->output_has_begun
= FALSE
;
3581 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3583 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
3585 if (p
->type
== bfd_indirect_link_order
3586 && (bfd_get_flavour ((sub
= p
->u
.indirect
.section
->owner
))
3587 == bfd_target_elf_flavour
)
3588 && elf_elfheader (sub
)->e_ident
[EI_CLASS
] == bed
->s
->elfclass
)
3590 if (! sub
->output_has_begun
)
3592 if (! elf_link_input_bfd (&finfo
, sub
))
3594 sub
->output_has_begun
= TRUE
;
3597 else if (p
->type
== bfd_section_reloc_link_order
3598 || p
->type
== bfd_symbol_reloc_link_order
)
3600 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
3605 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
3611 /* Output any global symbols that got converted to local in a
3612 version script or due to symbol visibility. We do this in a
3613 separate step since ELF requires all local symbols to appear
3614 prior to any global symbols. FIXME: We should only do this if
3615 some global symbols were, in fact, converted to become local.
3616 FIXME: Will this work correctly with the Irix 5 linker? */
3617 eoinfo
.failed
= FALSE
;
3618 eoinfo
.finfo
= &finfo
;
3619 eoinfo
.localsyms
= TRUE
;
3620 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
3625 /* That wrote out all the local symbols. Finish up the symbol table
3626 with the global symbols. Even if we want to strip everything we
3627 can, we still need to deal with those global symbols that got
3628 converted to local in a version script. */
3630 /* The sh_info field records the index of the first non local symbol. */
3631 symtab_hdr
->sh_info
= bfd_get_symcount (abfd
);
3634 && finfo
.dynsym_sec
->output_section
!= bfd_abs_section_ptr
)
3636 Elf_Internal_Sym sym
;
3637 Elf_External_Sym
*dynsym
=
3638 (Elf_External_Sym
*) finfo
.dynsym_sec
->contents
;
3639 long last_local
= 0;
3641 /* Write out the section symbols for the output sections. */
3648 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3651 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3654 Elf_External_Sym
*dest
;
3656 indx
= elf_section_data (s
)->this_idx
;
3657 BFD_ASSERT (indx
> 0);
3658 sym
.st_shndx
= indx
;
3659 sym
.st_value
= s
->vma
;
3660 dest
= dynsym
+ elf_section_data (s
)->dynindx
;
3661 elf_swap_symbol_out (abfd
, &sym
, dest
, 0);
3664 last_local
= bfd_count_sections (abfd
);
3667 /* Write out the local dynsyms. */
3668 if (elf_hash_table (info
)->dynlocal
)
3670 struct elf_link_local_dynamic_entry
*e
;
3671 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
3674 Elf_External_Sym
*dest
;
3676 sym
.st_size
= e
->isym
.st_size
;
3677 sym
.st_other
= e
->isym
.st_other
;
3679 /* Copy the internal symbol as is.
3680 Note that we saved a word of storage and overwrote
3681 the original st_name with the dynstr_index. */
3684 if (e
->isym
.st_shndx
!= SHN_UNDEF
3685 && (e
->isym
.st_shndx
< SHN_LORESERVE
3686 || e
->isym
.st_shndx
> SHN_HIRESERVE
))
3688 s
= bfd_section_from_elf_index (e
->input_bfd
,
3692 elf_section_data (s
->output_section
)->this_idx
;
3693 sym
.st_value
= (s
->output_section
->vma
3695 + e
->isym
.st_value
);
3698 if (last_local
< e
->dynindx
)
3699 last_local
= e
->dynindx
;
3701 dest
= dynsym
+ e
->dynindx
;
3702 elf_swap_symbol_out (abfd
, &sym
, dest
, 0);
3706 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
=
3710 /* We get the global symbols from the hash table. */
3711 eoinfo
.failed
= FALSE
;
3712 eoinfo
.localsyms
= FALSE
;
3713 eoinfo
.finfo
= &finfo
;
3714 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
3719 /* If backend needs to output some symbols not present in the hash
3720 table, do it now. */
3721 if (bed
->elf_backend_output_arch_syms
)
3723 typedef bfd_boolean (*out_sym_func
)
3724 (void *, const char *, Elf_Internal_Sym
*, asection
*);
3726 if (! ((*bed
->elf_backend_output_arch_syms
)
3727 (abfd
, info
, &finfo
, (out_sym_func
) elf_link_output_sym
)))
3731 /* Flush all symbols to the file. */
3732 if (! elf_link_flush_output_syms (&finfo
))
3735 /* Now we know the size of the symtab section. */
3736 off
+= symtab_hdr
->sh_size
;
3738 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3739 if (symtab_shndx_hdr
->sh_name
!= 0)
3741 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
3742 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
3743 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
3744 amt
= bfd_get_symcount (abfd
) * sizeof (Elf_External_Sym_Shndx
);
3745 symtab_shndx_hdr
->sh_size
= amt
;
3747 off
= _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr
,
3750 if (bfd_seek (abfd
, symtab_shndx_hdr
->sh_offset
, SEEK_SET
) != 0
3751 || (bfd_bwrite (finfo
.symshndxbuf
, amt
, abfd
) != amt
))
3756 /* Finish up and write out the symbol string table (.strtab)
3758 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3759 /* sh_name was set in prep_headers. */
3760 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3761 symstrtab_hdr
->sh_flags
= 0;
3762 symstrtab_hdr
->sh_addr
= 0;
3763 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
3764 symstrtab_hdr
->sh_entsize
= 0;
3765 symstrtab_hdr
->sh_link
= 0;
3766 symstrtab_hdr
->sh_info
= 0;
3767 /* sh_offset is set just below. */
3768 symstrtab_hdr
->sh_addralign
= 1;
3770 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, TRUE
);
3771 elf_tdata (abfd
)->next_file_pos
= off
;
3773 if (bfd_get_symcount (abfd
) > 0)
3775 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
3776 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
3780 /* Adjust the relocs to have the correct symbol indices. */
3781 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3783 if ((o
->flags
& SEC_RELOC
) == 0)
3786 elf_link_adjust_relocs (abfd
, &elf_section_data (o
)->rel_hdr
,
3787 elf_section_data (o
)->rel_count
,
3788 elf_section_data (o
)->rel_hashes
);
3789 if (elf_section_data (o
)->rel_hdr2
!= NULL
)
3790 elf_link_adjust_relocs (abfd
, elf_section_data (o
)->rel_hdr2
,
3791 elf_section_data (o
)->rel_count2
,
3792 (elf_section_data (o
)->rel_hashes
3793 + elf_section_data (o
)->rel_count
));
3795 /* Set the reloc_count field to 0 to prevent write_relocs from
3796 trying to swap the relocs out itself. */
3800 if (dynamic
&& info
->combreloc
&& dynobj
!= NULL
)
3801 relativecount
= elf_link_sort_relocs (abfd
, info
, &reldyn
);
3803 /* If we are linking against a dynamic object, or generating a
3804 shared library, finish up the dynamic linking information. */
3807 Elf_External_Dyn
*dyncon
, *dynconend
;
3809 /* Fix up .dynamic entries. */
3810 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
3811 BFD_ASSERT (o
!= NULL
);
3813 dyncon
= (Elf_External_Dyn
*) o
->contents
;
3814 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
3815 for (; dyncon
< dynconend
; dyncon
++)
3817 Elf_Internal_Dyn dyn
;
3821 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3828 if (relativecount
> 0 && dyncon
+ 1 < dynconend
)
3830 switch (elf_section_data (reldyn
)->this_hdr
.sh_type
)
3832 case SHT_REL
: dyn
.d_tag
= DT_RELCOUNT
; break;
3833 case SHT_RELA
: dyn
.d_tag
= DT_RELACOUNT
; break;
3836 if (dyn
.d_tag
!= DT_NULL
)
3838 dyn
.d_un
.d_val
= relativecount
;
3839 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
3845 name
= info
->init_function
;
3848 name
= info
->fini_function
;
3851 struct elf_link_hash_entry
*h
;
3853 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3854 FALSE
, FALSE
, TRUE
);
3856 && (h
->root
.type
== bfd_link_hash_defined
3857 || h
->root
.type
== bfd_link_hash_defweak
))
3859 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
3860 o
= h
->root
.u
.def
.section
;
3861 if (o
->output_section
!= NULL
)
3862 dyn
.d_un
.d_val
+= (o
->output_section
->vma
3863 + o
->output_offset
);
3866 /* The symbol is imported from another shared
3867 library and does not apply to this one. */
3871 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
3876 case DT_PREINIT_ARRAYSZ
:
3877 name
= ".preinit_array";
3879 case DT_INIT_ARRAYSZ
:
3880 name
= ".init_array";
3882 case DT_FINI_ARRAYSZ
:
3883 name
= ".fini_array";
3885 o
= bfd_get_section_by_name (abfd
, name
);
3888 (*_bfd_error_handler
)
3889 (_("%s: could not find output section %s"),
3890 bfd_get_filename (abfd
), name
);
3893 if (o
->_raw_size
== 0)
3894 (*_bfd_error_handler
)
3895 (_("warning: %s section has zero size"), name
);
3896 dyn
.d_un
.d_val
= o
->_raw_size
;
3897 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
3900 case DT_PREINIT_ARRAY
:
3901 name
= ".preinit_array";
3904 name
= ".init_array";
3907 name
= ".fini_array";
3920 name
= ".gnu.version_d";
3923 name
= ".gnu.version_r";
3926 name
= ".gnu.version";
3928 o
= bfd_get_section_by_name (abfd
, name
);
3931 (*_bfd_error_handler
)
3932 (_("%s: could not find output section %s"),
3933 bfd_get_filename (abfd
), name
);
3936 dyn
.d_un
.d_ptr
= o
->vma
;
3937 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
3944 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
3949 for (i
= 1; i
< elf_numsections (abfd
); i
++)
3951 Elf_Internal_Shdr
*hdr
;
3953 hdr
= elf_elfsections (abfd
)[i
];
3954 if (hdr
->sh_type
== type
3955 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
3957 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
3958 dyn
.d_un
.d_val
+= hdr
->sh_size
;
3961 if (dyn
.d_un
.d_val
== 0
3962 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
3963 dyn
.d_un
.d_val
= hdr
->sh_addr
;
3967 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
3973 /* If we have created any dynamic sections, then output them. */
3976 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
3979 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
3981 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
3982 || o
->_raw_size
== 0
3983 || o
->output_section
== bfd_abs_section_ptr
)
3985 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
3987 /* At this point, we are only interested in sections
3988 created by _bfd_elf_link_create_dynamic_sections. */
3991 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
3993 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
3995 if (! bfd_set_section_contents (abfd
, o
->output_section
,
3997 (file_ptr
) o
->output_offset
,
4003 /* The contents of the .dynstr section are actually in a
4005 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
4006 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4007 || ! _bfd_elf_strtab_emit (abfd
,
4008 elf_hash_table (info
)->dynstr
))
4014 if (info
->relocatable
)
4016 bfd_boolean failed
= FALSE
;
4018 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4023 /* If we have optimized stabs strings, output them. */
4024 if (elf_hash_table (info
)->stab_info
!= NULL
)
4026 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
4030 if (info
->eh_frame_hdr
)
4032 if (! _bfd_elf_write_section_eh_frame_hdr (abfd
, info
))
4036 if (finfo
.symstrtab
!= NULL
)
4037 _bfd_stringtab_free (finfo
.symstrtab
);
4038 if (finfo
.contents
!= NULL
)
4039 free (finfo
.contents
);
4040 if (finfo
.external_relocs
!= NULL
)
4041 free (finfo
.external_relocs
);
4042 if (finfo
.internal_relocs
!= NULL
)
4043 free (finfo
.internal_relocs
);
4044 if (finfo
.external_syms
!= NULL
)
4045 free (finfo
.external_syms
);
4046 if (finfo
.locsym_shndx
!= NULL
)
4047 free (finfo
.locsym_shndx
);
4048 if (finfo
.internal_syms
!= NULL
)
4049 free (finfo
.internal_syms
);
4050 if (finfo
.indices
!= NULL
)
4051 free (finfo
.indices
);
4052 if (finfo
.sections
!= NULL
)
4053 free (finfo
.sections
);
4054 if (finfo
.symbuf
!= NULL
)
4055 free (finfo
.symbuf
);
4056 if (finfo
.symshndxbuf
!= NULL
)
4057 free (finfo
.symshndxbuf
);
4058 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4060 if ((o
->flags
& SEC_RELOC
) != 0
4061 && elf_section_data (o
)->rel_hashes
!= NULL
)
4062 free (elf_section_data (o
)->rel_hashes
);
4065 elf_tdata (abfd
)->linker
= TRUE
;
4070 if (finfo
.symstrtab
!= NULL
)
4071 _bfd_stringtab_free (finfo
.symstrtab
);
4072 if (finfo
.contents
!= NULL
)
4073 free (finfo
.contents
);
4074 if (finfo
.external_relocs
!= NULL
)
4075 free (finfo
.external_relocs
);
4076 if (finfo
.internal_relocs
!= NULL
)
4077 free (finfo
.internal_relocs
);
4078 if (finfo
.external_syms
!= NULL
)
4079 free (finfo
.external_syms
);
4080 if (finfo
.locsym_shndx
!= NULL
)
4081 free (finfo
.locsym_shndx
);
4082 if (finfo
.internal_syms
!= NULL
)
4083 free (finfo
.internal_syms
);
4084 if (finfo
.indices
!= NULL
)
4085 free (finfo
.indices
);
4086 if (finfo
.sections
!= NULL
)
4087 free (finfo
.sections
);
4088 if (finfo
.symbuf
!= NULL
)
4089 free (finfo
.symbuf
);
4090 if (finfo
.symshndxbuf
!= NULL
)
4091 free (finfo
.symshndxbuf
);
4092 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
4094 if ((o
->flags
& SEC_RELOC
) != 0
4095 && elf_section_data (o
)->rel_hashes
!= NULL
)
4096 free (elf_section_data (o
)->rel_hashes
);
4102 /* Add a symbol to the output symbol table. */
4105 elf_link_output_sym (struct elf_final_link_info
*finfo
,
4107 Elf_Internal_Sym
*elfsym
,
4108 asection
*input_sec
)
4110 Elf_External_Sym
*dest
;
4111 Elf_External_Sym_Shndx
*destshndx
;
4112 bfd_boolean (*output_symbol_hook
)
4113 (bfd
*, struct bfd_link_info
*info
, const char *,
4114 Elf_Internal_Sym
*, asection
*);
4116 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
4117 elf_backend_link_output_symbol_hook
;
4118 if (output_symbol_hook
!= NULL
)
4120 if (! ((*output_symbol_hook
)
4121 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
4125 if (name
== NULL
|| *name
== '\0')
4126 elfsym
->st_name
= 0;
4127 else if (input_sec
->flags
& SEC_EXCLUDE
)
4128 elfsym
->st_name
= 0;
4131 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
4133 if (elfsym
->st_name
== (unsigned long) -1)
4137 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
4139 if (! elf_link_flush_output_syms (finfo
))
4143 dest
= finfo
->symbuf
+ finfo
->symbuf_count
;
4144 destshndx
= finfo
->symshndxbuf
;
4145 if (destshndx
!= NULL
)
4147 if (bfd_get_symcount (finfo
->output_bfd
) >= finfo
->shndxbuf_size
)
4151 amt
= finfo
->shndxbuf_size
* sizeof (Elf_External_Sym_Shndx
);
4152 finfo
->symshndxbuf
= destshndx
= bfd_realloc (destshndx
, amt
* 2);
4153 if (destshndx
== NULL
)
4155 memset ((char *) destshndx
+ amt
, 0, amt
);
4156 finfo
->shndxbuf_size
*= 2;
4158 destshndx
+= bfd_get_symcount (finfo
->output_bfd
);
4161 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
, dest
, destshndx
);
4162 finfo
->symbuf_count
+= 1;
4163 bfd_get_symcount (finfo
->output_bfd
) += 1;
4168 /* Flush the output symbols to the file. */
4171 elf_link_flush_output_syms (struct elf_final_link_info
*finfo
)
4173 if (finfo
->symbuf_count
> 0)
4175 Elf_Internal_Shdr
*hdr
;
4179 hdr
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
4180 pos
= hdr
->sh_offset
+ hdr
->sh_size
;
4181 amt
= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
4182 if (bfd_seek (finfo
->output_bfd
, pos
, SEEK_SET
) != 0
4183 || bfd_bwrite (finfo
->symbuf
, amt
, finfo
->output_bfd
) != amt
)
4186 hdr
->sh_size
+= amt
;
4187 finfo
->symbuf_count
= 0;
4193 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
4194 allowing an unsatisfied unversioned symbol in the DSO to match a
4195 versioned symbol that would normally require an explicit version.
4196 We also handle the case that a DSO references a hidden symbol
4197 which may be satisfied by a versioned symbol in another DSO. */
4200 elf_link_check_versioned_symbol (struct bfd_link_info
*info
,
4201 struct elf_link_hash_entry
*h
)
4204 struct elf_link_loaded_list
*loaded
;
4206 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
4209 switch (h
->root
.type
)
4215 case bfd_link_hash_undefined
:
4216 case bfd_link_hash_undefweak
:
4217 abfd
= h
->root
.u
.undef
.abfd
;
4218 if ((abfd
->flags
& DYNAMIC
) == 0 || elf_dt_soname (abfd
) == NULL
)
4222 case bfd_link_hash_defined
:
4223 case bfd_link_hash_defweak
:
4224 abfd
= h
->root
.u
.def
.section
->owner
;
4227 case bfd_link_hash_common
:
4228 abfd
= h
->root
.u
.c
.p
->section
->owner
;
4231 BFD_ASSERT (abfd
!= NULL
);
4233 for (loaded
= elf_hash_table (info
)->loaded
;
4235 loaded
= loaded
->next
)
4238 Elf_Internal_Shdr
*hdr
;
4239 bfd_size_type symcount
;
4240 bfd_size_type extsymcount
;
4241 bfd_size_type extsymoff
;
4242 Elf_Internal_Shdr
*versymhdr
;
4243 Elf_Internal_Sym
*isym
;
4244 Elf_Internal_Sym
*isymend
;
4245 Elf_Internal_Sym
*isymbuf
;
4246 Elf_External_Versym
*ever
;
4247 Elf_External_Versym
*extversym
;
4249 input
= loaded
->abfd
;
4251 /* We check each DSO for a possible hidden versioned definition. */
4253 || (input
->flags
& DYNAMIC
) == 0
4254 || elf_dynversym (input
) == 0)
4257 hdr
= &elf_tdata (input
)->dynsymtab_hdr
;
4259 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4260 if (elf_bad_symtab (input
))
4262 extsymcount
= symcount
;
4267 extsymcount
= symcount
- hdr
->sh_info
;
4268 extsymoff
= hdr
->sh_info
;
4271 if (extsymcount
== 0)
4274 isymbuf
= bfd_elf_get_elf_syms (input
, hdr
, extsymcount
, extsymoff
,
4276 if (isymbuf
== NULL
)
4279 /* Read in any version definitions. */
4280 versymhdr
= &elf_tdata (input
)->dynversym_hdr
;
4281 extversym
= bfd_malloc (versymhdr
->sh_size
);
4282 if (extversym
== NULL
)
4285 if (bfd_seek (input
, versymhdr
->sh_offset
, SEEK_SET
) != 0
4286 || (bfd_bread (extversym
, versymhdr
->sh_size
, input
)
4287 != versymhdr
->sh_size
))
4295 ever
= extversym
+ extsymoff
;
4296 isymend
= isymbuf
+ extsymcount
;
4297 for (isym
= isymbuf
; isym
< isymend
; isym
++, ever
++)
4300 Elf_Internal_Versym iver
;
4301 unsigned short version_index
;
4303 if (ELF_ST_BIND (isym
->st_info
) == STB_LOCAL
4304 || isym
->st_shndx
== SHN_UNDEF
)
4307 name
= bfd_elf_string_from_elf_section (input
,
4310 if (strcmp (name
, h
->root
.root
.string
) != 0)
4313 _bfd_elf_swap_versym_in (input
, ever
, &iver
);
4315 if ((iver
.vs_vers
& VERSYM_HIDDEN
) == 0)
4317 /* If we have a non-hidden versioned sym, then it should
4318 have provided a definition for the undefined sym. */
4322 version_index
= iver
.vs_vers
& VERSYM_VERSION
;
4323 if (version_index
== 1 || version_index
== 2)
4325 /* This is the base or first version. We can use it. */
4339 /* Add an external symbol to the symbol table. This is called from
4340 the hash table traversal routine. When generating a shared object,
4341 we go through the symbol table twice. The first time we output
4342 anything that might have been forced to local scope in a version
4343 script. The second time we output the symbols that are still
4347 elf_link_output_extsym (struct elf_link_hash_entry
*h
, void *data
)
4349 struct elf_outext_info
*eoinfo
= data
;
4350 struct elf_final_link_info
*finfo
= eoinfo
->finfo
;
4352 Elf_Internal_Sym sym
;
4353 asection
*input_sec
;
4355 if (h
->root
.type
== bfd_link_hash_warning
)
4357 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4358 if (h
->root
.type
== bfd_link_hash_new
)
4362 /* Decide whether to output this symbol in this pass. */
4363 if (eoinfo
->localsyms
)
4365 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
4370 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4374 /* If we have an undefined symbol reference here then it must have
4375 come from a shared library that is being linked in. (Undefined
4376 references in regular files have already been handled). If we
4377 are reporting errors for this situation then do so now. */
4378 if (h
->root
.type
== bfd_link_hash_undefined
4379 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
4380 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
4381 && ! elf_link_check_versioned_symbol (finfo
->info
, h
)
4382 && finfo
->info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
)
4384 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
4385 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
4386 NULL
, 0, finfo
->info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
)))
4388 eoinfo
->failed
= TRUE
;
4393 /* We should also warn if a forced local symbol is referenced from
4394 shared libraries. */
4395 if (! finfo
->info
->relocatable
4396 && (! finfo
->info
->shared
)
4397 && (h
->elf_link_hash_flags
4398 & (ELF_LINK_FORCED_LOCAL
| ELF_LINK_HASH_REF_DYNAMIC
| ELF_LINK_DYNAMIC_DEF
| ELF_LINK_DYNAMIC_WEAK
))
4399 == (ELF_LINK_FORCED_LOCAL
| ELF_LINK_HASH_REF_DYNAMIC
)
4400 && ! elf_link_check_versioned_symbol (finfo
->info
, h
))
4402 (*_bfd_error_handler
)
4403 (_("%s: %s symbol `%s' in %s is referenced by DSO"),
4404 bfd_get_filename (finfo
->output_bfd
),
4405 ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
4407 : ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
4408 ? "hidden" : "local",
4409 h
->root
.root
.string
,
4410 bfd_archive_filename (h
->root
.u
.def
.section
->owner
));
4411 eoinfo
->failed
= TRUE
;
4415 /* We don't want to output symbols that have never been mentioned by
4416 a regular file, or that we have been told to strip. However, if
4417 h->indx is set to -2, the symbol is used by a reloc and we must
4421 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4422 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
4423 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
4424 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4426 else if (finfo
->info
->strip
== strip_all
)
4428 else if (finfo
->info
->strip
== strip_some
4429 && bfd_hash_lookup (finfo
->info
->keep_hash
,
4430 h
->root
.root
.string
, FALSE
, FALSE
) == NULL
)
4432 else if (finfo
->info
->strip_discarded
4433 && (h
->root
.type
== bfd_link_hash_defined
4434 || h
->root
.type
== bfd_link_hash_defweak
)
4435 && elf_discarded_section (h
->root
.u
.def
.section
))
4440 /* If we're stripping it, and it's not a dynamic symbol, there's
4441 nothing else to do unless it is a forced local symbol. */
4444 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
4448 sym
.st_size
= h
->size
;
4449 sym
.st_other
= h
->other
;
4450 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4451 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, h
->type
);
4452 else if (h
->root
.type
== bfd_link_hash_undefweak
4453 || h
->root
.type
== bfd_link_hash_defweak
)
4454 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
4456 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
4458 switch (h
->root
.type
)
4461 case bfd_link_hash_new
:
4462 case bfd_link_hash_warning
:
4466 case bfd_link_hash_undefined
:
4467 case bfd_link_hash_undefweak
:
4468 input_sec
= bfd_und_section_ptr
;
4469 sym
.st_shndx
= SHN_UNDEF
;
4472 case bfd_link_hash_defined
:
4473 case bfd_link_hash_defweak
:
4475 input_sec
= h
->root
.u
.def
.section
;
4476 if (input_sec
->output_section
!= NULL
)
4479 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
4480 input_sec
->output_section
);
4481 if (sym
.st_shndx
== SHN_BAD
)
4483 (*_bfd_error_handler
)
4484 (_("%s: could not find output section %s for input section %s"),
4485 bfd_get_filename (finfo
->output_bfd
),
4486 input_sec
->output_section
->name
,
4488 eoinfo
->failed
= TRUE
;
4492 /* ELF symbols in relocatable files are section relative,
4493 but in nonrelocatable files they are virtual
4495 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
4496 if (! finfo
->info
->relocatable
)
4498 sym
.st_value
+= input_sec
->output_section
->vma
;
4499 if (h
->type
== STT_TLS
)
4501 /* STT_TLS symbols are relative to PT_TLS segment
4503 BFD_ASSERT (finfo
->first_tls_sec
!= NULL
);
4504 sym
.st_value
-= finfo
->first_tls_sec
->vma
;
4510 BFD_ASSERT (input_sec
->owner
== NULL
4511 || (input_sec
->owner
->flags
& DYNAMIC
) != 0);
4512 sym
.st_shndx
= SHN_UNDEF
;
4513 input_sec
= bfd_und_section_ptr
;
4518 case bfd_link_hash_common
:
4519 input_sec
= h
->root
.u
.c
.p
->section
;
4520 sym
.st_shndx
= SHN_COMMON
;
4521 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
4524 case bfd_link_hash_indirect
:
4525 /* These symbols are created by symbol versioning. They point
4526 to the decorated version of the name. For example, if the
4527 symbol foo@@GNU_1.2 is the default, which should be used when
4528 foo is used with no version, then we add an indirect symbol
4529 foo which points to foo@@GNU_1.2. We ignore these symbols,
4530 since the indirected symbol is already in the hash table. */
4534 /* Give the processor backend a chance to tweak the symbol value,
4535 and also to finish up anything that needs to be done for this
4536 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
4537 forced local syms when non-shared is due to a historical quirk. */
4538 if ((h
->dynindx
!= -1
4539 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
4540 && ((finfo
->info
->shared
4541 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4542 || h
->root
.type
!= bfd_link_hash_undefweak
))
4543 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
4544 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4546 const struct elf_backend_data
*bed
;
4548 bed
= get_elf_backend_data (finfo
->output_bfd
);
4549 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
4550 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
4552 eoinfo
->failed
= TRUE
;
4557 /* If we are marking the symbol as undefined, and there are no
4558 non-weak references to this symbol from a regular object, then
4559 mark the symbol as weak undefined; if there are non-weak
4560 references, mark the symbol as strong. We can't do this earlier,
4561 because it might not be marked as undefined until the
4562 finish_dynamic_symbol routine gets through with it. */
4563 if (sym
.st_shndx
== SHN_UNDEF
4564 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
4565 && (ELF_ST_BIND (sym
.st_info
) == STB_GLOBAL
4566 || ELF_ST_BIND (sym
.st_info
) == STB_WEAK
))
4570 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
) != 0)
4571 bindtype
= STB_GLOBAL
;
4573 bindtype
= STB_WEAK
;
4574 sym
.st_info
= ELF_ST_INFO (bindtype
, ELF_ST_TYPE (sym
.st_info
));
4577 /* If a non-weak symbol with non-default visibility is not defined
4578 locally, it is a fatal error. */
4579 if (! finfo
->info
->relocatable
4580 && ELF_ST_VISIBILITY (sym
.st_other
) != STV_DEFAULT
4581 && ELF_ST_BIND (sym
.st_info
) != STB_WEAK
4582 && h
->root
.type
== bfd_link_hash_undefined
4583 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4585 (*_bfd_error_handler
)
4586 (_("%s: %s symbol `%s' isn't defined"),
4587 bfd_get_filename (finfo
->output_bfd
),
4588 ELF_ST_VISIBILITY (sym
.st_other
) == STV_PROTECTED
4590 : ELF_ST_VISIBILITY (sym
.st_other
) == STV_INTERNAL
4591 ? "internal" : "hidden",
4592 h
->root
.root
.string
);
4593 eoinfo
->failed
= TRUE
;
4597 /* If this symbol should be put in the .dynsym section, then put it
4598 there now. We already know the symbol index. We also fill in
4599 the entry in the .hash section. */
4600 if (h
->dynindx
!= -1
4601 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
4605 size_t hash_entry_size
;
4606 bfd_byte
*bucketpos
;
4608 Elf_External_Sym
*esym
;
4610 sym
.st_name
= h
->dynstr_index
;
4611 esym
= (Elf_External_Sym
*) finfo
->dynsym_sec
->contents
+ h
->dynindx
;
4612 elf_swap_symbol_out (finfo
->output_bfd
, &sym
, esym
, 0);
4614 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
4615 bucket
= h
->elf_hash_value
% bucketcount
;
4617 = elf_section_data (finfo
->hash_sec
)->this_hdr
.sh_entsize
;
4618 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
4619 + (bucket
+ 2) * hash_entry_size
);
4620 chain
= bfd_get (8 * hash_entry_size
, finfo
->output_bfd
, bucketpos
);
4621 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, h
->dynindx
, bucketpos
);
4622 bfd_put (8 * hash_entry_size
, finfo
->output_bfd
, chain
,
4623 ((bfd_byte
*) finfo
->hash_sec
->contents
4624 + (bucketcount
+ 2 + h
->dynindx
) * hash_entry_size
));
4626 if (finfo
->symver_sec
!= NULL
&& finfo
->symver_sec
->contents
!= NULL
)
4628 Elf_Internal_Versym iversym
;
4629 Elf_External_Versym
*eversym
;
4631 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4633 if (h
->verinfo
.verdef
== NULL
)
4634 iversym
.vs_vers
= 0;
4636 iversym
.vs_vers
= h
->verinfo
.verdef
->vd_exp_refno
+ 1;
4640 if (h
->verinfo
.vertree
== NULL
)
4641 iversym
.vs_vers
= 1;
4643 iversym
.vs_vers
= h
->verinfo
.vertree
->vernum
+ 1;
4646 if ((h
->elf_link_hash_flags
& ELF_LINK_HIDDEN
) != 0)
4647 iversym
.vs_vers
|= VERSYM_HIDDEN
;
4649 eversym
= (Elf_External_Versym
*) finfo
->symver_sec
->contents
;
4650 eversym
+= h
->dynindx
;
4651 _bfd_elf_swap_versym_out (finfo
->output_bfd
, &iversym
, eversym
);
4655 /* If we're stripping it, then it was just a dynamic symbol, and
4656 there's nothing else to do. */
4657 if (strip
|| (input_sec
->flags
& SEC_EXCLUDE
) != 0)
4660 h
->indx
= bfd_get_symcount (finfo
->output_bfd
);
4662 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
4664 eoinfo
->failed
= TRUE
;
4671 /* Link an input file into the linker output file. This function
4672 handles all the sections and relocations of the input file at once.
4673 This is so that we only have to read the local symbols once, and
4674 don't have to keep them in memory. */
4677 elf_link_input_bfd (struct elf_final_link_info
*finfo
, bfd
*input_bfd
)
4679 bfd_boolean (*relocate_section
)
4680 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
4681 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
4683 Elf_Internal_Shdr
*symtab_hdr
;
4686 Elf_Internal_Sym
*isymbuf
;
4687 Elf_Internal_Sym
*isym
;
4688 Elf_Internal_Sym
*isymend
;
4690 asection
**ppsection
;
4692 const struct elf_backend_data
*bed
;
4693 bfd_boolean emit_relocs
;
4694 struct elf_link_hash_entry
**sym_hashes
;
4696 output_bfd
= finfo
->output_bfd
;
4697 bed
= get_elf_backend_data (output_bfd
);
4698 relocate_section
= bed
->elf_backend_relocate_section
;
4700 /* If this is a dynamic object, we don't want to do anything here:
4701 we don't want the local symbols, and we don't want the section
4703 if ((input_bfd
->flags
& DYNAMIC
) != 0)
4706 emit_relocs
= (finfo
->info
->relocatable
4707 || finfo
->info
->emitrelocations
4708 || bed
->elf_backend_emit_relocs
);
4710 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4711 if (elf_bad_symtab (input_bfd
))
4713 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
4718 locsymcount
= symtab_hdr
->sh_info
;
4719 extsymoff
= symtab_hdr
->sh_info
;
4722 /* Read the local symbols. */
4723 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
4724 if (isymbuf
== NULL
&& locsymcount
!= 0)
4726 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
4727 finfo
->internal_syms
,
4728 finfo
->external_syms
,
4729 finfo
->locsym_shndx
);
4730 if (isymbuf
== NULL
)
4734 /* Find local symbol sections and adjust values of symbols in
4735 SEC_MERGE sections. Write out those local symbols we know are
4736 going into the output file. */
4737 isymend
= isymbuf
+ locsymcount
;
4738 for (isym
= isymbuf
, pindex
= finfo
->indices
, ppsection
= finfo
->sections
;
4740 isym
++, pindex
++, ppsection
++)
4744 Elf_Internal_Sym osym
;
4748 if (elf_bad_symtab (input_bfd
))
4750 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
4757 if (isym
->st_shndx
== SHN_UNDEF
)
4758 isec
= bfd_und_section_ptr
;
4759 else if (isym
->st_shndx
< SHN_LORESERVE
4760 || isym
->st_shndx
> SHN_HIRESERVE
)
4762 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
4764 && isec
->sec_info_type
== ELF_INFO_TYPE_MERGE
4765 && ELF_ST_TYPE (isym
->st_info
) != STT_SECTION
)
4767 _bfd_merged_section_offset (output_bfd
, &isec
,
4768 elf_section_data (isec
)->sec_info
,
4771 else if (isym
->st_shndx
== SHN_ABS
)
4772 isec
= bfd_abs_section_ptr
;
4773 else if (isym
->st_shndx
== SHN_COMMON
)
4774 isec
= bfd_com_section_ptr
;
4783 /* Don't output the first, undefined, symbol. */
4784 if (ppsection
== finfo
->sections
)
4787 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
4789 /* We never output section symbols. Instead, we use the
4790 section symbol of the corresponding section in the output
4795 /* If we are stripping all symbols, we don't want to output this
4797 if (finfo
->info
->strip
== strip_all
)
4800 /* If we are discarding all local symbols, we don't want to
4801 output this one. If we are generating a relocatable output
4802 file, then some of the local symbols may be required by
4803 relocs; we output them below as we discover that they are
4805 if (finfo
->info
->discard
== discard_all
)
4808 /* If this symbol is defined in a section which we are
4809 discarding, we don't need to keep it, but note that
4810 linker_mark is only reliable for sections that have contents.
4811 For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
4812 as well as linker_mark. */
4813 if ((isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
4815 && ((! isec
->linker_mark
&& (isec
->flags
& SEC_HAS_CONTENTS
) != 0)
4816 || (! finfo
->info
->relocatable
4817 && (isec
->flags
& SEC_EXCLUDE
) != 0)))
4820 /* Get the name of the symbol. */
4821 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
4826 /* See if we are discarding symbols with this name. */
4827 if ((finfo
->info
->strip
== strip_some
4828 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, FALSE
, FALSE
)
4830 || (((finfo
->info
->discard
== discard_sec_merge
4831 && (isec
->flags
& SEC_MERGE
) && ! finfo
->info
->relocatable
)
4832 || finfo
->info
->discard
== discard_l
)
4833 && bfd_is_local_label_name (input_bfd
, name
)))
4836 /* If we get here, we are going to output this symbol. */
4840 /* Adjust the section index for the output file. */
4841 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
4842 isec
->output_section
);
4843 if (osym
.st_shndx
== SHN_BAD
)
4846 *pindex
= bfd_get_symcount (output_bfd
);
4848 /* ELF symbols in relocatable files are section relative, but
4849 in executable files they are virtual addresses. Note that
4850 this code assumes that all ELF sections have an associated
4851 BFD section with a reasonable value for output_offset; below
4852 we assume that they also have a reasonable value for
4853 output_section. Any special sections must be set up to meet
4854 these requirements. */
4855 osym
.st_value
+= isec
->output_offset
;
4856 if (! finfo
->info
->relocatable
)
4858 osym
.st_value
+= isec
->output_section
->vma
;
4859 if (ELF_ST_TYPE (osym
.st_info
) == STT_TLS
)
4861 /* STT_TLS symbols are relative to PT_TLS segment base. */
4862 BFD_ASSERT (finfo
->first_tls_sec
!= NULL
);
4863 osym
.st_value
-= finfo
->first_tls_sec
->vma
;
4867 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
4871 /* Relocate the contents of each section. */
4872 sym_hashes
= elf_sym_hashes (input_bfd
);
4873 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4877 if (! o
->linker_mark
)
4879 /* This section was omitted from the link. */
4883 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
4884 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
4887 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
4889 /* Section was created by _bfd_elf_link_create_dynamic_sections
4894 /* Get the contents of the section. They have been cached by a
4895 relaxation routine. Note that o is a section in an input
4896 file, so the contents field will not have been set by any of
4897 the routines which work on output files. */
4898 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
4899 contents
= elf_section_data (o
)->this_hdr
.contents
;
4902 contents
= finfo
->contents
;
4903 if (! bfd_get_section_contents (input_bfd
, o
, contents
, 0,
4908 if ((o
->flags
& SEC_RELOC
) != 0)
4910 Elf_Internal_Rela
*internal_relocs
;
4912 /* Get the swapped relocs. */
4914 = _bfd_elf_link_read_relocs (input_bfd
, o
, finfo
->external_relocs
,
4915 finfo
->internal_relocs
, FALSE
);
4916 if (internal_relocs
== NULL
4917 && o
->reloc_count
> 0)
4920 /* Run through the relocs looking for any against symbols
4921 from discarded sections and section symbols from
4922 removed link-once sections. Complain about relocs
4923 against discarded sections. Zero relocs against removed
4924 link-once sections. Preserve debug information as much
4926 if (!elf_section_ignore_discarded_relocs (o
))
4928 Elf_Internal_Rela
*rel
, *relend
;
4930 rel
= internal_relocs
;
4931 relend
= rel
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
4932 for ( ; rel
< relend
; rel
++)
4934 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
4937 if (r_symndx
>= locsymcount
4938 || (elf_bad_symtab (input_bfd
)
4939 && finfo
->sections
[r_symndx
] == NULL
))
4941 struct elf_link_hash_entry
*h
;
4943 h
= sym_hashes
[r_symndx
- extsymoff
];
4944 while (h
->root
.type
== bfd_link_hash_indirect
4945 || h
->root
.type
== bfd_link_hash_warning
)
4946 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4948 /* Complain if the definition comes from a
4949 discarded section. */
4950 sec
= h
->root
.u
.def
.section
;
4951 if ((h
->root
.type
== bfd_link_hash_defined
4952 || h
->root
.type
== bfd_link_hash_defweak
)
4953 && elf_discarded_section (sec
))
4955 if ((o
->flags
& SEC_DEBUGGING
) != 0)
4957 BFD_ASSERT (r_symndx
!= 0);
4958 /* Try to preserve debug information. */
4959 if ((o
->flags
& SEC_DEBUGGING
) != 0
4960 && sec
->kept_section
!= NULL
4961 && sec
->_raw_size
== sec
->kept_section
->_raw_size
)
4962 h
->root
.u
.def
.section
4963 = sec
->kept_section
;
4965 memset (rel
, 0, sizeof (*rel
));
4968 finfo
->info
->callbacks
->error_handler
4969 (LD_DEFINITION_IN_DISCARDED_SECTION
,
4970 _("%T: discarded in section `%s' from %s\n"),
4971 h
->root
.root
.string
,
4972 h
->root
.root
.string
,
4973 h
->root
.u
.def
.section
->name
,
4974 bfd_archive_filename (h
->root
.u
.def
.section
->owner
));
4979 sec
= finfo
->sections
[r_symndx
];
4981 if (sec
!= NULL
&& elf_discarded_section (sec
))
4983 if ((o
->flags
& SEC_DEBUGGING
) != 0
4984 || (sec
->flags
& SEC_LINK_ONCE
) != 0)
4986 BFD_ASSERT (r_symndx
!= 0);
4987 /* Try to preserve debug information. */
4988 if ((o
->flags
& SEC_DEBUGGING
) != 0
4989 && sec
->kept_section
!= NULL
4990 && sec
->_raw_size
== sec
->kept_section
->_raw_size
)
4991 finfo
->sections
[r_symndx
]
4992 = sec
->kept_section
;
4996 = ELF_R_INFO (0, ELF_R_TYPE (rel
->r_info
));
5006 ok
= asprintf (&buf
, "local symbol %d",
5009 buf
= (char *) "local symbol";
5010 finfo
->info
->callbacks
->error_handler
5011 (LD_DEFINITION_IN_DISCARDED_SECTION
,
5012 _("%T: discarded in section `%s' from %s\n"),
5013 buf
, buf
, sec
->name
,
5014 bfd_archive_filename (input_bfd
));
5023 /* Relocate the section by invoking a back end routine.
5025 The back end routine is responsible for adjusting the
5026 section contents as necessary, and (if using Rela relocs
5027 and generating a relocatable output file) adjusting the
5028 reloc addend as necessary.
5030 The back end routine does not have to worry about setting
5031 the reloc address or the reloc symbol index.
5033 The back end routine is given a pointer to the swapped in
5034 internal symbols, and can access the hash table entries
5035 for the external symbols via elf_sym_hashes (input_bfd).
5037 When generating relocatable output, the back end routine
5038 must handle STB_LOCAL/STT_SECTION symbols specially. The
5039 output symbol is going to be a section symbol
5040 corresponding to the output section, which will require
5041 the addend to be adjusted. */
5043 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
5044 input_bfd
, o
, contents
,
5052 Elf_Internal_Rela
*irela
;
5053 Elf_Internal_Rela
*irelaend
;
5054 bfd_vma last_offset
;
5055 struct elf_link_hash_entry
**rel_hash
;
5056 Elf_Internal_Shdr
*input_rel_hdr
, *input_rel_hdr2
;
5057 unsigned int next_erel
;
5058 bfd_boolean (*reloc_emitter
)
5059 (bfd
*, asection
*, Elf_Internal_Shdr
*, Elf_Internal_Rela
*);
5060 bfd_boolean rela_normal
;
5062 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
5063 rela_normal
= (bed
->rela_normal
5064 && (input_rel_hdr
->sh_entsize
5065 == sizeof (Elf_External_Rela
)));
5067 /* Adjust the reloc addresses and symbol indices. */
5069 irela
= internal_relocs
;
5070 irelaend
= irela
+ o
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5071 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
5072 + elf_section_data (o
->output_section
)->rel_count
5073 + elf_section_data (o
->output_section
)->rel_count2
);
5074 last_offset
= o
->output_offset
;
5075 if (!finfo
->info
->relocatable
)
5076 last_offset
+= o
->output_section
->vma
;
5077 for (next_erel
= 0; irela
< irelaend
; irela
++, next_erel
++)
5079 unsigned long r_symndx
;
5081 Elf_Internal_Sym sym
;
5083 if (next_erel
== bed
->s
->int_rels_per_ext_rel
)
5089 irela
->r_offset
= _bfd_elf_section_offset (output_bfd
,
5092 if (irela
->r_offset
>= (bfd_vma
) -2)
5094 /* This is a reloc for a deleted entry or somesuch.
5095 Turn it into an R_*_NONE reloc, at the same
5096 offset as the last reloc. elf_eh_frame.c and
5097 elf_bfd_discard_info rely on reloc offsets
5099 irela
->r_offset
= last_offset
;
5101 irela
->r_addend
= 0;
5105 irela
->r_offset
+= o
->output_offset
;
5107 /* Relocs in an executable have to be virtual addresses. */
5108 if (!finfo
->info
->relocatable
)
5109 irela
->r_offset
+= o
->output_section
->vma
;
5111 last_offset
= irela
->r_offset
;
5113 r_symndx
= ELF_R_SYM (irela
->r_info
);
5114 if (r_symndx
== STN_UNDEF
)
5117 if (r_symndx
>= locsymcount
5118 || (elf_bad_symtab (input_bfd
)
5119 && finfo
->sections
[r_symndx
] == NULL
))
5121 struct elf_link_hash_entry
*rh
;
5124 /* This is a reloc against a global symbol. We
5125 have not yet output all the local symbols, so
5126 we do not know the symbol index of any global
5127 symbol. We set the rel_hash entry for this
5128 reloc to point to the global hash table entry
5129 for this symbol. The symbol index is then
5130 set at the end of elf_bfd_final_link. */
5131 indx
= r_symndx
- extsymoff
;
5132 rh
= elf_sym_hashes (input_bfd
)[indx
];
5133 while (rh
->root
.type
== bfd_link_hash_indirect
5134 || rh
->root
.type
== bfd_link_hash_warning
)
5135 rh
= (struct elf_link_hash_entry
*) rh
->root
.u
.i
.link
;
5137 /* Setting the index to -2 tells
5138 elf_link_output_extsym that this symbol is
5140 BFD_ASSERT (rh
->indx
< 0);
5148 /* This is a reloc against a local symbol. */
5151 sym
= isymbuf
[r_symndx
];
5152 sec
= finfo
->sections
[r_symndx
];
5153 if (ELF_ST_TYPE (sym
.st_info
) == STT_SECTION
)
5155 /* I suppose the backend ought to fill in the
5156 section of any STT_SECTION symbol against a
5157 processor specific section. If we have
5158 discarded a section, the output_section will
5159 be the absolute section. */
5160 if (bfd_is_abs_section (sec
)
5162 && bfd_is_abs_section (sec
->output_section
)))
5164 else if (sec
== NULL
|| sec
->owner
== NULL
)
5166 bfd_set_error (bfd_error_bad_value
);
5171 r_symndx
= sec
->output_section
->target_index
;
5172 BFD_ASSERT (r_symndx
!= 0);
5175 /* Adjust the addend according to where the
5176 section winds up in the output section. */
5178 irela
->r_addend
+= sec
->output_offset
;
5182 if (finfo
->indices
[r_symndx
] == -1)
5184 unsigned long shlink
;
5188 if (finfo
->info
->strip
== strip_all
)
5190 /* You can't do ld -r -s. */
5191 bfd_set_error (bfd_error_invalid_operation
);
5195 /* This symbol was skipped earlier, but
5196 since it is needed by a reloc, we
5197 must output it now. */
5198 shlink
= symtab_hdr
->sh_link
;
5199 name
= (bfd_elf_string_from_elf_section
5200 (input_bfd
, shlink
, sym
.st_name
));
5204 osec
= sec
->output_section
;
5206 _bfd_elf_section_from_bfd_section (output_bfd
,
5208 if (sym
.st_shndx
== SHN_BAD
)
5211 sym
.st_value
+= sec
->output_offset
;
5212 if (! finfo
->info
->relocatable
)
5214 sym
.st_value
+= osec
->vma
;
5215 if (ELF_ST_TYPE (sym
.st_info
) == STT_TLS
)
5217 /* STT_TLS symbols are relative to PT_TLS
5219 BFD_ASSERT (finfo
->first_tls_sec
!= NULL
);
5220 sym
.st_value
-= finfo
->first_tls_sec
->vma
;
5224 finfo
->indices
[r_symndx
]
5225 = bfd_get_symcount (output_bfd
);
5227 if (! elf_link_output_sym (finfo
, name
, &sym
, sec
))
5231 r_symndx
= finfo
->indices
[r_symndx
];
5234 irela
->r_info
= ELF_R_INFO (r_symndx
,
5235 ELF_R_TYPE (irela
->r_info
));
5238 /* Swap out the relocs. */
5239 if (bed
->elf_backend_emit_relocs
5240 && !(finfo
->info
->relocatable
5241 || finfo
->info
->emitrelocations
))
5242 reloc_emitter
= bed
->elf_backend_emit_relocs
;
5244 reloc_emitter
= _bfd_elf_link_output_relocs
;
5246 if (input_rel_hdr
->sh_size
!= 0
5247 && ! (*reloc_emitter
) (output_bfd
, o
, input_rel_hdr
,
5251 input_rel_hdr2
= elf_section_data (o
)->rel_hdr2
;
5252 if (input_rel_hdr2
&& input_rel_hdr2
->sh_size
!= 0)
5254 internal_relocs
+= (NUM_SHDR_ENTRIES (input_rel_hdr
)
5255 * bed
->s
->int_rels_per_ext_rel
);
5256 if (! (*reloc_emitter
) (output_bfd
, o
, input_rel_hdr2
,
5263 /* Write out the modified section contents. */
5264 if (bed
->elf_backend_write_section
5265 && (*bed
->elf_backend_write_section
) (output_bfd
, o
, contents
))
5267 /* Section written out. */
5269 else switch (o
->sec_info_type
)
5271 case ELF_INFO_TYPE_STABS
:
5272 if (! (_bfd_write_section_stabs
5274 &elf_hash_table (finfo
->info
)->stab_info
,
5275 o
, &elf_section_data (o
)->sec_info
, contents
)))
5278 case ELF_INFO_TYPE_MERGE
:
5279 if (! _bfd_write_merged_section (output_bfd
, o
,
5280 elf_section_data (o
)->sec_info
))
5283 case ELF_INFO_TYPE_EH_FRAME
:
5285 if (! _bfd_elf_write_section_eh_frame (output_bfd
, finfo
->info
,
5292 bfd_size_type sec_size
;
5294 sec_size
= (o
->_cooked_size
!= 0 ? o
->_cooked_size
: o
->_raw_size
);
5295 if (! (o
->flags
& SEC_EXCLUDE
)
5296 && ! bfd_set_section_contents (output_bfd
, o
->output_section
,
5298 (file_ptr
) o
->output_offset
,
5309 /* Generate a reloc when linking an ELF file. This is a reloc
5310 requested by the linker, and does come from any input file. This
5311 is used to build constructor and destructor tables when linking
5315 elf_reloc_link_order (bfd
*output_bfd
,
5316 struct bfd_link_info
*info
,
5317 asection
*output_section
,
5318 struct bfd_link_order
*link_order
)
5320 reloc_howto_type
*howto
;
5324 struct elf_link_hash_entry
**rel_hash_ptr
;
5325 Elf_Internal_Shdr
*rel_hdr
;
5326 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
5327 Elf_Internal_Rela irel
[MAX_INT_RELS_PER_EXT_REL
];
5331 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
5334 bfd_set_error (bfd_error_bad_value
);
5338 addend
= link_order
->u
.reloc
.p
->addend
;
5340 /* Figure out the symbol index. */
5341 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
5342 + elf_section_data (output_section
)->rel_count
5343 + elf_section_data (output_section
)->rel_count2
);
5344 if (link_order
->type
== bfd_section_reloc_link_order
)
5346 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
5347 BFD_ASSERT (indx
!= 0);
5348 *rel_hash_ptr
= NULL
;
5352 struct elf_link_hash_entry
*h
;
5354 /* Treat a reloc against a defined symbol as though it were
5355 actually against the section. */
5356 h
= ((struct elf_link_hash_entry
*)
5357 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
5358 link_order
->u
.reloc
.p
->u
.name
,
5359 FALSE
, FALSE
, TRUE
));
5361 && (h
->root
.type
== bfd_link_hash_defined
5362 || h
->root
.type
== bfd_link_hash_defweak
))
5366 section
= h
->root
.u
.def
.section
;
5367 indx
= section
->output_section
->target_index
;
5368 *rel_hash_ptr
= NULL
;
5369 /* It seems that we ought to add the symbol value to the
5370 addend here, but in practice it has already been added
5371 because it was passed to constructor_callback. */
5372 addend
+= section
->output_section
->vma
+ section
->output_offset
;
5376 /* Setting the index to -2 tells elf_link_output_extsym that
5377 this symbol is used by a reloc. */
5384 if (! ((*info
->callbacks
->unattached_reloc
)
5385 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0)))
5391 /* If this is an inplace reloc, we must write the addend into the
5393 if (howto
->partial_inplace
&& addend
!= 0)
5396 bfd_reloc_status_type rstat
;
5399 const char *sym_name
;
5401 size
= bfd_get_reloc_size (howto
);
5402 buf
= bfd_zmalloc (size
);
5405 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
5412 case bfd_reloc_outofrange
:
5415 case bfd_reloc_overflow
:
5416 if (link_order
->type
== bfd_section_reloc_link_order
)
5417 sym_name
= bfd_section_name (output_bfd
,
5418 link_order
->u
.reloc
.p
->u
.section
);
5420 sym_name
= link_order
->u
.reloc
.p
->u
.name
;
5421 if (! ((*info
->callbacks
->reloc_overflow
)
5422 (info
, sym_name
, howto
->name
, addend
, NULL
, NULL
, 0)))
5429 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
5430 link_order
->offset
, size
);
5436 /* The address of a reloc is relative to the section in a
5437 relocatable file, and is a virtual address in an executable
5439 offset
= link_order
->offset
;
5440 if (! info
->relocatable
)
5441 offset
+= output_section
->vma
;
5443 for (i
= 0; i
< bed
->s
->int_rels_per_ext_rel
; i
++)
5445 irel
[i
].r_offset
= offset
;
5447 irel
[i
].r_addend
= 0;
5449 irel
[0].r_info
= ELF_R_INFO (indx
, howto
->type
);
5451 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
5452 erel
= rel_hdr
->contents
;
5453 if (rel_hdr
->sh_type
== SHT_REL
)
5455 erel
+= (elf_section_data (output_section
)->rel_count
5456 * sizeof (Elf_External_Rel
));
5457 (*bed
->s
->swap_reloc_out
) (output_bfd
, irel
, erel
);
5461 irel
[0].r_addend
= addend
;
5462 erel
+= (elf_section_data (output_section
)->rel_count
5463 * sizeof (Elf_External_Rela
));
5464 (*bed
->s
->swap_reloca_out
) (output_bfd
, irel
, erel
);
5467 ++elf_section_data (output_section
)->rel_count
;
5472 /* Garbage collect unused sections. */
5474 static bfd_boolean elf_gc_sweep_symbol
5475 (struct elf_link_hash_entry
*, void *);
5477 static bfd_boolean elf_gc_allocate_got_offsets
5478 (struct elf_link_hash_entry
*, void *);
5480 /* The mark phase of garbage collection. For a given section, mark
5481 it and any sections in this section's group, and all the sections
5482 which define symbols to which it refers. */
5484 typedef asection
* (*gc_mark_hook_fn
)
5485 (asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5486 struct elf_link_hash_entry
*, Elf_Internal_Sym
*);
5489 elf_gc_mark (struct bfd_link_info
*info
,
5491 gc_mark_hook_fn gc_mark_hook
)
5494 asection
*group_sec
;
5498 /* Mark all the sections in the group. */
5499 group_sec
= elf_section_data (sec
)->next_in_group
;
5500 if (group_sec
&& !group_sec
->gc_mark
)
5501 if (!elf_gc_mark (info
, group_sec
, gc_mark_hook
))
5504 /* Look through the section relocs. */
5506 if ((sec
->flags
& SEC_RELOC
) != 0 && sec
->reloc_count
> 0)
5508 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
5509 Elf_Internal_Shdr
*symtab_hdr
;
5510 struct elf_link_hash_entry
**sym_hashes
;
5513 bfd
*input_bfd
= sec
->owner
;
5514 const struct elf_backend_data
*bed
= get_elf_backend_data (input_bfd
);
5515 Elf_Internal_Sym
*isym
= NULL
;
5517 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5518 sym_hashes
= elf_sym_hashes (input_bfd
);
5520 /* Read the local symbols. */
5521 if (elf_bad_symtab (input_bfd
))
5523 nlocsyms
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
5527 extsymoff
= nlocsyms
= symtab_hdr
->sh_info
;
5529 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5530 if (isym
== NULL
&& nlocsyms
!= 0)
5532 isym
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, nlocsyms
, 0,
5538 /* Read the relocations. */
5539 relstart
= _bfd_elf_link_read_relocs (input_bfd
, sec
, NULL
, NULL
,
5541 if (relstart
== NULL
)
5546 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5548 for (rel
= relstart
; rel
< relend
; rel
++)
5550 unsigned long r_symndx
;
5552 struct elf_link_hash_entry
*h
;
5554 r_symndx
= ELF_R_SYM (rel
->r_info
);
5558 if (r_symndx
>= nlocsyms
5559 || ELF_ST_BIND (isym
[r_symndx
].st_info
) != STB_LOCAL
)
5561 h
= sym_hashes
[r_symndx
- extsymoff
];
5562 rsec
= (*gc_mark_hook
) (sec
, info
, rel
, h
, NULL
);
5566 rsec
= (*gc_mark_hook
) (sec
, info
, rel
, NULL
, &isym
[r_symndx
]);
5569 if (rsec
&& !rsec
->gc_mark
)
5571 if (bfd_get_flavour (rsec
->owner
) != bfd_target_elf_flavour
)
5573 else if (!elf_gc_mark (info
, rsec
, gc_mark_hook
))
5582 if (elf_section_data (sec
)->relocs
!= relstart
)
5585 if (isym
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isym
)
5587 if (! info
->keep_memory
)
5590 symtab_hdr
->contents
= (unsigned char *) isym
;
5597 /* The sweep phase of garbage collection. Remove all garbage sections. */
5599 typedef bfd_boolean (*gc_sweep_hook_fn
)
5600 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
5603 elf_gc_sweep (struct bfd_link_info
*info
, gc_sweep_hook_fn gc_sweep_hook
)
5607 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5611 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
5614 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5616 /* Keep special sections. Keep .debug sections. */
5617 if ((o
->flags
& SEC_LINKER_CREATED
)
5618 || (o
->flags
& SEC_DEBUGGING
))
5624 /* Skip sweeping sections already excluded. */
5625 if (o
->flags
& SEC_EXCLUDE
)
5628 /* Since this is early in the link process, it is simple
5629 to remove a section from the output. */
5630 o
->flags
|= SEC_EXCLUDE
;
5632 /* But we also have to update some of the relocation
5633 info we collected before. */
5635 && (o
->flags
& SEC_RELOC
) && o
->reloc_count
> 0)
5637 Elf_Internal_Rela
*internal_relocs
;
5641 = _bfd_elf_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
5643 if (internal_relocs
== NULL
)
5646 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
5648 if (elf_section_data (o
)->relocs
!= internal_relocs
)
5649 free (internal_relocs
);
5657 /* Remove the symbols that were in the swept sections from the dynamic
5658 symbol table. GCFIXME: Anyone know how to get them out of the
5659 static symbol table as well? */
5663 elf_link_hash_traverse (elf_hash_table (info
), elf_gc_sweep_symbol
, &i
);
5665 elf_hash_table (info
)->dynsymcount
= i
;
5671 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
5674 elf_gc_sweep_symbol (struct elf_link_hash_entry
*h
, void *idxptr
)
5678 if (h
->root
.type
== bfd_link_hash_warning
)
5679 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5681 if (h
->dynindx
!= -1
5682 && ((h
->root
.type
!= bfd_link_hash_defined
5683 && h
->root
.type
!= bfd_link_hash_defweak
)
5684 || h
->root
.u
.def
.section
->gc_mark
))
5685 h
->dynindx
= (*idx
)++;
5690 /* Propogate collected vtable information. This is called through
5691 elf_link_hash_traverse. */
5694 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry
*h
, void *okp
)
5696 if (h
->root
.type
== bfd_link_hash_warning
)
5697 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5699 /* Those that are not vtables. */
5700 if (h
->vtable_parent
== NULL
)
5703 /* Those vtables that do not have parents, we cannot merge. */
5704 if (h
->vtable_parent
== (struct elf_link_hash_entry
*) -1)
5707 /* If we've already been done, exit. */
5708 if (h
->vtable_entries_used
&& h
->vtable_entries_used
[-1])
5711 /* Make sure the parent's table is up to date. */
5712 elf_gc_propagate_vtable_entries_used (h
->vtable_parent
, okp
);
5714 if (h
->vtable_entries_used
== NULL
)
5716 /* None of this table's entries were referenced. Re-use the
5718 h
->vtable_entries_used
= h
->vtable_parent
->vtable_entries_used
;
5719 h
->vtable_entries_size
= h
->vtable_parent
->vtable_entries_size
;
5724 bfd_boolean
*cu
, *pu
;
5726 /* Or the parent's entries into ours. */
5727 cu
= h
->vtable_entries_used
;
5729 pu
= h
->vtable_parent
->vtable_entries_used
;
5732 const struct elf_backend_data
*bed
;
5733 unsigned int log_file_align
;
5735 bed
= get_elf_backend_data (h
->root
.u
.def
.section
->owner
);
5736 log_file_align
= bed
->s
->log_file_align
;
5737 n
= h
->vtable_parent
->vtable_entries_size
>> log_file_align
;
5752 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry
*h
, void *okp
)
5755 bfd_vma hstart
, hend
;
5756 Elf_Internal_Rela
*relstart
, *relend
, *rel
;
5757 const struct elf_backend_data
*bed
;
5758 unsigned int log_file_align
;
5760 if (h
->root
.type
== bfd_link_hash_warning
)
5761 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5763 /* Take care of both those symbols that do not describe vtables as
5764 well as those that are not loaded. */
5765 if (h
->vtable_parent
== NULL
)
5768 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5769 || h
->root
.type
== bfd_link_hash_defweak
);
5771 sec
= h
->root
.u
.def
.section
;
5772 hstart
= h
->root
.u
.def
.value
;
5773 hend
= hstart
+ h
->size
;
5775 relstart
= _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, TRUE
);
5777 return *(bfd_boolean
*) okp
= FALSE
;
5778 bed
= get_elf_backend_data (sec
->owner
);
5779 log_file_align
= bed
->s
->log_file_align
;
5781 relend
= relstart
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5783 for (rel
= relstart
; rel
< relend
; ++rel
)
5784 if (rel
->r_offset
>= hstart
&& rel
->r_offset
< hend
)
5786 /* If the entry is in use, do nothing. */
5787 if (h
->vtable_entries_used
5788 && (rel
->r_offset
- hstart
) < h
->vtable_entries_size
)
5790 bfd_vma entry
= (rel
->r_offset
- hstart
) >> log_file_align
;
5791 if (h
->vtable_entries_used
[entry
])
5794 /* Otherwise, kill it. */
5795 rel
->r_offset
= rel
->r_info
= rel
->r_addend
= 0;
5801 /* Do mark and sweep of unused sections. */
5804 elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5806 bfd_boolean ok
= TRUE
;
5808 asection
* (*gc_mark_hook
)
5809 (asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5810 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*);
5812 if (!get_elf_backend_data (abfd
)->can_gc_sections
5813 || info
->relocatable
|| info
->emitrelocations
5814 || elf_hash_table (info
)->dynamic_sections_created
)
5817 /* Apply transitive closure to the vtable entry usage info. */
5818 elf_link_hash_traverse (elf_hash_table (info
),
5819 elf_gc_propagate_vtable_entries_used
,
5824 /* Kill the vtable relocations that were not used. */
5825 elf_link_hash_traverse (elf_hash_table (info
),
5826 elf_gc_smash_unused_vtentry_relocs
,
5831 /* Grovel through relocs to find out who stays ... */
5833 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
5834 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
5838 if (bfd_get_flavour (sub
) != bfd_target_elf_flavour
)
5841 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
5843 if (o
->flags
& SEC_KEEP
)
5844 if (!elf_gc_mark (info
, o
, gc_mark_hook
))
5849 /* ... and mark SEC_EXCLUDE for those that go. */
5850 if (!elf_gc_sweep (info
, get_elf_backend_data (abfd
)->gc_sweep_hook
))
5856 /* Called from check_relocs to record the existance of a VTINHERIT reloc. */
5859 elf_gc_record_vtinherit (bfd
*abfd
,
5861 struct elf_link_hash_entry
*h
,
5864 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
5865 struct elf_link_hash_entry
**search
, *child
;
5866 bfd_size_type extsymcount
;
5868 /* The sh_info field of the symtab header tells us where the
5869 external symbols start. We don't care about the local symbols at
5871 extsymcount
= elf_tdata (abfd
)->symtab_hdr
.sh_size
/sizeof (Elf_External_Sym
);
5872 if (!elf_bad_symtab (abfd
))
5873 extsymcount
-= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
5875 sym_hashes
= elf_sym_hashes (abfd
);
5876 sym_hashes_end
= sym_hashes
+ extsymcount
;
5878 /* Hunt down the child symbol, which is in this section at the same
5879 offset as the relocation. */
5880 for (search
= sym_hashes
; search
!= sym_hashes_end
; ++search
)
5882 if ((child
= *search
) != NULL
5883 && (child
->root
.type
== bfd_link_hash_defined
5884 || child
->root
.type
== bfd_link_hash_defweak
)
5885 && child
->root
.u
.def
.section
== sec
5886 && child
->root
.u
.def
.value
== offset
)
5890 (*_bfd_error_handler
) ("%s: %s+%lu: No symbol found for INHERIT",
5891 bfd_archive_filename (abfd
), sec
->name
,
5892 (unsigned long) offset
);
5893 bfd_set_error (bfd_error_invalid_operation
);
5899 /* This *should* only be the absolute section. It could potentially
5900 be that someone has defined a non-global vtable though, which
5901 would be bad. It isn't worth paging in the local symbols to be
5902 sure though; that case should simply be handled by the assembler. */
5904 child
->vtable_parent
= (struct elf_link_hash_entry
*) -1;
5907 child
->vtable_parent
= h
;
5912 /* Called from check_relocs to record the existance of a VTENTRY reloc. */
5915 elf_gc_record_vtentry (bfd
*abfd ATTRIBUTE_UNUSED
,
5916 asection
*sec ATTRIBUTE_UNUSED
,
5917 struct elf_link_hash_entry
*h
,
5920 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5921 unsigned int log_file_align
= bed
->s
->log_file_align
;
5923 if (addend
>= h
->vtable_entries_size
)
5925 size_t size
, bytes
, file_align
;
5926 bfd_boolean
*ptr
= h
->vtable_entries_used
;
5928 /* While the symbol is undefined, we have to be prepared to handle
5930 file_align
= 1 << log_file_align
;
5931 if (h
->root
.type
== bfd_link_hash_undefined
)
5932 size
= addend
+ file_align
;
5938 /* Oops! We've got a reference past the defined end of
5939 the table. This is probably a bug -- shall we warn? */
5940 size
= addend
+ file_align
;
5943 size
= (size
+ file_align
- 1) & -file_align
;
5945 /* Allocate one extra entry for use as a "done" flag for the
5946 consolidation pass. */
5947 bytes
= ((size
>> log_file_align
) + 1) * sizeof (bfd_boolean
);
5951 ptr
= bfd_realloc (ptr
- 1, bytes
);
5957 oldbytes
= (((h
->vtable_entries_size
>> log_file_align
) + 1)
5958 * sizeof (bfd_boolean
));
5959 memset (((char *) ptr
) + oldbytes
, 0, bytes
- oldbytes
);
5963 ptr
= bfd_zmalloc (bytes
);
5968 /* And arrange for that done flag to be at index -1. */
5969 h
->vtable_entries_used
= ptr
+ 1;
5970 h
->vtable_entries_size
= size
;
5973 h
->vtable_entries_used
[addend
>> log_file_align
] = TRUE
;
5978 /* And an accompanying bit to work out final got entry offsets once
5979 we're done. Should be called from final_link. */
5982 elf_gc_common_finalize_got_offsets (bfd
*abfd
,
5983 struct bfd_link_info
*info
)
5986 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5989 /* The GOT offset is relative to the .got section, but the GOT header is
5990 put into the .got.plt section, if the backend uses it. */
5991 if (bed
->want_got_plt
)
5994 gotoff
= bed
->got_header_size
;
5996 /* Do the local .got entries first. */
5997 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
5999 bfd_signed_vma
*local_got
;
6000 bfd_size_type j
, locsymcount
;
6001 Elf_Internal_Shdr
*symtab_hdr
;
6003 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
6006 local_got
= elf_local_got_refcounts (i
);
6010 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
6011 if (elf_bad_symtab (i
))
6012 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6014 locsymcount
= symtab_hdr
->sh_info
;
6016 for (j
= 0; j
< locsymcount
; ++j
)
6018 if (local_got
[j
] > 0)
6020 local_got
[j
] = gotoff
;
6021 gotoff
+= ARCH_SIZE
/ 8;
6024 local_got
[j
] = (bfd_vma
) -1;
6028 /* Then the global .got entries. .plt refcounts are handled by
6029 adjust_dynamic_symbol */
6030 elf_link_hash_traverse (elf_hash_table (info
),
6031 elf_gc_allocate_got_offsets
,
6036 /* We need a special top-level link routine to convert got reference counts
6037 to real got offsets. */
6040 elf_gc_allocate_got_offsets (struct elf_link_hash_entry
*h
, void *offarg
)
6042 bfd_vma
*off
= offarg
;
6044 if (h
->root
.type
== bfd_link_hash_warning
)
6045 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6047 if (h
->got
.refcount
> 0)
6049 h
->got
.offset
= off
[0];
6050 off
[0] += ARCH_SIZE
/ 8;
6053 h
->got
.offset
= (bfd_vma
) -1;
6058 /* Many folk need no more in the way of final link than this, once
6059 got entry reference counting is enabled. */
6062 elf_gc_common_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
6064 if (!elf_gc_common_finalize_got_offsets (abfd
, info
))
6067 /* Invoke the regular ELF backend linker to do all the work. */
6068 return elf_bfd_final_link (abfd
, info
);
6071 /* This function will be called though elf_link_hash_traverse to store
6072 all hash value of the exported symbols in an array. */
6075 elf_collect_hash_codes (struct elf_link_hash_entry
*h
, void *data
)
6077 unsigned long **valuep
= data
;
6083 if (h
->root
.type
== bfd_link_hash_warning
)
6084 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6086 /* Ignore indirect symbols. These are added by the versioning code. */
6087 if (h
->dynindx
== -1)
6090 name
= h
->root
.root
.string
;
6091 p
= strchr (name
, ELF_VER_CHR
);
6094 alc
= bfd_malloc (p
- name
+ 1);
6095 memcpy (alc
, name
, p
- name
);
6096 alc
[p
- name
] = '\0';
6100 /* Compute the hash value. */
6101 ha
= bfd_elf_hash (name
);
6103 /* Store the found hash value in the array given as the argument. */
6106 /* And store it in the struct so that we can put it in the hash table
6108 h
->elf_hash_value
= ha
;
6117 elf_reloc_symbol_deleted_p (bfd_vma offset
, void *cookie
)
6119 struct elf_reloc_cookie
*rcookie
= cookie
;
6121 if (rcookie
->bad_symtab
)
6122 rcookie
->rel
= rcookie
->rels
;
6124 for (; rcookie
->rel
< rcookie
->relend
; rcookie
->rel
++)
6126 unsigned long r_symndx
;
6128 if (! rcookie
->bad_symtab
)
6129 if (rcookie
->rel
->r_offset
> offset
)
6131 if (rcookie
->rel
->r_offset
!= offset
)
6134 r_symndx
= ELF_R_SYM (rcookie
->rel
->r_info
);
6135 if (r_symndx
== SHN_UNDEF
)
6138 if (r_symndx
>= rcookie
->locsymcount
6139 || ELF_ST_BIND (rcookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
6141 struct elf_link_hash_entry
*h
;
6143 h
= rcookie
->sym_hashes
[r_symndx
- rcookie
->extsymoff
];
6145 while (h
->root
.type
== bfd_link_hash_indirect
6146 || h
->root
.type
== bfd_link_hash_warning
)
6147 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6149 if ((h
->root
.type
== bfd_link_hash_defined
6150 || h
->root
.type
== bfd_link_hash_defweak
)
6151 && elf_discarded_section (h
->root
.u
.def
.section
))
6158 /* It's not a relocation against a global symbol,
6159 but it could be a relocation against a local
6160 symbol for a discarded section. */
6162 Elf_Internal_Sym
*isym
;
6164 /* Need to: get the symbol; get the section. */
6165 isym
= &rcookie
->locsyms
[r_symndx
];
6166 if (isym
->st_shndx
< SHN_LORESERVE
|| isym
->st_shndx
> SHN_HIRESERVE
)
6168 isec
= section_from_elf_index (rcookie
->abfd
, isym
->st_shndx
);
6169 if (isec
!= NULL
&& elf_discarded_section (isec
))
6178 /* Discard unneeded references to discarded sections.
6179 Returns TRUE if any section's size was changed. */
6180 /* This function assumes that the relocations are in sorted order,
6181 which is true for all known assemblers. */
6184 elf_bfd_discard_info (bfd
*output_bfd
, struct bfd_link_info
*info
)
6186 struct elf_reloc_cookie cookie
;
6187 asection
*stab
, *eh
;
6188 Elf_Internal_Shdr
*symtab_hdr
;
6189 const struct elf_backend_data
*bed
;
6192 bfd_boolean ret
= FALSE
;
6194 if (info
->traditional_format
6195 || info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
6196 || ! is_elf_hash_table (info
))
6199 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
6201 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6204 bed
= get_elf_backend_data (abfd
);
6206 if ((abfd
->flags
& DYNAMIC
) != 0)
6209 eh
= bfd_get_section_by_name (abfd
, ".eh_frame");
6210 if (info
->relocatable
6212 && (eh
->_raw_size
== 0
6213 || bfd_is_abs_section (eh
->output_section
))))
6216 stab
= bfd_get_section_by_name (abfd
, ".stab");
6218 && (stab
->_raw_size
== 0
6219 || bfd_is_abs_section (stab
->output_section
)
6220 || stab
->sec_info_type
!= ELF_INFO_TYPE_STABS
))
6225 && bed
->elf_backend_discard_info
== NULL
)
6228 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6230 cookie
.sym_hashes
= elf_sym_hashes (abfd
);
6231 cookie
.bad_symtab
= elf_bad_symtab (abfd
);
6232 if (cookie
.bad_symtab
)
6234 cookie
.locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
6235 cookie
.extsymoff
= 0;
6239 cookie
.locsymcount
= symtab_hdr
->sh_info
;
6240 cookie
.extsymoff
= symtab_hdr
->sh_info
;
6243 cookie
.locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6244 if (cookie
.locsyms
== NULL
&& cookie
.locsymcount
!= 0)
6246 cookie
.locsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
6247 cookie
.locsymcount
, 0,
6249 if (cookie
.locsyms
== NULL
)
6256 count
= stab
->reloc_count
;
6258 cookie
.rels
= _bfd_elf_link_read_relocs (abfd
, stab
, NULL
, NULL
,
6260 if (cookie
.rels
!= NULL
)
6262 cookie
.rel
= cookie
.rels
;
6263 cookie
.relend
= cookie
.rels
;
6264 cookie
.relend
+= count
* bed
->s
->int_rels_per_ext_rel
;
6265 if (_bfd_discard_section_stabs (abfd
, stab
,
6266 elf_section_data (stab
)->sec_info
,
6267 elf_reloc_symbol_deleted_p
,
6270 if (elf_section_data (stab
)->relocs
!= cookie
.rels
)
6278 count
= eh
->reloc_count
;
6280 cookie
.rels
= _bfd_elf_link_read_relocs (abfd
, eh
, NULL
, NULL
,
6282 cookie
.rel
= cookie
.rels
;
6283 cookie
.relend
= cookie
.rels
;
6284 if (cookie
.rels
!= NULL
)
6285 cookie
.relend
+= count
* bed
->s
->int_rels_per_ext_rel
;
6287 if (_bfd_elf_discard_section_eh_frame (abfd
, info
, eh
,
6288 elf_reloc_symbol_deleted_p
,
6292 if (cookie
.rels
!= NULL
6293 && elf_section_data (eh
)->relocs
!= cookie
.rels
)
6297 if (bed
->elf_backend_discard_info
!= NULL
6298 && (*bed
->elf_backend_discard_info
) (abfd
, &cookie
, info
))
6301 if (cookie
.locsyms
!= NULL
6302 && symtab_hdr
->contents
!= (unsigned char *) cookie
.locsyms
)
6304 if (! info
->keep_memory
)
6305 free (cookie
.locsyms
);
6307 symtab_hdr
->contents
= (unsigned char *) cookie
.locsyms
;
6311 if (info
->eh_frame_hdr
6312 && !info
->relocatable
6313 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd
, info
))
6320 elf_section_ignore_discarded_relocs (asection
*sec
)
6322 const struct elf_backend_data
*bed
;
6324 switch (sec
->sec_info_type
)
6326 case ELF_INFO_TYPE_STABS
:
6327 case ELF_INFO_TYPE_EH_FRAME
:
6333 bed
= get_elf_backend_data (sec
->owner
);
6334 if (bed
->elf_backend_ignore_discarded_relocs
!= NULL
6335 && (*bed
->elf_backend_ignore_discarded_relocs
) (sec
))