2 Copyright 1995, 1996, 1997 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 static boolean elf_link_add_object_symbols
23 PARAMS ((bfd
*, struct bfd_link_info
*));
24 static boolean elf_link_add_archive_symbols
25 PARAMS ((bfd
*, struct bfd_link_info
*));
26 static boolean elf_export_symbol
27 PARAMS ((struct elf_link_hash_entry
*, PTR
));
28 static boolean elf_adjust_dynamic_symbol
29 PARAMS ((struct elf_link_hash_entry
*, PTR
));
31 /* This struct is used to pass information to routines called via
32 elf_link_hash_traverse which must return failure. */
34 struct elf_info_failed
37 struct bfd_link_info
*info
;
40 /* Given an ELF BFD, add symbols to the global hash table as
44 elf_bfd_link_add_symbols (abfd
, info
)
46 struct bfd_link_info
*info
;
48 switch (bfd_get_format (abfd
))
51 return elf_link_add_object_symbols (abfd
, info
);
53 return elf_link_add_archive_symbols (abfd
, info
);
55 bfd_set_error (bfd_error_wrong_format
);
61 /* Add symbols from an ELF archive file to the linker hash table. We
62 don't use _bfd_generic_link_add_archive_symbols because of a
63 problem which arises on UnixWare. The UnixWare libc.so is an
64 archive which includes an entry libc.so.1 which defines a bunch of
65 symbols. The libc.so archive also includes a number of other
66 object files, which also define symbols, some of which are the same
67 as those defined in libc.so.1. Correct linking requires that we
68 consider each object file in turn, and include it if it defines any
69 symbols we need. _bfd_generic_link_add_archive_symbols does not do
70 this; it looks through the list of undefined symbols, and includes
71 any object file which defines them. When this algorithm is used on
72 UnixWare, it winds up pulling in libc.so.1 early and defining a
73 bunch of symbols. This means that some of the other objects in the
74 archive are not included in the link, which is incorrect since they
75 precede libc.so.1 in the archive.
77 Fortunately, ELF archive handling is simpler than that done by
78 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
79 oddities. In ELF, if we find a symbol in the archive map, and the
80 symbol is currently undefined, we know that we must pull in that
83 Unfortunately, we do have to make multiple passes over the symbol
84 table until nothing further is resolved. */
87 elf_link_add_archive_symbols (abfd
, info
)
89 struct bfd_link_info
*info
;
92 boolean
*defined
= NULL
;
93 boolean
*included
= NULL
;
97 if (! bfd_has_map (abfd
))
99 /* An empty archive is a special case. */
100 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
102 bfd_set_error (bfd_error_no_armap
);
106 /* Keep track of all symbols we know to be already defined, and all
107 files we know to be already included. This is to speed up the
108 second and subsequent passes. */
109 c
= bfd_ardata (abfd
)->symdef_count
;
112 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
113 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
114 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
116 memset (defined
, 0, c
* sizeof (boolean
));
117 memset (included
, 0, c
* sizeof (boolean
));
119 symdefs
= bfd_ardata (abfd
)->symdefs
;
132 symdefend
= symdef
+ c
;
133 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
135 struct elf_link_hash_entry
*h
;
137 struct bfd_link_hash_entry
*undefs_tail
;
140 if (defined
[i
] || included
[i
])
142 if (symdef
->file_offset
== last
)
148 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
149 false, false, false);
150 if (h
== (struct elf_link_hash_entry
*) NULL
)
152 if (h
->root
.type
!= bfd_link_hash_undefined
)
154 if (h
->root
.type
!= bfd_link_hash_undefweak
)
159 /* We need to include this archive member. */
161 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
162 if (element
== (bfd
*) NULL
)
165 if (! bfd_check_format (element
, bfd_object
))
168 /* Doublecheck that we have not included this object
169 already--it should be impossible, but there may be
170 something wrong with the archive. */
171 if (element
->archive_pass
!= 0)
173 bfd_set_error (bfd_error_bad_value
);
176 element
->archive_pass
= 1;
178 undefs_tail
= info
->hash
->undefs_tail
;
180 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
183 if (! elf_link_add_object_symbols (element
, info
))
186 /* If there are any new undefined symbols, we need to make
187 another pass through the archive in order to see whether
188 they can be defined. FIXME: This isn't perfect, because
189 common symbols wind up on undefs_tail and because an
190 undefined symbol which is defined later on in this pass
191 does not require another pass. This isn't a bug, but it
192 does make the code less efficient than it could be. */
193 if (undefs_tail
!= info
->hash
->undefs_tail
)
196 /* Look backward to mark all symbols from this object file
197 which we have already seen in this pass. */
201 included
[mark
] = true;
206 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
208 /* We mark subsequent symbols from this object file as we go
209 on through the loop. */
210 last
= symdef
->file_offset
;
221 if (defined
!= (boolean
*) NULL
)
223 if (included
!= (boolean
*) NULL
)
228 /* Add symbols from an ELF object file to the linker hash table. */
231 elf_link_add_object_symbols (abfd
, info
)
233 struct bfd_link_info
*info
;
235 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
236 const Elf_Internal_Sym
*,
237 const char **, flagword
*,
238 asection
**, bfd_vma
*));
239 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
240 asection
*, const Elf_Internal_Rela
*));
242 Elf_Internal_Shdr
*hdr
;
246 Elf_External_Sym
*buf
= NULL
;
247 struct elf_link_hash_entry
**sym_hash
;
249 Elf_External_Dyn
*dynbuf
= NULL
;
250 struct elf_link_hash_entry
*weaks
;
251 Elf_External_Sym
*esym
;
252 Elf_External_Sym
*esymend
;
254 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
255 collect
= get_elf_backend_data (abfd
)->collect
;
257 /* As a GNU extension, any input sections which are named
258 .gnu.warning.SYMBOL are treated as warning symbols for the given
259 symbol. This differs from .gnu.warning sections, which generate
260 warnings when they are included in an output file. */
265 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
269 name
= bfd_get_section_name (abfd
, s
);
270 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
275 name
+= sizeof ".gnu.warning." - 1;
277 /* If this is a shared object, then look up the symbol
278 in the hash table. If it is there, and it is already
279 been defined, then we will not be using the entry
280 from this shared object, so we don't need to warn.
281 FIXME: If we see the definition in a regular object
282 later on, we will warn, but we shouldn't. The only
283 fix is to keep track of what warnings we are supposed
284 to emit, and then handle them all at the end of the
286 if ((abfd
->flags
& DYNAMIC
) != 0
287 && abfd
->xvec
== info
->hash
->creator
)
289 struct elf_link_hash_entry
*h
;
291 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
294 /* FIXME: What about bfd_link_hash_common? */
296 && (h
->root
.type
== bfd_link_hash_defined
297 || h
->root
.type
== bfd_link_hash_defweak
))
299 /* We don't want to issue this warning. Clobber
300 the section size so that the warning does not
301 get copied into the output file. */
307 sz
= bfd_section_size (abfd
, s
);
308 msg
= (char *) bfd_alloc (abfd
, sz
);
312 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
315 if (! (_bfd_generic_link_add_one_symbol
316 (info
, abfd
, name
, BSF_WARNING
, s
, (bfd_vma
) 0, msg
,
317 false, collect
, (struct bfd_link_hash_entry
**) NULL
)))
320 if (! info
->relocateable
)
322 /* Clobber the section size so that the warning does
323 not get copied into the output file. */
330 /* A stripped shared library might only have a dynamic symbol table,
331 not a regular symbol table. In that case we can still go ahead
332 and link using the dynamic symbol table. */
333 if (elf_onesymtab (abfd
) == 0
334 && elf_dynsymtab (abfd
) != 0)
336 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
337 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
340 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
341 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
343 /* The sh_info field of the symtab header tells us where the
344 external symbols start. We don't care about the local symbols at
346 if (elf_bad_symtab (abfd
))
348 extsymcount
= symcount
;
353 extsymcount
= symcount
- hdr
->sh_info
;
354 extsymoff
= hdr
->sh_info
;
357 buf
= ((Elf_External_Sym
*)
358 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
359 if (buf
== NULL
&& extsymcount
!= 0)
362 /* We store a pointer to the hash table entry for each external
364 sym_hash
= ((struct elf_link_hash_entry
**)
366 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
367 if (sym_hash
== NULL
)
369 elf_sym_hashes (abfd
) = sym_hash
;
371 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
375 /* If we are creating a shared library, create all the dynamic
376 sections immediately. We need to attach them to something,
377 so we attach them to this BFD, provided it is the right
378 format. FIXME: If there are no input BFD's of the same
379 format as the output, we can't make a shared library. */
381 && ! elf_hash_table (info
)->dynamic_sections_created
382 && abfd
->xvec
== info
->hash
->creator
)
384 if (! elf_link_create_dynamic_sections (abfd
, info
))
393 bfd_size_type oldsize
;
394 bfd_size_type strindex
;
398 /* You can't use -r against a dynamic object. Also, there's no
399 hope of using a dynamic object which does not exactly match
400 the format of the output file. */
401 if (info
->relocateable
402 || info
->hash
->creator
!= abfd
->xvec
)
404 bfd_set_error (bfd_error_invalid_operation
);
408 /* Find the name to use in a DT_NEEDED entry that refers to this
409 object. If the object has a DT_SONAME entry, we use it.
410 Otherwise, if the generic linker stuck something in
411 elf_dt_name, we use that. Otherwise, we just use the file
412 name. If the generic linker put a null string into
413 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
414 there is a DT_SONAME entry. */
416 name
= bfd_get_filename (abfd
);
417 if (elf_dt_name (abfd
) != NULL
)
419 name
= elf_dt_name (abfd
);
423 s
= bfd_get_section_by_name (abfd
, ".dynamic");
426 Elf_External_Dyn
*extdyn
;
427 Elf_External_Dyn
*extdynend
;
431 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
435 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
436 (file_ptr
) 0, s
->_raw_size
))
439 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
442 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
445 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
446 for (; extdyn
< extdynend
; extdyn
++)
448 Elf_Internal_Dyn dyn
;
450 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
451 if (dyn
.d_tag
== DT_SONAME
)
453 name
= bfd_elf_string_from_elf_section (abfd
, link
,
458 if (dyn
.d_tag
== DT_NEEDED
)
460 struct bfd_link_needed_list
*n
, **pn
;
463 n
= ((struct bfd_link_needed_list
*)
464 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
465 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
467 if (n
== NULL
|| fnm
== NULL
)
469 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
476 for (pn
= &elf_hash_table (info
)->needed
;
488 /* We do not want to include any of the sections in a dynamic
489 object in the output file. We hack by simply clobbering the
490 list of sections in the BFD. This could be handled more
491 cleanly by, say, a new section flag; the existing
492 SEC_NEVER_LOAD flag is not the one we want, because that one
493 still implies that the section takes up space in the output
495 abfd
->sections
= NULL
;
496 abfd
->section_count
= 0;
498 /* If this is the first dynamic object found in the link, create
499 the special sections required for dynamic linking. */
500 if (! elf_hash_table (info
)->dynamic_sections_created
)
502 if (! elf_link_create_dynamic_sections (abfd
, info
))
508 /* Add a DT_NEEDED entry for this dynamic object. */
509 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
510 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
512 if (strindex
== (bfd_size_type
) -1)
515 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
518 Elf_External_Dyn
*dyncon
, *dynconend
;
520 /* The hash table size did not change, which means that
521 the dynamic object name was already entered. If we
522 have already included this dynamic object in the
523 link, just ignore it. There is no reason to include
524 a particular dynamic object more than once. */
525 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
527 BFD_ASSERT (sdyn
!= NULL
);
529 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
530 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
532 for (; dyncon
< dynconend
; dyncon
++)
534 Elf_Internal_Dyn dyn
;
536 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
538 if (dyn
.d_tag
== DT_NEEDED
539 && dyn
.d_un
.d_val
== strindex
)
548 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
552 /* Save the SONAME, if there is one, because sometimes the
553 linker emulation code will need to know it. */
555 name
= bfd_get_filename (abfd
);
556 elf_dt_name (abfd
) = name
;
560 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
562 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
563 != extsymcount
* sizeof (Elf_External_Sym
)))
568 esymend
= buf
+ extsymcount
;
569 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
571 Elf_Internal_Sym sym
;
577 struct elf_link_hash_entry
*h
;
579 boolean size_change_ok
, type_change_ok
;
582 elf_swap_symbol_in (abfd
, esym
, &sym
);
584 flags
= BSF_NO_FLAGS
;
586 value
= sym
.st_value
;
589 bind
= ELF_ST_BIND (sym
.st_info
);
590 if (bind
== STB_LOCAL
)
592 /* This should be impossible, since ELF requires that all
593 global symbols follow all local symbols, and that sh_info
594 point to the first global symbol. Unfortunatealy, Irix 5
598 else if (bind
== STB_GLOBAL
)
600 if (sym
.st_shndx
!= SHN_UNDEF
601 && sym
.st_shndx
!= SHN_COMMON
)
606 else if (bind
== STB_WEAK
)
610 /* Leave it up to the processor backend. */
613 if (sym
.st_shndx
== SHN_UNDEF
)
614 sec
= bfd_und_section_ptr
;
615 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
617 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
621 sec
= bfd_abs_section_ptr
;
623 else if (sym
.st_shndx
== SHN_ABS
)
624 sec
= bfd_abs_section_ptr
;
625 else if (sym
.st_shndx
== SHN_COMMON
)
627 sec
= bfd_com_section_ptr
;
628 /* What ELF calls the size we call the value. What ELF
629 calls the value we call the alignment. */
634 /* Leave it up to the processor backend. */
637 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
638 if (name
== (const char *) NULL
)
643 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
647 /* The hook function sets the name to NULL if this symbol
648 should be skipped for some reason. */
649 if (name
== (const char *) NULL
)
653 /* Sanity check that all possibilities were handled. */
654 if (sec
== (asection
*) NULL
)
656 bfd_set_error (bfd_error_bad_value
);
660 if (bfd_is_und_section (sec
)
661 || bfd_is_com_section (sec
))
666 size_change_ok
= false;
667 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
668 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
670 /* We need to look up the symbol now in order to get some of
671 the dynamic object handling right. We pass the hash
672 table entry in to _bfd_generic_link_add_one_symbol so
673 that it does not have to look it up again. */
674 if (! bfd_is_und_section (sec
))
675 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
678 h
= ((struct elf_link_hash_entry
*)
679 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true,
685 if (h
->root
.type
== bfd_link_hash_new
)
686 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
688 while (h
->root
.type
== bfd_link_hash_indirect
689 || h
->root
.type
== bfd_link_hash_warning
)
690 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
692 /* It's OK to change the type if it used to be a weak
694 if (h
->root
.type
== bfd_link_hash_defweak
695 || h
->root
.type
== bfd_link_hash_undefweak
)
696 type_change_ok
= true;
698 /* It's OK to change the size if it used to be a weak
699 definition, or if it used to be undefined, or if we will
700 be overriding an old definition. */
702 || h
->root
.type
== bfd_link_hash_undefined
)
703 size_change_ok
= true;
705 /* If we are looking at a dynamic object, and this is a
706 definition, we need to see if it has already been defined
707 by some other object. If it has, we want to use the
708 existing definition, and we do not want to report a
709 multiple symbol definition error; we do this by
710 clobbering sec to be bfd_und_section_ptr. We treat a
711 common symbol as a definition if the symbol in the shared
712 library is a function, since common symbols always
713 represent variables; this can cause confusion in
714 principle, but any such confusion would seem to indicate
715 an erroneous program or shared library. */
716 if (dynamic
&& definition
)
718 if (h
->root
.type
== bfd_link_hash_defined
719 || h
->root
.type
== bfd_link_hash_defweak
720 || (h
->root
.type
== bfd_link_hash_common
722 || ELF_ST_TYPE (sym
.st_info
) == STT_FUNC
)))
724 sec
= bfd_und_section_ptr
;
726 size_change_ok
= true;
727 if (h
->root
.type
== bfd_link_hash_common
)
728 type_change_ok
= true;
732 /* Similarly, if we are not looking at a dynamic object, and
733 we have a definition, we want to override any definition
734 we may have from a dynamic object. Symbols from regular
735 files always take precedence over symbols from dynamic
736 objects, even if they are defined after the dynamic
737 object in the link. */
740 || (bfd_is_com_section (sec
)
741 && (h
->root
.type
== bfd_link_hash_defweak
742 || h
->type
== STT_FUNC
)))
743 && (h
->root
.type
== bfd_link_hash_defined
744 || h
->root
.type
== bfd_link_hash_defweak
)
745 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
746 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
747 == bfd_target_elf_flavour
)
748 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
751 /* Change the hash table entry to undefined, and let
752 _bfd_generic_link_add_one_symbol do the right thing
753 with the new definition. */
754 h
->root
.type
= bfd_link_hash_undefined
;
755 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
756 size_change_ok
= true;
757 if (bfd_is_com_section (sec
))
758 type_change_ok
= true;
762 if (! (_bfd_generic_link_add_one_symbol
763 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
764 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
768 while (h
->root
.type
== bfd_link_hash_indirect
769 || h
->root
.type
== bfd_link_hash_warning
)
770 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
776 && (flags
& BSF_WEAK
) != 0
777 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
778 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
779 && h
->weakdef
== NULL
)
781 /* Keep a list of all weak defined non function symbols from
782 a dynamic object, using the weakdef field. Later in this
783 function we will set the weakdef field to the correct
784 value. We only put non-function symbols from dynamic
785 objects on this list, because that happens to be the only
786 time we need to know the normal symbol corresponding to a
787 weak symbol, and the information is time consuming to
788 figure out. If the weakdef field is not already NULL,
789 then this symbol was already defined by some previous
790 dynamic object, and we will be using that previous
791 definition anyhow. */
798 /* Get the alignment of a common symbol. */
799 if (sym
.st_shndx
== SHN_COMMON
800 && h
->root
.type
== bfd_link_hash_common
)
801 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
803 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
809 /* Remember the symbol size and type. */
811 && (definition
|| h
->size
== 0))
813 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
814 (*_bfd_error_handler
)
815 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
816 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
817 bfd_get_filename (abfd
));
819 h
->size
= sym
.st_size
;
821 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
822 && (definition
|| h
->type
== STT_NOTYPE
))
824 if (h
->type
!= STT_NOTYPE
825 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
827 (*_bfd_error_handler
)
828 ("Warning: type of symbol `%s' changed from %d to %d in %s",
829 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
830 bfd_get_filename (abfd
));
832 h
->type
= ELF_ST_TYPE (sym
.st_info
);
835 if (sym
.st_other
!= 0
836 && (definition
|| h
->other
== 0))
837 h
->other
= sym
.st_other
;
839 /* Set a flag in the hash table entry indicating the type of
840 reference or definition we just found. Keep a count of
841 the number of dynamic symbols we find. A dynamic symbol
842 is one which is referenced or defined by both a regular
843 object and a shared object. */
844 old_flags
= h
->elf_link_hash_flags
;
849 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
851 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
853 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
854 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
860 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
862 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
863 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
864 | ELF_LINK_HASH_REF_REGULAR
)) != 0
865 || (h
->weakdef
!= NULL
867 && h
->weakdef
->dynindx
!= -1))
871 h
->elf_link_hash_flags
|= new_flag
;
872 if (dynsym
&& h
->dynindx
== -1)
874 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
876 if (h
->weakdef
!= NULL
878 && h
->weakdef
->dynindx
== -1)
880 if (! _bfd_elf_link_record_dynamic_symbol (info
,
888 /* Now set the weakdefs field correctly for all the weak defined
889 symbols we found. The only way to do this is to search all the
890 symbols. Since we only need the information for non functions in
891 dynamic objects, that's the only time we actually put anything on
892 the list WEAKS. We need this information so that if a regular
893 object refers to a symbol defined weakly in a dynamic object, the
894 real symbol in the dynamic object is also put in the dynamic
895 symbols; we also must arrange for both symbols to point to the
896 same memory location. We could handle the general case of symbol
897 aliasing, but a general symbol alias can only be generated in
898 assembler code, handling it correctly would be very time
899 consuming, and other ELF linkers don't handle general aliasing
901 while (weaks
!= NULL
)
903 struct elf_link_hash_entry
*hlook
;
906 struct elf_link_hash_entry
**hpp
;
907 struct elf_link_hash_entry
**hppend
;
910 weaks
= hlook
->weakdef
;
911 hlook
->weakdef
= NULL
;
913 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
914 || hlook
->root
.type
== bfd_link_hash_defweak
915 || hlook
->root
.type
== bfd_link_hash_common
916 || hlook
->root
.type
== bfd_link_hash_indirect
);
917 slook
= hlook
->root
.u
.def
.section
;
918 vlook
= hlook
->root
.u
.def
.value
;
920 hpp
= elf_sym_hashes (abfd
);
921 hppend
= hpp
+ extsymcount
;
922 for (; hpp
< hppend
; hpp
++)
924 struct elf_link_hash_entry
*h
;
927 if (h
!= NULL
&& h
!= hlook
928 && h
->root
.type
== bfd_link_hash_defined
929 && h
->root
.u
.def
.section
== slook
930 && h
->root
.u
.def
.value
== vlook
)
934 /* If the weak definition is in the list of dynamic
935 symbols, make sure the real definition is put there
937 if (hlook
->dynindx
!= -1
940 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
944 /* If the real definition is in the list of dynamic
945 symbols, make sure the weak definition is put there
946 as well. If we don't do this, then the dynamic
947 loader might not merge the entries for the real
948 definition and the weak definition. */
950 && hlook
->dynindx
== -1)
952 if (! _bfd_elf_link_record_dynamic_symbol (info
, hlook
))
967 /* If this object is the same format as the output object, and it is
968 not a shared library, then let the backend look through the
971 This is required to build global offset table entries and to
972 arrange for dynamic relocs. It is not required for the
973 particular common case of linking non PIC code, even when linking
974 against shared libraries, but unfortunately there is no way of
975 knowing whether an object file has been compiled PIC or not.
976 Looking through the relocs is not particularly time consuming.
977 The problem is that we must either (1) keep the relocs in memory,
978 which causes the linker to require additional runtime memory or
979 (2) read the relocs twice from the input file, which wastes time.
980 This would be a good case for using mmap.
982 I have no idea how to handle linking PIC code into a file of a
983 different format. It probably can't be done. */
984 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
986 && abfd
->xvec
== info
->hash
->creator
987 && check_relocs
!= NULL
)
991 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
993 Elf_Internal_Rela
*internal_relocs
;
996 if ((o
->flags
& SEC_RELOC
) == 0
997 || o
->reloc_count
== 0)
1000 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
1001 (abfd
, o
, (PTR
) NULL
,
1002 (Elf_Internal_Rela
*) NULL
,
1003 info
->keep_memory
));
1004 if (internal_relocs
== NULL
)
1007 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
1009 if (! info
->keep_memory
)
1010 free (internal_relocs
);
1017 /* If this is a non-traditional, non-relocateable link, try to
1018 optimize the handling of the .stab/.stabstr sections. */
1020 && ! info
->relocateable
1021 && ! info
->traditional_format
1022 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
1023 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
1025 asection
*stab
, *stabstr
;
1027 stab
= bfd_get_section_by_name (abfd
, ".stab");
1030 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
1032 if (stabstr
!= NULL
)
1034 struct bfd_elf_section_data
*secdata
;
1036 secdata
= elf_section_data (stab
);
1037 if (! _bfd_link_section_stabs (abfd
,
1038 &elf_hash_table (info
)->stab_info
,
1040 &secdata
->stab_info
))
1056 /* Create some sections which will be filled in with dynamic linking
1057 information. ABFD is an input file which requires dynamic sections
1058 to be created. The dynamic sections take up virtual memory space
1059 when the final executable is run, so we need to create them before
1060 addresses are assigned to the output sections. We work out the
1061 actual contents and size of these sections later. */
1064 elf_link_create_dynamic_sections (abfd
, info
)
1066 struct bfd_link_info
*info
;
1069 register asection
*s
;
1070 struct elf_link_hash_entry
*h
;
1071 struct elf_backend_data
*bed
;
1073 if (elf_hash_table (info
)->dynamic_sections_created
)
1076 /* Make sure that all dynamic sections use the same input BFD. */
1077 if (elf_hash_table (info
)->dynobj
== NULL
)
1078 elf_hash_table (info
)->dynobj
= abfd
;
1080 abfd
= elf_hash_table (info
)->dynobj
;
1082 /* Note that we set the SEC_IN_MEMORY flag for all of these
1084 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1085 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1087 /* A dynamically linked executable has a .interp section, but a
1088 shared library does not. */
1091 s
= bfd_make_section (abfd
, ".interp");
1093 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1097 s
= bfd_make_section (abfd
, ".dynsym");
1099 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1100 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1103 s
= bfd_make_section (abfd
, ".dynstr");
1105 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1108 /* Create a strtab to hold the dynamic symbol names. */
1109 if (elf_hash_table (info
)->dynstr
== NULL
)
1111 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1112 if (elf_hash_table (info
)->dynstr
== NULL
)
1116 s
= bfd_make_section (abfd
, ".dynamic");
1118 || ! bfd_set_section_flags (abfd
, s
, flags
)
1119 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1122 /* The special symbol _DYNAMIC is always set to the start of the
1123 .dynamic section. This call occurs before we have processed the
1124 symbols for any dynamic object, so we don't have to worry about
1125 overriding a dynamic definition. We could set _DYNAMIC in a
1126 linker script, but we only want to define it if we are, in fact,
1127 creating a .dynamic section. We don't want to define it if there
1128 is no .dynamic section, since on some ELF platforms the start up
1129 code examines it to decide how to initialize the process. */
1131 if (! (_bfd_generic_link_add_one_symbol
1132 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1133 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1134 (struct bfd_link_hash_entry
**) &h
)))
1136 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1137 h
->type
= STT_OBJECT
;
1140 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1143 s
= bfd_make_section (abfd
, ".hash");
1145 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1146 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1149 /* Let the backend create the rest of the sections. This lets the
1150 backend set the right flags. The backend will normally create
1151 the .got and .plt sections. */
1152 bed
= get_elf_backend_data (abfd
);
1153 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1156 elf_hash_table (info
)->dynamic_sections_created
= true;
1161 /* Add an entry to the .dynamic table. */
1164 elf_add_dynamic_entry (info
, tag
, val
)
1165 struct bfd_link_info
*info
;
1169 Elf_Internal_Dyn dyn
;
1173 bfd_byte
*newcontents
;
1175 dynobj
= elf_hash_table (info
)->dynobj
;
1177 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1178 BFD_ASSERT (s
!= NULL
);
1180 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1181 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1182 if (newcontents
== NULL
)
1186 dyn
.d_un
.d_val
= val
;
1187 elf_swap_dyn_out (dynobj
, &dyn
,
1188 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1190 s
->_raw_size
= newsize
;
1191 s
->contents
= newcontents
;
1197 /* Read and swap the relocs for a section. They may have been cached.
1198 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1199 they are used as buffers to read into. They are known to be large
1200 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1201 value is allocated using either malloc or bfd_alloc, according to
1202 the KEEP_MEMORY argument. */
1205 NAME(_bfd_elf
,link_read_relocs
) (abfd
, o
, external_relocs
, internal_relocs
,
1209 PTR external_relocs
;
1210 Elf_Internal_Rela
*internal_relocs
;
1211 boolean keep_memory
;
1213 Elf_Internal_Shdr
*rel_hdr
;
1215 Elf_Internal_Rela
*alloc2
= NULL
;
1217 if (elf_section_data (o
)->relocs
!= NULL
)
1218 return elf_section_data (o
)->relocs
;
1220 if (o
->reloc_count
== 0)
1223 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1225 if (internal_relocs
== NULL
)
1229 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1231 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1233 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1234 if (internal_relocs
== NULL
)
1238 if (external_relocs
== NULL
)
1240 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1243 external_relocs
= alloc1
;
1246 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1247 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1248 != rel_hdr
->sh_size
))
1251 /* Swap in the relocs. For convenience, we always produce an
1252 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1254 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1256 Elf_External_Rel
*erel
;
1257 Elf_External_Rel
*erelend
;
1258 Elf_Internal_Rela
*irela
;
1260 erel
= (Elf_External_Rel
*) external_relocs
;
1261 erelend
= erel
+ o
->reloc_count
;
1262 irela
= internal_relocs
;
1263 for (; erel
< erelend
; erel
++, irela
++)
1265 Elf_Internal_Rel irel
;
1267 elf_swap_reloc_in (abfd
, erel
, &irel
);
1268 irela
->r_offset
= irel
.r_offset
;
1269 irela
->r_info
= irel
.r_info
;
1270 irela
->r_addend
= 0;
1275 Elf_External_Rela
*erela
;
1276 Elf_External_Rela
*erelaend
;
1277 Elf_Internal_Rela
*irela
;
1279 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1281 erela
= (Elf_External_Rela
*) external_relocs
;
1282 erelaend
= erela
+ o
->reloc_count
;
1283 irela
= internal_relocs
;
1284 for (; erela
< erelaend
; erela
++, irela
++)
1285 elf_swap_reloca_in (abfd
, erela
, irela
);
1288 /* Cache the results for next time, if we can. */
1290 elf_section_data (o
)->relocs
= internal_relocs
;
1295 /* Don't free alloc2, since if it was allocated we are passing it
1296 back (under the name of internal_relocs). */
1298 return internal_relocs
;
1309 /* Record an assignment to a symbol made by a linker script. We need
1310 this in case some dynamic object refers to this symbol. */
1314 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1316 struct bfd_link_info
*info
;
1320 struct elf_link_hash_entry
*h
;
1322 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1325 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1329 if (h
->root
.type
== bfd_link_hash_new
)
1330 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
1332 /* If this symbol is being provided by the linker script, and it is
1333 currently defined by a dynamic object, but not by a regular
1334 object, then mark it as undefined so that the generic linker will
1335 force the correct value. */
1337 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1338 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1339 h
->root
.type
= bfd_link_hash_undefined
;
1341 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1342 h
->type
= STT_OBJECT
;
1344 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1345 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1347 && h
->dynindx
== -1)
1349 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1352 /* If this is a weak defined symbol, and we know a corresponding
1353 real symbol from the same dynamic object, make sure the real
1354 symbol is also made into a dynamic symbol. */
1355 if (h
->weakdef
!= NULL
1356 && h
->weakdef
->dynindx
== -1)
1358 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1367 /* Array used to determine the number of hash table buckets to use
1368 based on the number of symbols there are. If there are fewer than
1369 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1370 fewer than 37 we use 17 buckets, and so forth. We never use more
1371 than 32771 buckets. */
1373 static const size_t elf_buckets
[] =
1375 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
1379 /* Set up the sizes and contents of the ELF dynamic sections. This is
1380 called by the ELF linker emulation before_allocation routine. We
1381 must set the sizes of the sections before the linker sets the
1382 addresses of the various sections. */
1385 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1386 export_dynamic
, filter_shlib
,
1387 auxiliary_filters
, info
, sinterpptr
)
1391 boolean export_dynamic
;
1392 const char *filter_shlib
;
1393 const char * const *auxiliary_filters
;
1394 struct bfd_link_info
*info
;
1395 asection
**sinterpptr
;
1398 struct elf_backend_data
*bed
;
1402 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1405 /* The backend may have to create some sections regardless of whether
1406 we're dynamic or not. */
1407 bed
= get_elf_backend_data (output_bfd
);
1408 if (bed
->elf_backend_always_size_sections
1409 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
1412 dynobj
= elf_hash_table (info
)->dynobj
;
1414 /* If there were no dynamic objects in the link, there is nothing to
1419 /* If we are supposed to export all symbols into the dynamic symbol
1420 table (this is not the normal case), then do so. */
1423 struct elf_info_failed eif
;
1427 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1433 if (elf_hash_table (info
)->dynamic_sections_created
)
1435 struct elf_info_failed eif
;
1436 struct elf_link_hash_entry
*h
;
1437 bfd_size_type strsize
;
1439 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1440 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1446 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1448 if (indx
== (bfd_size_type
) -1
1449 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1455 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1463 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1465 if (indx
== (bfd_size_type
) -1
1466 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1470 if (filter_shlib
!= NULL
)
1474 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
1475 filter_shlib
, true, true);
1476 if (indx
== (bfd_size_type
) -1
1477 || ! elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
1481 if (auxiliary_filters
!= NULL
)
1483 const char * const *p
;
1485 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
1489 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
1491 if (indx
== (bfd_size_type
) -1
1492 || ! elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
1497 /* Find all symbols which were defined in a dynamic object and make
1498 the backend pick a reasonable value for them. */
1501 elf_link_hash_traverse (elf_hash_table (info
),
1502 elf_adjust_dynamic_symbol
,
1507 /* Add some entries to the .dynamic section. We fill in some of the
1508 values later, in elf_bfd_final_link, but we must add the entries
1509 now so that we know the final size of the .dynamic section. */
1510 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1513 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1514 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1516 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1519 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1522 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1523 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1525 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1528 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1529 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1530 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1531 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1532 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1533 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1534 sizeof (Elf_External_Sym
)))
1538 /* The backend must work out the sizes of all the other dynamic
1540 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1543 if (elf_hash_table (info
)->dynamic_sections_created
)
1548 size_t bucketcount
= 0;
1549 Elf_Internal_Sym isym
;
1551 /* Set the size of the .dynsym and .hash sections. We counted
1552 the number of dynamic symbols in elf_link_add_object_symbols.
1553 We will build the contents of .dynsym and .hash when we build
1554 the final symbol table, because until then we do not know the
1555 correct value to give the symbols. We built the .dynstr
1556 section as we went along in elf_link_add_object_symbols. */
1557 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1558 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1559 BFD_ASSERT (s
!= NULL
);
1560 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1561 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1562 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1565 /* The first entry in .dynsym is a dummy symbol. */
1572 elf_swap_symbol_out (output_bfd
, &isym
,
1573 (PTR
) (Elf_External_Sym
*) s
->contents
);
1575 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1577 bucketcount
= elf_buckets
[i
];
1578 if (dynsymcount
< elf_buckets
[i
+ 1])
1582 s
= bfd_get_section_by_name (dynobj
, ".hash");
1583 BFD_ASSERT (s
!= NULL
);
1584 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1585 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1586 if (s
->contents
== NULL
)
1588 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1590 put_word (output_bfd
, bucketcount
, s
->contents
);
1591 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1593 elf_hash_table (info
)->bucketcount
= bucketcount
;
1595 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1596 BFD_ASSERT (s
!= NULL
);
1597 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1599 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1607 /* This routine is used to export all defined symbols into the dynamic
1608 symbol table. It is called via elf_link_hash_traverse. */
1611 elf_export_symbol (h
, data
)
1612 struct elf_link_hash_entry
*h
;
1615 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1617 if (h
->dynindx
== -1
1618 && (h
->elf_link_hash_flags
1619 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1621 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1632 /* Make the backend pick a good value for a dynamic symbol. This is
1633 called via elf_link_hash_traverse, and also calls itself
1637 elf_adjust_dynamic_symbol (h
, data
)
1638 struct elf_link_hash_entry
*h
;
1641 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1643 struct elf_backend_data
*bed
;
1645 /* If this symbol was mentioned in a non-ELF file, try to set
1646 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1647 permit a non-ELF file to correctly refer to a symbol defined in
1648 an ELF dynamic object. */
1649 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
1651 if (h
->root
.type
!= bfd_link_hash_defined
1652 && h
->root
.type
!= bfd_link_hash_defweak
)
1653 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1656 if (h
->root
.u
.def
.section
->owner
!= NULL
1657 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
1658 == bfd_target_elf_flavour
))
1659 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1661 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1664 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1665 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1667 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1675 /* If this is a final link, and the symbol was defined as a common
1676 symbol in a regular object file, and there was no definition in
1677 any dynamic object, then the linker will have allocated space for
1678 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
1679 flag will not have been set. */
1680 if (h
->root
.type
== bfd_link_hash_defined
1681 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1682 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
1683 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1684 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
1685 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1687 /* If -Bsymbolic was used (which means to bind references to global
1688 symbols to the definition within the shared object), and this
1689 symbol was defined in a regular object, then it actually doesn't
1690 need a PLT entry. */
1691 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1692 && eif
->info
->shared
1693 && eif
->info
->symbolic
1694 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1695 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1697 /* If this symbol does not require a PLT entry, and it is not
1698 defined by a dynamic object, or is not referenced by a regular
1699 object, ignore it. We do have to handle a weak defined symbol,
1700 even if no regular object refers to it, if we decided to add it
1701 to the dynamic symbol table. FIXME: Do we normally need to worry
1702 about symbols which are defined by one dynamic object and
1703 referenced by another one? */
1704 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1705 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1706 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1707 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1708 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1711 /* If we've already adjusted this symbol, don't do it again. This
1712 can happen via a recursive call. */
1713 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1716 /* Don't look at this symbol again. Note that we must set this
1717 after checking the above conditions, because we may look at a
1718 symbol once, decide not to do anything, and then get called
1719 recursively later after REF_REGULAR is set below. */
1720 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1722 /* If this is a weak definition, and we know a real definition, and
1723 the real symbol is not itself defined by a regular object file,
1724 then get a good value for the real definition. We handle the
1725 real symbol first, for the convenience of the backend routine.
1727 Note that there is a confusing case here. If the real definition
1728 is defined by a regular object file, we don't get the real symbol
1729 from the dynamic object, but we do get the weak symbol. If the
1730 processor backend uses a COPY reloc, then if some routine in the
1731 dynamic object changes the real symbol, we will not see that
1732 change in the corresponding weak symbol. This is the way other
1733 ELF linkers work as well, and seems to be a result of the shared
1736 I will clarify this issue. Most SVR4 shared libraries define the
1737 variable _timezone and define timezone as a weak synonym. The
1738 tzset call changes _timezone. If you write
1739 extern int timezone;
1741 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1742 you might expect that, since timezone is a synonym for _timezone,
1743 the same number will print both times. However, if the processor
1744 backend uses a COPY reloc, then actually timezone will be copied
1745 into your process image, and, since you define _timezone
1746 yourself, _timezone will not. Thus timezone and _timezone will
1747 wind up at different memory locations. The tzset call will set
1748 _timezone, leaving timezone unchanged. */
1750 if (h
->weakdef
!= NULL
)
1752 struct elf_link_hash_entry
*weakdef
;
1754 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1755 || h
->root
.type
== bfd_link_hash_defweak
);
1756 weakdef
= h
->weakdef
;
1757 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1758 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1759 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1760 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1762 /* This symbol is defined by a regular object file, so we
1763 will not do anything special. Clear weakdef for the
1764 convenience of the processor backend. */
1769 /* There is an implicit reference by a regular object file
1770 via the weak symbol. */
1771 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1772 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1777 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1778 bed
= get_elf_backend_data (dynobj
);
1779 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1788 /* Final phase of ELF linker. */
1790 /* A structure we use to avoid passing large numbers of arguments. */
1792 struct elf_final_link_info
1794 /* General link information. */
1795 struct bfd_link_info
*info
;
1798 /* Symbol string table. */
1799 struct bfd_strtab_hash
*symstrtab
;
1800 /* .dynsym section. */
1801 asection
*dynsym_sec
;
1802 /* .hash section. */
1804 /* Buffer large enough to hold contents of any section. */
1806 /* Buffer large enough to hold external relocs of any section. */
1807 PTR external_relocs
;
1808 /* Buffer large enough to hold internal relocs of any section. */
1809 Elf_Internal_Rela
*internal_relocs
;
1810 /* Buffer large enough to hold external local symbols of any input
1812 Elf_External_Sym
*external_syms
;
1813 /* Buffer large enough to hold internal local symbols of any input
1815 Elf_Internal_Sym
*internal_syms
;
1816 /* Array large enough to hold a symbol index for each local symbol
1817 of any input BFD. */
1819 /* Array large enough to hold a section pointer for each local
1820 symbol of any input BFD. */
1821 asection
**sections
;
1822 /* Buffer to hold swapped out symbols. */
1823 Elf_External_Sym
*symbuf
;
1824 /* Number of swapped out symbols in buffer. */
1825 size_t symbuf_count
;
1826 /* Number of symbols which fit in symbuf. */
1830 static boolean elf_link_output_sym
1831 PARAMS ((struct elf_final_link_info
*, const char *,
1832 Elf_Internal_Sym
*, asection
*));
1833 static boolean elf_link_flush_output_syms
1834 PARAMS ((struct elf_final_link_info
*));
1835 static boolean elf_link_output_extsym
1836 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1837 static boolean elf_link_input_bfd
1838 PARAMS ((struct elf_final_link_info
*, bfd
*));
1839 static boolean elf_reloc_link_order
1840 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1841 struct bfd_link_order
*));
1843 /* This struct is used to pass information to routines called via
1844 elf_link_hash_traverse which must return failure. */
1846 struct elf_finfo_failed
1849 struct elf_final_link_info
*finfo
;
1852 /* Do the final step of an ELF link. */
1855 elf_bfd_final_link (abfd
, info
)
1857 struct bfd_link_info
*info
;
1861 struct elf_final_link_info finfo
;
1862 register asection
*o
;
1863 register struct bfd_link_order
*p
;
1865 size_t max_contents_size
;
1866 size_t max_external_reloc_size
;
1867 size_t max_internal_reloc_count
;
1868 size_t max_sym_count
;
1870 Elf_Internal_Sym elfsym
;
1872 Elf_Internal_Shdr
*symtab_hdr
;
1873 Elf_Internal_Shdr
*symstrtab_hdr
;
1874 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1875 struct elf_finfo_failed eif
;
1878 abfd
->flags
|= DYNAMIC
;
1880 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1881 dynobj
= elf_hash_table (info
)->dynobj
;
1884 finfo
.output_bfd
= abfd
;
1885 finfo
.symstrtab
= elf_stringtab_init ();
1886 if (finfo
.symstrtab
== NULL
)
1890 finfo
.dynsym_sec
= NULL
;
1891 finfo
.hash_sec
= NULL
;
1895 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1896 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1897 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1899 finfo
.contents
= NULL
;
1900 finfo
.external_relocs
= NULL
;
1901 finfo
.internal_relocs
= NULL
;
1902 finfo
.external_syms
= NULL
;
1903 finfo
.internal_syms
= NULL
;
1904 finfo
.indices
= NULL
;
1905 finfo
.sections
= NULL
;
1906 finfo
.symbuf
= NULL
;
1907 finfo
.symbuf_count
= 0;
1909 /* Count up the number of relocations we will output for each output
1910 section, so that we know the sizes of the reloc sections. We
1911 also figure out some maximum sizes. */
1912 max_contents_size
= 0;
1913 max_external_reloc_size
= 0;
1914 max_internal_reloc_count
= 0;
1916 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1920 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1922 if (p
->type
== bfd_section_reloc_link_order
1923 || p
->type
== bfd_symbol_reloc_link_order
)
1925 else if (p
->type
== bfd_indirect_link_order
)
1929 sec
= p
->u
.indirect
.section
;
1931 /* Mark all sections which are to be included in the
1932 link. This will normally be every section. We need
1933 to do this so that we can identify any sections which
1934 the linker has decided to not include. */
1935 sec
->linker_mark
= true;
1937 if (info
->relocateable
)
1938 o
->reloc_count
+= sec
->reloc_count
;
1940 if (sec
->_raw_size
> max_contents_size
)
1941 max_contents_size
= sec
->_raw_size
;
1942 if (sec
->_cooked_size
> max_contents_size
)
1943 max_contents_size
= sec
->_cooked_size
;
1945 /* We are interested in just local symbols, not all
1947 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1951 if (elf_bad_symtab (sec
->owner
))
1952 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1953 / sizeof (Elf_External_Sym
));
1955 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1957 if (sym_count
> max_sym_count
)
1958 max_sym_count
= sym_count
;
1960 if ((sec
->flags
& SEC_RELOC
) != 0)
1964 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1965 if (ext_size
> max_external_reloc_size
)
1966 max_external_reloc_size
= ext_size
;
1967 if (sec
->reloc_count
> max_internal_reloc_count
)
1968 max_internal_reloc_count
= sec
->reloc_count
;
1974 if (o
->reloc_count
> 0)
1975 o
->flags
|= SEC_RELOC
;
1978 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1979 set it (this is probably a bug) and if it is set
1980 assign_section_numbers will create a reloc section. */
1981 o
->flags
&=~ SEC_RELOC
;
1984 /* If the SEC_ALLOC flag is not set, force the section VMA to
1985 zero. This is done in elf_fake_sections as well, but forcing
1986 the VMA to 0 here will ensure that relocs against these
1987 sections are handled correctly. */
1988 if ((o
->flags
& SEC_ALLOC
) == 0
1989 && ! o
->user_set_vma
)
1993 /* Figure out the file positions for everything but the symbol table
1994 and the relocs. We set symcount to force assign_section_numbers
1995 to create a symbol table. */
1996 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1997 BFD_ASSERT (! abfd
->output_has_begun
);
1998 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
2001 /* That created the reloc sections. Set their sizes, and assign
2002 them file positions, and allocate some buffers. */
2003 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2005 if ((o
->flags
& SEC_RELOC
) != 0)
2007 Elf_Internal_Shdr
*rel_hdr
;
2008 register struct elf_link_hash_entry
**p
, **pend
;
2010 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2012 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
2014 /* The contents field must last into write_object_contents,
2015 so we allocate it with bfd_alloc rather than malloc. */
2016 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
2017 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
2020 p
= ((struct elf_link_hash_entry
**)
2021 bfd_malloc (o
->reloc_count
2022 * sizeof (struct elf_link_hash_entry
*)));
2023 if (p
== NULL
&& o
->reloc_count
!= 0)
2025 elf_section_data (o
)->rel_hashes
= p
;
2026 pend
= p
+ o
->reloc_count
;
2027 for (; p
< pend
; p
++)
2030 /* Use the reloc_count field as an index when outputting the
2036 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2038 /* We have now assigned file positions for all the sections except
2039 .symtab and .strtab. We start the .symtab section at the current
2040 file position, and write directly to it. We build the .strtab
2041 section in memory. */
2043 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2044 /* sh_name is set in prep_headers. */
2045 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2046 symtab_hdr
->sh_flags
= 0;
2047 symtab_hdr
->sh_addr
= 0;
2048 symtab_hdr
->sh_size
= 0;
2049 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2050 /* sh_link is set in assign_section_numbers. */
2051 /* sh_info is set below. */
2052 /* sh_offset is set just below. */
2053 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
2055 off
= elf_tdata (abfd
)->next_file_pos
;
2056 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
2058 /* Note that at this point elf_tdata (abfd)->next_file_pos is
2059 incorrect. We do not yet know the size of the .symtab section.
2060 We correct next_file_pos below, after we do know the size. */
2062 /* Allocate a buffer to hold swapped out symbols. This is to avoid
2063 continuously seeking to the right position in the file. */
2064 if (! info
->keep_memory
|| max_sym_count
< 20)
2065 finfo
.symbuf_size
= 20;
2067 finfo
.symbuf_size
= max_sym_count
;
2068 finfo
.symbuf
= ((Elf_External_Sym
*)
2069 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
2070 if (finfo
.symbuf
== NULL
)
2073 /* Start writing out the symbol table. The first symbol is always a
2075 if (info
->strip
!= strip_all
|| info
->relocateable
)
2077 elfsym
.st_value
= 0;
2080 elfsym
.st_other
= 0;
2081 elfsym
.st_shndx
= SHN_UNDEF
;
2082 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2083 &elfsym
, bfd_und_section_ptr
))
2088 /* Some standard ELF linkers do this, but we don't because it causes
2089 bootstrap comparison failures. */
2090 /* Output a file symbol for the output file as the second symbol.
2091 We output this even if we are discarding local symbols, although
2092 I'm not sure if this is correct. */
2093 elfsym
.st_value
= 0;
2095 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2096 elfsym
.st_other
= 0;
2097 elfsym
.st_shndx
= SHN_ABS
;
2098 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
2099 &elfsym
, bfd_abs_section_ptr
))
2103 /* Output a symbol for each section. We output these even if we are
2104 discarding local symbols, since they are used for relocs. These
2105 symbols have no names. We store the index of each one in the
2106 index field of the section, so that we can find it again when
2107 outputting relocs. */
2108 if (info
->strip
!= strip_all
|| info
->relocateable
)
2110 elfsym
.st_value
= 0;
2112 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2113 elfsym
.st_other
= 0;
2114 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2116 o
= section_from_elf_index (abfd
, i
);
2118 o
->target_index
= abfd
->symcount
;
2119 elfsym
.st_shndx
= i
;
2120 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2126 /* Allocate some memory to hold information read in from the input
2128 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
2129 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
2130 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
2131 bfd_malloc (max_internal_reloc_count
2132 * sizeof (Elf_Internal_Rela
)));
2133 finfo
.external_syms
= ((Elf_External_Sym
*)
2134 bfd_malloc (max_sym_count
2135 * sizeof (Elf_External_Sym
)));
2136 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
2137 bfd_malloc (max_sym_count
2138 * sizeof (Elf_Internal_Sym
)));
2139 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
2140 finfo
.sections
= ((asection
**)
2141 bfd_malloc (max_sym_count
* sizeof (asection
*)));
2142 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
2143 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
2144 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
2145 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
2146 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
2147 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
2148 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
2151 /* Since ELF permits relocations to be against local symbols, we
2152 must have the local symbols available when we do the relocations.
2153 Since we would rather only read the local symbols once, and we
2154 would rather not keep them in memory, we handle all the
2155 relocations for a single input file at the same time.
2157 Unfortunately, there is no way to know the total number of local
2158 symbols until we have seen all of them, and the local symbol
2159 indices precede the global symbol indices. This means that when
2160 we are generating relocateable output, and we see a reloc against
2161 a global symbol, we can not know the symbol index until we have
2162 finished examining all the local symbols to see which ones we are
2163 going to output. To deal with this, we keep the relocations in
2164 memory, and don't output them until the end of the link. This is
2165 an unfortunate waste of memory, but I don't see a good way around
2166 it. Fortunately, it only happens when performing a relocateable
2167 link, which is not the common case. FIXME: If keep_memory is set
2168 we could write the relocs out and then read them again; I don't
2169 know how bad the memory loss will be. */
2171 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
2172 sub
->output_has_begun
= false;
2173 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2175 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
2177 if (p
->type
== bfd_indirect_link_order
2178 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2179 == bfd_target_elf_flavour
))
2181 sub
= p
->u
.indirect
.section
->owner
;
2182 if (! sub
->output_has_begun
)
2184 if (! elf_link_input_bfd (&finfo
, sub
))
2186 sub
->output_has_begun
= true;
2189 else if (p
->type
== bfd_section_reloc_link_order
2190 || p
->type
== bfd_symbol_reloc_link_order
)
2192 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2197 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2203 /* That wrote out all the local symbols. Finish up the symbol table
2204 with the global symbols. */
2206 /* The sh_info field records the index of the first non local
2208 symtab_hdr
->sh_info
= abfd
->symcount
;
2210 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2212 /* We get the global symbols from the hash table. */
2215 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2220 /* Flush all symbols to the file. */
2221 if (! elf_link_flush_output_syms (&finfo
))
2224 /* Now we know the size of the symtab section. */
2225 off
+= symtab_hdr
->sh_size
;
2227 /* Finish up and write out the symbol string table (.strtab)
2229 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2230 /* sh_name was set in prep_headers. */
2231 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2232 symstrtab_hdr
->sh_flags
= 0;
2233 symstrtab_hdr
->sh_addr
= 0;
2234 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2235 symstrtab_hdr
->sh_entsize
= 0;
2236 symstrtab_hdr
->sh_link
= 0;
2237 symstrtab_hdr
->sh_info
= 0;
2238 /* sh_offset is set just below. */
2239 symstrtab_hdr
->sh_addralign
= 1;
2241 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2242 elf_tdata (abfd
)->next_file_pos
= off
;
2244 if (abfd
->symcount
> 0)
2246 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2247 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2251 /* Adjust the relocs to have the correct symbol indices. */
2252 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2254 struct elf_link_hash_entry
**rel_hash
;
2255 Elf_Internal_Shdr
*rel_hdr
;
2257 if ((o
->flags
& SEC_RELOC
) == 0)
2260 rel_hash
= elf_section_data (o
)->rel_hashes
;
2261 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2262 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2264 if (*rel_hash
== NULL
)
2267 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2269 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2271 Elf_External_Rel
*erel
;
2272 Elf_Internal_Rel irel
;
2274 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2275 elf_swap_reloc_in (abfd
, erel
, &irel
);
2276 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2277 ELF_R_TYPE (irel
.r_info
));
2278 elf_swap_reloc_out (abfd
, &irel
, erel
);
2282 Elf_External_Rela
*erela
;
2283 Elf_Internal_Rela irela
;
2285 BFD_ASSERT (rel_hdr
->sh_entsize
2286 == sizeof (Elf_External_Rela
));
2288 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2289 elf_swap_reloca_in (abfd
, erela
, &irela
);
2290 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2291 ELF_R_TYPE (irela
.r_info
));
2292 elf_swap_reloca_out (abfd
, &irela
, erela
);
2296 /* Set the reloc_count field to 0 to prevent write_relocs from
2297 trying to swap the relocs out itself. */
2301 /* If we are linking against a dynamic object, or generating a
2302 shared library, finish up the dynamic linking information. */
2305 Elf_External_Dyn
*dyncon
, *dynconend
;
2307 /* Fix up .dynamic entries. */
2308 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2309 BFD_ASSERT (o
!= NULL
);
2311 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2312 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2313 for (; dyncon
< dynconend
; dyncon
++)
2315 Elf_Internal_Dyn dyn
;
2319 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2326 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2327 magic _init and _fini symbols. This is pretty ugly,
2328 but we are compatible. */
2336 struct elf_link_hash_entry
*h
;
2338 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2339 false, false, true);
2341 && (h
->root
.type
== bfd_link_hash_defined
2342 || h
->root
.type
== bfd_link_hash_defweak
))
2344 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2345 o
= h
->root
.u
.def
.section
;
2346 if (o
->output_section
!= NULL
)
2347 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2348 + o
->output_offset
);
2351 /* The symbol is imported from another shared
2352 library and does not apply to this one. */
2356 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2370 o
= bfd_get_section_by_name (abfd
, name
);
2371 BFD_ASSERT (o
!= NULL
);
2372 dyn
.d_un
.d_ptr
= o
->vma
;
2373 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2380 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2385 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2387 Elf_Internal_Shdr
*hdr
;
2389 hdr
= elf_elfsections (abfd
)[i
];
2390 if (hdr
->sh_type
== type
2391 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2393 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2394 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2397 if (dyn
.d_un
.d_val
== 0
2398 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2399 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2403 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2409 /* If we have created any dynamic sections, then output them. */
2412 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2415 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2417 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2418 || o
->_raw_size
== 0)
2420 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
2422 /* At this point, we are only interested in sections
2423 created by elf_link_create_dynamic_sections. */
2426 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2428 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2430 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2431 o
->contents
, o
->output_offset
,
2439 /* The contents of the .dynstr section are actually in a
2441 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2442 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2443 || ! _bfd_stringtab_emit (abfd
,
2444 elf_hash_table (info
)->dynstr
))
2450 /* If we have optimized stabs strings, output them. */
2451 if (elf_hash_table (info
)->stab_info
!= NULL
)
2453 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
2457 if (finfo
.symstrtab
!= NULL
)
2458 _bfd_stringtab_free (finfo
.symstrtab
);
2459 if (finfo
.contents
!= NULL
)
2460 free (finfo
.contents
);
2461 if (finfo
.external_relocs
!= NULL
)
2462 free (finfo
.external_relocs
);
2463 if (finfo
.internal_relocs
!= NULL
)
2464 free (finfo
.internal_relocs
);
2465 if (finfo
.external_syms
!= NULL
)
2466 free (finfo
.external_syms
);
2467 if (finfo
.internal_syms
!= NULL
)
2468 free (finfo
.internal_syms
);
2469 if (finfo
.indices
!= NULL
)
2470 free (finfo
.indices
);
2471 if (finfo
.sections
!= NULL
)
2472 free (finfo
.sections
);
2473 if (finfo
.symbuf
!= NULL
)
2474 free (finfo
.symbuf
);
2475 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2477 if ((o
->flags
& SEC_RELOC
) != 0
2478 && elf_section_data (o
)->rel_hashes
!= NULL
)
2479 free (elf_section_data (o
)->rel_hashes
);
2482 elf_tdata (abfd
)->linker
= true;
2487 if (finfo
.symstrtab
!= NULL
)
2488 _bfd_stringtab_free (finfo
.symstrtab
);
2489 if (finfo
.contents
!= NULL
)
2490 free (finfo
.contents
);
2491 if (finfo
.external_relocs
!= NULL
)
2492 free (finfo
.external_relocs
);
2493 if (finfo
.internal_relocs
!= NULL
)
2494 free (finfo
.internal_relocs
);
2495 if (finfo
.external_syms
!= NULL
)
2496 free (finfo
.external_syms
);
2497 if (finfo
.internal_syms
!= NULL
)
2498 free (finfo
.internal_syms
);
2499 if (finfo
.indices
!= NULL
)
2500 free (finfo
.indices
);
2501 if (finfo
.sections
!= NULL
)
2502 free (finfo
.sections
);
2503 if (finfo
.symbuf
!= NULL
)
2504 free (finfo
.symbuf
);
2505 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2507 if ((o
->flags
& SEC_RELOC
) != 0
2508 && elf_section_data (o
)->rel_hashes
!= NULL
)
2509 free (elf_section_data (o
)->rel_hashes
);
2515 /* Add a symbol to the output symbol table. */
2518 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2519 struct elf_final_link_info
*finfo
;
2521 Elf_Internal_Sym
*elfsym
;
2522 asection
*input_sec
;
2524 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2525 struct bfd_link_info
*info
,
2530 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2531 elf_backend_link_output_symbol_hook
;
2532 if (output_symbol_hook
!= NULL
)
2534 if (! ((*output_symbol_hook
)
2535 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2539 if (name
== (const char *) NULL
|| *name
== '\0')
2540 elfsym
->st_name
= 0;
2543 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2546 if (elfsym
->st_name
== (unsigned long) -1)
2550 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2552 if (! elf_link_flush_output_syms (finfo
))
2556 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2557 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2558 ++finfo
->symbuf_count
;
2560 ++finfo
->output_bfd
->symcount
;
2565 /* Flush the output symbols to the file. */
2568 elf_link_flush_output_syms (finfo
)
2569 struct elf_final_link_info
*finfo
;
2571 if (finfo
->symbuf_count
> 0)
2573 Elf_Internal_Shdr
*symtab
;
2575 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2577 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2579 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2580 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2581 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2584 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2586 finfo
->symbuf_count
= 0;
2592 /* Add an external symbol to the symbol table. This is called from
2593 the hash table traversal routine. */
2596 elf_link_output_extsym (h
, data
)
2597 struct elf_link_hash_entry
*h
;
2600 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2601 struct elf_final_link_info
*finfo
= eif
->finfo
;
2603 Elf_Internal_Sym sym
;
2604 asection
*input_sec
;
2606 /* If we are not creating a shared library, and this symbol is
2607 referenced by a shared library but is not defined anywhere, then
2608 warn that it is undefined. If we do not do this, the runtime
2609 linker will complain that the symbol is undefined when the
2610 program is run. We don't have to worry about symbols that are
2611 referenced by regular files, because we will already have issued
2612 warnings for them. */
2613 if (! finfo
->info
->relocateable
2614 && ! finfo
->info
->shared
2615 && h
->root
.type
== bfd_link_hash_undefined
2616 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2617 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2619 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2620 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2621 (asection
*) NULL
, 0)))
2628 /* We don't want to output symbols that have never been mentioned by
2629 a regular file, or that we have been told to strip. However, if
2630 h->indx is set to -2, the symbol is used by a reloc and we must
2634 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2635 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2636 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2637 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2639 else if (finfo
->info
->strip
== strip_all
2640 || (finfo
->info
->strip
== strip_some
2641 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2642 h
->root
.root
.string
,
2643 false, false) == NULL
))
2648 /* If we're stripping it, and it's not a dynamic symbol, there's
2649 nothing else to do. */
2650 if (strip
&& h
->dynindx
== -1)
2654 sym
.st_size
= h
->size
;
2655 sym
.st_other
= h
->other
;
2656 if (h
->root
.type
== bfd_link_hash_undefweak
2657 || h
->root
.type
== bfd_link_hash_defweak
)
2658 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2660 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2662 switch (h
->root
.type
)
2665 case bfd_link_hash_new
:
2669 case bfd_link_hash_undefined
:
2670 input_sec
= bfd_und_section_ptr
;
2671 sym
.st_shndx
= SHN_UNDEF
;
2674 case bfd_link_hash_undefweak
:
2675 input_sec
= bfd_und_section_ptr
;
2676 sym
.st_shndx
= SHN_UNDEF
;
2679 case bfd_link_hash_defined
:
2680 case bfd_link_hash_defweak
:
2682 input_sec
= h
->root
.u
.def
.section
;
2683 if (input_sec
->output_section
!= NULL
)
2686 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2687 input_sec
->output_section
);
2688 if (sym
.st_shndx
== (unsigned short) -1)
2694 /* ELF symbols in relocateable files are section relative,
2695 but in nonrelocateable files they are virtual
2697 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2698 if (! finfo
->info
->relocateable
)
2699 sym
.st_value
+= input_sec
->output_section
->vma
;
2703 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2704 == bfd_target_elf_flavour
)
2705 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2706 sym
.st_shndx
= SHN_UNDEF
;
2707 input_sec
= bfd_und_section_ptr
;
2712 case bfd_link_hash_common
:
2713 input_sec
= bfd_com_section_ptr
;
2714 sym
.st_shndx
= SHN_COMMON
;
2715 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2718 case bfd_link_hash_indirect
:
2719 case bfd_link_hash_warning
:
2720 /* We can't represent these symbols in ELF. A warning symbol
2721 may have come from a .gnu.warning.SYMBOL section anyhow. We
2722 just put the target symbol in the hash table. If the target
2723 symbol does not really exist, don't do anything. */
2724 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2726 return (elf_link_output_extsym
2727 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2730 /* If this symbol should be put in the .dynsym section, then put it
2731 there now. We have already know the symbol index. We also fill
2732 in the entry in the .hash section. */
2733 if (h
->dynindx
!= -1
2734 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2736 struct elf_backend_data
*bed
;
2739 bfd_byte
*bucketpos
;
2742 sym
.st_name
= h
->dynstr_index
;
2744 /* Give the processor backend a chance to tweak the symbol
2745 value, and also to finish up anything that needs to be done
2747 bed
= get_elf_backend_data (finfo
->output_bfd
);
2748 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2749 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2755 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2756 (PTR
) (((Elf_External_Sym
*)
2757 finfo
->dynsym_sec
->contents
)
2760 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2761 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2763 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2764 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2765 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2766 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2767 put_word (finfo
->output_bfd
, chain
,
2768 ((bfd_byte
*) finfo
->hash_sec
->contents
2769 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2772 /* If we're stripping it, then it was just a dynamic symbol, and
2773 there's nothing else to do. */
2777 h
->indx
= finfo
->output_bfd
->symcount
;
2779 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2788 /* Link an input file into the linker output file. This function
2789 handles all the sections and relocations of the input file at once.
2790 This is so that we only have to read the local symbols once, and
2791 don't have to keep them in memory. */
2794 elf_link_input_bfd (finfo
, input_bfd
)
2795 struct elf_final_link_info
*finfo
;
2798 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2799 bfd
*, asection
*, bfd_byte
*,
2800 Elf_Internal_Rela
*,
2801 Elf_Internal_Sym
*, asection
**));
2803 Elf_Internal_Shdr
*symtab_hdr
;
2806 Elf_External_Sym
*external_syms
;
2807 Elf_External_Sym
*esym
;
2808 Elf_External_Sym
*esymend
;
2809 Elf_Internal_Sym
*isym
;
2811 asection
**ppsection
;
2814 output_bfd
= finfo
->output_bfd
;
2816 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2818 /* If this is a dynamic object, we don't want to do anything here:
2819 we don't want the local symbols, and we don't want the section
2821 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2824 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2825 if (elf_bad_symtab (input_bfd
))
2827 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2832 locsymcount
= symtab_hdr
->sh_info
;
2833 extsymoff
= symtab_hdr
->sh_info
;
2836 /* Read the local symbols. */
2837 if (symtab_hdr
->contents
!= NULL
)
2838 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
2839 else if (locsymcount
== 0)
2840 external_syms
= NULL
;
2843 external_syms
= finfo
->external_syms
;
2844 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2845 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
2846 locsymcount
, input_bfd
)
2847 != locsymcount
* sizeof (Elf_External_Sym
)))
2851 /* Swap in the local symbols and write out the ones which we know
2852 are going into the output file. */
2853 esym
= external_syms
;
2854 esymend
= esym
+ locsymcount
;
2855 isym
= finfo
->internal_syms
;
2856 pindex
= finfo
->indices
;
2857 ppsection
= finfo
->sections
;
2858 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2862 Elf_Internal_Sym osym
;
2864 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2867 if (elf_bad_symtab (input_bfd
))
2869 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2876 if (isym
->st_shndx
== SHN_UNDEF
)
2877 isec
= bfd_und_section_ptr
;
2878 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2879 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2880 else if (isym
->st_shndx
== SHN_ABS
)
2881 isec
= bfd_abs_section_ptr
;
2882 else if (isym
->st_shndx
== SHN_COMMON
)
2883 isec
= bfd_com_section_ptr
;
2892 /* Don't output the first, undefined, symbol. */
2893 if (esym
== external_syms
)
2896 /* If we are stripping all symbols, we don't want to output this
2898 if (finfo
->info
->strip
== strip_all
)
2901 /* We never output section symbols. Instead, we use the section
2902 symbol of the corresponding section in the output file. */
2903 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2906 /* If we are discarding all local symbols, we don't want to
2907 output this one. If we are generating a relocateable output
2908 file, then some of the local symbols may be required by
2909 relocs; we output them below as we discover that they are
2911 if (finfo
->info
->discard
== discard_all
)
2914 /* If this symbol is defined in a section which we are
2915 discarding, we don't need to keep it. For the benefit of the
2916 MIPS ELF linker, we check SEC_EXCLUDE as well as linker_mark. */
2917 if (isym
->st_shndx
> 0
2918 && isym
->st_shndx
< SHN_LORESERVE
2920 && (! isec
->linker_mark
2921 || (! finfo
->info
->relocateable
2922 && (isec
->flags
& SEC_EXCLUDE
) != 0)))
2925 /* Get the name of the symbol. */
2926 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2931 /* See if we are discarding symbols with this name. */
2932 if ((finfo
->info
->strip
== strip_some
2933 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2935 || (finfo
->info
->discard
== discard_l
2936 && strncmp (name
, finfo
->info
->lprefix
,
2937 finfo
->info
->lprefix_len
) == 0))
2940 /* If we get here, we are going to output this symbol. */
2944 /* Adjust the section index for the output file. */
2945 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2946 isec
->output_section
);
2947 if (osym
.st_shndx
== (unsigned short) -1)
2950 *pindex
= output_bfd
->symcount
;
2952 /* ELF symbols in relocateable files are section relative, but
2953 in executable files they are virtual addresses. Note that
2954 this code assumes that all ELF sections have an associated
2955 BFD section with a reasonable value for output_offset; below
2956 we assume that they also have a reasonable value for
2957 output_section. Any special sections must be set up to meet
2958 these requirements. */
2959 osym
.st_value
+= isec
->output_offset
;
2960 if (! finfo
->info
->relocateable
)
2961 osym
.st_value
+= isec
->output_section
->vma
;
2963 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2967 /* Relocate the contents of each section. */
2968 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2972 if (! o
->linker_mark
)
2974 /* This section was omitted from the link. */
2978 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2979 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2982 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
2984 /* Section was created by elf_link_create_dynamic_sections
2989 /* Get the contents of the section. They have been cached by a
2990 relaxation routine. Note that o is a section in an input
2991 file, so the contents field will not have been set by any of
2992 the routines which work on output files. */
2993 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
2994 contents
= elf_section_data (o
)->this_hdr
.contents
;
2997 contents
= finfo
->contents
;
2998 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
2999 (file_ptr
) 0, o
->_raw_size
))
3003 if ((o
->flags
& SEC_RELOC
) != 0)
3005 Elf_Internal_Rela
*internal_relocs
;
3007 /* Get the swapped relocs. */
3008 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
3009 (input_bfd
, o
, finfo
->external_relocs
,
3010 finfo
->internal_relocs
, false));
3011 if (internal_relocs
== NULL
3012 && o
->reloc_count
> 0)
3015 /* Relocate the section by invoking a back end routine.
3017 The back end routine is responsible for adjusting the
3018 section contents as necessary, and (if using Rela relocs
3019 and generating a relocateable output file) adjusting the
3020 reloc addend as necessary.
3022 The back end routine does not have to worry about setting
3023 the reloc address or the reloc symbol index.
3025 The back end routine is given a pointer to the swapped in
3026 internal symbols, and can access the hash table entries
3027 for the external symbols via elf_sym_hashes (input_bfd).
3029 When generating relocateable output, the back end routine
3030 must handle STB_LOCAL/STT_SECTION symbols specially. The
3031 output symbol is going to be a section symbol
3032 corresponding to the output section, which will require
3033 the addend to be adjusted. */
3035 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
3036 input_bfd
, o
, contents
,
3038 finfo
->internal_syms
,
3042 if (finfo
->info
->relocateable
)
3044 Elf_Internal_Rela
*irela
;
3045 Elf_Internal_Rela
*irelaend
;
3046 struct elf_link_hash_entry
**rel_hash
;
3047 Elf_Internal_Shdr
*input_rel_hdr
;
3048 Elf_Internal_Shdr
*output_rel_hdr
;
3050 /* Adjust the reloc addresses and symbol indices. */
3052 irela
= internal_relocs
;
3053 irelaend
= irela
+ o
->reloc_count
;
3054 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
3055 + o
->output_section
->reloc_count
);
3056 for (; irela
< irelaend
; irela
++, rel_hash
++)
3058 unsigned long r_symndx
;
3059 Elf_Internal_Sym
*isym
;
3062 irela
->r_offset
+= o
->output_offset
;
3064 r_symndx
= ELF_R_SYM (irela
->r_info
);
3069 if (r_symndx
>= locsymcount
3070 || (elf_bad_symtab (input_bfd
)
3071 && finfo
->sections
[r_symndx
] == NULL
))
3075 /* This is a reloc against a global symbol. We
3076 have not yet output all the local symbols, so
3077 we do not know the symbol index of any global
3078 symbol. We set the rel_hash entry for this
3079 reloc to point to the global hash table entry
3080 for this symbol. The symbol index is then
3081 set at the end of elf_bfd_final_link. */
3082 indx
= r_symndx
- extsymoff
;
3083 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
3085 /* Setting the index to -2 tells
3086 elf_link_output_extsym that this symbol is
3088 BFD_ASSERT ((*rel_hash
)->indx
< 0);
3089 (*rel_hash
)->indx
= -2;
3094 /* This is a reloc against a local symbol. */
3097 isym
= finfo
->internal_syms
+ r_symndx
;
3098 sec
= finfo
->sections
[r_symndx
];
3099 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
3101 /* I suppose the backend ought to fill in the
3102 section of any STT_SECTION symbol against a
3103 processor specific section. If we have
3104 discarded a section, the output_section will
3105 be the absolute section. */
3107 && (bfd_is_abs_section (sec
)
3108 || (sec
->output_section
!= NULL
3109 && bfd_is_abs_section (sec
->output_section
))))
3111 else if (sec
== NULL
|| sec
->owner
== NULL
)
3113 bfd_set_error (bfd_error_bad_value
);
3118 r_symndx
= sec
->output_section
->target_index
;
3119 BFD_ASSERT (r_symndx
!= 0);
3124 if (finfo
->indices
[r_symndx
] == -1)
3130 if (finfo
->info
->strip
== strip_all
)
3132 /* You can't do ld -r -s. */
3133 bfd_set_error (bfd_error_invalid_operation
);
3137 /* This symbol was skipped earlier, but
3138 since it is needed by a reloc, we
3139 must output it now. */
3140 link
= symtab_hdr
->sh_link
;
3141 name
= bfd_elf_string_from_elf_section (input_bfd
,
3147 osec
= sec
->output_section
;
3149 _bfd_elf_section_from_bfd_section (output_bfd
,
3151 if (isym
->st_shndx
== (unsigned short) -1)
3154 isym
->st_value
+= sec
->output_offset
;
3155 if (! finfo
->info
->relocateable
)
3156 isym
->st_value
+= osec
->vma
;
3158 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
3160 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
3164 r_symndx
= finfo
->indices
[r_symndx
];
3167 irela
->r_info
= ELF_R_INFO (r_symndx
,
3168 ELF_R_TYPE (irela
->r_info
));
3171 /* Swap out the relocs. */
3172 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
3173 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
3174 BFD_ASSERT (output_rel_hdr
->sh_entsize
3175 == input_rel_hdr
->sh_entsize
);
3176 irela
= internal_relocs
;
3177 irelaend
= irela
+ o
->reloc_count
;
3178 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
3180 Elf_External_Rel
*erel
;
3182 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
3183 + o
->output_section
->reloc_count
);
3184 for (; irela
< irelaend
; irela
++, erel
++)
3186 Elf_Internal_Rel irel
;
3188 irel
.r_offset
= irela
->r_offset
;
3189 irel
.r_info
= irela
->r_info
;
3190 BFD_ASSERT (irela
->r_addend
== 0);
3191 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3196 Elf_External_Rela
*erela
;
3198 BFD_ASSERT (input_rel_hdr
->sh_entsize
3199 == sizeof (Elf_External_Rela
));
3200 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
3201 + o
->output_section
->reloc_count
);
3202 for (; irela
< irelaend
; irela
++, erela
++)
3203 elf_swap_reloca_out (output_bfd
, irela
, erela
);
3206 o
->output_section
->reloc_count
+= o
->reloc_count
;
3210 /* Write out the modified section contents. */
3211 if (elf_section_data (o
)->stab_info
== NULL
)
3213 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
3214 contents
, o
->output_offset
,
3215 (o
->_cooked_size
!= 0
3222 if (! _bfd_write_section_stabs (output_bfd
, o
,
3223 &elf_section_data (o
)->stab_info
,
3232 /* Generate a reloc when linking an ELF file. This is a reloc
3233 requested by the linker, and does come from any input file. This
3234 is used to build constructor and destructor tables when linking
3238 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
3240 struct bfd_link_info
*info
;
3241 asection
*output_section
;
3242 struct bfd_link_order
*link_order
;
3244 reloc_howto_type
*howto
;
3248 struct elf_link_hash_entry
**rel_hash_ptr
;
3249 Elf_Internal_Shdr
*rel_hdr
;
3251 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3254 bfd_set_error (bfd_error_bad_value
);
3258 addend
= link_order
->u
.reloc
.p
->addend
;
3260 /* Figure out the symbol index. */
3261 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3262 + output_section
->reloc_count
);
3263 if (link_order
->type
== bfd_section_reloc_link_order
)
3265 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3266 BFD_ASSERT (indx
!= 0);
3267 *rel_hash_ptr
= NULL
;
3271 struct elf_link_hash_entry
*h
;
3273 /* Treat a reloc against a defined symbol as though it were
3274 actually against the section. */
3275 h
= ((struct elf_link_hash_entry
*)
3276 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3277 link_order
->u
.reloc
.p
->u
.name
,
3278 false, false, true));
3280 && (h
->root
.type
== bfd_link_hash_defined
3281 || h
->root
.type
== bfd_link_hash_defweak
))
3285 section
= h
->root
.u
.def
.section
;
3286 indx
= section
->output_section
->target_index
;
3287 *rel_hash_ptr
= NULL
;
3288 /* It seems that we ought to add the symbol value to the
3289 addend here, but in practice it has already been added
3290 because it was passed to constructor_callback. */
3291 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3295 /* Setting the index to -2 tells elf_link_output_extsym that
3296 this symbol is used by a reloc. */
3303 if (! ((*info
->callbacks
->unattached_reloc
)
3304 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3305 (asection
*) NULL
, (bfd_vma
) 0)))
3311 /* If this is an inplace reloc, we must write the addend into the
3313 if (howto
->partial_inplace
&& addend
!= 0)
3316 bfd_reloc_status_type rstat
;
3320 size
= bfd_get_reloc_size (howto
);
3321 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3322 if (buf
== (bfd_byte
*) NULL
)
3324 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3330 case bfd_reloc_outofrange
:
3332 case bfd_reloc_overflow
:
3333 if (! ((*info
->callbacks
->reloc_overflow
)
3335 (link_order
->type
== bfd_section_reloc_link_order
3336 ? bfd_section_name (output_bfd
,
3337 link_order
->u
.reloc
.p
->u
.section
)
3338 : link_order
->u
.reloc
.p
->u
.name
),
3339 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3347 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3348 (file_ptr
) link_order
->offset
, size
);
3354 /* The address of a reloc is relative to the section in a
3355 relocateable file, and is a virtual address in an executable
3357 offset
= link_order
->offset
;
3358 if (! info
->relocateable
)
3359 offset
+= output_section
->vma
;
3361 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3363 if (rel_hdr
->sh_type
== SHT_REL
)
3365 Elf_Internal_Rel irel
;
3366 Elf_External_Rel
*erel
;
3368 irel
.r_offset
= offset
;
3369 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3370 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3371 + output_section
->reloc_count
);
3372 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3376 Elf_Internal_Rela irela
;
3377 Elf_External_Rela
*erela
;
3379 irela
.r_offset
= offset
;
3380 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3381 irela
.r_addend
= addend
;
3382 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3383 + output_section
->reloc_count
);
3384 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3387 ++output_section
->reloc_count
;
3393 /* Allocate a pointer to live in a linker created section. */
3396 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3398 struct bfd_link_info
*info
;
3399 elf_linker_section_t
*lsect
;
3400 struct elf_link_hash_entry
*h
;
3401 const Elf_Internal_Rela
*rel
;
3403 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3404 elf_linker_section_pointers_t
*linker_section_ptr
;
3405 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3407 BFD_ASSERT (lsect
!= NULL
);
3409 /* Is this a global symbol? */
3412 /* Has this symbol already been allocated, if so, our work is done */
3413 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3418 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3419 /* Make sure this symbol is output as a dynamic symbol. */
3420 if (h
->dynindx
== -1)
3422 if (! elf_link_record_dynamic_symbol (info
, h
))
3426 if (lsect
->rel_section
)
3427 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3430 else /* Allocation of a pointer to a local symbol */
3432 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3434 /* Allocate a table to hold the local symbols if first time */
3437 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3438 register unsigned int i
;
3440 ptr
= (elf_linker_section_pointers_t
**)
3441 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3446 elf_local_ptr_offsets (abfd
) = ptr
;
3447 for (i
= 0; i
< num_symbols
; i
++)
3448 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3451 /* Has this symbol already been allocated, if so, our work is done */
3452 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3457 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3461 /* If we are generating a shared object, we need to
3462 output a R_<xxx>_RELATIVE reloc so that the
3463 dynamic linker can adjust this GOT entry. */
3464 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3465 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3469 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3470 from internal memory. */
3471 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3472 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3473 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3475 if (!linker_section_ptr
)
3478 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3479 linker_section_ptr
->addend
= rel
->r_addend
;
3480 linker_section_ptr
->which
= lsect
->which
;
3481 linker_section_ptr
->written_address_p
= false;
3482 *ptr_linker_section_ptr
= linker_section_ptr
;
3485 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3487 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
3488 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3489 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3490 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3492 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3494 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
3495 lsect
->sym_hash
->root
.root
.string
,
3496 (long)ARCH_SIZE
/ 8,
3497 (long)lsect
->sym_hash
->root
.u
.def
.value
);
3503 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3505 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3508 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3509 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3517 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3520 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3523 /* Fill in the address for a pointer generated in alinker section. */
3526 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3529 struct bfd_link_info
*info
;
3530 elf_linker_section_t
*lsect
;
3531 struct elf_link_hash_entry
*h
;
3533 const Elf_Internal_Rela
*rel
;
3536 elf_linker_section_pointers_t
*linker_section_ptr
;
3538 BFD_ASSERT (lsect
!= NULL
);
3540 if (h
!= NULL
) /* global symbol */
3542 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3546 BFD_ASSERT (linker_section_ptr
!= NULL
);
3548 if (! elf_hash_table (info
)->dynamic_sections_created
3551 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3553 /* This is actually a static link, or it is a
3554 -Bsymbolic link and the symbol is defined
3555 locally. We must initialize this entry in the
3558 When doing a dynamic link, we create a .rela.<xxx>
3559 relocation entry to initialize the value. This
3560 is done in the finish_dynamic_symbol routine. */
3561 if (!linker_section_ptr
->written_address_p
)
3563 linker_section_ptr
->written_address_p
= true;
3564 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3565 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3569 else /* local symbol */
3571 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3572 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3573 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3574 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3578 BFD_ASSERT (linker_section_ptr
!= NULL
);
3580 /* Write out pointer if it hasn't been rewritten out before */
3581 if (!linker_section_ptr
->written_address_p
)
3583 linker_section_ptr
->written_address_p
= true;
3584 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3585 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3589 asection
*srel
= lsect
->rel_section
;
3590 Elf_Internal_Rela outrel
;
3592 /* We need to generate a relative reloc for the dynamic linker. */
3594 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3597 BFD_ASSERT (srel
!= NULL
);
3599 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3600 + lsect
->section
->output_offset
3601 + linker_section_ptr
->offset
);
3602 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3603 outrel
.r_addend
= 0;
3604 elf_swap_reloca_out (output_bfd
, &outrel
,
3605 (((Elf_External_Rela
*)
3606 lsect
->section
->contents
)
3607 + lsect
->section
->reloc_count
));
3608 ++lsect
->section
->reloc_count
;
3613 relocation
= (lsect
->section
->output_offset
3614 + linker_section_ptr
->offset
3615 - lsect
->hole_offset
3616 - lsect
->sym_offset
);
3619 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3620 lsect
->name
, (long)relocation
, (long)relocation
);
3623 /* Subtract out the addend, because it will get added back in by the normal
3625 return relocation
- linker_section_ptr
->addend
;