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_name, we use that. Otherwise, we just use the file
384 name. If the generic linker put a null string into
385 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
386 there is a DT_SONAME entry. */
388 name
= bfd_get_filename (abfd
);
389 if (elf_dt_name (abfd
) != NULL
)
391 name
= elf_dt_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 (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
))
524 /* Save the SONAME, if there is one, because sometimes the
525 linker emulation code will need to know it. */
527 name
= bfd_get_filename (abfd
);
528 elf_dt_name (abfd
) = name
;
532 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
534 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
535 != extsymcount
* sizeof (Elf_External_Sym
)))
540 esymend
= buf
+ extsymcount
;
541 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
543 Elf_Internal_Sym sym
;
549 struct elf_link_hash_entry
*h
;
551 boolean size_change_ok
, type_change_ok
;
554 elf_swap_symbol_in (abfd
, esym
, &sym
);
556 flags
= BSF_NO_FLAGS
;
558 value
= sym
.st_value
;
561 bind
= ELF_ST_BIND (sym
.st_info
);
562 if (bind
== STB_LOCAL
)
564 /* This should be impossible, since ELF requires that all
565 global symbols follow all local symbols, and that sh_info
566 point to the first global symbol. Unfortunatealy, Irix 5
570 else if (bind
== STB_GLOBAL
)
572 if (sym
.st_shndx
!= SHN_UNDEF
573 && sym
.st_shndx
!= SHN_COMMON
)
578 else if (bind
== STB_WEAK
)
582 /* Leave it up to the processor backend. */
585 if (sym
.st_shndx
== SHN_UNDEF
)
586 sec
= bfd_und_section_ptr
;
587 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
589 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
593 sec
= bfd_abs_section_ptr
;
595 else if (sym
.st_shndx
== SHN_ABS
)
596 sec
= bfd_abs_section_ptr
;
597 else if (sym
.st_shndx
== SHN_COMMON
)
599 sec
= bfd_com_section_ptr
;
600 /* What ELF calls the size we call the value. What ELF
601 calls the value we call the alignment. */
606 /* Leave it up to the processor backend. */
609 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
610 if (name
== (const char *) NULL
)
615 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
619 /* The hook function sets the name to NULL if this symbol
620 should be skipped for some reason. */
621 if (name
== (const char *) NULL
)
625 /* Sanity check that all possibilities were handled. */
626 if (sec
== (asection
*) NULL
)
628 bfd_set_error (bfd_error_bad_value
);
632 if (bfd_is_und_section (sec
)
633 || bfd_is_com_section (sec
))
638 size_change_ok
= false;
639 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
640 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
642 /* We need to look up the symbol now in order to get some of
643 the dynamic object handling right. We pass the hash
644 table entry in to _bfd_generic_link_add_one_symbol so
645 that it does not have to look it up again. */
646 if (! bfd_is_und_section (sec
))
647 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
650 h
= ((struct elf_link_hash_entry
*)
651 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true,
657 if (h
->root
.type
== bfd_link_hash_new
)
658 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
660 while (h
->root
.type
== bfd_link_hash_indirect
661 || h
->root
.type
== bfd_link_hash_warning
)
662 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
664 /* It's OK to change the type if it used to be a weak
666 if (h
->root
.type
== bfd_link_hash_defweak
667 || h
->root
.type
== bfd_link_hash_undefweak
)
668 type_change_ok
= true;
670 /* It's OK to change the size if it used to be a weak
671 definition, or if it used to be undefined, or if we will
672 be overriding an old definition. */
674 || h
->root
.type
== bfd_link_hash_undefined
)
675 size_change_ok
= true;
677 /* If we are looking at a dynamic object, and this is a
678 definition, we need to see if it has already been defined
679 by some other object. If it has, we want to use the
680 existing definition, and we do not want to report a
681 multiple symbol definition error; we do this by
682 clobbering sec to be bfd_und_section_ptr. */
683 if (dynamic
&& definition
)
685 if (h
->root
.type
== bfd_link_hash_defined
686 || h
->root
.type
== bfd_link_hash_defweak
687 || (h
->root
.type
== bfd_link_hash_common
688 && bind
== STB_WEAK
))
690 sec
= bfd_und_section_ptr
;
692 size_change_ok
= true;
696 /* Similarly, if we are not looking at a dynamic object, and
697 we have a definition, we want to override any definition
698 we may have from a dynamic object. Symbols from regular
699 files always take precedence over symbols from dynamic
700 objects, even if they are defined after the dynamic
701 object in the link. */
704 && (h
->root
.type
== bfd_link_hash_defined
705 || h
->root
.type
== bfd_link_hash_defweak
)
706 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
707 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
708 == bfd_target_elf_flavour
)
709 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
712 /* Change the hash table entry to undefined, and let
713 _bfd_generic_link_add_one_symbol do the right thing
714 with the new definition. */
715 h
->root
.type
= bfd_link_hash_undefined
;
716 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
717 size_change_ok
= true;
721 if (! (_bfd_generic_link_add_one_symbol
722 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
723 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
727 while (h
->root
.type
== bfd_link_hash_indirect
728 || h
->root
.type
== bfd_link_hash_warning
)
729 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
735 && (flags
& BSF_WEAK
) != 0
736 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
737 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
738 && h
->weakdef
== NULL
)
740 /* Keep a list of all weak defined non function symbols from
741 a dynamic object, using the weakdef field. Later in this
742 function we will set the weakdef field to the correct
743 value. We only put non-function symbols from dynamic
744 objects on this list, because that happens to be the only
745 time we need to know the normal symbol corresponding to a
746 weak symbol, and the information is time consuming to
747 figure out. If the weakdef field is not already NULL,
748 then this symbol was already defined by some previous
749 dynamic object, and we will be using that previous
750 definition anyhow. */
757 /* Get the alignment of a common symbol. */
758 if (sym
.st_shndx
== SHN_COMMON
759 && h
->root
.type
== bfd_link_hash_common
)
760 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
762 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
768 /* Remember the symbol size and type. */
770 && (definition
|| h
->size
== 0))
772 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
773 (*_bfd_error_handler
)
774 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
775 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
776 bfd_get_filename (abfd
));
778 h
->size
= sym
.st_size
;
780 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
781 && (definition
|| h
->type
== STT_NOTYPE
))
783 if (h
->type
!= STT_NOTYPE
784 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
786 (*_bfd_error_handler
)
787 ("Warning: type of symbol `%s' changed from %d to %d in %s",
788 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
789 bfd_get_filename (abfd
));
791 h
->type
= ELF_ST_TYPE (sym
.st_info
);
794 /* Set a flag in the hash table entry indicating the type of
795 reference or definition we just found. Keep a count of
796 the number of dynamic symbols we find. A dynamic symbol
797 is one which is referenced or defined by both a regular
798 object and a shared object, or one which is referenced or
799 defined by more than one shared object. */
800 old_flags
= h
->elf_link_hash_flags
;
805 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
807 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
809 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
810 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
816 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
818 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
819 if ((old_flags
& new_flag
) != 0
820 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
821 | ELF_LINK_HASH_REF_REGULAR
)) != 0
822 || (h
->weakdef
!= NULL
823 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
824 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
828 h
->elf_link_hash_flags
|= new_flag
;
829 if (dynsym
&& h
->dynindx
== -1)
831 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
833 if (h
->weakdef
!= NULL
835 && h
->weakdef
->dynindx
== -1)
837 if (! _bfd_elf_link_record_dynamic_symbol (info
,
845 /* Now set the weakdefs field correctly for all the weak defined
846 symbols we found. The only way to do this is to search all the
847 symbols. Since we only need the information for non functions in
848 dynamic objects, that's the only time we actually put anything on
849 the list WEAKS. We need this information so that if a regular
850 object refers to a symbol defined weakly in a dynamic object, the
851 real symbol in the dynamic object is also put in the dynamic
852 symbols; we also must arrange for both symbols to point to the
853 same memory location. We could handle the general case of symbol
854 aliasing, but a general symbol alias can only be generated in
855 assembler code, handling it correctly would be very time
856 consuming, and other ELF linkers don't handle general aliasing
858 while (weaks
!= NULL
)
860 struct elf_link_hash_entry
*hlook
;
863 struct elf_link_hash_entry
**hpp
;
864 struct elf_link_hash_entry
**hppend
;
867 weaks
= hlook
->weakdef
;
868 hlook
->weakdef
= NULL
;
870 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
871 || hlook
->root
.type
== bfd_link_hash_defweak
872 || hlook
->root
.type
== bfd_link_hash_common
873 || hlook
->root
.type
== bfd_link_hash_indirect
);
874 slook
= hlook
->root
.u
.def
.section
;
875 vlook
= hlook
->root
.u
.def
.value
;
877 hpp
= elf_sym_hashes (abfd
);
878 hppend
= hpp
+ extsymcount
;
879 for (; hpp
< hppend
; hpp
++)
881 struct elf_link_hash_entry
*h
;
884 if (h
!= NULL
&& h
!= hlook
885 && h
->root
.type
== bfd_link_hash_defined
886 && h
->root
.u
.def
.section
== slook
887 && h
->root
.u
.def
.value
== vlook
)
891 /* If the weak definition is in the list of dynamic
892 symbols, make sure the real definition is put there
894 if (hlook
->dynindx
!= -1
897 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
912 /* If this object is the same format as the output object, and it is
913 not a shared library, then let the backend look through the
916 This is required to build global offset table entries and to
917 arrange for dynamic relocs. It is not required for the
918 particular common case of linking non PIC code, even when linking
919 against shared libraries, but unfortunately there is no way of
920 knowing whether an object file has been compiled PIC or not.
921 Looking through the relocs is not particularly time consuming.
922 The problem is that we must either (1) keep the relocs in memory,
923 which causes the linker to require additional runtime memory or
924 (2) read the relocs twice from the input file, which wastes time.
925 This would be a good case for using mmap.
927 I have no idea how to handle linking PIC code into a file of a
928 different format. It probably can't be done. */
929 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
931 && abfd
->xvec
== info
->hash
->creator
932 && check_relocs
!= NULL
)
936 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
938 Elf_Internal_Rela
*internal_relocs
;
941 if ((o
->flags
& SEC_RELOC
) == 0
942 || o
->reloc_count
== 0)
945 /* I believe we can ignore the relocs for any section which
946 does not form part of the final process image, such as a
947 debugging section. */
948 if ((o
->flags
& SEC_ALLOC
) == 0)
951 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
952 (Elf_Internal_Rela
*) NULL
,
954 if (internal_relocs
== NULL
)
957 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
959 if (! info
->keep_memory
)
960 free (internal_relocs
);
977 /* Create some sections which will be filled in with dynamic linking
978 information. ABFD is an input file which requires dynamic sections
979 to be created. The dynamic sections take up virtual memory space
980 when the final executable is run, so we need to create them before
981 addresses are assigned to the output sections. We work out the
982 actual contents and size of these sections later. */
985 elf_link_create_dynamic_sections (abfd
, info
)
987 struct bfd_link_info
*info
;
990 register asection
*s
;
991 struct elf_link_hash_entry
*h
;
992 struct elf_backend_data
*bed
;
994 if (elf_hash_table (info
)->dynamic_sections_created
)
997 /* Make sure that all dynamic sections use the same input BFD. */
998 if (elf_hash_table (info
)->dynobj
== NULL
)
999 elf_hash_table (info
)->dynobj
= abfd
;
1001 abfd
= elf_hash_table (info
)->dynobj
;
1003 /* Note that we set the SEC_IN_MEMORY flag for all of these
1005 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1007 /* A dynamically linked executable has a .interp section, but a
1008 shared library does not. */
1011 s
= bfd_make_section (abfd
, ".interp");
1013 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1017 s
= bfd_make_section (abfd
, ".dynsym");
1019 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1020 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1023 s
= bfd_make_section (abfd
, ".dynstr");
1025 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1028 /* Create a strtab to hold the dynamic symbol names. */
1029 if (elf_hash_table (info
)->dynstr
== NULL
)
1031 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1032 if (elf_hash_table (info
)->dynstr
== NULL
)
1036 s
= bfd_make_section (abfd
, ".dynamic");
1038 || ! bfd_set_section_flags (abfd
, s
, flags
)
1039 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1042 /* The special symbol _DYNAMIC is always set to the start of the
1043 .dynamic section. This call occurs before we have processed the
1044 symbols for any dynamic object, so we don't have to worry about
1045 overriding a dynamic definition. We could set _DYNAMIC in a
1046 linker script, but we only want to define it if we are, in fact,
1047 creating a .dynamic section. We don't want to define it if there
1048 is no .dynamic section, since on some ELF platforms the start up
1049 code examines it to decide how to initialize the process. */
1051 if (! (_bfd_generic_link_add_one_symbol
1052 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1053 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1054 (struct bfd_link_hash_entry
**) &h
)))
1056 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1057 h
->type
= STT_OBJECT
;
1060 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1063 s
= bfd_make_section (abfd
, ".hash");
1065 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1066 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1069 /* Let the backend create the rest of the sections. This lets the
1070 backend set the right flags. The backend will normally create
1071 the .got and .plt sections. */
1072 bed
= get_elf_backend_data (abfd
);
1073 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1076 elf_hash_table (info
)->dynamic_sections_created
= true;
1081 /* Add an entry to the .dynamic table. */
1084 elf_add_dynamic_entry (info
, tag
, val
)
1085 struct bfd_link_info
*info
;
1089 Elf_Internal_Dyn dyn
;
1093 bfd_byte
*newcontents
;
1095 dynobj
= elf_hash_table (info
)->dynobj
;
1097 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1098 BFD_ASSERT (s
!= NULL
);
1100 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1101 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1102 if (newcontents
== NULL
)
1106 dyn
.d_un
.d_val
= val
;
1107 elf_swap_dyn_out (dynobj
, &dyn
,
1108 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1110 s
->_raw_size
= newsize
;
1111 s
->contents
= newcontents
;
1117 /* Read and swap the relocs for a section. They may have been cached.
1118 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1119 they are used as buffers to read into. They are known to be large
1120 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1121 value is allocated using either malloc or bfd_alloc, according to
1122 the KEEP_MEMORY argument. */
1124 static Elf_Internal_Rela
*
1125 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1128 PTR external_relocs
;
1129 Elf_Internal_Rela
*internal_relocs
;
1130 boolean keep_memory
;
1132 Elf_Internal_Shdr
*rel_hdr
;
1134 Elf_Internal_Rela
*alloc2
= NULL
;
1136 if (elf_section_data (o
)->relocs
!= NULL
)
1137 return elf_section_data (o
)->relocs
;
1139 if (o
->reloc_count
== 0)
1142 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1144 if (internal_relocs
== NULL
)
1148 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1150 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1152 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1153 if (internal_relocs
== NULL
)
1157 if (external_relocs
== NULL
)
1159 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1162 external_relocs
= alloc1
;
1165 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1166 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1167 != rel_hdr
->sh_size
))
1170 /* Swap in the relocs. For convenience, we always produce an
1171 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1173 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1175 Elf_External_Rel
*erel
;
1176 Elf_External_Rel
*erelend
;
1177 Elf_Internal_Rela
*irela
;
1179 erel
= (Elf_External_Rel
*) external_relocs
;
1180 erelend
= erel
+ o
->reloc_count
;
1181 irela
= internal_relocs
;
1182 for (; erel
< erelend
; erel
++, irela
++)
1184 Elf_Internal_Rel irel
;
1186 elf_swap_reloc_in (abfd
, erel
, &irel
);
1187 irela
->r_offset
= irel
.r_offset
;
1188 irela
->r_info
= irel
.r_info
;
1189 irela
->r_addend
= 0;
1194 Elf_External_Rela
*erela
;
1195 Elf_External_Rela
*erelaend
;
1196 Elf_Internal_Rela
*irela
;
1198 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1200 erela
= (Elf_External_Rela
*) external_relocs
;
1201 erelaend
= erela
+ o
->reloc_count
;
1202 irela
= internal_relocs
;
1203 for (; erela
< erelaend
; erela
++, irela
++)
1204 elf_swap_reloca_in (abfd
, erela
, irela
);
1207 /* Cache the results for next time, if we can. */
1209 elf_section_data (o
)->relocs
= internal_relocs
;
1214 /* Don't free alloc2, since if it was allocated we are passing it
1215 back (under the name of internal_relocs). */
1217 return internal_relocs
;
1228 /* Record an assignment to a symbol made by a linker script. We need
1229 this in case some dynamic object refers to this symbol. */
1233 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1235 struct bfd_link_info
*info
;
1239 struct elf_link_hash_entry
*h
;
1241 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1244 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1248 if (h
->root
.type
== bfd_link_hash_new
)
1249 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
1251 /* If this symbol is being provided by the linker script, and it is
1252 currently defined by a dynamic object, but not by a regular
1253 object, then mark it as undefined so that the generic linker will
1254 force the correct value. */
1256 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1257 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1258 h
->root
.type
= bfd_link_hash_undefined
;
1260 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1261 h
->type
= STT_OBJECT
;
1263 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1264 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1266 && h
->dynindx
== -1)
1268 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1271 /* If this is a weak defined symbol, and we know a corresponding
1272 real symbol from the same dynamic object, make sure the real
1273 symbol is also made into a dynamic symbol. */
1274 if (h
->weakdef
!= NULL
1275 && h
->weakdef
->dynindx
== -1)
1277 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1286 /* Array used to determine the number of hash table buckets to use
1287 based on the number of symbols there are. If there are fewer than
1288 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1289 fewer than 37 we use 17 buckets, and so forth. We never use more
1290 than 521 buckets. */
1292 static const size_t elf_buckets
[] =
1294 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1297 /* Set up the sizes and contents of the ELF dynamic sections. This is
1298 called by the ELF linker emulation before_allocation routine. We
1299 must set the sizes of the sections before the linker sets the
1300 addresses of the various sections. */
1303 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1304 export_dynamic
, info
, sinterpptr
)
1308 boolean export_dynamic
;
1309 struct bfd_link_info
*info
;
1310 asection
**sinterpptr
;
1313 struct elf_backend_data
*bed
;
1317 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1320 dynobj
= elf_hash_table (info
)->dynobj
;
1322 /* If there were no dynamic objects in the link, there is nothing to
1327 /* If we are supposed to export all symbols into the dynamic symbol
1328 table (this is not the normal case), then do so. */
1331 struct elf_info_failed eif
;
1335 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1341 if (elf_hash_table (info
)->dynamic_sections_created
)
1343 struct elf_info_failed eif
;
1344 struct elf_link_hash_entry
*h
;
1345 bfd_size_type strsize
;
1347 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1348 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1354 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1356 if (indx
== (bfd_size_type
) -1
1357 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1363 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1371 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1373 if (indx
== (bfd_size_type
) -1
1374 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1378 /* Find all symbols which were defined in a dynamic object and make
1379 the backend pick a reasonable value for them. */
1382 elf_link_hash_traverse (elf_hash_table (info
),
1383 elf_adjust_dynamic_symbol
,
1388 /* Add some entries to the .dynamic section. We fill in some of the
1389 values later, in elf_bfd_final_link, but we must add the entries
1390 now so that we know the final size of the .dynamic section. */
1391 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1394 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1395 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1397 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1400 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1403 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1404 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1406 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1409 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1410 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1411 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1412 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1413 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1414 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1415 sizeof (Elf_External_Sym
)))
1419 /* The backend must work out the sizes of all the other dynamic
1421 bed
= get_elf_backend_data (output_bfd
);
1422 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1425 if (elf_hash_table (info
)->dynamic_sections_created
)
1430 size_t bucketcount
= 0;
1431 Elf_Internal_Sym isym
;
1433 /* Set the size of the .dynsym and .hash sections. We counted
1434 the number of dynamic symbols in elf_link_add_object_symbols.
1435 We will build the contents of .dynsym and .hash when we build
1436 the final symbol table, because until then we do not know the
1437 correct value to give the symbols. We built the .dynstr
1438 section as we went along in elf_link_add_object_symbols. */
1439 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1440 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1441 BFD_ASSERT (s
!= NULL
);
1442 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1443 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1444 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1447 /* The first entry in .dynsym is a dummy symbol. */
1454 elf_swap_symbol_out (output_bfd
, &isym
,
1455 (PTR
) (Elf_External_Sym
*) s
->contents
);
1457 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1459 bucketcount
= elf_buckets
[i
];
1460 if (dynsymcount
< elf_buckets
[i
+ 1])
1464 s
= bfd_get_section_by_name (dynobj
, ".hash");
1465 BFD_ASSERT (s
!= NULL
);
1466 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1467 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1468 if (s
->contents
== NULL
)
1470 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1472 put_word (output_bfd
, bucketcount
, s
->contents
);
1473 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1475 elf_hash_table (info
)->bucketcount
= bucketcount
;
1477 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1478 BFD_ASSERT (s
!= NULL
);
1479 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1481 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1489 /* This routine is used to export all defined symbols into the dynamic
1490 symbol table. It is called via elf_link_hash_traverse. */
1493 elf_export_symbol (h
, data
)
1494 struct elf_link_hash_entry
*h
;
1497 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1499 if (h
->dynindx
== -1
1500 && (h
->elf_link_hash_flags
1501 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1503 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1514 /* Make the backend pick a good value for a dynamic symbol. This is
1515 called via elf_link_hash_traverse, and also calls itself
1519 elf_adjust_dynamic_symbol (h
, data
)
1520 struct elf_link_hash_entry
*h
;
1523 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1525 struct elf_backend_data
*bed
;
1527 /* If this symbol was mentioned in a non-ELF file, try to set
1528 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1529 permit a non-ELF file to correctly refer to a symbol defined in
1530 an ELF dynamic object. */
1531 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
1533 if (h
->root
.type
!= bfd_link_hash_defined
1534 && h
->root
.type
!= bfd_link_hash_defweak
)
1535 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1538 if (h
->root
.u
.def
.section
->owner
!= NULL
1539 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
1540 == bfd_target_elf_flavour
))
1541 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1543 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1546 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1547 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1549 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1557 /* If -Bsymbolic was used (which means to bind references to global
1558 symbols to the definition within the shared object), and this
1559 symbol was defined in a regular object, then it actually doesn't
1560 need a PLT entry. */
1561 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1562 && eif
->info
->shared
1563 && eif
->info
->symbolic
1564 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1565 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1567 /* If this symbol does not require a PLT entry, and it is not
1568 defined by a dynamic object, or is not referenced by a regular
1569 object, ignore it. We do have to handle a weak defined symbol,
1570 even if no regular object refers to it, if we decided to add it
1571 to the dynamic symbol table. FIXME: Do we normally need to worry
1572 about symbols which are defined by one dynamic object and
1573 referenced by another one? */
1574 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1575 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1576 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1577 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1578 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1581 /* If we've already adjusted this symbol, don't do it again. This
1582 can happen via a recursive call. */
1583 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1586 /* Don't look at this symbol again. Note that we must set this
1587 after checking the above conditions, because we may look at a
1588 symbol once, decide not to do anything, and then get called
1589 recursively later after REF_REGULAR is set below. */
1590 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1592 /* If this is a weak definition, and we know a real definition, and
1593 the real symbol is not itself defined by a regular object file,
1594 then get a good value for the real definition. We handle the
1595 real symbol first, for the convenience of the backend routine.
1597 Note that there is a confusing case here. If the real definition
1598 is defined by a regular object file, we don't get the real symbol
1599 from the dynamic object, but we do get the weak symbol. If the
1600 processor backend uses a COPY reloc, then if some routine in the
1601 dynamic object changes the real symbol, we will not see that
1602 change in the corresponding weak symbol. This is the way other
1603 ELF linkers work as well, and seems to be a result of the shared
1606 I will clarify this issue. Most SVR4 shared libraries define the
1607 variable _timezone and define timezone as a weak synonym. The
1608 tzset call changes _timezone. If you write
1609 extern int timezone;
1611 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1612 you might expect that, since timezone is a synonym for _timezone,
1613 the same number will print both times. However, if the processor
1614 backend uses a COPY reloc, then actually timezone will be copied
1615 into your process image, and, since you define _timezone
1616 yourself, _timezone will not. Thus timezone and _timezone will
1617 wind up at different memory locations. The tzset call will set
1618 _timezone, leaving timezone unchanged. */
1620 if (h
->weakdef
!= NULL
)
1622 struct elf_link_hash_entry
*weakdef
;
1624 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1625 || h
->root
.type
== bfd_link_hash_defweak
);
1626 weakdef
= h
->weakdef
;
1627 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1628 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1629 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1630 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1632 /* This symbol is defined by a regular object file, so we
1633 will not do anything special. Clear weakdef for the
1634 convenience of the processor backend. */
1639 /* There is an implicit reference by a regular object file
1640 via the weak symbol. */
1641 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1642 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1647 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1648 bed
= get_elf_backend_data (dynobj
);
1649 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1658 /* Final phase of ELF linker. */
1660 /* A structure we use to avoid passing large numbers of arguments. */
1662 struct elf_final_link_info
1664 /* General link information. */
1665 struct bfd_link_info
*info
;
1668 /* Symbol string table. */
1669 struct bfd_strtab_hash
*symstrtab
;
1670 /* .dynsym section. */
1671 asection
*dynsym_sec
;
1672 /* .hash section. */
1674 /* Buffer large enough to hold contents of any section. */
1676 /* Buffer large enough to hold external relocs of any section. */
1677 PTR external_relocs
;
1678 /* Buffer large enough to hold internal relocs of any section. */
1679 Elf_Internal_Rela
*internal_relocs
;
1680 /* Buffer large enough to hold external local symbols of any input
1682 Elf_External_Sym
*external_syms
;
1683 /* Buffer large enough to hold internal local symbols of any input
1685 Elf_Internal_Sym
*internal_syms
;
1686 /* Array large enough to hold a symbol index for each local symbol
1687 of any input BFD. */
1689 /* Array large enough to hold a section pointer for each local
1690 symbol of any input BFD. */
1691 asection
**sections
;
1692 /* Buffer to hold swapped out symbols. */
1693 Elf_External_Sym
*symbuf
;
1694 /* Number of swapped out symbols in buffer. */
1695 size_t symbuf_count
;
1696 /* Number of symbols which fit in symbuf. */
1700 static boolean elf_link_output_sym
1701 PARAMS ((struct elf_final_link_info
*, const char *,
1702 Elf_Internal_Sym
*, asection
*));
1703 static boolean elf_link_flush_output_syms
1704 PARAMS ((struct elf_final_link_info
*));
1705 static boolean elf_link_output_extsym
1706 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1707 static boolean elf_link_input_bfd
1708 PARAMS ((struct elf_final_link_info
*, bfd
*));
1709 static boolean elf_reloc_link_order
1710 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1711 struct bfd_link_order
*));
1713 /* This struct is used to pass information to routines called via
1714 elf_link_hash_traverse which must return failure. */
1716 struct elf_finfo_failed
1719 struct elf_final_link_info
*finfo
;
1722 /* Do the final step of an ELF link. */
1725 elf_bfd_final_link (abfd
, info
)
1727 struct bfd_link_info
*info
;
1731 struct elf_final_link_info finfo
;
1732 register asection
*o
;
1733 register struct bfd_link_order
*p
;
1735 size_t max_contents_size
;
1736 size_t max_external_reloc_size
;
1737 size_t max_internal_reloc_count
;
1738 size_t max_sym_count
;
1740 Elf_Internal_Sym elfsym
;
1742 Elf_Internal_Shdr
*symtab_hdr
;
1743 Elf_Internal_Shdr
*symstrtab_hdr
;
1744 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1745 struct elf_finfo_failed eif
;
1748 abfd
->flags
|= DYNAMIC
;
1750 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1751 dynobj
= elf_hash_table (info
)->dynobj
;
1754 finfo
.output_bfd
= abfd
;
1755 finfo
.symstrtab
= elf_stringtab_init ();
1756 if (finfo
.symstrtab
== NULL
)
1760 finfo
.dynsym_sec
= NULL
;
1761 finfo
.hash_sec
= NULL
;
1765 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1766 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1767 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1769 finfo
.contents
= NULL
;
1770 finfo
.external_relocs
= NULL
;
1771 finfo
.internal_relocs
= NULL
;
1772 finfo
.external_syms
= NULL
;
1773 finfo
.internal_syms
= NULL
;
1774 finfo
.indices
= NULL
;
1775 finfo
.sections
= NULL
;
1776 finfo
.symbuf
= NULL
;
1777 finfo
.symbuf_count
= 0;
1779 /* Count up the number of relocations we will output for each output
1780 section, so that we know the sizes of the reloc sections. We
1781 also figure out some maximum sizes. */
1782 max_contents_size
= 0;
1783 max_external_reloc_size
= 0;
1784 max_internal_reloc_count
= 0;
1786 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1790 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1792 if (p
->type
== bfd_section_reloc_link_order
1793 || p
->type
== bfd_symbol_reloc_link_order
)
1795 else if (p
->type
== bfd_indirect_link_order
)
1799 sec
= p
->u
.indirect
.section
;
1801 if (info
->relocateable
)
1802 o
->reloc_count
+= sec
->reloc_count
;
1804 if (sec
->_raw_size
> max_contents_size
)
1805 max_contents_size
= sec
->_raw_size
;
1806 if (sec
->_cooked_size
> max_contents_size
)
1807 max_contents_size
= sec
->_cooked_size
;
1809 /* We are interested in just local symbols, not all
1811 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1815 if (elf_bad_symtab (sec
->owner
))
1816 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1817 / sizeof (Elf_External_Sym
));
1819 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1821 if (sym_count
> max_sym_count
)
1822 max_sym_count
= sym_count
;
1824 if ((sec
->flags
& SEC_RELOC
) != 0)
1828 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1829 if (ext_size
> max_external_reloc_size
)
1830 max_external_reloc_size
= ext_size
;
1831 if (sec
->reloc_count
> max_internal_reloc_count
)
1832 max_internal_reloc_count
= sec
->reloc_count
;
1838 if (o
->reloc_count
> 0)
1839 o
->flags
|= SEC_RELOC
;
1842 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1843 set it (this is probably a bug) and if it is set
1844 assign_section_numbers will create a reloc section. */
1845 o
->flags
&=~ SEC_RELOC
;
1848 /* If the SEC_ALLOC flag is not set, force the section VMA to
1849 zero. This is done in elf_fake_sections as well, but forcing
1850 the VMA to 0 here will ensure that relocs against these
1851 sections are handled correctly. */
1852 if ((o
->flags
& SEC_ALLOC
) == 0)
1856 /* Figure out the file positions for everything but the symbol table
1857 and the relocs. We set symcount to force assign_section_numbers
1858 to create a symbol table. */
1859 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1860 BFD_ASSERT (! abfd
->output_has_begun
);
1861 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1864 /* That created the reloc sections. Set their sizes, and assign
1865 them file positions, and allocate some buffers. */
1866 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1868 if ((o
->flags
& SEC_RELOC
) != 0)
1870 Elf_Internal_Shdr
*rel_hdr
;
1871 register struct elf_link_hash_entry
**p
, **pend
;
1873 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1875 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1877 /* The contents field must last into write_object_contents,
1878 so we allocate it with bfd_alloc rather than malloc. */
1879 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1880 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1883 p
= ((struct elf_link_hash_entry
**)
1884 bfd_malloc (o
->reloc_count
1885 * sizeof (struct elf_link_hash_entry
*)));
1886 if (p
== NULL
&& o
->reloc_count
!= 0)
1888 elf_section_data (o
)->rel_hashes
= p
;
1889 pend
= p
+ o
->reloc_count
;
1890 for (; p
< pend
; p
++)
1893 /* Use the reloc_count field as an index when outputting the
1899 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1901 /* We have now assigned file positions for all the sections except
1902 .symtab and .strtab. We start the .symtab section at the current
1903 file position, and write directly to it. We build the .strtab
1904 section in memory. */
1906 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1907 /* sh_name is set in prep_headers. */
1908 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1909 symtab_hdr
->sh_flags
= 0;
1910 symtab_hdr
->sh_addr
= 0;
1911 symtab_hdr
->sh_size
= 0;
1912 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1913 /* sh_link is set in assign_section_numbers. */
1914 /* sh_info is set below. */
1915 /* sh_offset is set just below. */
1916 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1918 off
= elf_tdata (abfd
)->next_file_pos
;
1919 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1921 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1922 incorrect. We do not yet know the size of the .symtab section.
1923 We correct next_file_pos below, after we do know the size. */
1925 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1926 continuously seeking to the right position in the file. */
1927 if (! info
->keep_memory
|| max_sym_count
< 20)
1928 finfo
.symbuf_size
= 20;
1930 finfo
.symbuf_size
= max_sym_count
;
1931 finfo
.symbuf
= ((Elf_External_Sym
*)
1932 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1933 if (finfo
.symbuf
== NULL
)
1936 /* Start writing out the symbol table. The first symbol is always a
1938 if (info
->strip
!= strip_all
|| info
->relocateable
)
1940 elfsym
.st_value
= 0;
1943 elfsym
.st_other
= 0;
1944 elfsym
.st_shndx
= SHN_UNDEF
;
1945 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1946 &elfsym
, bfd_und_section_ptr
))
1951 /* Some standard ELF linkers do this, but we don't because it causes
1952 bootstrap comparison failures. */
1953 /* Output a file symbol for the output file as the second symbol.
1954 We output this even if we are discarding local symbols, although
1955 I'm not sure if this is correct. */
1956 elfsym
.st_value
= 0;
1958 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1959 elfsym
.st_other
= 0;
1960 elfsym
.st_shndx
= SHN_ABS
;
1961 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1962 &elfsym
, bfd_abs_section_ptr
))
1966 /* Output a symbol for each section. We output these even if we are
1967 discarding local symbols, since they are used for relocs. These
1968 symbols have no names. We store the index of each one in the
1969 index field of the section, so that we can find it again when
1970 outputting relocs. */
1971 if (info
->strip
!= strip_all
|| info
->relocateable
)
1973 elfsym
.st_value
= 0;
1975 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1976 elfsym
.st_other
= 0;
1977 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1979 o
= section_from_elf_index (abfd
, i
);
1981 o
->target_index
= abfd
->symcount
;
1982 elfsym
.st_shndx
= i
;
1983 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1989 /* Allocate some memory to hold information read in from the input
1991 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
1992 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
1993 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1994 bfd_malloc (max_internal_reloc_count
1995 * sizeof (Elf_Internal_Rela
)));
1996 finfo
.external_syms
= ((Elf_External_Sym
*)
1997 bfd_malloc (max_sym_count
1998 * sizeof (Elf_External_Sym
)));
1999 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
2000 bfd_malloc (max_sym_count
2001 * sizeof (Elf_Internal_Sym
)));
2002 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
2003 finfo
.sections
= ((asection
**)
2004 bfd_malloc (max_sym_count
* sizeof (asection
*)));
2005 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
2006 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
2007 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
2008 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
2009 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
2010 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
2011 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
2014 /* Since ELF permits relocations to be against local symbols, we
2015 must have the local symbols available when we do the relocations.
2016 Since we would rather only read the local symbols once, and we
2017 would rather not keep them in memory, we handle all the
2018 relocations for a single input file at the same time.
2020 Unfortunately, there is no way to know the total number of local
2021 symbols until we have seen all of them, and the local symbol
2022 indices precede the global symbol indices. This means that when
2023 we are generating relocateable output, and we see a reloc against
2024 a global symbol, we can not know the symbol index until we have
2025 finished examining all the local symbols to see which ones we are
2026 going to output. To deal with this, we keep the relocations in
2027 memory, and don't output them until the end of the link. This is
2028 an unfortunate waste of memory, but I don't see a good way around
2029 it. Fortunately, it only happens when performing a relocateable
2030 link, which is not the common case. FIXME: If keep_memory is set
2031 we could write the relocs out and then read them again; I don't
2032 know how bad the memory loss will be. */
2034 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
2035 sub
->output_has_begun
= false;
2036 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2038 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
2040 if (p
->type
== bfd_indirect_link_order
2041 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2042 == bfd_target_elf_flavour
))
2044 sub
= p
->u
.indirect
.section
->owner
;
2045 if (! sub
->output_has_begun
)
2047 if (! elf_link_input_bfd (&finfo
, sub
))
2049 sub
->output_has_begun
= true;
2052 else if (p
->type
== bfd_section_reloc_link_order
2053 || p
->type
== bfd_symbol_reloc_link_order
)
2055 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2060 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2066 /* That wrote out all the local symbols. Finish up the symbol table
2067 with the global symbols. */
2069 /* The sh_info field records the index of the first non local
2071 symtab_hdr
->sh_info
= abfd
->symcount
;
2073 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2075 /* We get the global symbols from the hash table. */
2078 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2083 /* Flush all symbols to the file. */
2084 if (! elf_link_flush_output_syms (&finfo
))
2087 /* Now we know the size of the symtab section. */
2088 off
+= symtab_hdr
->sh_size
;
2090 /* Finish up and write out the symbol string table (.strtab)
2092 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2093 /* sh_name was set in prep_headers. */
2094 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2095 symstrtab_hdr
->sh_flags
= 0;
2096 symstrtab_hdr
->sh_addr
= 0;
2097 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2098 symstrtab_hdr
->sh_entsize
= 0;
2099 symstrtab_hdr
->sh_link
= 0;
2100 symstrtab_hdr
->sh_info
= 0;
2101 /* sh_offset is set just below. */
2102 symstrtab_hdr
->sh_addralign
= 1;
2104 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2105 elf_tdata (abfd
)->next_file_pos
= off
;
2107 if (abfd
->symcount
> 0)
2109 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2110 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2114 /* Adjust the relocs to have the correct symbol indices. */
2115 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2117 struct elf_link_hash_entry
**rel_hash
;
2118 Elf_Internal_Shdr
*rel_hdr
;
2120 if ((o
->flags
& SEC_RELOC
) == 0)
2123 rel_hash
= elf_section_data (o
)->rel_hashes
;
2124 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2125 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2127 if (*rel_hash
== NULL
)
2130 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2132 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2134 Elf_External_Rel
*erel
;
2135 Elf_Internal_Rel irel
;
2137 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2138 elf_swap_reloc_in (abfd
, erel
, &irel
);
2139 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2140 ELF_R_TYPE (irel
.r_info
));
2141 elf_swap_reloc_out (abfd
, &irel
, erel
);
2145 Elf_External_Rela
*erela
;
2146 Elf_Internal_Rela irela
;
2148 BFD_ASSERT (rel_hdr
->sh_entsize
2149 == sizeof (Elf_External_Rela
));
2151 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2152 elf_swap_reloca_in (abfd
, erela
, &irela
);
2153 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2154 ELF_R_TYPE (irela
.r_info
));
2155 elf_swap_reloca_out (abfd
, &irela
, erela
);
2159 /* Set the reloc_count field to 0 to prevent write_relocs from
2160 trying to swap the relocs out itself. */
2164 /* If we are linking against a dynamic object, or generating a
2165 shared library, finish up the dynamic linking information. */
2168 Elf_External_Dyn
*dyncon
, *dynconend
;
2170 /* Fix up .dynamic entries. */
2171 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2172 BFD_ASSERT (o
!= NULL
);
2174 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2175 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2176 for (; dyncon
< dynconend
; dyncon
++)
2178 Elf_Internal_Dyn dyn
;
2182 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2189 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2190 magic _init and _fini symbols. This is pretty ugly,
2191 but we are compatible. */
2199 struct elf_link_hash_entry
*h
;
2201 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2202 false, false, true);
2204 && (h
->root
.type
== bfd_link_hash_defined
2205 || h
->root
.type
== bfd_link_hash_defweak
))
2207 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2208 o
= h
->root
.u
.def
.section
;
2209 if (o
->output_section
!= NULL
)
2210 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2211 + o
->output_offset
);
2214 /* The symbol is imported from another shared
2215 library and does not apply to this one. */
2219 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2233 o
= bfd_get_section_by_name (abfd
, name
);
2234 BFD_ASSERT (o
!= NULL
);
2235 dyn
.d_un
.d_ptr
= o
->vma
;
2236 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2243 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2248 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2250 Elf_Internal_Shdr
*hdr
;
2252 hdr
= elf_elfsections (abfd
)[i
];
2253 if (hdr
->sh_type
== type
2254 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2256 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2257 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2260 if (dyn
.d_un
.d_val
== 0
2261 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2262 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2266 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2272 /* If we have created any dynamic sections, then output them. */
2275 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2278 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2280 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2281 || o
->_raw_size
== 0)
2283 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2285 /* At this point, we are only interested in sections
2286 created by elf_link_create_dynamic_sections. FIXME:
2287 This test is fragile. */
2290 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2292 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2294 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2295 o
->contents
, o
->output_offset
,
2303 /* The contents of the .dynstr section are actually in a
2305 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2306 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2307 || ! _bfd_stringtab_emit (abfd
,
2308 elf_hash_table (info
)->dynstr
))
2314 if (finfo
.symstrtab
!= NULL
)
2315 _bfd_stringtab_free (finfo
.symstrtab
);
2316 if (finfo
.contents
!= NULL
)
2317 free (finfo
.contents
);
2318 if (finfo
.external_relocs
!= NULL
)
2319 free (finfo
.external_relocs
);
2320 if (finfo
.internal_relocs
!= NULL
)
2321 free (finfo
.internal_relocs
);
2322 if (finfo
.external_syms
!= NULL
)
2323 free (finfo
.external_syms
);
2324 if (finfo
.internal_syms
!= NULL
)
2325 free (finfo
.internal_syms
);
2326 if (finfo
.indices
!= NULL
)
2327 free (finfo
.indices
);
2328 if (finfo
.sections
!= NULL
)
2329 free (finfo
.sections
);
2330 if (finfo
.symbuf
!= NULL
)
2331 free (finfo
.symbuf
);
2332 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2334 if ((o
->flags
& SEC_RELOC
) != 0
2335 && elf_section_data (o
)->rel_hashes
!= NULL
)
2336 free (elf_section_data (o
)->rel_hashes
);
2339 elf_tdata (abfd
)->linker
= true;
2344 if (finfo
.symstrtab
!= NULL
)
2345 _bfd_stringtab_free (finfo
.symstrtab
);
2346 if (finfo
.contents
!= NULL
)
2347 free (finfo
.contents
);
2348 if (finfo
.external_relocs
!= NULL
)
2349 free (finfo
.external_relocs
);
2350 if (finfo
.internal_relocs
!= NULL
)
2351 free (finfo
.internal_relocs
);
2352 if (finfo
.external_syms
!= NULL
)
2353 free (finfo
.external_syms
);
2354 if (finfo
.internal_syms
!= NULL
)
2355 free (finfo
.internal_syms
);
2356 if (finfo
.indices
!= NULL
)
2357 free (finfo
.indices
);
2358 if (finfo
.sections
!= NULL
)
2359 free (finfo
.sections
);
2360 if (finfo
.symbuf
!= NULL
)
2361 free (finfo
.symbuf
);
2362 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2364 if ((o
->flags
& SEC_RELOC
) != 0
2365 && elf_section_data (o
)->rel_hashes
!= NULL
)
2366 free (elf_section_data (o
)->rel_hashes
);
2372 /* Add a symbol to the output symbol table. */
2375 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2376 struct elf_final_link_info
*finfo
;
2378 Elf_Internal_Sym
*elfsym
;
2379 asection
*input_sec
;
2381 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2382 struct bfd_link_info
*info
,
2387 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2388 elf_backend_link_output_symbol_hook
;
2389 if (output_symbol_hook
!= NULL
)
2391 if (! ((*output_symbol_hook
)
2392 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2396 if (name
== (const char *) NULL
|| *name
== '\0')
2397 elfsym
->st_name
= 0;
2400 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2403 if (elfsym
->st_name
== (unsigned long) -1)
2407 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2409 if (! elf_link_flush_output_syms (finfo
))
2413 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2414 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2415 ++finfo
->symbuf_count
;
2417 ++finfo
->output_bfd
->symcount
;
2422 /* Flush the output symbols to the file. */
2425 elf_link_flush_output_syms (finfo
)
2426 struct elf_final_link_info
*finfo
;
2428 if (finfo
->symbuf_count
> 0)
2430 Elf_Internal_Shdr
*symtab
;
2432 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2434 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2436 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2437 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2438 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2441 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2443 finfo
->symbuf_count
= 0;
2449 /* Add an external symbol to the symbol table. This is called from
2450 the hash table traversal routine. */
2453 elf_link_output_extsym (h
, data
)
2454 struct elf_link_hash_entry
*h
;
2457 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2458 struct elf_final_link_info
*finfo
= eif
->finfo
;
2460 Elf_Internal_Sym sym
;
2461 asection
*input_sec
;
2463 /* If we are not creating a shared library, and this symbol is
2464 referenced by a shared library but is not defined anywhere, then
2465 warn that it is undefined. If we do not do this, the runtime
2466 linker will complain that the symbol is undefined when the
2467 program is run. We don't have to worry about symbols that are
2468 referenced by regular files, because we will already have issued
2469 warnings for them. */
2470 if (! finfo
->info
->relocateable
2471 && ! finfo
->info
->shared
2472 && h
->root
.type
== bfd_link_hash_undefined
2473 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2474 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2476 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2477 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2478 (asection
*) NULL
, 0)))
2485 /* We don't want to output symbols that have never been mentioned by
2486 a regular file, or that we have been told to strip. However, if
2487 h->indx is set to -2, the symbol is used by a reloc and we must
2491 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2492 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2493 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2494 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2496 else if (finfo
->info
->strip
== strip_all
2497 || (finfo
->info
->strip
== strip_some
2498 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2499 h
->root
.root
.string
,
2500 false, false) == NULL
))
2505 /* If we're stripping it, and it's not a dynamic symbol, there's
2506 nothing else to do. */
2507 if (strip
&& h
->dynindx
== -1)
2511 sym
.st_size
= h
->size
;
2513 if (h
->root
.type
== bfd_link_hash_undefweak
2514 || h
->root
.type
== bfd_link_hash_defweak
)
2515 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2517 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2519 switch (h
->root
.type
)
2522 case bfd_link_hash_new
:
2526 case bfd_link_hash_undefined
:
2527 input_sec
= bfd_und_section_ptr
;
2528 sym
.st_shndx
= SHN_UNDEF
;
2531 case bfd_link_hash_undefweak
:
2532 input_sec
= bfd_und_section_ptr
;
2533 sym
.st_shndx
= SHN_UNDEF
;
2536 case bfd_link_hash_defined
:
2537 case bfd_link_hash_defweak
:
2539 input_sec
= h
->root
.u
.def
.section
;
2540 if (input_sec
->output_section
!= NULL
)
2543 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2544 input_sec
->output_section
);
2545 if (sym
.st_shndx
== (unsigned short) -1)
2551 /* ELF symbols in relocateable files are section relative,
2552 but in nonrelocateable files they are virtual
2554 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2555 if (! finfo
->info
->relocateable
)
2556 sym
.st_value
+= input_sec
->output_section
->vma
;
2560 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2561 == bfd_target_elf_flavour
)
2562 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2563 sym
.st_shndx
= SHN_UNDEF
;
2564 input_sec
= bfd_und_section_ptr
;
2569 case bfd_link_hash_common
:
2570 input_sec
= bfd_com_section_ptr
;
2571 sym
.st_shndx
= SHN_COMMON
;
2572 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2575 case bfd_link_hash_indirect
:
2576 case bfd_link_hash_warning
:
2577 /* We can't represent these symbols in ELF. A warning symbol
2578 may have come from a .gnu.warning.SYMBOL section anyhow. We
2579 just put the target symbol in the hash table. If the target
2580 symbol does not really exist, don't do anything. */
2581 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2583 return (elf_link_output_extsym
2584 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2587 /* If this symbol should be put in the .dynsym section, then put it
2588 there now. We have already know the symbol index. We also fill
2589 in the entry in the .hash section. */
2590 if (h
->dynindx
!= -1
2591 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2593 struct elf_backend_data
*bed
;
2596 bfd_byte
*bucketpos
;
2599 sym
.st_name
= h
->dynstr_index
;
2601 /* Give the processor backend a chance to tweak the symbol
2602 value, and also to finish up anything that needs to be done
2604 bed
= get_elf_backend_data (finfo
->output_bfd
);
2605 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2606 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2612 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2613 (PTR
) (((Elf_External_Sym
*)
2614 finfo
->dynsym_sec
->contents
)
2617 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2618 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2620 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2621 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2622 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2623 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2624 put_word (finfo
->output_bfd
, chain
,
2625 ((bfd_byte
*) finfo
->hash_sec
->contents
2626 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2629 /* If we're stripping it, then it was just a dynamic symbol, and
2630 there's nothing else to do. */
2634 h
->indx
= finfo
->output_bfd
->symcount
;
2636 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2645 /* Link an input file into the linker output file. This function
2646 handles all the sections and relocations of the input file at once.
2647 This is so that we only have to read the local symbols once, and
2648 don't have to keep them in memory. */
2651 elf_link_input_bfd (finfo
, input_bfd
)
2652 struct elf_final_link_info
*finfo
;
2655 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2656 bfd
*, asection
*, bfd_byte
*,
2657 Elf_Internal_Rela
*,
2658 Elf_Internal_Sym
*, asection
**));
2660 Elf_Internal_Shdr
*symtab_hdr
;
2663 Elf_External_Sym
*esym
;
2664 Elf_External_Sym
*esymend
;
2665 Elf_Internal_Sym
*isym
;
2667 asection
**ppsection
;
2670 output_bfd
= finfo
->output_bfd
;
2672 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2674 /* If this is a dynamic object, we don't want to do anything here:
2675 we don't want the local symbols, and we don't want the section
2677 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2680 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2681 if (elf_bad_symtab (input_bfd
))
2683 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2688 locsymcount
= symtab_hdr
->sh_info
;
2689 extsymoff
= symtab_hdr
->sh_info
;
2692 /* Read the local symbols. */
2694 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2695 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2696 locsymcount
, input_bfd
)
2697 != locsymcount
* sizeof (Elf_External_Sym
))))
2700 /* Swap in the local symbols and write out the ones which we know
2701 are going into the output file. */
2702 esym
= finfo
->external_syms
;
2703 esymend
= esym
+ locsymcount
;
2704 isym
= finfo
->internal_syms
;
2705 pindex
= finfo
->indices
;
2706 ppsection
= finfo
->sections
;
2707 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2711 Elf_Internal_Sym osym
;
2713 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2716 if (elf_bad_symtab (input_bfd
))
2718 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2725 if (isym
->st_shndx
== SHN_UNDEF
)
2726 isec
= bfd_und_section_ptr
;
2727 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2728 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2729 else if (isym
->st_shndx
== SHN_ABS
)
2730 isec
= bfd_abs_section_ptr
;
2731 else if (isym
->st_shndx
== SHN_COMMON
)
2732 isec
= bfd_com_section_ptr
;
2741 /* Don't output the first, undefined, symbol. */
2742 if (esym
== finfo
->external_syms
)
2745 /* If we are stripping all symbols, we don't want to output this
2747 if (finfo
->info
->strip
== strip_all
)
2750 /* We never output section symbols. Instead, we use the section
2751 symbol of the corresponding section in the output file. */
2752 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2755 /* If we are discarding all local symbols, we don't want to
2756 output this one. If we are generating a relocateable output
2757 file, then some of the local symbols may be required by
2758 relocs; we output them below as we discover that they are
2760 if (finfo
->info
->discard
== discard_all
)
2763 /* Get the name of the symbol. */
2764 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2769 /* See if we are discarding symbols with this name. */
2770 if ((finfo
->info
->strip
== strip_some
2771 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2773 || (finfo
->info
->discard
== discard_l
2774 && strncmp (name
, finfo
->info
->lprefix
,
2775 finfo
->info
->lprefix_len
) == 0))
2778 /* If we get here, we are going to output this symbol. */
2782 /* Adjust the section index for the output file. */
2783 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2784 isec
->output_section
);
2785 if (osym
.st_shndx
== (unsigned short) -1)
2788 *pindex
= output_bfd
->symcount
;
2790 /* ELF symbols in relocateable files are section relative, but
2791 in executable files they are virtual addresses. Note that
2792 this code assumes that all ELF sections have an associated
2793 BFD section with a reasonable value for output_offset; below
2794 we assume that they also have a reasonable value for
2795 output_section. Any special sections must be set up to meet
2796 these requirements. */
2797 osym
.st_value
+= isec
->output_offset
;
2798 if (! finfo
->info
->relocateable
)
2799 osym
.st_value
+= isec
->output_section
->vma
;
2801 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2805 /* Relocate the contents of each section. */
2806 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2808 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2811 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2812 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2814 /* Section was created by elf_link_create_dynamic_sections.
2815 FIXME: This test is fragile. */
2819 /* Read the contents of the section. */
2820 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2821 (file_ptr
) 0, o
->_raw_size
))
2824 if ((o
->flags
& SEC_RELOC
) != 0)
2826 Elf_Internal_Rela
*internal_relocs
;
2828 /* Get the swapped relocs. */
2829 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2830 finfo
->external_relocs
,
2831 finfo
->internal_relocs
,
2833 if (internal_relocs
== NULL
2834 && o
->reloc_count
> 0)
2837 /* Relocate the section by invoking a back end routine.
2839 The back end routine is responsible for adjusting the
2840 section contents as necessary, and (if using Rela relocs
2841 and generating a relocateable output file) adjusting the
2842 reloc addend as necessary.
2844 The back end routine does not have to worry about setting
2845 the reloc address or the reloc symbol index.
2847 The back end routine is given a pointer to the swapped in
2848 internal symbols, and can access the hash table entries
2849 for the external symbols via elf_sym_hashes (input_bfd).
2851 When generating relocateable output, the back end routine
2852 must handle STB_LOCAL/STT_SECTION symbols specially. The
2853 output symbol is going to be a section symbol
2854 corresponding to the output section, which will require
2855 the addend to be adjusted. */
2857 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2861 finfo
->internal_syms
,
2865 if (finfo
->info
->relocateable
)
2867 Elf_Internal_Rela
*irela
;
2868 Elf_Internal_Rela
*irelaend
;
2869 struct elf_link_hash_entry
**rel_hash
;
2870 Elf_Internal_Shdr
*input_rel_hdr
;
2871 Elf_Internal_Shdr
*output_rel_hdr
;
2873 /* Adjust the reloc addresses and symbol indices. */
2875 irela
= internal_relocs
;
2876 irelaend
= irela
+ o
->reloc_count
;
2877 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2878 + o
->output_section
->reloc_count
);
2879 for (; irela
< irelaend
; irela
++, rel_hash
++)
2881 unsigned long r_symndx
;
2882 Elf_Internal_Sym
*isym
;
2885 irela
->r_offset
+= o
->output_offset
;
2887 r_symndx
= ELF_R_SYM (irela
->r_info
);
2892 if (r_symndx
>= locsymcount
2893 || (elf_bad_symtab (input_bfd
)
2894 && finfo
->sections
[r_symndx
] == NULL
))
2898 /* This is a reloc against a global symbol. We
2899 have not yet output all the local symbols, so
2900 we do not know the symbol index of any global
2901 symbol. We set the rel_hash entry for this
2902 reloc to point to the global hash table entry
2903 for this symbol. The symbol index is then
2904 set at the end of elf_bfd_final_link. */
2905 indx
= r_symndx
- extsymoff
;
2906 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2908 /* Setting the index to -2 tells
2909 elf_link_output_extsym that this symbol is
2911 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2912 (*rel_hash
)->indx
= -2;
2917 /* This is a reloc against a local symbol. */
2920 isym
= finfo
->internal_syms
+ r_symndx
;
2921 sec
= finfo
->sections
[r_symndx
];
2922 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2924 /* I suppose the backend ought to fill in the
2925 section of any STT_SECTION symbol against a
2926 processor specific section. */
2927 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2929 else if (sec
== NULL
|| sec
->owner
== NULL
)
2931 bfd_set_error (bfd_error_bad_value
);
2936 r_symndx
= sec
->output_section
->target_index
;
2937 BFD_ASSERT (r_symndx
!= 0);
2942 if (finfo
->indices
[r_symndx
] == -1)
2948 if (finfo
->info
->strip
== strip_all
)
2950 /* You can't do ld -r -s. */
2951 bfd_set_error (bfd_error_invalid_operation
);
2955 /* This symbol was skipped earlier, but
2956 since it is needed by a reloc, we
2957 must output it now. */
2958 link
= symtab_hdr
->sh_link
;
2959 name
= bfd_elf_string_from_elf_section (input_bfd
,
2965 osec
= sec
->output_section
;
2967 _bfd_elf_section_from_bfd_section (output_bfd
,
2969 if (isym
->st_shndx
== (unsigned short) -1)
2972 isym
->st_value
+= sec
->output_offset
;
2973 if (! finfo
->info
->relocateable
)
2974 isym
->st_value
+= osec
->vma
;
2976 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2978 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2982 r_symndx
= finfo
->indices
[r_symndx
];
2985 irela
->r_info
= ELF_R_INFO (r_symndx
,
2986 ELF_R_TYPE (irela
->r_info
));
2989 /* Swap out the relocs. */
2990 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2991 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2992 BFD_ASSERT (output_rel_hdr
->sh_entsize
2993 == input_rel_hdr
->sh_entsize
);
2994 irela
= internal_relocs
;
2995 irelaend
= irela
+ o
->reloc_count
;
2996 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2998 Elf_External_Rel
*erel
;
3000 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
3001 + o
->output_section
->reloc_count
);
3002 for (; irela
< irelaend
; irela
++, erel
++)
3004 Elf_Internal_Rel irel
;
3006 irel
.r_offset
= irela
->r_offset
;
3007 irel
.r_info
= irela
->r_info
;
3008 BFD_ASSERT (irela
->r_addend
== 0);
3009 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3014 Elf_External_Rela
*erela
;
3016 BFD_ASSERT (input_rel_hdr
->sh_entsize
3017 == sizeof (Elf_External_Rela
));
3018 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
3019 + o
->output_section
->reloc_count
);
3020 for (; irela
< irelaend
; irela
++, erela
++)
3021 elf_swap_reloca_out (output_bfd
, irela
, erela
);
3024 o
->output_section
->reloc_count
+= o
->reloc_count
;
3028 /* Write out the modified section contents. */
3029 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
3030 finfo
->contents
, o
->output_offset
,
3031 (o
->_cooked_size
!= 0
3040 /* Generate a reloc when linking an ELF file. This is a reloc
3041 requested by the linker, and does come from any input file. This
3042 is used to build constructor and destructor tables when linking
3046 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
3048 struct bfd_link_info
*info
;
3049 asection
*output_section
;
3050 struct bfd_link_order
*link_order
;
3052 reloc_howto_type
*howto
;
3056 struct elf_link_hash_entry
**rel_hash_ptr
;
3057 Elf_Internal_Shdr
*rel_hdr
;
3059 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3062 bfd_set_error (bfd_error_bad_value
);
3066 addend
= link_order
->u
.reloc
.p
->addend
;
3068 /* Figure out the symbol index. */
3069 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3070 + output_section
->reloc_count
);
3071 if (link_order
->type
== bfd_section_reloc_link_order
)
3073 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3074 BFD_ASSERT (indx
!= 0);
3075 *rel_hash_ptr
= NULL
;
3079 struct elf_link_hash_entry
*h
;
3081 /* Treat a reloc against a defined symbol as though it were
3082 actually against the section. */
3083 h
= ((struct elf_link_hash_entry
*)
3084 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3085 link_order
->u
.reloc
.p
->u
.name
,
3086 false, false, true));
3088 && (h
->root
.type
== bfd_link_hash_defined
3089 || h
->root
.type
== bfd_link_hash_defweak
))
3093 section
= h
->root
.u
.def
.section
;
3094 indx
= section
->output_section
->target_index
;
3095 *rel_hash_ptr
= NULL
;
3096 /* It seems that we ought to add the symbol value to the
3097 addend here, but in practice it has already been added
3098 because it was passed to constructor_callback. */
3099 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3103 /* Setting the index to -2 tells elf_link_output_extsym that
3104 this symbol is used by a reloc. */
3111 if (! ((*info
->callbacks
->unattached_reloc
)
3112 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3113 (asection
*) NULL
, (bfd_vma
) 0)))
3119 /* If this is an inplace reloc, we must write the addend into the
3121 if (howto
->partial_inplace
&& addend
!= 0)
3124 bfd_reloc_status_type rstat
;
3128 size
= bfd_get_reloc_size (howto
);
3129 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3130 if (buf
== (bfd_byte
*) NULL
)
3132 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3138 case bfd_reloc_outofrange
:
3140 case bfd_reloc_overflow
:
3141 if (! ((*info
->callbacks
->reloc_overflow
)
3143 (link_order
->type
== bfd_section_reloc_link_order
3144 ? bfd_section_name (output_bfd
,
3145 link_order
->u
.reloc
.p
->u
.section
)
3146 : link_order
->u
.reloc
.p
->u
.name
),
3147 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3155 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3156 (file_ptr
) link_order
->offset
, size
);
3162 /* The address of a reloc is relative to the section in a
3163 relocateable file, and is a virtual address in an executable
3165 offset
= link_order
->offset
;
3166 if (! info
->relocateable
)
3167 offset
+= output_section
->vma
;
3169 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3171 if (rel_hdr
->sh_type
== SHT_REL
)
3173 Elf_Internal_Rel irel
;
3174 Elf_External_Rel
*erel
;
3176 irel
.r_offset
= offset
;
3177 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3178 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3179 + output_section
->reloc_count
);
3180 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3184 Elf_Internal_Rela irela
;
3185 Elf_External_Rela
*erela
;
3187 irela
.r_offset
= offset
;
3188 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3189 irela
.r_addend
= addend
;
3190 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3191 + output_section
->reloc_count
);
3192 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3195 ++output_section
->reloc_count
;
3201 /* Allocate a pointer to live in a linker created section. */
3204 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3206 struct bfd_link_info
*info
;
3207 elf_linker_section_t
*lsect
;
3208 struct elf_link_hash_entry
*h
;
3209 const Elf_Internal_Rela
*rel
;
3211 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3212 elf_linker_section_pointers_t
*linker_section_ptr
;
3213 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3215 BFD_ASSERT (lsect
!= NULL
);
3217 /* Is this a global symbol? */
3220 /* Has this symbol already been allocated, if so, our work is done */
3221 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3226 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3227 /* Make sure this symbol is output as a dynamic symbol. */
3228 if (h
->dynindx
== -1)
3230 if (! elf_link_record_dynamic_symbol (info
, h
))
3234 if (lsect
->rel_section
)
3235 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3238 else /* Allocation of a pointer to a local symbol */
3240 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3242 /* Allocate a table to hold the local symbols if first time */
3245 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3246 register unsigned int i
;
3248 ptr
= (elf_linker_section_pointers_t
**)
3249 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3254 elf_local_ptr_offsets (abfd
) = ptr
;
3255 for (i
= 0; i
< num_symbols
; i
++)
3256 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3259 /* Has this symbol already been allocated, if so, our work is done */
3260 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3265 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3269 /* If we are generating a shared object, we need to
3270 output a R_<xxx>_RELATIVE reloc so that the
3271 dynamic linker can adjust this GOT entry. */
3272 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3273 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3277 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3278 from internal memory. */
3279 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3280 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3281 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3283 if (!linker_section_ptr
)
3286 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3287 linker_section_ptr
->addend
= rel
->r_addend
;
3288 linker_section_ptr
->which
= lsect
->which
;
3289 linker_section_ptr
->written_address_p
= false;
3290 *ptr_linker_section_ptr
= linker_section_ptr
;
3292 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3294 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
;
3295 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3296 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3297 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3298 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3301 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3303 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3306 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3307 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3315 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3318 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3321 /* Fill in the address for a pointer generated in alinker section. */
3324 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3327 struct bfd_link_info
*info
;
3328 elf_linker_section_t
*lsect
;
3329 struct elf_link_hash_entry
*h
;
3331 const Elf_Internal_Rela
*rel
;
3334 elf_linker_section_pointers_t
*linker_section_ptr
;
3336 BFD_ASSERT (lsect
!= NULL
);
3338 if (h
!= NULL
) /* global symbol */
3340 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3344 BFD_ASSERT (linker_section_ptr
!= NULL
);
3346 if (! elf_hash_table (info
)->dynamic_sections_created
3349 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3351 /* This is actually a static link, or it is a
3352 -Bsymbolic link and the symbol is defined
3353 locally. We must initialize this entry in the
3356 When doing a dynamic link, we create a .rela.<xxx>
3357 relocation entry to initialize the value. This
3358 is done in the finish_dynamic_symbol routine. */
3359 if (!linker_section_ptr
->written_address_p
)
3361 linker_section_ptr
->written_address_p
= true;
3362 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3363 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3367 else /* local symbol */
3369 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3370 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3371 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3372 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3376 BFD_ASSERT (linker_section_ptr
!= NULL
);
3378 /* Write out pointer if it hasn't been rewritten out before */
3379 if (!linker_section_ptr
->written_address_p
)
3381 linker_section_ptr
->written_address_p
= true;
3382 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3383 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3387 asection
*srel
= lsect
->rel_section
;
3388 Elf_Internal_Rela outrel
;
3390 /* We need to generate a relative reloc for the dynamic linker. */
3392 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3395 BFD_ASSERT (srel
!= NULL
);
3397 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3398 + lsect
->section
->output_offset
3399 + linker_section_ptr
->offset
);
3400 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3401 outrel
.r_addend
= 0;
3402 elf_swap_reloca_out (output_bfd
, &outrel
,
3403 (((Elf_External_Rela
*)
3404 lsect
->section
->contents
)
3405 + lsect
->section
->reloc_count
));
3406 ++lsect
->section
->reloc_count
;
3411 relocation
= (lsect
->section
->output_offset
3412 + linker_section_ptr
->offset
3413 - lsect
->hole_offset
3414 - lsect
->sym_offset
);
3417 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3418 lsect
->name
, (long)relocation
, (long)relocation
);
3421 /* Subtract out the addend, because it will get added back in by the normal
3423 return relocation
- linker_section_ptr
->addend
;