2 Copyright 1995, 1996 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 Elf_Internal_Rela
*elf_link_read_relocs
27 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
28 static boolean elf_export_symbol
29 PARAMS ((struct elf_link_hash_entry
*, PTR
));
30 static boolean elf_adjust_dynamic_symbol
31 PARAMS ((struct elf_link_hash_entry
*, PTR
));
33 /* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
36 struct elf_info_failed
39 struct bfd_link_info
*info
;
42 /* Given an ELF BFD, add symbols to the global hash table as
46 elf_bfd_link_add_symbols (abfd
, info
)
48 struct bfd_link_info
*info
;
50 switch (bfd_get_format (abfd
))
53 return elf_link_add_object_symbols (abfd
, info
);
55 return elf_link_add_archive_symbols (abfd
, info
);
57 bfd_set_error (bfd_error_wrong_format
);
63 /* Add symbols from an ELF archive file to the linker hash table. We
64 don't use _bfd_generic_link_add_archive_symbols because of a
65 problem which arises on UnixWare. The UnixWare libc.so is an
66 archive which includes an entry libc.so.1 which defines a bunch of
67 symbols. The libc.so archive also includes a number of other
68 object files, which also define symbols, some of which are the same
69 as those defined in libc.so.1. Correct linking requires that we
70 consider each object file in turn, and include it if it defines any
71 symbols we need. _bfd_generic_link_add_archive_symbols does not do
72 this; it looks through the list of undefined symbols, and includes
73 any object file which defines them. When this algorithm is used on
74 UnixWare, it winds up pulling in libc.so.1 early and defining a
75 bunch of symbols. This means that some of the other objects in the
76 archive are not included in the link, which is incorrect since they
77 precede libc.so.1 in the archive.
79 Fortunately, ELF archive handling is simpler than that done by
80 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
81 oddities. In ELF, if we find a symbol in the archive map, and the
82 symbol is currently undefined, we know that we must pull in that
85 Unfortunately, we do have to make multiple passes over the symbol
86 table until nothing further is resolved. */
89 elf_link_add_archive_symbols (abfd
, info
)
91 struct bfd_link_info
*info
;
94 boolean
*defined
= NULL
;
95 boolean
*included
= NULL
;
99 if (! bfd_has_map (abfd
))
101 /* An empty archive is a special case. */
102 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
104 bfd_set_error (bfd_error_no_armap
);
108 /* Keep track of all symbols we know to be already defined, and all
109 files we know to be already included. This is to speed up the
110 second and subsequent passes. */
111 c
= bfd_ardata (abfd
)->symdef_count
;
114 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
115 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
116 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
118 memset (defined
, 0, c
* sizeof (boolean
));
119 memset (included
, 0, c
* sizeof (boolean
));
121 symdefs
= bfd_ardata (abfd
)->symdefs
;
134 symdefend
= symdef
+ c
;
135 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
137 struct elf_link_hash_entry
*h
;
139 struct bfd_link_hash_entry
*undefs_tail
;
142 if (defined
[i
] || included
[i
])
144 if (symdef
->file_offset
== last
)
150 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
151 false, false, false);
152 if (h
== (struct elf_link_hash_entry
*) NULL
)
154 if (h
->root
.type
!= bfd_link_hash_undefined
)
156 if (h
->root
.type
!= bfd_link_hash_undefweak
)
161 /* We need to include this archive member. */
163 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
164 if (element
== (bfd
*) NULL
)
167 if (! bfd_check_format (element
, bfd_object
))
170 /* Doublecheck that we have not included this object
171 already--it should be impossible, but there may be
172 something wrong with the archive. */
173 if (element
->archive_pass
!= 0)
175 bfd_set_error (bfd_error_bad_value
);
178 element
->archive_pass
= 1;
180 undefs_tail
= info
->hash
->undefs_tail
;
182 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
185 if (! elf_link_add_object_symbols (element
, info
))
188 /* If there are any new undefined symbols, we need to make
189 another pass through the archive in order to see whether
190 they can be defined. FIXME: This isn't perfect, because
191 common symbols wind up on undefs_tail and because an
192 undefined symbol which is defined later on in this pass
193 does not require another pass. This isn't a bug, but it
194 does make the code less efficient than it could be. */
195 if (undefs_tail
!= info
->hash
->undefs_tail
)
198 /* Look backward to mark all symbols from this object file
199 which we have already seen in this pass. */
203 included
[mark
] = true;
208 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
210 /* We mark subsequent symbols from this object file as we go
211 on through the loop. */
212 last
= symdef
->file_offset
;
223 if (defined
!= (boolean
*) NULL
)
225 if (included
!= (boolean
*) NULL
)
230 /* Add symbols from an ELF object file to the linker hash table. */
233 elf_link_add_object_symbols (abfd
, info
)
235 struct bfd_link_info
*info
;
237 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
238 const Elf_Internal_Sym
*,
239 const char **, flagword
*,
240 asection
**, bfd_vma
*));
241 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
242 asection
*, const Elf_Internal_Rela
*));
244 Elf_Internal_Shdr
*hdr
;
248 Elf_External_Sym
*buf
= NULL
;
249 struct elf_link_hash_entry
**sym_hash
;
251 Elf_External_Dyn
*dynbuf
= NULL
;
252 struct elf_link_hash_entry
*weaks
;
253 Elf_External_Sym
*esym
;
254 Elf_External_Sym
*esymend
;
256 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
257 collect
= get_elf_backend_data (abfd
)->collect
;
259 /* As a GNU extension, any input sections which are named
260 .gnu.warning.SYMBOL are treated as warning symbols for the given
261 symbol. This differs from .gnu.warning sections, which generate
262 warnings when they are included in an output file. */
267 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
271 name
= bfd_get_section_name (abfd
, s
);
272 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
277 sz
= bfd_section_size (abfd
, s
);
278 msg
= (char *) bfd_alloc (abfd
, sz
);
282 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
285 if (! (_bfd_generic_link_add_one_symbol
287 name
+ sizeof ".gnu.warning." - 1,
288 BSF_WARNING
, s
, (bfd_vma
) 0, msg
, false, collect
,
289 (struct bfd_link_hash_entry
**) NULL
)))
292 if (! info
->relocateable
)
294 /* Clobber the section size so that the warning does
295 not get copied into the output file. */
302 /* A stripped shared library might only have a dynamic symbol table,
303 not a regular symbol table. In that case we can still go ahead
304 and link using the dynamic symbol table. */
305 if (elf_onesymtab (abfd
) == 0
306 && elf_dynsymtab (abfd
) != 0)
308 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
309 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
312 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
313 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
315 /* The sh_info field of the symtab header tells us where the
316 external symbols start. We don't care about the local symbols at
318 if (elf_bad_symtab (abfd
))
320 extsymcount
= symcount
;
325 extsymcount
= symcount
- hdr
->sh_info
;
326 extsymoff
= hdr
->sh_info
;
329 buf
= ((Elf_External_Sym
*)
330 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
331 if (buf
== NULL
&& extsymcount
!= 0)
334 /* We store a pointer to the hash table entry for each external
336 sym_hash
= ((struct elf_link_hash_entry
**)
338 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
339 if (sym_hash
== NULL
)
341 elf_sym_hashes (abfd
) = sym_hash
;
343 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
347 /* If we are creating a shared library, create all the dynamic
348 sections immediately. We need to attach them to something,
349 so we attach them to this BFD, provided it is the right
350 format. FIXME: If there are no input BFD's of the same
351 format as the output, we can't make a shared library. */
353 && ! elf_hash_table (info
)->dynamic_sections_created
354 && abfd
->xvec
== info
->hash
->creator
)
356 if (! elf_link_create_dynamic_sections (abfd
, info
))
365 bfd_size_type oldsize
;
366 bfd_size_type strindex
;
370 /* You can't use -r against a dynamic object. Also, there's no
371 hope of using a dynamic object which does not exactly match
372 the format of the output file. */
373 if (info
->relocateable
374 || info
->hash
->creator
!= abfd
->xvec
)
376 bfd_set_error (bfd_error_invalid_operation
);
380 /* Find the name to use in a DT_NEEDED entry that refers to this
381 object. If the object has a DT_SONAME entry, we use it.
382 Otherwise, if the generic linker stuck something in
383 elf_dt_needed_name, we use that. Otherwise, we just use the
384 file name. If the generic linker put a null string into
385 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
386 even if there is a DT_SONAME entry. */
388 name
= bfd_get_filename (abfd
);
389 if (elf_dt_needed_name (abfd
) != NULL
)
391 name
= elf_dt_needed_name (abfd
);
395 s
= bfd_get_section_by_name (abfd
, ".dynamic");
398 Elf_External_Dyn
*extdyn
;
399 Elf_External_Dyn
*extdynend
;
403 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
407 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
408 (file_ptr
) 0, s
->_raw_size
))
411 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
414 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
417 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
418 for (; extdyn
< extdynend
; extdyn
++)
420 Elf_Internal_Dyn dyn
;
422 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
423 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
425 name
= bfd_elf_string_from_elf_section (abfd
, link
,
430 if (dyn
.d_tag
== DT_NEEDED
)
432 struct bfd_link_needed_list
*n
, **pn
;
435 n
= ((struct bfd_link_needed_list
*)
436 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
437 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
439 if (n
== NULL
|| fnm
== NULL
)
441 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
448 for (pn
= &elf_hash_table (info
)->needed
;
460 /* We do not want to include any of the sections in a dynamic
461 object in the output file. We hack by simply clobbering the
462 list of sections in the BFD. This could be handled more
463 cleanly by, say, a new section flag; the existing
464 SEC_NEVER_LOAD flag is not the one we want, because that one
465 still implies that the section takes up space in the output
467 abfd
->sections
= NULL
;
468 abfd
->section_count
= 0;
470 /* If this is the first dynamic object found in the link, create
471 the special sections required for dynamic linking. */
472 if (! elf_hash_table (info
)->dynamic_sections_created
)
474 if (! elf_link_create_dynamic_sections (abfd
, info
))
480 /* Add a DT_NEEDED entry for this dynamic object. */
481 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
482 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
484 if (strindex
== (bfd_size_type
) -1)
487 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
490 Elf_External_Dyn
*dyncon
, *dynconend
;
492 /* The hash table size did not change, which means that
493 the dynamic object name was already entered. If we
494 have already included this dynamic object in the
495 link, just ignore it. There is no reason to include
496 a particular dynamic object more than once. */
497 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
499 BFD_ASSERT (sdyn
!= NULL
);
501 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
502 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
504 for (; dyncon
< dynconend
; dyncon
++)
506 Elf_Internal_Dyn dyn
;
508 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
510 if (dyn
.d_tag
== DT_NEEDED
511 && dyn
.d_un
.d_val
== strindex
)
520 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
526 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
528 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
529 != extsymcount
* sizeof (Elf_External_Sym
)))
534 esymend
= buf
+ extsymcount
;
535 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
537 Elf_Internal_Sym sym
;
543 struct elf_link_hash_entry
*h
;
545 boolean size_change_ok
, type_change_ok
;
548 elf_swap_symbol_in (abfd
, esym
, &sym
);
550 flags
= BSF_NO_FLAGS
;
552 value
= sym
.st_value
;
555 bind
= ELF_ST_BIND (sym
.st_info
);
556 if (bind
== STB_LOCAL
)
558 /* This should be impossible, since ELF requires that all
559 global symbols follow all local symbols, and that sh_info
560 point to the first global symbol. Unfortunatealy, Irix 5
564 else if (bind
== STB_GLOBAL
)
566 if (sym
.st_shndx
!= SHN_UNDEF
567 && sym
.st_shndx
!= SHN_COMMON
)
572 else if (bind
== STB_WEAK
)
576 /* Leave it up to the processor backend. */
579 if (sym
.st_shndx
== SHN_UNDEF
)
580 sec
= bfd_und_section_ptr
;
581 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
583 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
587 sec
= bfd_abs_section_ptr
;
589 else if (sym
.st_shndx
== SHN_ABS
)
590 sec
= bfd_abs_section_ptr
;
591 else if (sym
.st_shndx
== SHN_COMMON
)
593 sec
= bfd_com_section_ptr
;
594 /* What ELF calls the size we call the value. What ELF
595 calls the value we call the alignment. */
600 /* Leave it up to the processor backend. */
603 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
604 if (name
== (const char *) NULL
)
609 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
613 /* The hook function sets the name to NULL if this symbol
614 should be skipped for some reason. */
615 if (name
== (const char *) NULL
)
619 /* Sanity check that all possibilities were handled. */
620 if (sec
== (asection
*) NULL
)
622 bfd_set_error (bfd_error_bad_value
);
626 if (bfd_is_und_section (sec
)
627 || bfd_is_com_section (sec
))
632 size_change_ok
= false;
633 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
634 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
636 /* We need to look up the symbol now in order to get some of
637 the dynamic object handling right. We pass the hash
638 table entry in to _bfd_generic_link_add_one_symbol so
639 that it does not have to look it up again. */
640 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
646 while (h
->root
.type
== bfd_link_hash_indirect
647 || h
->root
.type
== bfd_link_hash_warning
)
648 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
650 /* It's OK to change the type if it used to be a weak
652 if (h
->root
.type
== bfd_link_hash_defweak
653 || h
->root
.type
== bfd_link_hash_undefweak
)
654 type_change_ok
= true;
656 /* It's OK to change the size if it used to be a weak
657 definition, or if it used to be undefined, or if we will
658 be overriding an old definition. */
660 || h
->root
.type
== bfd_link_hash_undefined
)
661 size_change_ok
= true;
663 /* If we are looking at a dynamic object, and this is a
664 definition, we need to see if it has already been defined
665 by some other object. If it has, we want to use the
666 existing definition, and we do not want to report a
667 multiple symbol definition error; we do this by
668 clobbering sec to be bfd_und_section_ptr. */
669 if (dynamic
&& definition
)
671 if (h
->root
.type
== bfd_link_hash_defined
672 || h
->root
.type
== bfd_link_hash_defweak
673 || (h
->root
.type
== bfd_link_hash_common
674 && bind
== STB_WEAK
))
676 sec
= bfd_und_section_ptr
;
678 size_change_ok
= true;
682 /* Similarly, if we are not looking at a dynamic object, and
683 we have a definition, we want to override any definition
684 we may have from a dynamic object. Symbols from regular
685 files always take precedence over symbols from dynamic
686 objects, even if they are defined after the dynamic
687 object in the link. */
690 && (h
->root
.type
== bfd_link_hash_defined
691 || h
->root
.type
== bfd_link_hash_defweak
)
692 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
693 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
694 == bfd_target_elf_flavour
)
695 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
698 /* Change the hash table entry to undefined, and let
699 _bfd_generic_link_add_one_symbol do the right thing
700 with the new definition. */
701 h
->root
.type
= bfd_link_hash_undefined
;
702 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
703 size_change_ok
= true;
707 if (! (_bfd_generic_link_add_one_symbol
708 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
709 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
713 while (h
->root
.type
== bfd_link_hash_indirect
714 || h
->root
.type
== bfd_link_hash_warning
)
715 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
721 && (flags
& BSF_WEAK
) != 0
722 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
723 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
724 && h
->weakdef
== NULL
)
726 /* Keep a list of all weak defined non function symbols from
727 a dynamic object, using the weakdef field. Later in this
728 function we will set the weakdef field to the correct
729 value. We only put non-function symbols from dynamic
730 objects on this list, because that happens to be the only
731 time we need to know the normal symbol corresponding to a
732 weak symbol, and the information is time consuming to
733 figure out. If the weakdef field is not already NULL,
734 then this symbol was already defined by some previous
735 dynamic object, and we will be using that previous
736 definition anyhow. */
743 /* Get the alignment of a common symbol. */
744 if (sym
.st_shndx
== SHN_COMMON
745 && h
->root
.type
== bfd_link_hash_common
)
746 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
748 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
754 /* Remember the symbol size and type. */
756 && (definition
|| h
->size
== 0))
758 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
759 (*_bfd_error_handler
)
760 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
761 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
762 bfd_get_filename (abfd
));
764 h
->size
= sym
.st_size
;
766 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
767 && (definition
|| h
->type
== STT_NOTYPE
))
769 if (h
->type
!= STT_NOTYPE
770 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
772 (*_bfd_error_handler
)
773 ("Warning: type of symbol `%s' changed from %d to %d in %s",
774 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
775 bfd_get_filename (abfd
));
777 h
->type
= ELF_ST_TYPE (sym
.st_info
);
780 /* Set a flag in the hash table entry indicating the type of
781 reference or definition we just found. Keep a count of
782 the number of dynamic symbols we find. A dynamic symbol
783 is one which is referenced or defined by both a regular
784 object and a shared object, or one which is referenced or
785 defined by more than one shared object. */
786 old_flags
= h
->elf_link_hash_flags
;
791 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
793 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
795 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
796 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
802 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
804 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
805 if ((old_flags
& new_flag
) != 0
806 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
807 | ELF_LINK_HASH_REF_REGULAR
)) != 0
808 || (h
->weakdef
!= NULL
809 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
810 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
814 h
->elf_link_hash_flags
|= new_flag
;
815 if (dynsym
&& h
->dynindx
== -1)
817 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
819 if (h
->weakdef
!= NULL
821 && h
->weakdef
->dynindx
== -1)
823 if (! _bfd_elf_link_record_dynamic_symbol (info
,
831 /* Now set the weakdefs field correctly for all the weak defined
832 symbols we found. The only way to do this is to search all the
833 symbols. Since we only need the information for non functions in
834 dynamic objects, that's the only time we actually put anything on
835 the list WEAKS. We need this information so that if a regular
836 object refers to a symbol defined weakly in a dynamic object, the
837 real symbol in the dynamic object is also put in the dynamic
838 symbols; we also must arrange for both symbols to point to the
839 same memory location. We could handle the general case of symbol
840 aliasing, but a general symbol alias can only be generated in
841 assembler code, handling it correctly would be very time
842 consuming, and other ELF linkers don't handle general aliasing
844 while (weaks
!= NULL
)
846 struct elf_link_hash_entry
*hlook
;
849 struct elf_link_hash_entry
**hpp
;
850 struct elf_link_hash_entry
**hppend
;
853 weaks
= hlook
->weakdef
;
854 hlook
->weakdef
= NULL
;
856 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
857 || hlook
->root
.type
== bfd_link_hash_defweak
858 || hlook
->root
.type
== bfd_link_hash_common
859 || hlook
->root
.type
== bfd_link_hash_indirect
);
860 slook
= hlook
->root
.u
.def
.section
;
861 vlook
= hlook
->root
.u
.def
.value
;
863 hpp
= elf_sym_hashes (abfd
);
864 hppend
= hpp
+ extsymcount
;
865 for (; hpp
< hppend
; hpp
++)
867 struct elf_link_hash_entry
*h
;
870 if (h
!= NULL
&& h
!= hlook
871 && (h
->root
.type
== bfd_link_hash_defined
872 || h
->root
.type
== bfd_link_hash_defweak
)
873 && h
->root
.u
.def
.section
== slook
874 && h
->root
.u
.def
.value
== vlook
)
878 /* If the weak definition is in the list of dynamic
879 symbols, make sure the real definition is put there
881 if (hlook
->dynindx
!= -1
884 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
899 /* If this object is the same format as the output object, and it is
900 not a shared library, then let the backend look through the
903 This is required to build global offset table entries and to
904 arrange for dynamic relocs. It is not required for the
905 particular common case of linking non PIC code, even when linking
906 against shared libraries, but unfortunately there is no way of
907 knowing whether an object file has been compiled PIC or not.
908 Looking through the relocs is not particularly time consuming.
909 The problem is that we must either (1) keep the relocs in memory,
910 which causes the linker to require additional runtime memory or
911 (2) read the relocs twice from the input file, which wastes time.
912 This would be a good case for using mmap.
914 I have no idea how to handle linking PIC code into a file of a
915 different format. It probably can't be done. */
916 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
918 && abfd
->xvec
== info
->hash
->creator
919 && check_relocs
!= NULL
)
923 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
925 Elf_Internal_Rela
*internal_relocs
;
928 if ((o
->flags
& SEC_RELOC
) == 0
929 || o
->reloc_count
== 0)
932 /* I believe we can ignore the relocs for any section which
933 does not form part of the final process image, such as a
934 debugging section. */
935 if ((o
->flags
& SEC_ALLOC
) == 0)
938 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
939 (Elf_Internal_Rela
*) NULL
,
941 if (internal_relocs
== NULL
)
944 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
946 if (! info
->keep_memory
)
947 free (internal_relocs
);
964 /* Create some sections which will be filled in with dynamic linking
965 information. ABFD is an input file which requires dynamic sections
966 to be created. The dynamic sections take up virtual memory space
967 when the final executable is run, so we need to create them before
968 addresses are assigned to the output sections. We work out the
969 actual contents and size of these sections later. */
972 elf_link_create_dynamic_sections (abfd
, info
)
974 struct bfd_link_info
*info
;
977 register asection
*s
;
978 struct elf_link_hash_entry
*h
;
979 struct elf_backend_data
*bed
;
981 if (elf_hash_table (info
)->dynamic_sections_created
)
984 /* Make sure that all dynamic sections use the same input BFD. */
985 if (elf_hash_table (info
)->dynobj
== NULL
)
986 elf_hash_table (info
)->dynobj
= abfd
;
988 abfd
= elf_hash_table (info
)->dynobj
;
990 /* Note that we set the SEC_IN_MEMORY flag for all of these
992 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
994 /* A dynamically linked executable has a .interp section, but a
995 shared library does not. */
998 s
= bfd_make_section (abfd
, ".interp");
1000 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1004 s
= bfd_make_section (abfd
, ".dynsym");
1006 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1007 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1010 s
= bfd_make_section (abfd
, ".dynstr");
1012 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1015 /* Create a strtab to hold the dynamic symbol names. */
1016 if (elf_hash_table (info
)->dynstr
== NULL
)
1018 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1019 if (elf_hash_table (info
)->dynstr
== NULL
)
1023 s
= bfd_make_section (abfd
, ".dynamic");
1025 || ! bfd_set_section_flags (abfd
, s
, flags
)
1026 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1029 /* The special symbol _DYNAMIC is always set to the start of the
1030 .dynamic section. This call occurs before we have processed the
1031 symbols for any dynamic object, so we don't have to worry about
1032 overriding a dynamic definition. We could set _DYNAMIC in a
1033 linker script, but we only want to define it if we are, in fact,
1034 creating a .dynamic section. We don't want to define it if there
1035 is no .dynamic section, since on some ELF platforms the start up
1036 code examines it to decide how to initialize the process. */
1038 if (! (_bfd_generic_link_add_one_symbol
1039 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1040 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1041 (struct bfd_link_hash_entry
**) &h
)))
1043 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1044 h
->type
= STT_OBJECT
;
1047 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1050 s
= bfd_make_section (abfd
, ".hash");
1052 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1053 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1056 /* Let the backend create the rest of the sections. This lets the
1057 backend set the right flags. The backend will normally create
1058 the .got and .plt sections. */
1059 bed
= get_elf_backend_data (abfd
);
1060 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1063 elf_hash_table (info
)->dynamic_sections_created
= true;
1068 /* Add an entry to the .dynamic table. */
1071 elf_add_dynamic_entry (info
, tag
, val
)
1072 struct bfd_link_info
*info
;
1076 Elf_Internal_Dyn dyn
;
1080 bfd_byte
*newcontents
;
1082 dynobj
= elf_hash_table (info
)->dynobj
;
1084 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1085 BFD_ASSERT (s
!= NULL
);
1087 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1088 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1089 if (newcontents
== NULL
)
1093 dyn
.d_un
.d_val
= val
;
1094 elf_swap_dyn_out (dynobj
, &dyn
,
1095 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1097 s
->_raw_size
= newsize
;
1098 s
->contents
= newcontents
;
1104 /* Read and swap the relocs for a section. They may have been cached.
1105 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1106 they are used as buffers to read into. They are known to be large
1107 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1108 value is allocated using either malloc or bfd_alloc, according to
1109 the KEEP_MEMORY argument. */
1111 static Elf_Internal_Rela
*
1112 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1115 PTR external_relocs
;
1116 Elf_Internal_Rela
*internal_relocs
;
1117 boolean keep_memory
;
1119 Elf_Internal_Shdr
*rel_hdr
;
1121 Elf_Internal_Rela
*alloc2
= NULL
;
1123 if (elf_section_data (o
)->relocs
!= NULL
)
1124 return elf_section_data (o
)->relocs
;
1126 if (o
->reloc_count
== 0)
1129 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1131 if (internal_relocs
== NULL
)
1135 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1137 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1139 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1140 if (internal_relocs
== NULL
)
1144 if (external_relocs
== NULL
)
1146 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1149 external_relocs
= alloc1
;
1152 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1153 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1154 != rel_hdr
->sh_size
))
1157 /* Swap in the relocs. For convenience, we always produce an
1158 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1160 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1162 Elf_External_Rel
*erel
;
1163 Elf_External_Rel
*erelend
;
1164 Elf_Internal_Rela
*irela
;
1166 erel
= (Elf_External_Rel
*) external_relocs
;
1167 erelend
= erel
+ o
->reloc_count
;
1168 irela
= internal_relocs
;
1169 for (; erel
< erelend
; erel
++, irela
++)
1171 Elf_Internal_Rel irel
;
1173 elf_swap_reloc_in (abfd
, erel
, &irel
);
1174 irela
->r_offset
= irel
.r_offset
;
1175 irela
->r_info
= irel
.r_info
;
1176 irela
->r_addend
= 0;
1181 Elf_External_Rela
*erela
;
1182 Elf_External_Rela
*erelaend
;
1183 Elf_Internal_Rela
*irela
;
1185 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1187 erela
= (Elf_External_Rela
*) external_relocs
;
1188 erelaend
= erela
+ o
->reloc_count
;
1189 irela
= internal_relocs
;
1190 for (; erela
< erelaend
; erela
++, irela
++)
1191 elf_swap_reloca_in (abfd
, erela
, irela
);
1194 /* Cache the results for next time, if we can. */
1196 elf_section_data (o
)->relocs
= internal_relocs
;
1201 /* Don't free alloc2, since if it was allocated we are passing it
1202 back (under the name of internal_relocs). */
1204 return internal_relocs
;
1215 /* Record an assignment to a symbol made by a linker script. We need
1216 this in case some dynamic object refers to this symbol. */
1220 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1222 struct bfd_link_info
*info
;
1226 struct elf_link_hash_entry
*h
;
1228 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1231 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1235 /* If this symbol is being provided by the linker script, and it is
1236 currently defined by a dynamic object, but not by a regular
1237 object, then mark it as undefined so that the generic linker will
1238 force the correct value. */
1240 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1241 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1242 h
->root
.type
= bfd_link_hash_undefined
;
1244 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1245 h
->type
= STT_OBJECT
;
1247 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1248 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1250 && h
->dynindx
== -1)
1252 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1255 /* If this is a weak defined symbol, and we know a corresponding
1256 real symbol from the same dynamic object, make sure the real
1257 symbol is also made into a dynamic symbol. */
1258 if (h
->weakdef
!= NULL
1259 && h
->weakdef
->dynindx
== -1)
1261 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1270 /* Array used to determine the number of hash table buckets to use
1271 based on the number of symbols there are. If there are fewer than
1272 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1273 fewer than 37 we use 17 buckets, and so forth. We never use more
1274 than 521 buckets. */
1276 static const size_t elf_buckets
[] =
1278 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1281 /* Set up the sizes and contents of the ELF dynamic sections. This is
1282 called by the ELF linker emulation before_allocation routine. We
1283 must set the sizes of the sections before the linker sets the
1284 addresses of the various sections. */
1287 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1288 export_dynamic
, info
, sinterpptr
)
1292 boolean export_dynamic
;
1293 struct bfd_link_info
*info
;
1294 asection
**sinterpptr
;
1297 struct elf_backend_data
*bed
;
1301 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1304 dynobj
= elf_hash_table (info
)->dynobj
;
1306 /* If there were no dynamic objects in the link, there is nothing to
1311 /* If we are supposed to export all symbols into the dynamic symbol
1312 table (this is not the normal case), then do so. */
1315 struct elf_info_failed eif
;
1319 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1325 if (elf_hash_table (info
)->dynamic_sections_created
)
1327 struct elf_info_failed eif
;
1328 struct elf_link_hash_entry
*h
;
1329 bfd_size_type strsize
;
1331 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1332 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1338 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1340 if (indx
== (bfd_size_type
) -1
1341 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1347 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1355 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1357 if (indx
== (bfd_size_type
) -1
1358 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1362 /* Find all symbols which were defined in a dynamic object and make
1363 the backend pick a reasonable value for them. */
1366 elf_link_hash_traverse (elf_hash_table (info
),
1367 elf_adjust_dynamic_symbol
,
1372 /* Add some entries to the .dynamic section. We fill in some of the
1373 values later, in elf_bfd_final_link, but we must add the entries
1374 now so that we know the final size of the .dynamic section. */
1375 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1378 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1379 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1381 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1384 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1387 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1388 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1390 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1393 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1394 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1395 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1396 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1397 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1398 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1399 sizeof (Elf_External_Sym
)))
1403 /* The backend must work out the sizes of all the other dynamic
1405 bed
= get_elf_backend_data (output_bfd
);
1406 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1409 if (elf_hash_table (info
)->dynamic_sections_created
)
1414 size_t bucketcount
= 0;
1415 Elf_Internal_Sym isym
;
1417 /* Set the size of the .dynsym and .hash sections. We counted
1418 the number of dynamic symbols in elf_link_add_object_symbols.
1419 We will build the contents of .dynsym and .hash when we build
1420 the final symbol table, because until then we do not know the
1421 correct value to give the symbols. We built the .dynstr
1422 section as we went along in elf_link_add_object_symbols. */
1423 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1424 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1425 BFD_ASSERT (s
!= NULL
);
1426 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1427 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1428 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1431 /* The first entry in .dynsym is a dummy symbol. */
1438 elf_swap_symbol_out (output_bfd
, &isym
,
1439 (PTR
) (Elf_External_Sym
*) s
->contents
);
1441 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1443 bucketcount
= elf_buckets
[i
];
1444 if (dynsymcount
< elf_buckets
[i
+ 1])
1448 s
= bfd_get_section_by_name (dynobj
, ".hash");
1449 BFD_ASSERT (s
!= NULL
);
1450 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1451 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1452 if (s
->contents
== NULL
)
1454 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1456 put_word (output_bfd
, bucketcount
, s
->contents
);
1457 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1459 elf_hash_table (info
)->bucketcount
= bucketcount
;
1461 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1462 BFD_ASSERT (s
!= NULL
);
1463 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1465 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1473 /* This routine is used to export all defined symbols into the dynamic
1474 symbol table. It is called via elf_link_hash_traverse. */
1477 elf_export_symbol (h
, data
)
1478 struct elf_link_hash_entry
*h
;
1481 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1483 if (h
->dynindx
== -1
1484 && (h
->elf_link_hash_flags
1485 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1487 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1498 /* Make the backend pick a good value for a dynamic symbol. This is
1499 called via elf_link_hash_traverse, and also calls itself
1503 elf_adjust_dynamic_symbol (h
, data
)
1504 struct elf_link_hash_entry
*h
;
1507 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1509 struct elf_backend_data
*bed
;
1511 /* If -Bsymbolic was used (which means to bind references to global
1512 symbols to the definition within the shared object), and this
1513 symbol was defined in a regular object, then it actually doesn't
1514 need a PLT entry. */
1515 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1516 && eif
->info
->shared
1517 && eif
->info
->symbolic
1518 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1519 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1521 /* If this symbol does not require a PLT entry, and it is not
1522 defined by a dynamic object, or is not referenced by a regular
1523 object, ignore it. We do have to handle a weak defined symbol,
1524 even if no regular object refers to it, if we decided to add it
1525 to the dynamic symbol table. FIXME: Do we normally need to worry
1526 about symbols which are defined by one dynamic object and
1527 referenced by another one? */
1528 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1529 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1530 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1531 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1532 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1535 /* If we've already adjusted this symbol, don't do it again. This
1536 can happen via a recursive call. */
1537 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1540 /* Don't look at this symbol again. Note that we must set this
1541 after checking the above conditions, because we may look at a
1542 symbol once, decide not to do anything, and then get called
1543 recursively later after REF_REGULAR is set below. */
1544 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1546 /* If this is a weak definition, and we know a real definition, and
1547 the real symbol is not itself defined by a regular object file,
1548 then get a good value for the real definition. We handle the
1549 real symbol first, for the convenience of the backend routine.
1551 Note that there is a confusing case here. If the real definition
1552 is defined by a regular object file, we don't get the real symbol
1553 from the dynamic object, but we do get the weak symbol. If the
1554 processor backend uses a COPY reloc, then if some routine in the
1555 dynamic object changes the real symbol, we will not see that
1556 change in the corresponding weak symbol. This is the way other
1557 ELF linkers work as well, and seems to be a result of the shared
1560 I will clarify this issue. Most SVR4 shared libraries define the
1561 variable _timezone and define timezone as a weak synonym. The
1562 tzset call changes _timezone. If you write
1563 extern int timezone;
1565 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1566 you might expect that, since timezone is a synonym for _timezone,
1567 the same number will print both times. However, if the processor
1568 backend uses a COPY reloc, then actually timezone will be copied
1569 into your process image, and, since you define _timezone
1570 yourself, _timezone will not. Thus timezone and _timezone will
1571 wind up at different memory locations. The tzset call will set
1572 _timezone, leaving timezone unchanged. */
1574 if (h
->weakdef
!= NULL
)
1576 struct elf_link_hash_entry
*weakdef
;
1578 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1579 || h
->root
.type
== bfd_link_hash_defweak
);
1580 weakdef
= h
->weakdef
;
1581 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1582 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1583 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1584 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1586 /* This symbol is defined by a regular object file, so we
1587 will not do anything special. Clear weakdef for the
1588 convenience of the processor backend. */
1593 /* There is an implicit reference by a regular object file
1594 via the weak symbol. */
1595 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1596 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1601 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1602 bed
= get_elf_backend_data (dynobj
);
1603 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1612 /* Final phase of ELF linker. */
1614 /* A structure we use to avoid passing large numbers of arguments. */
1616 struct elf_final_link_info
1618 /* General link information. */
1619 struct bfd_link_info
*info
;
1622 /* Symbol string table. */
1623 struct bfd_strtab_hash
*symstrtab
;
1624 /* .dynsym section. */
1625 asection
*dynsym_sec
;
1626 /* .hash section. */
1628 /* Buffer large enough to hold contents of any section. */
1630 /* Buffer large enough to hold external relocs of any section. */
1631 PTR external_relocs
;
1632 /* Buffer large enough to hold internal relocs of any section. */
1633 Elf_Internal_Rela
*internal_relocs
;
1634 /* Buffer large enough to hold external local symbols of any input
1636 Elf_External_Sym
*external_syms
;
1637 /* Buffer large enough to hold internal local symbols of any input
1639 Elf_Internal_Sym
*internal_syms
;
1640 /* Array large enough to hold a symbol index for each local symbol
1641 of any input BFD. */
1643 /* Array large enough to hold a section pointer for each local
1644 symbol of any input BFD. */
1645 asection
**sections
;
1646 /* Buffer to hold swapped out symbols. */
1647 Elf_External_Sym
*symbuf
;
1648 /* Number of swapped out symbols in buffer. */
1649 size_t symbuf_count
;
1650 /* Number of symbols which fit in symbuf. */
1654 static boolean elf_link_output_sym
1655 PARAMS ((struct elf_final_link_info
*, const char *,
1656 Elf_Internal_Sym
*, asection
*));
1657 static boolean elf_link_flush_output_syms
1658 PARAMS ((struct elf_final_link_info
*));
1659 static boolean elf_link_output_extsym
1660 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1661 static boolean elf_link_input_bfd
1662 PARAMS ((struct elf_final_link_info
*, bfd
*));
1663 static boolean elf_reloc_link_order
1664 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1665 struct bfd_link_order
*));
1667 /* This struct is used to pass information to routines called via
1668 elf_link_hash_traverse which must return failure. */
1670 struct elf_finfo_failed
1673 struct elf_final_link_info
*finfo
;
1676 /* Do the final step of an ELF link. */
1679 elf_bfd_final_link (abfd
, info
)
1681 struct bfd_link_info
*info
;
1685 struct elf_final_link_info finfo
;
1686 register asection
*o
;
1687 register struct bfd_link_order
*p
;
1689 size_t max_contents_size
;
1690 size_t max_external_reloc_size
;
1691 size_t max_internal_reloc_count
;
1692 size_t max_sym_count
;
1694 Elf_Internal_Sym elfsym
;
1696 Elf_Internal_Shdr
*symtab_hdr
;
1697 Elf_Internal_Shdr
*symstrtab_hdr
;
1698 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1699 struct elf_finfo_failed eif
;
1702 abfd
->flags
|= DYNAMIC
;
1704 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1705 dynobj
= elf_hash_table (info
)->dynobj
;
1708 finfo
.output_bfd
= abfd
;
1709 finfo
.symstrtab
= elf_stringtab_init ();
1710 if (finfo
.symstrtab
== NULL
)
1714 finfo
.dynsym_sec
= NULL
;
1715 finfo
.hash_sec
= NULL
;
1719 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1720 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1721 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1723 finfo
.contents
= NULL
;
1724 finfo
.external_relocs
= NULL
;
1725 finfo
.internal_relocs
= NULL
;
1726 finfo
.external_syms
= NULL
;
1727 finfo
.internal_syms
= NULL
;
1728 finfo
.indices
= NULL
;
1729 finfo
.sections
= NULL
;
1730 finfo
.symbuf
= NULL
;
1731 finfo
.symbuf_count
= 0;
1733 /* Count up the number of relocations we will output for each output
1734 section, so that we know the sizes of the reloc sections. We
1735 also figure out some maximum sizes. */
1736 max_contents_size
= 0;
1737 max_external_reloc_size
= 0;
1738 max_internal_reloc_count
= 0;
1740 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1744 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1746 if (p
->type
== bfd_section_reloc_link_order
1747 || p
->type
== bfd_symbol_reloc_link_order
)
1749 else if (p
->type
== bfd_indirect_link_order
)
1753 sec
= p
->u
.indirect
.section
;
1755 if (info
->relocateable
)
1756 o
->reloc_count
+= sec
->reloc_count
;
1758 if (sec
->_raw_size
> max_contents_size
)
1759 max_contents_size
= sec
->_raw_size
;
1760 if (sec
->_cooked_size
> max_contents_size
)
1761 max_contents_size
= sec
->_cooked_size
;
1763 /* We are interested in just local symbols, not all
1765 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1769 if (elf_bad_symtab (sec
->owner
))
1770 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1771 / sizeof (Elf_External_Sym
));
1773 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1775 if (sym_count
> max_sym_count
)
1776 max_sym_count
= sym_count
;
1778 if ((sec
->flags
& SEC_RELOC
) != 0)
1782 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1783 if (ext_size
> max_external_reloc_size
)
1784 max_external_reloc_size
= ext_size
;
1785 if (sec
->reloc_count
> max_internal_reloc_count
)
1786 max_internal_reloc_count
= sec
->reloc_count
;
1792 if (o
->reloc_count
> 0)
1793 o
->flags
|= SEC_RELOC
;
1796 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1797 set it (this is probably a bug) and if it is set
1798 assign_section_numbers will create a reloc section. */
1799 o
->flags
&=~ SEC_RELOC
;
1802 /* If the SEC_ALLOC flag is not set, force the section VMA to
1803 zero. This is done in elf_fake_sections as well, but forcing
1804 the VMA to 0 here will ensure that relocs against these
1805 sections are handled correctly. */
1806 if ((o
->flags
& SEC_ALLOC
) == 0)
1810 /* Figure out the file positions for everything but the symbol table
1811 and the relocs. We set symcount to force assign_section_numbers
1812 to create a symbol table. */
1813 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1814 BFD_ASSERT (! abfd
->output_has_begun
);
1815 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1818 /* That created the reloc sections. Set their sizes, and assign
1819 them file positions, and allocate some buffers. */
1820 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1822 if ((o
->flags
& SEC_RELOC
) != 0)
1824 Elf_Internal_Shdr
*rel_hdr
;
1825 register struct elf_link_hash_entry
**p
, **pend
;
1827 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1829 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1831 /* The contents field must last into write_object_contents,
1832 so we allocate it with bfd_alloc rather than malloc. */
1833 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1834 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1837 p
= ((struct elf_link_hash_entry
**)
1838 bfd_malloc (o
->reloc_count
1839 * sizeof (struct elf_link_hash_entry
*)));
1840 if (p
== NULL
&& o
->reloc_count
!= 0)
1842 elf_section_data (o
)->rel_hashes
= p
;
1843 pend
= p
+ o
->reloc_count
;
1844 for (; p
< pend
; p
++)
1847 /* Use the reloc_count field as an index when outputting the
1853 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1855 /* We have now assigned file positions for all the sections except
1856 .symtab and .strtab. We start the .symtab section at the current
1857 file position, and write directly to it. We build the .strtab
1858 section in memory. */
1860 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1861 /* sh_name is set in prep_headers. */
1862 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1863 symtab_hdr
->sh_flags
= 0;
1864 symtab_hdr
->sh_addr
= 0;
1865 symtab_hdr
->sh_size
= 0;
1866 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1867 /* sh_link is set in assign_section_numbers. */
1868 /* sh_info is set below. */
1869 /* sh_offset is set just below. */
1870 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1872 off
= elf_tdata (abfd
)->next_file_pos
;
1873 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1875 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1876 incorrect. We do not yet know the size of the .symtab section.
1877 We correct next_file_pos below, after we do know the size. */
1879 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1880 continuously seeking to the right position in the file. */
1881 if (! info
->keep_memory
|| max_sym_count
< 20)
1882 finfo
.symbuf_size
= 20;
1884 finfo
.symbuf_size
= max_sym_count
;
1885 finfo
.symbuf
= ((Elf_External_Sym
*)
1886 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1887 if (finfo
.symbuf
== NULL
)
1890 /* Start writing out the symbol table. The first symbol is always a
1892 elfsym
.st_value
= 0;
1895 elfsym
.st_other
= 0;
1896 elfsym
.st_shndx
= SHN_UNDEF
;
1897 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1898 &elfsym
, bfd_und_section_ptr
))
1902 /* Some standard ELF linkers do this, but we don't because it causes
1903 bootstrap comparison failures. */
1904 /* Output a file symbol for the output file as the second symbol.
1905 We output this even if we are discarding local symbols, although
1906 I'm not sure if this is correct. */
1907 elfsym
.st_value
= 0;
1909 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1910 elfsym
.st_other
= 0;
1911 elfsym
.st_shndx
= SHN_ABS
;
1912 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1913 &elfsym
, bfd_abs_section_ptr
))
1917 /* Output a symbol for each section. We output these even if we are
1918 discarding local symbols, since they are used for relocs. These
1919 symbols have no names. We store the index of each one in the
1920 index field of the section, so that we can find it again when
1921 outputting relocs. */
1922 elfsym
.st_value
= 0;
1924 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1925 elfsym
.st_other
= 0;
1926 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1928 o
= section_from_elf_index (abfd
, i
);
1930 o
->target_index
= abfd
->symcount
;
1931 elfsym
.st_shndx
= i
;
1932 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1937 /* Allocate some memory to hold information read in from the input
1939 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
1940 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
1941 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1942 bfd_malloc (max_internal_reloc_count
1943 * sizeof (Elf_Internal_Rela
)));
1944 finfo
.external_syms
= ((Elf_External_Sym
*)
1945 bfd_malloc (max_sym_count
1946 * sizeof (Elf_External_Sym
)));
1947 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1948 bfd_malloc (max_sym_count
1949 * sizeof (Elf_Internal_Sym
)));
1950 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
1951 finfo
.sections
= ((asection
**)
1952 bfd_malloc (max_sym_count
* sizeof (asection
*)));
1953 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
1954 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
1955 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
1956 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
1957 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
1958 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
1959 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
1962 /* Since ELF permits relocations to be against local symbols, we
1963 must have the local symbols available when we do the relocations.
1964 Since we would rather only read the local symbols once, and we
1965 would rather not keep them in memory, we handle all the
1966 relocations for a single input file at the same time.
1968 Unfortunately, there is no way to know the total number of local
1969 symbols until we have seen all of them, and the local symbol
1970 indices precede the global symbol indices. This means that when
1971 we are generating relocateable output, and we see a reloc against
1972 a global symbol, we can not know the symbol index until we have
1973 finished examining all the local symbols to see which ones we are
1974 going to output. To deal with this, we keep the relocations in
1975 memory, and don't output them until the end of the link. This is
1976 an unfortunate waste of memory, but I don't see a good way around
1977 it. Fortunately, it only happens when performing a relocateable
1978 link, which is not the common case. FIXME: If keep_memory is set
1979 we could write the relocs out and then read them again; I don't
1980 know how bad the memory loss will be. */
1982 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
1983 sub
->output_has_begun
= false;
1984 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1986 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1988 if (p
->type
== bfd_indirect_link_order
1989 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
1990 == bfd_target_elf_flavour
))
1992 sub
= p
->u
.indirect
.section
->owner
;
1993 if (! sub
->output_has_begun
)
1995 if (! elf_link_input_bfd (&finfo
, sub
))
1997 sub
->output_has_begun
= true;
2000 else if (p
->type
== bfd_section_reloc_link_order
2001 || p
->type
== bfd_symbol_reloc_link_order
)
2003 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2008 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2014 /* That wrote out all the local symbols. Finish up the symbol table
2015 with the global symbols. */
2017 /* The sh_info field records the index of the first non local
2019 symtab_hdr
->sh_info
= abfd
->symcount
;
2021 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2023 /* We get the global symbols from the hash table. */
2026 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2031 /* Flush all symbols to the file. */
2032 if (! elf_link_flush_output_syms (&finfo
))
2035 /* Now we know the size of the symtab section. */
2036 off
+= symtab_hdr
->sh_size
;
2038 /* Finish up and write out the symbol string table (.strtab)
2040 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2041 /* sh_name was set in prep_headers. */
2042 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2043 symstrtab_hdr
->sh_flags
= 0;
2044 symstrtab_hdr
->sh_addr
= 0;
2045 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2046 symstrtab_hdr
->sh_entsize
= 0;
2047 symstrtab_hdr
->sh_link
= 0;
2048 symstrtab_hdr
->sh_info
= 0;
2049 /* sh_offset is set just below. */
2050 symstrtab_hdr
->sh_addralign
= 1;
2052 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2053 elf_tdata (abfd
)->next_file_pos
= off
;
2055 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2056 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2059 /* Adjust the relocs to have the correct symbol indices. */
2060 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2062 struct elf_link_hash_entry
**rel_hash
;
2063 Elf_Internal_Shdr
*rel_hdr
;
2065 if ((o
->flags
& SEC_RELOC
) == 0)
2068 rel_hash
= elf_section_data (o
)->rel_hashes
;
2069 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2070 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2072 if (*rel_hash
== NULL
)
2075 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2077 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2079 Elf_External_Rel
*erel
;
2080 Elf_Internal_Rel irel
;
2082 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2083 elf_swap_reloc_in (abfd
, erel
, &irel
);
2084 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2085 ELF_R_TYPE (irel
.r_info
));
2086 elf_swap_reloc_out (abfd
, &irel
, erel
);
2090 Elf_External_Rela
*erela
;
2091 Elf_Internal_Rela irela
;
2093 BFD_ASSERT (rel_hdr
->sh_entsize
2094 == sizeof (Elf_External_Rela
));
2096 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2097 elf_swap_reloca_in (abfd
, erela
, &irela
);
2098 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2099 ELF_R_TYPE (irela
.r_info
));
2100 elf_swap_reloca_out (abfd
, &irela
, erela
);
2104 /* Set the reloc_count field to 0 to prevent write_relocs from
2105 trying to swap the relocs out itself. */
2109 /* If we are linking against a dynamic object, or generating a
2110 shared library, finish up the dynamic linking information. */
2113 Elf_External_Dyn
*dyncon
, *dynconend
;
2115 /* Fix up .dynamic entries. */
2116 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2117 BFD_ASSERT (o
!= NULL
);
2119 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2120 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2121 for (; dyncon
< dynconend
; dyncon
++)
2123 Elf_Internal_Dyn dyn
;
2127 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2134 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2135 magic _init and _fini symbols. This is pretty ugly,
2136 but we are compatible. */
2144 struct elf_link_hash_entry
*h
;
2146 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2147 false, false, true);
2149 && (h
->root
.type
== bfd_link_hash_defined
2150 || h
->root
.type
== bfd_link_hash_defweak
))
2152 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2153 o
= h
->root
.u
.def
.section
;
2154 if (o
->output_section
!= NULL
)
2155 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2156 + o
->output_offset
);
2159 /* The symbol is imported from another shared
2160 library and does not apply to this one. */
2164 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2178 o
= bfd_get_section_by_name (abfd
, name
);
2179 BFD_ASSERT (o
!= NULL
);
2180 dyn
.d_un
.d_ptr
= o
->vma
;
2181 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2188 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2193 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2195 Elf_Internal_Shdr
*hdr
;
2197 hdr
= elf_elfsections (abfd
)[i
];
2198 if (hdr
->sh_type
== type
2199 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2201 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2202 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2205 if (dyn
.d_un
.d_val
== 0
2206 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2207 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2211 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2217 /* If we have created any dynamic sections, then output them. */
2220 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2223 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2225 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2226 || o
->_raw_size
== 0)
2228 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2230 /* At this point, we are only interested in sections
2231 created by elf_link_create_dynamic_sections. FIXME:
2232 This test is fragile. */
2235 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2237 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2239 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2240 o
->contents
, o
->output_offset
,
2248 /* The contents of the .dynstr section are actually in a
2250 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2251 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2252 || ! _bfd_stringtab_emit (abfd
,
2253 elf_hash_table (info
)->dynstr
))
2259 if (finfo
.symstrtab
!= NULL
)
2260 _bfd_stringtab_free (finfo
.symstrtab
);
2261 if (finfo
.contents
!= NULL
)
2262 free (finfo
.contents
);
2263 if (finfo
.external_relocs
!= NULL
)
2264 free (finfo
.external_relocs
);
2265 if (finfo
.internal_relocs
!= NULL
)
2266 free (finfo
.internal_relocs
);
2267 if (finfo
.external_syms
!= NULL
)
2268 free (finfo
.external_syms
);
2269 if (finfo
.internal_syms
!= NULL
)
2270 free (finfo
.internal_syms
);
2271 if (finfo
.indices
!= NULL
)
2272 free (finfo
.indices
);
2273 if (finfo
.sections
!= NULL
)
2274 free (finfo
.sections
);
2275 if (finfo
.symbuf
!= NULL
)
2276 free (finfo
.symbuf
);
2277 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2279 if ((o
->flags
& SEC_RELOC
) != 0
2280 && elf_section_data (o
)->rel_hashes
!= NULL
)
2281 free (elf_section_data (o
)->rel_hashes
);
2284 elf_tdata (abfd
)->linker
= true;
2289 if (finfo
.symstrtab
!= NULL
)
2290 _bfd_stringtab_free (finfo
.symstrtab
);
2291 if (finfo
.contents
!= NULL
)
2292 free (finfo
.contents
);
2293 if (finfo
.external_relocs
!= NULL
)
2294 free (finfo
.external_relocs
);
2295 if (finfo
.internal_relocs
!= NULL
)
2296 free (finfo
.internal_relocs
);
2297 if (finfo
.external_syms
!= NULL
)
2298 free (finfo
.external_syms
);
2299 if (finfo
.internal_syms
!= NULL
)
2300 free (finfo
.internal_syms
);
2301 if (finfo
.indices
!= NULL
)
2302 free (finfo
.indices
);
2303 if (finfo
.sections
!= NULL
)
2304 free (finfo
.sections
);
2305 if (finfo
.symbuf
!= NULL
)
2306 free (finfo
.symbuf
);
2307 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2309 if ((o
->flags
& SEC_RELOC
) != 0
2310 && elf_section_data (o
)->rel_hashes
!= NULL
)
2311 free (elf_section_data (o
)->rel_hashes
);
2317 /* Add a symbol to the output symbol table. */
2320 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2321 struct elf_final_link_info
*finfo
;
2323 Elf_Internal_Sym
*elfsym
;
2324 asection
*input_sec
;
2326 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2327 struct bfd_link_info
*info
,
2332 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2333 elf_backend_link_output_symbol_hook
;
2334 if (output_symbol_hook
!= NULL
)
2336 if (! ((*output_symbol_hook
)
2337 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2341 if (name
== (const char *) NULL
|| *name
== '\0')
2342 elfsym
->st_name
= 0;
2345 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2348 if (elfsym
->st_name
== (unsigned long) -1)
2352 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2354 if (! elf_link_flush_output_syms (finfo
))
2358 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2359 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2360 ++finfo
->symbuf_count
;
2362 ++finfo
->output_bfd
->symcount
;
2367 /* Flush the output symbols to the file. */
2370 elf_link_flush_output_syms (finfo
)
2371 struct elf_final_link_info
*finfo
;
2373 Elf_Internal_Shdr
*symtab
;
2375 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2377 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2379 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2380 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2381 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2384 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2386 finfo
->symbuf_count
= 0;
2391 /* Add an external symbol to the symbol table. This is called from
2392 the hash table traversal routine. */
2395 elf_link_output_extsym (h
, data
)
2396 struct elf_link_hash_entry
*h
;
2399 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2400 struct elf_final_link_info
*finfo
= eif
->finfo
;
2402 Elf_Internal_Sym sym
;
2403 asection
*input_sec
;
2405 /* If we are not creating a shared library, and this symbol is
2406 referenced by a shared library but is not defined anywhere, then
2407 warn that it is undefined. If we do not do this, the runtime
2408 linker will complain that the symbol is undefined when the
2409 program is run. We don't have to worry about symbols that are
2410 referenced by regular files, because we will already have issued
2411 warnings for them. */
2412 if (! finfo
->info
->relocateable
2413 && ! finfo
->info
->shared
2414 && h
->root
.type
== bfd_link_hash_undefined
2415 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2416 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2418 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2419 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2420 (asection
*) NULL
, 0)))
2427 /* We don't want to output symbols that have never been mentioned by
2428 a regular file, or that we have been told to strip. However, if
2429 h->indx is set to -2, the symbol is used by a reloc and we must
2433 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2434 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2435 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2436 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2438 else if (finfo
->info
->strip
== strip_all
2439 || (finfo
->info
->strip
== strip_some
2440 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2441 h
->root
.root
.string
,
2442 false, false) == NULL
))
2447 /* If we're stripping it, and it's not a dynamic symbol, there's
2448 nothing else to do. */
2449 if (strip
&& h
->dynindx
== -1)
2453 sym
.st_size
= h
->size
;
2455 if (h
->root
.type
== bfd_link_hash_undefweak
2456 || h
->root
.type
== bfd_link_hash_defweak
)
2457 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2459 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2461 switch (h
->root
.type
)
2464 case bfd_link_hash_new
:
2468 case bfd_link_hash_undefined
:
2469 input_sec
= bfd_und_section_ptr
;
2470 sym
.st_shndx
= SHN_UNDEF
;
2473 case bfd_link_hash_undefweak
:
2474 input_sec
= bfd_und_section_ptr
;
2475 sym
.st_shndx
= SHN_UNDEF
;
2478 case bfd_link_hash_defined
:
2479 case bfd_link_hash_defweak
:
2481 input_sec
= h
->root
.u
.def
.section
;
2482 if (input_sec
->output_section
!= NULL
)
2485 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2486 input_sec
->output_section
);
2487 if (sym
.st_shndx
== (unsigned short) -1)
2493 /* ELF symbols in relocateable files are section relative,
2494 but in nonrelocateable files they are virtual
2496 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2497 if (! finfo
->info
->relocateable
)
2498 sym
.st_value
+= input_sec
->output_section
->vma
;
2502 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2503 == bfd_target_elf_flavour
)
2504 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2505 sym
.st_shndx
= SHN_UNDEF
;
2506 input_sec
= bfd_und_section_ptr
;
2511 case bfd_link_hash_common
:
2512 input_sec
= bfd_com_section_ptr
;
2513 sym
.st_shndx
= SHN_COMMON
;
2514 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2517 case bfd_link_hash_indirect
:
2518 case bfd_link_hash_warning
:
2519 /* We can't represent these symbols in ELF. A warning symbol
2520 may have come from a .gnu.warning.SYMBOL section anyhow. We
2521 just put the target symbol in the hash table. If the target
2522 symbol does not really exist, don't do anything. */
2523 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2525 return (elf_link_output_extsym
2526 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2529 /* If this symbol should be put in the .dynsym section, then put it
2530 there now. We have already know the symbol index. We also fill
2531 in the entry in the .hash section. */
2532 if (h
->dynindx
!= -1
2533 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2535 struct elf_backend_data
*bed
;
2538 bfd_byte
*bucketpos
;
2541 sym
.st_name
= h
->dynstr_index
;
2543 /* Give the processor backend a chance to tweak the symbol
2544 value, and also to finish up anything that needs to be done
2546 bed
= get_elf_backend_data (finfo
->output_bfd
);
2547 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2548 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2554 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2555 (PTR
) (((Elf_External_Sym
*)
2556 finfo
->dynsym_sec
->contents
)
2559 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2560 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2562 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2563 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2564 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2565 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2566 put_word (finfo
->output_bfd
, chain
,
2567 ((bfd_byte
*) finfo
->hash_sec
->contents
2568 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2571 /* If we're stripping it, then it was just a dynamic symbol, and
2572 there's nothing else to do. */
2576 h
->indx
= finfo
->output_bfd
->symcount
;
2578 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2587 /* Link an input file into the linker output file. This function
2588 handles all the sections and relocations of the input file at once.
2589 This is so that we only have to read the local symbols once, and
2590 don't have to keep them in memory. */
2593 elf_link_input_bfd (finfo
, input_bfd
)
2594 struct elf_final_link_info
*finfo
;
2597 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2598 bfd
*, asection
*, bfd_byte
*,
2599 Elf_Internal_Rela
*,
2600 Elf_Internal_Sym
*, asection
**));
2602 Elf_Internal_Shdr
*symtab_hdr
;
2605 Elf_External_Sym
*esym
;
2606 Elf_External_Sym
*esymend
;
2607 Elf_Internal_Sym
*isym
;
2609 asection
**ppsection
;
2612 output_bfd
= finfo
->output_bfd
;
2614 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2616 /* If this is a dynamic object, we don't want to do anything here:
2617 we don't want the local symbols, and we don't want the section
2619 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2622 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2623 if (elf_bad_symtab (input_bfd
))
2625 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2630 locsymcount
= symtab_hdr
->sh_info
;
2631 extsymoff
= symtab_hdr
->sh_info
;
2634 /* Read the local symbols. */
2636 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2637 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2638 locsymcount
, input_bfd
)
2639 != locsymcount
* sizeof (Elf_External_Sym
))))
2642 /* Swap in the local symbols and write out the ones which we know
2643 are going into the output file. */
2644 esym
= finfo
->external_syms
;
2645 esymend
= esym
+ locsymcount
;
2646 isym
= finfo
->internal_syms
;
2647 pindex
= finfo
->indices
;
2648 ppsection
= finfo
->sections
;
2649 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2653 Elf_Internal_Sym osym
;
2655 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2658 if (elf_bad_symtab (input_bfd
))
2660 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2667 if (isym
->st_shndx
== SHN_UNDEF
)
2668 isec
= bfd_und_section_ptr
;
2669 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2670 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2671 else if (isym
->st_shndx
== SHN_ABS
)
2672 isec
= bfd_abs_section_ptr
;
2673 else if (isym
->st_shndx
== SHN_COMMON
)
2674 isec
= bfd_com_section_ptr
;
2683 /* Don't output the first, undefined, symbol. */
2684 if (esym
== finfo
->external_syms
)
2687 /* If we are stripping all symbols, we don't want to output this
2689 if (finfo
->info
->strip
== strip_all
)
2692 /* We never output section symbols. Instead, we use the section
2693 symbol of the corresponding section in the output file. */
2694 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2697 /* If we are discarding all local symbols, we don't want to
2698 output this one. If we are generating a relocateable output
2699 file, then some of the local symbols may be required by
2700 relocs; we output them below as we discover that they are
2702 if (finfo
->info
->discard
== discard_all
)
2705 /* Get the name of the symbol. */
2706 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2711 /* See if we are discarding symbols with this name. */
2712 if ((finfo
->info
->strip
== strip_some
2713 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2715 || (finfo
->info
->discard
== discard_l
2716 && strncmp (name
, finfo
->info
->lprefix
,
2717 finfo
->info
->lprefix_len
) == 0))
2720 /* If we get here, we are going to output this symbol. */
2724 /* Adjust the section index for the output file. */
2725 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2726 isec
->output_section
);
2727 if (osym
.st_shndx
== (unsigned short) -1)
2730 *pindex
= output_bfd
->symcount
;
2732 /* ELF symbols in relocateable files are section relative, but
2733 in executable files they are virtual addresses. Note that
2734 this code assumes that all ELF sections have an associated
2735 BFD section with a reasonable value for output_offset; below
2736 we assume that they also have a reasonable value for
2737 output_section. Any special sections must be set up to meet
2738 these requirements. */
2739 osym
.st_value
+= isec
->output_offset
;
2740 if (! finfo
->info
->relocateable
)
2741 osym
.st_value
+= isec
->output_section
->vma
;
2743 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2747 /* Relocate the contents of each section. */
2748 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2750 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2753 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2754 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2756 /* Section was created by elf_link_create_dynamic_sections.
2757 FIXME: This test is fragile. */
2761 /* Read the contents of the section. */
2762 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2763 (file_ptr
) 0, o
->_raw_size
))
2766 if ((o
->flags
& SEC_RELOC
) != 0)
2768 Elf_Internal_Rela
*internal_relocs
;
2770 /* Get the swapped relocs. */
2771 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2772 finfo
->external_relocs
,
2773 finfo
->internal_relocs
,
2775 if (internal_relocs
== NULL
2776 && o
->reloc_count
> 0)
2779 /* Relocate the section by invoking a back end routine.
2781 The back end routine is responsible for adjusting the
2782 section contents as necessary, and (if using Rela relocs
2783 and generating a relocateable output file) adjusting the
2784 reloc addend as necessary.
2786 The back end routine does not have to worry about setting
2787 the reloc address or the reloc symbol index.
2789 The back end routine is given a pointer to the swapped in
2790 internal symbols, and can access the hash table entries
2791 for the external symbols via elf_sym_hashes (input_bfd).
2793 When generating relocateable output, the back end routine
2794 must handle STB_LOCAL/STT_SECTION symbols specially. The
2795 output symbol is going to be a section symbol
2796 corresponding to the output section, which will require
2797 the addend to be adjusted. */
2799 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2803 finfo
->internal_syms
,
2807 if (finfo
->info
->relocateable
)
2809 Elf_Internal_Rela
*irela
;
2810 Elf_Internal_Rela
*irelaend
;
2811 struct elf_link_hash_entry
**rel_hash
;
2812 Elf_Internal_Shdr
*input_rel_hdr
;
2813 Elf_Internal_Shdr
*output_rel_hdr
;
2815 /* Adjust the reloc addresses and symbol indices. */
2817 irela
= internal_relocs
;
2818 irelaend
= irela
+ o
->reloc_count
;
2819 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2820 + o
->output_section
->reloc_count
);
2821 for (; irela
< irelaend
; irela
++, rel_hash
++)
2823 unsigned long r_symndx
;
2824 Elf_Internal_Sym
*isym
;
2827 irela
->r_offset
+= o
->output_offset
;
2829 r_symndx
= ELF_R_SYM (irela
->r_info
);
2834 if (r_symndx
>= locsymcount
2835 || (elf_bad_symtab (input_bfd
)
2836 && finfo
->sections
[r_symndx
] == NULL
))
2840 /* This is a reloc against a global symbol. We
2841 have not yet output all the local symbols, so
2842 we do not know the symbol index of any global
2843 symbol. We set the rel_hash entry for this
2844 reloc to point to the global hash table entry
2845 for this symbol. The symbol index is then
2846 set at the end of elf_bfd_final_link. */
2847 indx
= r_symndx
- extsymoff
;
2848 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2850 /* Setting the index to -2 tells
2851 elf_link_output_extsym that this symbol is
2853 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2854 (*rel_hash
)->indx
= -2;
2859 /* This is a reloc against a local symbol. */
2862 isym
= finfo
->internal_syms
+ r_symndx
;
2863 sec
= finfo
->sections
[r_symndx
];
2864 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2866 /* I suppose the backend ought to fill in the
2867 section of any STT_SECTION symbol against a
2868 processor specific section. */
2869 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2871 else if (sec
== NULL
|| sec
->owner
== NULL
)
2873 bfd_set_error (bfd_error_bad_value
);
2878 r_symndx
= sec
->output_section
->target_index
;
2879 BFD_ASSERT (r_symndx
!= 0);
2884 if (finfo
->indices
[r_symndx
] == -1)
2890 if (finfo
->info
->strip
== strip_all
)
2892 /* You can't do ld -r -s. */
2893 bfd_set_error (bfd_error_invalid_operation
);
2897 /* This symbol was skipped earlier, but
2898 since it is needed by a reloc, we
2899 must output it now. */
2900 link
= symtab_hdr
->sh_link
;
2901 name
= bfd_elf_string_from_elf_section (input_bfd
,
2907 osec
= sec
->output_section
;
2909 _bfd_elf_section_from_bfd_section (output_bfd
,
2911 if (isym
->st_shndx
== (unsigned short) -1)
2914 isym
->st_value
+= sec
->output_offset
;
2915 if (! finfo
->info
->relocateable
)
2916 isym
->st_value
+= osec
->vma
;
2918 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2920 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2924 r_symndx
= finfo
->indices
[r_symndx
];
2927 irela
->r_info
= ELF_R_INFO (r_symndx
,
2928 ELF_R_TYPE (irela
->r_info
));
2931 /* Swap out the relocs. */
2932 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2933 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2934 BFD_ASSERT (output_rel_hdr
->sh_entsize
2935 == input_rel_hdr
->sh_entsize
);
2936 irela
= internal_relocs
;
2937 irelaend
= irela
+ o
->reloc_count
;
2938 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2940 Elf_External_Rel
*erel
;
2942 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2943 + o
->output_section
->reloc_count
);
2944 for (; irela
< irelaend
; irela
++, erel
++)
2946 Elf_Internal_Rel irel
;
2948 irel
.r_offset
= irela
->r_offset
;
2949 irel
.r_info
= irela
->r_info
;
2950 BFD_ASSERT (irela
->r_addend
== 0);
2951 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
2956 Elf_External_Rela
*erela
;
2958 BFD_ASSERT (input_rel_hdr
->sh_entsize
2959 == sizeof (Elf_External_Rela
));
2960 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
2961 + o
->output_section
->reloc_count
);
2962 for (; irela
< irelaend
; irela
++, erela
++)
2963 elf_swap_reloca_out (output_bfd
, irela
, erela
);
2966 o
->output_section
->reloc_count
+= o
->reloc_count
;
2970 /* Write out the modified section contents. */
2971 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2972 finfo
->contents
, o
->output_offset
,
2973 (o
->_cooked_size
!= 0
2982 /* Generate a reloc when linking an ELF file. This is a reloc
2983 requested by the linker, and does come from any input file. This
2984 is used to build constructor and destructor tables when linking
2988 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
2990 struct bfd_link_info
*info
;
2991 asection
*output_section
;
2992 struct bfd_link_order
*link_order
;
2994 reloc_howto_type
*howto
;
2998 struct elf_link_hash_entry
**rel_hash_ptr
;
2999 Elf_Internal_Shdr
*rel_hdr
;
3001 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3004 bfd_set_error (bfd_error_bad_value
);
3008 addend
= link_order
->u
.reloc
.p
->addend
;
3010 /* Figure out the symbol index. */
3011 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3012 + output_section
->reloc_count
);
3013 if (link_order
->type
== bfd_section_reloc_link_order
)
3015 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3016 BFD_ASSERT (indx
!= 0);
3017 *rel_hash_ptr
= NULL
;
3021 struct elf_link_hash_entry
*h
;
3023 /* Treat a reloc against a defined symbol as though it were
3024 actually against the section. */
3025 h
= elf_link_hash_lookup (elf_hash_table (info
),
3026 link_order
->u
.reloc
.p
->u
.name
,
3027 false, false, true);
3029 && (h
->root
.type
== bfd_link_hash_defined
3030 || h
->root
.type
== bfd_link_hash_defweak
))
3034 section
= h
->root
.u
.def
.section
;
3035 indx
= section
->output_section
->target_index
;
3036 *rel_hash_ptr
= NULL
;
3037 /* It seems that we ought to add the symbol value to the
3038 addend here, but in practice it has already been added
3039 because it was passed to constructor_callback. */
3040 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3044 /* Setting the index to -2 tells elf_link_output_extsym that
3045 this symbol is used by a reloc. */
3052 if (! ((*info
->callbacks
->unattached_reloc
)
3053 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3054 (asection
*) NULL
, (bfd_vma
) 0)))
3060 /* If this is an inplace reloc, we must write the addend into the
3062 if (howto
->partial_inplace
&& addend
!= 0)
3065 bfd_reloc_status_type rstat
;
3069 size
= bfd_get_reloc_size (howto
);
3070 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3071 if (buf
== (bfd_byte
*) NULL
)
3073 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3079 case bfd_reloc_outofrange
:
3081 case bfd_reloc_overflow
:
3082 if (! ((*info
->callbacks
->reloc_overflow
)
3084 (link_order
->type
== bfd_section_reloc_link_order
3085 ? bfd_section_name (output_bfd
,
3086 link_order
->u
.reloc
.p
->u
.section
)
3087 : link_order
->u
.reloc
.p
->u
.name
),
3088 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3096 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3097 (file_ptr
) link_order
->offset
, size
);
3103 /* The address of a reloc is relative to the section in a
3104 relocateable file, and is a virtual address in an executable
3106 offset
= link_order
->offset
;
3107 if (! info
->relocateable
)
3108 offset
+= output_section
->vma
;
3110 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3112 if (rel_hdr
->sh_type
== SHT_REL
)
3114 Elf_Internal_Rel irel
;
3115 Elf_External_Rel
*erel
;
3117 irel
.r_offset
= offset
;
3118 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3119 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3120 + output_section
->reloc_count
);
3121 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3125 Elf_Internal_Rela irela
;
3126 Elf_External_Rela
*erela
;
3128 irela
.r_offset
= offset
;
3129 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3130 irela
.r_addend
= addend
;
3131 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3132 + output_section
->reloc_count
);
3133 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3136 ++output_section
->reloc_count
;
3142 /* Allocate a pointer to live in a linker created section. */
3145 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3147 struct bfd_link_info
*info
;
3148 elf_linker_section_t
*lsect
;
3149 struct elf_link_hash_entry
*h
;
3150 const Elf_Internal_Rela
*rel
;
3152 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3153 elf_linker_section_pointers_t
*linker_section_ptr
;
3154 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3156 BFD_ASSERT (lsect
!= NULL
);
3158 /* Is this a global symbol? */
3161 /* Has this symbol already been allocated, if so, our work is done */
3162 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3167 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3168 /* Make sure this symbol is output as a dynamic symbol. */
3169 if (h
->dynindx
== -1)
3171 if (! elf_link_record_dynamic_symbol (info
, h
))
3175 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3176 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3179 else /* Allocation of a pointer to a local symbol */
3181 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3183 /* Allocate a table to hold the local symbols if first time */
3186 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3187 register unsigned int i
;
3189 ptr
= (elf_linker_section_pointers_t
**)
3190 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3195 elf_local_ptr_offsets (abfd
) = ptr
;
3196 for (i
= 0; i
< num_symbols
; i
++)
3197 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3200 /* Has this symbol already been allocated, if so, our work is done */
3201 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3206 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3210 /* If we are generating a shared object, we need to
3211 output a R_PPC_RELATIVE reloc so that the
3212 dynamic linker can adjust this GOT entry. */
3213 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3214 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3218 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3219 from internal memory. */
3220 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3221 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3222 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3224 if (!linker_section_ptr
)
3227 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3228 linker_section_ptr
->addend
= rel
->r_addend
;
3229 linker_section_ptr
->which
= lsect
->which
;
3230 linker_section_ptr
->written_address_p
= false;
3231 *ptr_linker_section_ptr
= linker_section_ptr
;
3233 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3235 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
;
3236 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3237 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3238 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3239 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3242 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3244 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3247 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3248 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3256 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3259 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3262 /* Fill in the address for a pointer generated in alinker section. */
3265 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3268 struct bfd_link_info
*info
;
3269 elf_linker_section_t
*lsect
;
3270 struct elf_link_hash_entry
*h
;
3272 const Elf_Internal_Rela
*rel
;
3275 elf_linker_section_pointers_t
*linker_section_ptr
;
3277 BFD_ASSERT (lsect
!= NULL
);
3279 if (!lsect
->section
->contents
)
3280 lsect
->section
->contents
= (unsigned char *) bfd_zalloc (output_bfd
,
3281 lsect
->section
->_raw_size
);
3283 if (h
!= NULL
) /* global symbol */
3285 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3289 BFD_ASSERT (linker_section_ptr
!= NULL
);
3291 if (! elf_hash_table (info
)->dynamic_sections_created
3294 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3296 /* This is actually a static link, or it is a
3297 -Bsymbolic link and the symbol is defined
3298 locally. We must initialize this entry in the
3301 When doing a dynamic link, we create a .rela.<xxx>
3302 relocation entry to initialize the value. This
3303 is done in the finish_dynamic_symbol routine. */
3304 if (!linker_section_ptr
->written_address_p
)
3306 linker_section_ptr
->written_address_p
= true;
3307 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3308 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3312 else /* local symbol */
3314 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3315 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3316 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3317 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3321 BFD_ASSERT (linker_section_ptr
!= NULL
);
3323 /* Write out pointer if it hasn't been rewritten out before */
3324 if (!linker_section_ptr
->written_address_p
)
3326 linker_section_ptr
->written_address_p
= true;
3327 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3328 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3332 asection
*srel
= lsect
->rel_section
;
3333 Elf_Internal_Rela outrel
;
3335 /* We need to generate a relative reloc for the dynamic linker. */
3337 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3340 BFD_ASSERT (srel
!= NULL
);
3342 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3343 + lsect
->section
->output_offset
3344 + linker_section_ptr
->offset
);
3345 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3346 outrel
.r_addend
= 0;
3347 elf_swap_reloca_out (output_bfd
, &outrel
,
3348 (((Elf_External_Rela
*)
3349 lsect
->section
->contents
)
3350 + lsect
->section
->reloc_count
));
3351 ++lsect
->section
->reloc_count
;
3356 relocation
= (lsect
->section
->output_offset
3357 + linker_section_ptr
->offset
3358 - lsect
->hole_offset
3359 - lsect
->sym_offset
);
3362 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3363 lsect
->name
, (long)relocation
, (long)relocation
);
3366 /* Subtract out the addend, because it will get added back in by the normal
3368 return relocation
- linker_section_ptr
->addend
;