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. We treat a
683 common symbol as a definition if the symbol in the shared
684 library is a function, since common symbols always
685 represent variables; this can cause confusion in
686 principle, but any such confusion would seem to indicate
687 an erroneous program or shared library. */
688 if (dynamic
&& definition
)
690 if (h
->root
.type
== bfd_link_hash_defined
691 || h
->root
.type
== bfd_link_hash_defweak
692 || (h
->root
.type
== bfd_link_hash_common
694 || ELF_ST_TYPE (sym
.st_info
) == STT_FUNC
)))
696 sec
= bfd_und_section_ptr
;
698 size_change_ok
= true;
699 if (h
->root
.type
== bfd_link_hash_common
)
700 type_change_ok
= true;
704 /* Similarly, if we are not looking at a dynamic object, and
705 we have a definition, we want to override any definition
706 we may have from a dynamic object. Symbols from regular
707 files always take precedence over symbols from dynamic
708 objects, even if they are defined after the dynamic
709 object in the link. */
712 || (bfd_is_com_section (sec
)
713 && (h
->root
.type
== bfd_link_hash_defweak
714 || h
->type
== STT_FUNC
)))
715 && (h
->root
.type
== bfd_link_hash_defined
716 || h
->root
.type
== bfd_link_hash_defweak
)
717 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
718 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
719 == bfd_target_elf_flavour
)
720 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
723 /* Change the hash table entry to undefined, and let
724 _bfd_generic_link_add_one_symbol do the right thing
725 with the new definition. */
726 h
->root
.type
= bfd_link_hash_undefined
;
727 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
728 size_change_ok
= true;
729 if (bfd_is_com_section (sec
))
730 type_change_ok
= true;
734 if (! (_bfd_generic_link_add_one_symbol
735 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
736 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
740 while (h
->root
.type
== bfd_link_hash_indirect
741 || h
->root
.type
== bfd_link_hash_warning
)
742 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
748 && (flags
& BSF_WEAK
) != 0
749 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
750 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
751 && h
->weakdef
== NULL
)
753 /* Keep a list of all weak defined non function symbols from
754 a dynamic object, using the weakdef field. Later in this
755 function we will set the weakdef field to the correct
756 value. We only put non-function symbols from dynamic
757 objects on this list, because that happens to be the only
758 time we need to know the normal symbol corresponding to a
759 weak symbol, and the information is time consuming to
760 figure out. If the weakdef field is not already NULL,
761 then this symbol was already defined by some previous
762 dynamic object, and we will be using that previous
763 definition anyhow. */
770 /* Get the alignment of a common symbol. */
771 if (sym
.st_shndx
== SHN_COMMON
772 && h
->root
.type
== bfd_link_hash_common
)
773 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
775 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
781 /* Remember the symbol size and type. */
783 && (definition
|| h
->size
== 0))
785 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
786 (*_bfd_error_handler
)
787 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
788 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
789 bfd_get_filename (abfd
));
791 h
->size
= sym
.st_size
;
793 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
794 && (definition
|| h
->type
== STT_NOTYPE
))
796 if (h
->type
!= STT_NOTYPE
797 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
799 (*_bfd_error_handler
)
800 ("Warning: type of symbol `%s' changed from %d to %d in %s",
801 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
802 bfd_get_filename (abfd
));
804 h
->type
= ELF_ST_TYPE (sym
.st_info
);
807 /* Set a flag in the hash table entry indicating the type of
808 reference or definition we just found. Keep a count of
809 the number of dynamic symbols we find. A dynamic symbol
810 is one which is referenced or defined by both a regular
811 object and a shared object, or one which is referenced or
812 defined by more than one shared object. */
813 old_flags
= h
->elf_link_hash_flags
;
818 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
820 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
822 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
823 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
829 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
831 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
832 if ((old_flags
& new_flag
) != 0
833 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
834 | ELF_LINK_HASH_REF_REGULAR
)) != 0
835 || (h
->weakdef
!= NULL
836 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
837 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
841 h
->elf_link_hash_flags
|= new_flag
;
842 if (dynsym
&& h
->dynindx
== -1)
844 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
846 if (h
->weakdef
!= NULL
848 && h
->weakdef
->dynindx
== -1)
850 if (! _bfd_elf_link_record_dynamic_symbol (info
,
858 /* Now set the weakdefs field correctly for all the weak defined
859 symbols we found. The only way to do this is to search all the
860 symbols. Since we only need the information for non functions in
861 dynamic objects, that's the only time we actually put anything on
862 the list WEAKS. We need this information so that if a regular
863 object refers to a symbol defined weakly in a dynamic object, the
864 real symbol in the dynamic object is also put in the dynamic
865 symbols; we also must arrange for both symbols to point to the
866 same memory location. We could handle the general case of symbol
867 aliasing, but a general symbol alias can only be generated in
868 assembler code, handling it correctly would be very time
869 consuming, and other ELF linkers don't handle general aliasing
871 while (weaks
!= NULL
)
873 struct elf_link_hash_entry
*hlook
;
876 struct elf_link_hash_entry
**hpp
;
877 struct elf_link_hash_entry
**hppend
;
880 weaks
= hlook
->weakdef
;
881 hlook
->weakdef
= NULL
;
883 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
884 || hlook
->root
.type
== bfd_link_hash_defweak
885 || hlook
->root
.type
== bfd_link_hash_common
886 || hlook
->root
.type
== bfd_link_hash_indirect
);
887 slook
= hlook
->root
.u
.def
.section
;
888 vlook
= hlook
->root
.u
.def
.value
;
890 hpp
= elf_sym_hashes (abfd
);
891 hppend
= hpp
+ extsymcount
;
892 for (; hpp
< hppend
; hpp
++)
894 struct elf_link_hash_entry
*h
;
897 if (h
!= NULL
&& h
!= hlook
898 && h
->root
.type
== bfd_link_hash_defined
899 && h
->root
.u
.def
.section
== slook
900 && h
->root
.u
.def
.value
== vlook
)
904 /* If the weak definition is in the list of dynamic
905 symbols, make sure the real definition is put there
907 if (hlook
->dynindx
!= -1
910 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
925 /* If this object is the same format as the output object, and it is
926 not a shared library, then let the backend look through the
929 This is required to build global offset table entries and to
930 arrange for dynamic relocs. It is not required for the
931 particular common case of linking non PIC code, even when linking
932 against shared libraries, but unfortunately there is no way of
933 knowing whether an object file has been compiled PIC or not.
934 Looking through the relocs is not particularly time consuming.
935 The problem is that we must either (1) keep the relocs in memory,
936 which causes the linker to require additional runtime memory or
937 (2) read the relocs twice from the input file, which wastes time.
938 This would be a good case for using mmap.
940 I have no idea how to handle linking PIC code into a file of a
941 different format. It probably can't be done. */
942 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
944 && abfd
->xvec
== info
->hash
->creator
945 && check_relocs
!= NULL
)
949 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
951 Elf_Internal_Rela
*internal_relocs
;
954 if ((o
->flags
& SEC_RELOC
) == 0
955 || o
->reloc_count
== 0)
958 /* I believe we can ignore the relocs for any section which
959 does not form part of the final process image, such as a
960 debugging section. */
961 if ((o
->flags
& SEC_ALLOC
) == 0)
964 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
965 (Elf_Internal_Rela
*) NULL
,
967 if (internal_relocs
== NULL
)
970 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
972 if (! info
->keep_memory
)
973 free (internal_relocs
);
980 /* If this is a non-traditional, non-relocateable link, try to
981 optimize the handling of the .stab/.stabstr sections. */
983 && ! info
->relocateable
984 && ! info
->traditional_format
985 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
986 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
988 asection
*stab
, *stabstr
;
990 stab
= bfd_get_section_by_name (abfd
, ".stab");
993 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
997 struct bfd_elf_section_data
*secdata
;
999 secdata
= elf_section_data (stab
);
1000 if (! _bfd_link_section_stabs (abfd
,
1001 &elf_hash_table (info
)->stab_info
,
1003 &secdata
->stab_info
))
1019 /* Create some sections which will be filled in with dynamic linking
1020 information. ABFD is an input file which requires dynamic sections
1021 to be created. The dynamic sections take up virtual memory space
1022 when the final executable is run, so we need to create them before
1023 addresses are assigned to the output sections. We work out the
1024 actual contents and size of these sections later. */
1027 elf_link_create_dynamic_sections (abfd
, info
)
1029 struct bfd_link_info
*info
;
1032 register asection
*s
;
1033 struct elf_link_hash_entry
*h
;
1034 struct elf_backend_data
*bed
;
1036 if (elf_hash_table (info
)->dynamic_sections_created
)
1039 /* Make sure that all dynamic sections use the same input BFD. */
1040 if (elf_hash_table (info
)->dynobj
== NULL
)
1041 elf_hash_table (info
)->dynobj
= abfd
;
1043 abfd
= elf_hash_table (info
)->dynobj
;
1045 /* Note that we set the SEC_IN_MEMORY flag for all of these
1047 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1049 /* A dynamically linked executable has a .interp section, but a
1050 shared library does not. */
1053 s
= bfd_make_section (abfd
, ".interp");
1055 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1059 s
= bfd_make_section (abfd
, ".dynsym");
1061 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1062 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1065 s
= bfd_make_section (abfd
, ".dynstr");
1067 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1070 /* Create a strtab to hold the dynamic symbol names. */
1071 if (elf_hash_table (info
)->dynstr
== NULL
)
1073 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1074 if (elf_hash_table (info
)->dynstr
== NULL
)
1078 s
= bfd_make_section (abfd
, ".dynamic");
1080 || ! bfd_set_section_flags (abfd
, s
, flags
)
1081 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1084 /* The special symbol _DYNAMIC is always set to the start of the
1085 .dynamic section. This call occurs before we have processed the
1086 symbols for any dynamic object, so we don't have to worry about
1087 overriding a dynamic definition. We could set _DYNAMIC in a
1088 linker script, but we only want to define it if we are, in fact,
1089 creating a .dynamic section. We don't want to define it if there
1090 is no .dynamic section, since on some ELF platforms the start up
1091 code examines it to decide how to initialize the process. */
1093 if (! (_bfd_generic_link_add_one_symbol
1094 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1095 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1096 (struct bfd_link_hash_entry
**) &h
)))
1098 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1099 h
->type
= STT_OBJECT
;
1102 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1105 s
= bfd_make_section (abfd
, ".hash");
1107 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1108 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1111 /* Let the backend create the rest of the sections. This lets the
1112 backend set the right flags. The backend will normally create
1113 the .got and .plt sections. */
1114 bed
= get_elf_backend_data (abfd
);
1115 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1118 elf_hash_table (info
)->dynamic_sections_created
= true;
1123 /* Add an entry to the .dynamic table. */
1126 elf_add_dynamic_entry (info
, tag
, val
)
1127 struct bfd_link_info
*info
;
1131 Elf_Internal_Dyn dyn
;
1135 bfd_byte
*newcontents
;
1137 dynobj
= elf_hash_table (info
)->dynobj
;
1139 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1140 BFD_ASSERT (s
!= NULL
);
1142 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1143 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1144 if (newcontents
== NULL
)
1148 dyn
.d_un
.d_val
= val
;
1149 elf_swap_dyn_out (dynobj
, &dyn
,
1150 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1152 s
->_raw_size
= newsize
;
1153 s
->contents
= newcontents
;
1159 /* Read and swap the relocs for a section. They may have been cached.
1160 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1161 they are used as buffers to read into. They are known to be large
1162 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1163 value is allocated using either malloc or bfd_alloc, according to
1164 the KEEP_MEMORY argument. */
1166 static Elf_Internal_Rela
*
1167 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1170 PTR external_relocs
;
1171 Elf_Internal_Rela
*internal_relocs
;
1172 boolean keep_memory
;
1174 Elf_Internal_Shdr
*rel_hdr
;
1176 Elf_Internal_Rela
*alloc2
= NULL
;
1178 if (elf_section_data (o
)->relocs
!= NULL
)
1179 return elf_section_data (o
)->relocs
;
1181 if (o
->reloc_count
== 0)
1184 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1186 if (internal_relocs
== NULL
)
1190 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1192 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1194 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1195 if (internal_relocs
== NULL
)
1199 if (external_relocs
== NULL
)
1201 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1204 external_relocs
= alloc1
;
1207 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1208 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1209 != rel_hdr
->sh_size
))
1212 /* Swap in the relocs. For convenience, we always produce an
1213 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1215 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1217 Elf_External_Rel
*erel
;
1218 Elf_External_Rel
*erelend
;
1219 Elf_Internal_Rela
*irela
;
1221 erel
= (Elf_External_Rel
*) external_relocs
;
1222 erelend
= erel
+ o
->reloc_count
;
1223 irela
= internal_relocs
;
1224 for (; erel
< erelend
; erel
++, irela
++)
1226 Elf_Internal_Rel irel
;
1228 elf_swap_reloc_in (abfd
, erel
, &irel
);
1229 irela
->r_offset
= irel
.r_offset
;
1230 irela
->r_info
= irel
.r_info
;
1231 irela
->r_addend
= 0;
1236 Elf_External_Rela
*erela
;
1237 Elf_External_Rela
*erelaend
;
1238 Elf_Internal_Rela
*irela
;
1240 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1242 erela
= (Elf_External_Rela
*) external_relocs
;
1243 erelaend
= erela
+ o
->reloc_count
;
1244 irela
= internal_relocs
;
1245 for (; erela
< erelaend
; erela
++, irela
++)
1246 elf_swap_reloca_in (abfd
, erela
, irela
);
1249 /* Cache the results for next time, if we can. */
1251 elf_section_data (o
)->relocs
= internal_relocs
;
1256 /* Don't free alloc2, since if it was allocated we are passing it
1257 back (under the name of internal_relocs). */
1259 return internal_relocs
;
1270 /* Record an assignment to a symbol made by a linker script. We need
1271 this in case some dynamic object refers to this symbol. */
1275 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1277 struct bfd_link_info
*info
;
1281 struct elf_link_hash_entry
*h
;
1283 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1286 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1290 if (h
->root
.type
== bfd_link_hash_new
)
1291 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
1293 /* If this symbol is being provided by the linker script, and it is
1294 currently defined by a dynamic object, but not by a regular
1295 object, then mark it as undefined so that the generic linker will
1296 force the correct value. */
1298 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1299 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1300 h
->root
.type
= bfd_link_hash_undefined
;
1302 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1303 h
->type
= STT_OBJECT
;
1305 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1306 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1308 && h
->dynindx
== -1)
1310 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1313 /* If this is a weak defined symbol, and we know a corresponding
1314 real symbol from the same dynamic object, make sure the real
1315 symbol is also made into a dynamic symbol. */
1316 if (h
->weakdef
!= NULL
1317 && h
->weakdef
->dynindx
== -1)
1319 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1328 /* Array used to determine the number of hash table buckets to use
1329 based on the number of symbols there are. If there are fewer than
1330 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1331 fewer than 37 we use 17 buckets, and so forth. We never use more
1332 than 521 buckets. */
1334 static const size_t elf_buckets
[] =
1336 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1339 /* Set up the sizes and contents of the ELF dynamic sections. This is
1340 called by the ELF linker emulation before_allocation routine. We
1341 must set the sizes of the sections before the linker sets the
1342 addresses of the various sections. */
1345 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1346 export_dynamic
, info
, sinterpptr
)
1350 boolean export_dynamic
;
1351 struct bfd_link_info
*info
;
1352 asection
**sinterpptr
;
1355 struct elf_backend_data
*bed
;
1359 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1362 dynobj
= elf_hash_table (info
)->dynobj
;
1364 /* If there were no dynamic objects in the link, there is nothing to
1369 /* If we are supposed to export all symbols into the dynamic symbol
1370 table (this is not the normal case), then do so. */
1373 struct elf_info_failed eif
;
1377 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1383 if (elf_hash_table (info
)->dynamic_sections_created
)
1385 struct elf_info_failed eif
;
1386 struct elf_link_hash_entry
*h
;
1387 bfd_size_type strsize
;
1389 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1390 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1396 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1398 if (indx
== (bfd_size_type
) -1
1399 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1405 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1413 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1415 if (indx
== (bfd_size_type
) -1
1416 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1420 /* Find all symbols which were defined in a dynamic object and make
1421 the backend pick a reasonable value for them. */
1424 elf_link_hash_traverse (elf_hash_table (info
),
1425 elf_adjust_dynamic_symbol
,
1430 /* Add some entries to the .dynamic section. We fill in some of the
1431 values later, in elf_bfd_final_link, but we must add the entries
1432 now so that we know the final size of the .dynamic section. */
1433 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1436 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1437 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1439 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1442 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1445 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1446 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1448 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1451 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1452 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1453 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1454 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1455 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1456 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1457 sizeof (Elf_External_Sym
)))
1461 /* The backend must work out the sizes of all the other dynamic
1463 bed
= get_elf_backend_data (output_bfd
);
1464 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1467 if (elf_hash_table (info
)->dynamic_sections_created
)
1472 size_t bucketcount
= 0;
1473 Elf_Internal_Sym isym
;
1475 /* Set the size of the .dynsym and .hash sections. We counted
1476 the number of dynamic symbols in elf_link_add_object_symbols.
1477 We will build the contents of .dynsym and .hash when we build
1478 the final symbol table, because until then we do not know the
1479 correct value to give the symbols. We built the .dynstr
1480 section as we went along in elf_link_add_object_symbols. */
1481 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1482 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1483 BFD_ASSERT (s
!= NULL
);
1484 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1485 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1486 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1489 /* The first entry in .dynsym is a dummy symbol. */
1496 elf_swap_symbol_out (output_bfd
, &isym
,
1497 (PTR
) (Elf_External_Sym
*) s
->contents
);
1499 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1501 bucketcount
= elf_buckets
[i
];
1502 if (dynsymcount
< elf_buckets
[i
+ 1])
1506 s
= bfd_get_section_by_name (dynobj
, ".hash");
1507 BFD_ASSERT (s
!= NULL
);
1508 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1509 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1510 if (s
->contents
== NULL
)
1512 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1514 put_word (output_bfd
, bucketcount
, s
->contents
);
1515 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1517 elf_hash_table (info
)->bucketcount
= bucketcount
;
1519 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1520 BFD_ASSERT (s
!= NULL
);
1521 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1523 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1531 /* This routine is used to export all defined symbols into the dynamic
1532 symbol table. It is called via elf_link_hash_traverse. */
1535 elf_export_symbol (h
, data
)
1536 struct elf_link_hash_entry
*h
;
1539 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1541 if (h
->dynindx
== -1
1542 && (h
->elf_link_hash_flags
1543 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1545 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1556 /* Make the backend pick a good value for a dynamic symbol. This is
1557 called via elf_link_hash_traverse, and also calls itself
1561 elf_adjust_dynamic_symbol (h
, data
)
1562 struct elf_link_hash_entry
*h
;
1565 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1567 struct elf_backend_data
*bed
;
1569 /* If this symbol was mentioned in a non-ELF file, try to set
1570 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1571 permit a non-ELF file to correctly refer to a symbol defined in
1572 an ELF dynamic object. */
1573 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
1575 if (h
->root
.type
!= bfd_link_hash_defined
1576 && h
->root
.type
!= bfd_link_hash_defweak
)
1577 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1580 if (h
->root
.u
.def
.section
->owner
!= NULL
1581 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
1582 == bfd_target_elf_flavour
))
1583 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1585 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1588 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1589 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1591 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1599 /* If this is a final link, and the symbol was defined as a common
1600 symbol in a regular object file, and there was no definition in
1601 any dynamic object, then the linker will have allocated space for
1602 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
1603 flag will not have been set. */
1604 if (h
->root
.type
== bfd_link_hash_defined
1605 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1606 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
1607 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1608 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
1609 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1611 /* If -Bsymbolic was used (which means to bind references to global
1612 symbols to the definition within the shared object), and this
1613 symbol was defined in a regular object, then it actually doesn't
1614 need a PLT entry. */
1615 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1616 && eif
->info
->shared
1617 && eif
->info
->symbolic
1618 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1619 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1621 /* If this symbol does not require a PLT entry, and it is not
1622 defined by a dynamic object, or is not referenced by a regular
1623 object, ignore it. We do have to handle a weak defined symbol,
1624 even if no regular object refers to it, if we decided to add it
1625 to the dynamic symbol table. FIXME: Do we normally need to worry
1626 about symbols which are defined by one dynamic object and
1627 referenced by another one? */
1628 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1629 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1630 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1631 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1632 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1635 /* If we've already adjusted this symbol, don't do it again. This
1636 can happen via a recursive call. */
1637 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1640 /* Don't look at this symbol again. Note that we must set this
1641 after checking the above conditions, because we may look at a
1642 symbol once, decide not to do anything, and then get called
1643 recursively later after REF_REGULAR is set below. */
1644 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1646 /* If this is a weak definition, and we know a real definition, and
1647 the real symbol is not itself defined by a regular object file,
1648 then get a good value for the real definition. We handle the
1649 real symbol first, for the convenience of the backend routine.
1651 Note that there is a confusing case here. If the real definition
1652 is defined by a regular object file, we don't get the real symbol
1653 from the dynamic object, but we do get the weak symbol. If the
1654 processor backend uses a COPY reloc, then if some routine in the
1655 dynamic object changes the real symbol, we will not see that
1656 change in the corresponding weak symbol. This is the way other
1657 ELF linkers work as well, and seems to be a result of the shared
1660 I will clarify this issue. Most SVR4 shared libraries define the
1661 variable _timezone and define timezone as a weak synonym. The
1662 tzset call changes _timezone. If you write
1663 extern int timezone;
1665 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1666 you might expect that, since timezone is a synonym for _timezone,
1667 the same number will print both times. However, if the processor
1668 backend uses a COPY reloc, then actually timezone will be copied
1669 into your process image, and, since you define _timezone
1670 yourself, _timezone will not. Thus timezone and _timezone will
1671 wind up at different memory locations. The tzset call will set
1672 _timezone, leaving timezone unchanged. */
1674 if (h
->weakdef
!= NULL
)
1676 struct elf_link_hash_entry
*weakdef
;
1678 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1679 || h
->root
.type
== bfd_link_hash_defweak
);
1680 weakdef
= h
->weakdef
;
1681 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1682 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1683 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1684 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1686 /* This symbol is defined by a regular object file, so we
1687 will not do anything special. Clear weakdef for the
1688 convenience of the processor backend. */
1693 /* There is an implicit reference by a regular object file
1694 via the weak symbol. */
1695 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1696 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1701 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1702 bed
= get_elf_backend_data (dynobj
);
1703 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1712 /* Final phase of ELF linker. */
1714 /* A structure we use to avoid passing large numbers of arguments. */
1716 struct elf_final_link_info
1718 /* General link information. */
1719 struct bfd_link_info
*info
;
1722 /* Symbol string table. */
1723 struct bfd_strtab_hash
*symstrtab
;
1724 /* .dynsym section. */
1725 asection
*dynsym_sec
;
1726 /* .hash section. */
1728 /* Buffer large enough to hold contents of any section. */
1730 /* Buffer large enough to hold external relocs of any section. */
1731 PTR external_relocs
;
1732 /* Buffer large enough to hold internal relocs of any section. */
1733 Elf_Internal_Rela
*internal_relocs
;
1734 /* Buffer large enough to hold external local symbols of any input
1736 Elf_External_Sym
*external_syms
;
1737 /* Buffer large enough to hold internal local symbols of any input
1739 Elf_Internal_Sym
*internal_syms
;
1740 /* Array large enough to hold a symbol index for each local symbol
1741 of any input BFD. */
1743 /* Array large enough to hold a section pointer for each local
1744 symbol of any input BFD. */
1745 asection
**sections
;
1746 /* Buffer to hold swapped out symbols. */
1747 Elf_External_Sym
*symbuf
;
1748 /* Number of swapped out symbols in buffer. */
1749 size_t symbuf_count
;
1750 /* Number of symbols which fit in symbuf. */
1754 static boolean elf_link_output_sym
1755 PARAMS ((struct elf_final_link_info
*, const char *,
1756 Elf_Internal_Sym
*, asection
*));
1757 static boolean elf_link_flush_output_syms
1758 PARAMS ((struct elf_final_link_info
*));
1759 static boolean elf_link_output_extsym
1760 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1761 static boolean elf_link_input_bfd
1762 PARAMS ((struct elf_final_link_info
*, bfd
*));
1763 static boolean elf_reloc_link_order
1764 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1765 struct bfd_link_order
*));
1767 /* This struct is used to pass information to routines called via
1768 elf_link_hash_traverse which must return failure. */
1770 struct elf_finfo_failed
1773 struct elf_final_link_info
*finfo
;
1776 /* Do the final step of an ELF link. */
1779 elf_bfd_final_link (abfd
, info
)
1781 struct bfd_link_info
*info
;
1785 struct elf_final_link_info finfo
;
1786 register asection
*o
;
1787 register struct bfd_link_order
*p
;
1789 size_t max_contents_size
;
1790 size_t max_external_reloc_size
;
1791 size_t max_internal_reloc_count
;
1792 size_t max_sym_count
;
1794 Elf_Internal_Sym elfsym
;
1796 Elf_Internal_Shdr
*symtab_hdr
;
1797 Elf_Internal_Shdr
*symstrtab_hdr
;
1798 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1799 struct elf_finfo_failed eif
;
1802 abfd
->flags
|= DYNAMIC
;
1804 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1805 dynobj
= elf_hash_table (info
)->dynobj
;
1808 finfo
.output_bfd
= abfd
;
1809 finfo
.symstrtab
= elf_stringtab_init ();
1810 if (finfo
.symstrtab
== NULL
)
1814 finfo
.dynsym_sec
= NULL
;
1815 finfo
.hash_sec
= NULL
;
1819 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1820 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1821 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1823 finfo
.contents
= NULL
;
1824 finfo
.external_relocs
= NULL
;
1825 finfo
.internal_relocs
= NULL
;
1826 finfo
.external_syms
= NULL
;
1827 finfo
.internal_syms
= NULL
;
1828 finfo
.indices
= NULL
;
1829 finfo
.sections
= NULL
;
1830 finfo
.symbuf
= NULL
;
1831 finfo
.symbuf_count
= 0;
1833 /* Count up the number of relocations we will output for each output
1834 section, so that we know the sizes of the reloc sections. We
1835 also figure out some maximum sizes. */
1836 max_contents_size
= 0;
1837 max_external_reloc_size
= 0;
1838 max_internal_reloc_count
= 0;
1840 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1844 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1846 if (p
->type
== bfd_section_reloc_link_order
1847 || p
->type
== bfd_symbol_reloc_link_order
)
1849 else if (p
->type
== bfd_indirect_link_order
)
1853 sec
= p
->u
.indirect
.section
;
1855 /* Mark all sections which are to be included in the
1856 link. This will normally be every section. We need
1857 to do this so that we can identify any sections which
1858 the linker has decided to not include. */
1859 sec
->linker_mark
= true;
1861 if (info
->relocateable
)
1862 o
->reloc_count
+= sec
->reloc_count
;
1864 if (sec
->_raw_size
> max_contents_size
)
1865 max_contents_size
= sec
->_raw_size
;
1866 if (sec
->_cooked_size
> max_contents_size
)
1867 max_contents_size
= sec
->_cooked_size
;
1869 /* We are interested in just local symbols, not all
1871 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1875 if (elf_bad_symtab (sec
->owner
))
1876 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1877 / sizeof (Elf_External_Sym
));
1879 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1881 if (sym_count
> max_sym_count
)
1882 max_sym_count
= sym_count
;
1884 if ((sec
->flags
& SEC_RELOC
) != 0)
1888 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1889 if (ext_size
> max_external_reloc_size
)
1890 max_external_reloc_size
= ext_size
;
1891 if (sec
->reloc_count
> max_internal_reloc_count
)
1892 max_internal_reloc_count
= sec
->reloc_count
;
1898 if (o
->reloc_count
> 0)
1899 o
->flags
|= SEC_RELOC
;
1902 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1903 set it (this is probably a bug) and if it is set
1904 assign_section_numbers will create a reloc section. */
1905 o
->flags
&=~ SEC_RELOC
;
1908 /* If the SEC_ALLOC flag is not set, force the section VMA to
1909 zero. This is done in elf_fake_sections as well, but forcing
1910 the VMA to 0 here will ensure that relocs against these
1911 sections are handled correctly. */
1912 if ((o
->flags
& SEC_ALLOC
) == 0
1913 && ! o
->user_set_vma
)
1917 /* Figure out the file positions for everything but the symbol table
1918 and the relocs. We set symcount to force assign_section_numbers
1919 to create a symbol table. */
1920 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1921 BFD_ASSERT (! abfd
->output_has_begun
);
1922 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1925 /* That created the reloc sections. Set their sizes, and assign
1926 them file positions, and allocate some buffers. */
1927 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1929 if ((o
->flags
& SEC_RELOC
) != 0)
1931 Elf_Internal_Shdr
*rel_hdr
;
1932 register struct elf_link_hash_entry
**p
, **pend
;
1934 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1936 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1938 /* The contents field must last into write_object_contents,
1939 so we allocate it with bfd_alloc rather than malloc. */
1940 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1941 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1944 p
= ((struct elf_link_hash_entry
**)
1945 bfd_malloc (o
->reloc_count
1946 * sizeof (struct elf_link_hash_entry
*)));
1947 if (p
== NULL
&& o
->reloc_count
!= 0)
1949 elf_section_data (o
)->rel_hashes
= p
;
1950 pend
= p
+ o
->reloc_count
;
1951 for (; p
< pend
; p
++)
1954 /* Use the reloc_count field as an index when outputting the
1960 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1962 /* We have now assigned file positions for all the sections except
1963 .symtab and .strtab. We start the .symtab section at the current
1964 file position, and write directly to it. We build the .strtab
1965 section in memory. */
1967 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1968 /* sh_name is set in prep_headers. */
1969 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1970 symtab_hdr
->sh_flags
= 0;
1971 symtab_hdr
->sh_addr
= 0;
1972 symtab_hdr
->sh_size
= 0;
1973 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1974 /* sh_link is set in assign_section_numbers. */
1975 /* sh_info is set below. */
1976 /* sh_offset is set just below. */
1977 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1979 off
= elf_tdata (abfd
)->next_file_pos
;
1980 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1982 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1983 incorrect. We do not yet know the size of the .symtab section.
1984 We correct next_file_pos below, after we do know the size. */
1986 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1987 continuously seeking to the right position in the file. */
1988 if (! info
->keep_memory
|| max_sym_count
< 20)
1989 finfo
.symbuf_size
= 20;
1991 finfo
.symbuf_size
= max_sym_count
;
1992 finfo
.symbuf
= ((Elf_External_Sym
*)
1993 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1994 if (finfo
.symbuf
== NULL
)
1997 /* Start writing out the symbol table. The first symbol is always a
1999 if (info
->strip
!= strip_all
|| info
->relocateable
)
2001 elfsym
.st_value
= 0;
2004 elfsym
.st_other
= 0;
2005 elfsym
.st_shndx
= SHN_UNDEF
;
2006 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2007 &elfsym
, bfd_und_section_ptr
))
2012 /* Some standard ELF linkers do this, but we don't because it causes
2013 bootstrap comparison failures. */
2014 /* Output a file symbol for the output file as the second symbol.
2015 We output this even if we are discarding local symbols, although
2016 I'm not sure if this is correct. */
2017 elfsym
.st_value
= 0;
2019 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2020 elfsym
.st_other
= 0;
2021 elfsym
.st_shndx
= SHN_ABS
;
2022 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
2023 &elfsym
, bfd_abs_section_ptr
))
2027 /* Output a symbol for each section. We output these even if we are
2028 discarding local symbols, since they are used for relocs. These
2029 symbols have no names. We store the index of each one in the
2030 index field of the section, so that we can find it again when
2031 outputting relocs. */
2032 if (info
->strip
!= strip_all
|| info
->relocateable
)
2034 elfsym
.st_value
= 0;
2036 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2037 elfsym
.st_other
= 0;
2038 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2040 o
= section_from_elf_index (abfd
, i
);
2042 o
->target_index
= abfd
->symcount
;
2043 elfsym
.st_shndx
= i
;
2044 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2050 /* Allocate some memory to hold information read in from the input
2052 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
2053 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
2054 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
2055 bfd_malloc (max_internal_reloc_count
2056 * sizeof (Elf_Internal_Rela
)));
2057 finfo
.external_syms
= ((Elf_External_Sym
*)
2058 bfd_malloc (max_sym_count
2059 * sizeof (Elf_External_Sym
)));
2060 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
2061 bfd_malloc (max_sym_count
2062 * sizeof (Elf_Internal_Sym
)));
2063 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
2064 finfo
.sections
= ((asection
**)
2065 bfd_malloc (max_sym_count
* sizeof (asection
*)));
2066 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
2067 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
2068 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
2069 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
2070 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
2071 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
2072 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
2075 /* Since ELF permits relocations to be against local symbols, we
2076 must have the local symbols available when we do the relocations.
2077 Since we would rather only read the local symbols once, and we
2078 would rather not keep them in memory, we handle all the
2079 relocations for a single input file at the same time.
2081 Unfortunately, there is no way to know the total number of local
2082 symbols until we have seen all of them, and the local symbol
2083 indices precede the global symbol indices. This means that when
2084 we are generating relocateable output, and we see a reloc against
2085 a global symbol, we can not know the symbol index until we have
2086 finished examining all the local symbols to see which ones we are
2087 going to output. To deal with this, we keep the relocations in
2088 memory, and don't output them until the end of the link. This is
2089 an unfortunate waste of memory, but I don't see a good way around
2090 it. Fortunately, it only happens when performing a relocateable
2091 link, which is not the common case. FIXME: If keep_memory is set
2092 we could write the relocs out and then read them again; I don't
2093 know how bad the memory loss will be. */
2095 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
2096 sub
->output_has_begun
= false;
2097 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2099 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
2101 if (p
->type
== bfd_indirect_link_order
2102 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2103 == bfd_target_elf_flavour
))
2105 sub
= p
->u
.indirect
.section
->owner
;
2106 if (! sub
->output_has_begun
)
2108 if (! elf_link_input_bfd (&finfo
, sub
))
2110 sub
->output_has_begun
= true;
2113 else if (p
->type
== bfd_section_reloc_link_order
2114 || p
->type
== bfd_symbol_reloc_link_order
)
2116 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2121 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2127 /* That wrote out all the local symbols. Finish up the symbol table
2128 with the global symbols. */
2130 /* The sh_info field records the index of the first non local
2132 symtab_hdr
->sh_info
= abfd
->symcount
;
2134 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2136 /* We get the global symbols from the hash table. */
2139 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2144 /* Flush all symbols to the file. */
2145 if (! elf_link_flush_output_syms (&finfo
))
2148 /* Now we know the size of the symtab section. */
2149 off
+= symtab_hdr
->sh_size
;
2151 /* Finish up and write out the symbol string table (.strtab)
2153 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2154 /* sh_name was set in prep_headers. */
2155 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2156 symstrtab_hdr
->sh_flags
= 0;
2157 symstrtab_hdr
->sh_addr
= 0;
2158 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2159 symstrtab_hdr
->sh_entsize
= 0;
2160 symstrtab_hdr
->sh_link
= 0;
2161 symstrtab_hdr
->sh_info
= 0;
2162 /* sh_offset is set just below. */
2163 symstrtab_hdr
->sh_addralign
= 1;
2165 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2166 elf_tdata (abfd
)->next_file_pos
= off
;
2168 if (abfd
->symcount
> 0)
2170 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2171 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2175 /* Adjust the relocs to have the correct symbol indices. */
2176 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2178 struct elf_link_hash_entry
**rel_hash
;
2179 Elf_Internal_Shdr
*rel_hdr
;
2181 if ((o
->flags
& SEC_RELOC
) == 0)
2184 rel_hash
= elf_section_data (o
)->rel_hashes
;
2185 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2186 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2188 if (*rel_hash
== NULL
)
2191 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2193 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2195 Elf_External_Rel
*erel
;
2196 Elf_Internal_Rel irel
;
2198 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2199 elf_swap_reloc_in (abfd
, erel
, &irel
);
2200 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2201 ELF_R_TYPE (irel
.r_info
));
2202 elf_swap_reloc_out (abfd
, &irel
, erel
);
2206 Elf_External_Rela
*erela
;
2207 Elf_Internal_Rela irela
;
2209 BFD_ASSERT (rel_hdr
->sh_entsize
2210 == sizeof (Elf_External_Rela
));
2212 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2213 elf_swap_reloca_in (abfd
, erela
, &irela
);
2214 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2215 ELF_R_TYPE (irela
.r_info
));
2216 elf_swap_reloca_out (abfd
, &irela
, erela
);
2220 /* Set the reloc_count field to 0 to prevent write_relocs from
2221 trying to swap the relocs out itself. */
2225 /* If we are linking against a dynamic object, or generating a
2226 shared library, finish up the dynamic linking information. */
2229 Elf_External_Dyn
*dyncon
, *dynconend
;
2231 /* Fix up .dynamic entries. */
2232 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2233 BFD_ASSERT (o
!= NULL
);
2235 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2236 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2237 for (; dyncon
< dynconend
; dyncon
++)
2239 Elf_Internal_Dyn dyn
;
2243 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2250 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2251 magic _init and _fini symbols. This is pretty ugly,
2252 but we are compatible. */
2260 struct elf_link_hash_entry
*h
;
2262 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2263 false, false, true);
2265 && (h
->root
.type
== bfd_link_hash_defined
2266 || h
->root
.type
== bfd_link_hash_defweak
))
2268 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2269 o
= h
->root
.u
.def
.section
;
2270 if (o
->output_section
!= NULL
)
2271 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2272 + o
->output_offset
);
2275 /* The symbol is imported from another shared
2276 library and does not apply to this one. */
2280 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2294 o
= bfd_get_section_by_name (abfd
, name
);
2295 BFD_ASSERT (o
!= NULL
);
2296 dyn
.d_un
.d_ptr
= o
->vma
;
2297 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2304 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2309 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2311 Elf_Internal_Shdr
*hdr
;
2313 hdr
= elf_elfsections (abfd
)[i
];
2314 if (hdr
->sh_type
== type
2315 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2317 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2318 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2321 if (dyn
.d_un
.d_val
== 0
2322 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2323 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2327 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2333 /* If we have created any dynamic sections, then output them. */
2336 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2339 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2341 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2342 || o
->_raw_size
== 0)
2344 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2346 /* At this point, we are only interested in sections
2347 created by elf_link_create_dynamic_sections. FIXME:
2348 This test is fragile. */
2351 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2353 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2355 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2356 o
->contents
, o
->output_offset
,
2364 /* The contents of the .dynstr section are actually in a
2366 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2367 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2368 || ! _bfd_stringtab_emit (abfd
,
2369 elf_hash_table (info
)->dynstr
))
2375 /* If we have optimized stabs strings, output them. */
2376 if (elf_hash_table (info
)->stab_info
!= NULL
)
2378 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
2382 if (finfo
.symstrtab
!= NULL
)
2383 _bfd_stringtab_free (finfo
.symstrtab
);
2384 if (finfo
.contents
!= NULL
)
2385 free (finfo
.contents
);
2386 if (finfo
.external_relocs
!= NULL
)
2387 free (finfo
.external_relocs
);
2388 if (finfo
.internal_relocs
!= NULL
)
2389 free (finfo
.internal_relocs
);
2390 if (finfo
.external_syms
!= NULL
)
2391 free (finfo
.external_syms
);
2392 if (finfo
.internal_syms
!= NULL
)
2393 free (finfo
.internal_syms
);
2394 if (finfo
.indices
!= NULL
)
2395 free (finfo
.indices
);
2396 if (finfo
.sections
!= NULL
)
2397 free (finfo
.sections
);
2398 if (finfo
.symbuf
!= NULL
)
2399 free (finfo
.symbuf
);
2400 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2402 if ((o
->flags
& SEC_RELOC
) != 0
2403 && elf_section_data (o
)->rel_hashes
!= NULL
)
2404 free (elf_section_data (o
)->rel_hashes
);
2407 elf_tdata (abfd
)->linker
= true;
2412 if (finfo
.symstrtab
!= NULL
)
2413 _bfd_stringtab_free (finfo
.symstrtab
);
2414 if (finfo
.contents
!= NULL
)
2415 free (finfo
.contents
);
2416 if (finfo
.external_relocs
!= NULL
)
2417 free (finfo
.external_relocs
);
2418 if (finfo
.internal_relocs
!= NULL
)
2419 free (finfo
.internal_relocs
);
2420 if (finfo
.external_syms
!= NULL
)
2421 free (finfo
.external_syms
);
2422 if (finfo
.internal_syms
!= NULL
)
2423 free (finfo
.internal_syms
);
2424 if (finfo
.indices
!= NULL
)
2425 free (finfo
.indices
);
2426 if (finfo
.sections
!= NULL
)
2427 free (finfo
.sections
);
2428 if (finfo
.symbuf
!= NULL
)
2429 free (finfo
.symbuf
);
2430 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2432 if ((o
->flags
& SEC_RELOC
) != 0
2433 && elf_section_data (o
)->rel_hashes
!= NULL
)
2434 free (elf_section_data (o
)->rel_hashes
);
2440 /* Add a symbol to the output symbol table. */
2443 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2444 struct elf_final_link_info
*finfo
;
2446 Elf_Internal_Sym
*elfsym
;
2447 asection
*input_sec
;
2449 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2450 struct bfd_link_info
*info
,
2455 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2456 elf_backend_link_output_symbol_hook
;
2457 if (output_symbol_hook
!= NULL
)
2459 if (! ((*output_symbol_hook
)
2460 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2464 if (name
== (const char *) NULL
|| *name
== '\0')
2465 elfsym
->st_name
= 0;
2468 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2471 if (elfsym
->st_name
== (unsigned long) -1)
2475 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2477 if (! elf_link_flush_output_syms (finfo
))
2481 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2482 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2483 ++finfo
->symbuf_count
;
2485 ++finfo
->output_bfd
->symcount
;
2490 /* Flush the output symbols to the file. */
2493 elf_link_flush_output_syms (finfo
)
2494 struct elf_final_link_info
*finfo
;
2496 if (finfo
->symbuf_count
> 0)
2498 Elf_Internal_Shdr
*symtab
;
2500 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2502 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2504 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2505 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2506 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2509 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2511 finfo
->symbuf_count
= 0;
2517 /* Add an external symbol to the symbol table. This is called from
2518 the hash table traversal routine. */
2521 elf_link_output_extsym (h
, data
)
2522 struct elf_link_hash_entry
*h
;
2525 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2526 struct elf_final_link_info
*finfo
= eif
->finfo
;
2528 Elf_Internal_Sym sym
;
2529 asection
*input_sec
;
2531 /* If we are not creating a shared library, and this symbol is
2532 referenced by a shared library but is not defined anywhere, then
2533 warn that it is undefined. If we do not do this, the runtime
2534 linker will complain that the symbol is undefined when the
2535 program is run. We don't have to worry about symbols that are
2536 referenced by regular files, because we will already have issued
2537 warnings for them. */
2538 if (! finfo
->info
->relocateable
2539 && ! finfo
->info
->shared
2540 && h
->root
.type
== bfd_link_hash_undefined
2541 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2542 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2544 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2545 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2546 (asection
*) NULL
, 0)))
2553 /* We don't want to output symbols that have never been mentioned by
2554 a regular file, or that we have been told to strip. However, if
2555 h->indx is set to -2, the symbol is used by a reloc and we must
2559 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2560 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2561 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2562 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2564 else if (finfo
->info
->strip
== strip_all
2565 || (finfo
->info
->strip
== strip_some
2566 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2567 h
->root
.root
.string
,
2568 false, false) == NULL
))
2573 /* If we're stripping it, and it's not a dynamic symbol, there's
2574 nothing else to do. */
2575 if (strip
&& h
->dynindx
== -1)
2579 sym
.st_size
= h
->size
;
2581 if (h
->root
.type
== bfd_link_hash_undefweak
2582 || h
->root
.type
== bfd_link_hash_defweak
)
2583 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2585 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2587 switch (h
->root
.type
)
2590 case bfd_link_hash_new
:
2594 case bfd_link_hash_undefined
:
2595 input_sec
= bfd_und_section_ptr
;
2596 sym
.st_shndx
= SHN_UNDEF
;
2599 case bfd_link_hash_undefweak
:
2600 input_sec
= bfd_und_section_ptr
;
2601 sym
.st_shndx
= SHN_UNDEF
;
2604 case bfd_link_hash_defined
:
2605 case bfd_link_hash_defweak
:
2607 input_sec
= h
->root
.u
.def
.section
;
2608 if (input_sec
->output_section
!= NULL
)
2611 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2612 input_sec
->output_section
);
2613 if (sym
.st_shndx
== (unsigned short) -1)
2619 /* ELF symbols in relocateable files are section relative,
2620 but in nonrelocateable files they are virtual
2622 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2623 if (! finfo
->info
->relocateable
)
2624 sym
.st_value
+= input_sec
->output_section
->vma
;
2628 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2629 == bfd_target_elf_flavour
)
2630 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2631 sym
.st_shndx
= SHN_UNDEF
;
2632 input_sec
= bfd_und_section_ptr
;
2637 case bfd_link_hash_common
:
2638 input_sec
= bfd_com_section_ptr
;
2639 sym
.st_shndx
= SHN_COMMON
;
2640 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2643 case bfd_link_hash_indirect
:
2644 case bfd_link_hash_warning
:
2645 /* We can't represent these symbols in ELF. A warning symbol
2646 may have come from a .gnu.warning.SYMBOL section anyhow. We
2647 just put the target symbol in the hash table. If the target
2648 symbol does not really exist, don't do anything. */
2649 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2651 return (elf_link_output_extsym
2652 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2655 /* If this symbol should be put in the .dynsym section, then put it
2656 there now. We have already know the symbol index. We also fill
2657 in the entry in the .hash section. */
2658 if (h
->dynindx
!= -1
2659 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2661 struct elf_backend_data
*bed
;
2664 bfd_byte
*bucketpos
;
2667 sym
.st_name
= h
->dynstr_index
;
2669 /* Give the processor backend a chance to tweak the symbol
2670 value, and also to finish up anything that needs to be done
2672 bed
= get_elf_backend_data (finfo
->output_bfd
);
2673 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2674 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2680 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2681 (PTR
) (((Elf_External_Sym
*)
2682 finfo
->dynsym_sec
->contents
)
2685 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2686 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2688 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2689 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2690 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2691 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2692 put_word (finfo
->output_bfd
, chain
,
2693 ((bfd_byte
*) finfo
->hash_sec
->contents
2694 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2697 /* If we're stripping it, then it was just a dynamic symbol, and
2698 there's nothing else to do. */
2702 h
->indx
= finfo
->output_bfd
->symcount
;
2704 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2713 /* Link an input file into the linker output file. This function
2714 handles all the sections and relocations of the input file at once.
2715 This is so that we only have to read the local symbols once, and
2716 don't have to keep them in memory. */
2719 elf_link_input_bfd (finfo
, input_bfd
)
2720 struct elf_final_link_info
*finfo
;
2723 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2724 bfd
*, asection
*, bfd_byte
*,
2725 Elf_Internal_Rela
*,
2726 Elf_Internal_Sym
*, asection
**));
2728 Elf_Internal_Shdr
*symtab_hdr
;
2731 Elf_External_Sym
*esym
;
2732 Elf_External_Sym
*esymend
;
2733 Elf_Internal_Sym
*isym
;
2735 asection
**ppsection
;
2738 output_bfd
= finfo
->output_bfd
;
2740 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2742 /* If this is a dynamic object, we don't want to do anything here:
2743 we don't want the local symbols, and we don't want the section
2745 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2748 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2749 if (elf_bad_symtab (input_bfd
))
2751 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2756 locsymcount
= symtab_hdr
->sh_info
;
2757 extsymoff
= symtab_hdr
->sh_info
;
2760 /* Read the local symbols. */
2762 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2763 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2764 locsymcount
, input_bfd
)
2765 != locsymcount
* sizeof (Elf_External_Sym
))))
2768 /* Swap in the local symbols and write out the ones which we know
2769 are going into the output file. */
2770 esym
= finfo
->external_syms
;
2771 esymend
= esym
+ locsymcount
;
2772 isym
= finfo
->internal_syms
;
2773 pindex
= finfo
->indices
;
2774 ppsection
= finfo
->sections
;
2775 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2779 Elf_Internal_Sym osym
;
2781 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2784 if (elf_bad_symtab (input_bfd
))
2786 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2793 if (isym
->st_shndx
== SHN_UNDEF
)
2794 isec
= bfd_und_section_ptr
;
2795 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2796 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2797 else if (isym
->st_shndx
== SHN_ABS
)
2798 isec
= bfd_abs_section_ptr
;
2799 else if (isym
->st_shndx
== SHN_COMMON
)
2800 isec
= bfd_com_section_ptr
;
2809 /* Don't output the first, undefined, symbol. */
2810 if (esym
== finfo
->external_syms
)
2813 /* If we are stripping all symbols, we don't want to output this
2815 if (finfo
->info
->strip
== strip_all
)
2818 /* We never output section symbols. Instead, we use the section
2819 symbol of the corresponding section in the output file. */
2820 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2823 /* If we are discarding all local symbols, we don't want to
2824 output this one. If we are generating a relocateable output
2825 file, then some of the local symbols may be required by
2826 relocs; we output them below as we discover that they are
2828 if (finfo
->info
->discard
== discard_all
)
2831 /* Get the name of the symbol. */
2832 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2837 /* See if we are discarding symbols with this name. */
2838 if ((finfo
->info
->strip
== strip_some
2839 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2841 || (finfo
->info
->discard
== discard_l
2842 && strncmp (name
, finfo
->info
->lprefix
,
2843 finfo
->info
->lprefix_len
) == 0))
2846 /* If we get here, we are going to output this symbol. */
2850 /* Adjust the section index for the output file. */
2851 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2852 isec
->output_section
);
2853 if (osym
.st_shndx
== (unsigned short) -1)
2856 *pindex
= output_bfd
->symcount
;
2858 /* ELF symbols in relocateable files are section relative, but
2859 in executable files they are virtual addresses. Note that
2860 this code assumes that all ELF sections have an associated
2861 BFD section with a reasonable value for output_offset; below
2862 we assume that they also have a reasonable value for
2863 output_section. Any special sections must be set up to meet
2864 these requirements. */
2865 osym
.st_value
+= isec
->output_offset
;
2866 if (! finfo
->info
->relocateable
)
2867 osym
.st_value
+= isec
->output_section
->vma
;
2869 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2873 /* Relocate the contents of each section. */
2874 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2876 if (! o
->linker_mark
)
2878 /* This section was omitted from the link. */
2882 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2883 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2886 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2887 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2889 /* Section was created by elf_link_create_dynamic_sections.
2890 FIXME: This test is fragile. */
2894 /* Read the contents of the section. */
2895 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2896 (file_ptr
) 0, o
->_raw_size
))
2899 if ((o
->flags
& SEC_RELOC
) != 0)
2901 Elf_Internal_Rela
*internal_relocs
;
2903 /* Get the swapped relocs. */
2904 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2905 finfo
->external_relocs
,
2906 finfo
->internal_relocs
,
2908 if (internal_relocs
== NULL
2909 && o
->reloc_count
> 0)
2912 /* Relocate the section by invoking a back end routine.
2914 The back end routine is responsible for adjusting the
2915 section contents as necessary, and (if using Rela relocs
2916 and generating a relocateable output file) adjusting the
2917 reloc addend as necessary.
2919 The back end routine does not have to worry about setting
2920 the reloc address or the reloc symbol index.
2922 The back end routine is given a pointer to the swapped in
2923 internal symbols, and can access the hash table entries
2924 for the external symbols via elf_sym_hashes (input_bfd).
2926 When generating relocateable output, the back end routine
2927 must handle STB_LOCAL/STT_SECTION symbols specially. The
2928 output symbol is going to be a section symbol
2929 corresponding to the output section, which will require
2930 the addend to be adjusted. */
2932 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2936 finfo
->internal_syms
,
2940 if (finfo
->info
->relocateable
)
2942 Elf_Internal_Rela
*irela
;
2943 Elf_Internal_Rela
*irelaend
;
2944 struct elf_link_hash_entry
**rel_hash
;
2945 Elf_Internal_Shdr
*input_rel_hdr
;
2946 Elf_Internal_Shdr
*output_rel_hdr
;
2948 /* Adjust the reloc addresses and symbol indices. */
2950 irela
= internal_relocs
;
2951 irelaend
= irela
+ o
->reloc_count
;
2952 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2953 + o
->output_section
->reloc_count
);
2954 for (; irela
< irelaend
; irela
++, rel_hash
++)
2956 unsigned long r_symndx
;
2957 Elf_Internal_Sym
*isym
;
2960 irela
->r_offset
+= o
->output_offset
;
2962 r_symndx
= ELF_R_SYM (irela
->r_info
);
2967 if (r_symndx
>= locsymcount
2968 || (elf_bad_symtab (input_bfd
)
2969 && finfo
->sections
[r_symndx
] == NULL
))
2973 /* This is a reloc against a global symbol. We
2974 have not yet output all the local symbols, so
2975 we do not know the symbol index of any global
2976 symbol. We set the rel_hash entry for this
2977 reloc to point to the global hash table entry
2978 for this symbol. The symbol index is then
2979 set at the end of elf_bfd_final_link. */
2980 indx
= r_symndx
- extsymoff
;
2981 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2983 /* Setting the index to -2 tells
2984 elf_link_output_extsym that this symbol is
2986 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2987 (*rel_hash
)->indx
= -2;
2992 /* This is a reloc against a local symbol. */
2995 isym
= finfo
->internal_syms
+ r_symndx
;
2996 sec
= finfo
->sections
[r_symndx
];
2997 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2999 /* I suppose the backend ought to fill in the
3000 section of any STT_SECTION symbol against a
3001 processor specific section. */
3002 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3004 else if (sec
== NULL
|| sec
->owner
== NULL
)
3006 bfd_set_error (bfd_error_bad_value
);
3011 r_symndx
= sec
->output_section
->target_index
;
3012 BFD_ASSERT (r_symndx
!= 0);
3017 if (finfo
->indices
[r_symndx
] == -1)
3023 if (finfo
->info
->strip
== strip_all
)
3025 /* You can't do ld -r -s. */
3026 bfd_set_error (bfd_error_invalid_operation
);
3030 /* This symbol was skipped earlier, but
3031 since it is needed by a reloc, we
3032 must output it now. */
3033 link
= symtab_hdr
->sh_link
;
3034 name
= bfd_elf_string_from_elf_section (input_bfd
,
3040 osec
= sec
->output_section
;
3042 _bfd_elf_section_from_bfd_section (output_bfd
,
3044 if (isym
->st_shndx
== (unsigned short) -1)
3047 isym
->st_value
+= sec
->output_offset
;
3048 if (! finfo
->info
->relocateable
)
3049 isym
->st_value
+= osec
->vma
;
3051 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
3053 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
3057 r_symndx
= finfo
->indices
[r_symndx
];
3060 irela
->r_info
= ELF_R_INFO (r_symndx
,
3061 ELF_R_TYPE (irela
->r_info
));
3064 /* Swap out the relocs. */
3065 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
3066 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
3067 BFD_ASSERT (output_rel_hdr
->sh_entsize
3068 == input_rel_hdr
->sh_entsize
);
3069 irela
= internal_relocs
;
3070 irelaend
= irela
+ o
->reloc_count
;
3071 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
3073 Elf_External_Rel
*erel
;
3075 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
3076 + o
->output_section
->reloc_count
);
3077 for (; irela
< irelaend
; irela
++, erel
++)
3079 Elf_Internal_Rel irel
;
3081 irel
.r_offset
= irela
->r_offset
;
3082 irel
.r_info
= irela
->r_info
;
3083 BFD_ASSERT (irela
->r_addend
== 0);
3084 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3089 Elf_External_Rela
*erela
;
3091 BFD_ASSERT (input_rel_hdr
->sh_entsize
3092 == sizeof (Elf_External_Rela
));
3093 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
3094 + o
->output_section
->reloc_count
);
3095 for (; irela
< irelaend
; irela
++, erela
++)
3096 elf_swap_reloca_out (output_bfd
, irela
, erela
);
3099 o
->output_section
->reloc_count
+= o
->reloc_count
;
3103 /* Write out the modified section contents. */
3104 if (elf_section_data (o
)->stab_info
== NULL
)
3106 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
3107 finfo
->contents
, o
->output_offset
,
3108 (o
->_cooked_size
!= 0
3115 if (! _bfd_write_section_stabs (output_bfd
, o
,
3116 &elf_section_data (o
)->stab_info
,
3125 /* Generate a reloc when linking an ELF file. This is a reloc
3126 requested by the linker, and does come from any input file. This
3127 is used to build constructor and destructor tables when linking
3131 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
3133 struct bfd_link_info
*info
;
3134 asection
*output_section
;
3135 struct bfd_link_order
*link_order
;
3137 reloc_howto_type
*howto
;
3141 struct elf_link_hash_entry
**rel_hash_ptr
;
3142 Elf_Internal_Shdr
*rel_hdr
;
3144 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3147 bfd_set_error (bfd_error_bad_value
);
3151 addend
= link_order
->u
.reloc
.p
->addend
;
3153 /* Figure out the symbol index. */
3154 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3155 + output_section
->reloc_count
);
3156 if (link_order
->type
== bfd_section_reloc_link_order
)
3158 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3159 BFD_ASSERT (indx
!= 0);
3160 *rel_hash_ptr
= NULL
;
3164 struct elf_link_hash_entry
*h
;
3166 /* Treat a reloc against a defined symbol as though it were
3167 actually against the section. */
3168 h
= ((struct elf_link_hash_entry
*)
3169 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3170 link_order
->u
.reloc
.p
->u
.name
,
3171 false, false, true));
3173 && (h
->root
.type
== bfd_link_hash_defined
3174 || h
->root
.type
== bfd_link_hash_defweak
))
3178 section
= h
->root
.u
.def
.section
;
3179 indx
= section
->output_section
->target_index
;
3180 *rel_hash_ptr
= NULL
;
3181 /* It seems that we ought to add the symbol value to the
3182 addend here, but in practice it has already been added
3183 because it was passed to constructor_callback. */
3184 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3188 /* Setting the index to -2 tells elf_link_output_extsym that
3189 this symbol is used by a reloc. */
3196 if (! ((*info
->callbacks
->unattached_reloc
)
3197 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3198 (asection
*) NULL
, (bfd_vma
) 0)))
3204 /* If this is an inplace reloc, we must write the addend into the
3206 if (howto
->partial_inplace
&& addend
!= 0)
3209 bfd_reloc_status_type rstat
;
3213 size
= bfd_get_reloc_size (howto
);
3214 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3215 if (buf
== (bfd_byte
*) NULL
)
3217 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3223 case bfd_reloc_outofrange
:
3225 case bfd_reloc_overflow
:
3226 if (! ((*info
->callbacks
->reloc_overflow
)
3228 (link_order
->type
== bfd_section_reloc_link_order
3229 ? bfd_section_name (output_bfd
,
3230 link_order
->u
.reloc
.p
->u
.section
)
3231 : link_order
->u
.reloc
.p
->u
.name
),
3232 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3240 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3241 (file_ptr
) link_order
->offset
, size
);
3247 /* The address of a reloc is relative to the section in a
3248 relocateable file, and is a virtual address in an executable
3250 offset
= link_order
->offset
;
3251 if (! info
->relocateable
)
3252 offset
+= output_section
->vma
;
3254 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3256 if (rel_hdr
->sh_type
== SHT_REL
)
3258 Elf_Internal_Rel irel
;
3259 Elf_External_Rel
*erel
;
3261 irel
.r_offset
= offset
;
3262 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3263 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3264 + output_section
->reloc_count
);
3265 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3269 Elf_Internal_Rela irela
;
3270 Elf_External_Rela
*erela
;
3272 irela
.r_offset
= offset
;
3273 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3274 irela
.r_addend
= addend
;
3275 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3276 + output_section
->reloc_count
);
3277 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3280 ++output_section
->reloc_count
;
3286 /* Allocate a pointer to live in a linker created section. */
3289 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3291 struct bfd_link_info
*info
;
3292 elf_linker_section_t
*lsect
;
3293 struct elf_link_hash_entry
*h
;
3294 const Elf_Internal_Rela
*rel
;
3296 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3297 elf_linker_section_pointers_t
*linker_section_ptr
;
3298 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3300 BFD_ASSERT (lsect
!= NULL
);
3302 /* Is this a global symbol? */
3305 /* Has this symbol already been allocated, if so, our work is done */
3306 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3311 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3312 /* Make sure this symbol is output as a dynamic symbol. */
3313 if (h
->dynindx
== -1)
3315 if (! elf_link_record_dynamic_symbol (info
, h
))
3319 if (lsect
->rel_section
)
3320 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3323 else /* Allocation of a pointer to a local symbol */
3325 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3327 /* Allocate a table to hold the local symbols if first time */
3330 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3331 register unsigned int i
;
3333 ptr
= (elf_linker_section_pointers_t
**)
3334 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3339 elf_local_ptr_offsets (abfd
) = ptr
;
3340 for (i
= 0; i
< num_symbols
; i
++)
3341 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3344 /* Has this symbol already been allocated, if so, our work is done */
3345 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3350 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3354 /* If we are generating a shared object, we need to
3355 output a R_<xxx>_RELATIVE reloc so that the
3356 dynamic linker can adjust this GOT entry. */
3357 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3358 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3362 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3363 from internal memory. */
3364 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3365 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3366 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3368 if (!linker_section_ptr
)
3371 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3372 linker_section_ptr
->addend
= rel
->r_addend
;
3373 linker_section_ptr
->which
= lsect
->which
;
3374 linker_section_ptr
->written_address_p
= false;
3375 *ptr_linker_section_ptr
= linker_section_ptr
;
3378 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3380 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
3381 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3382 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3383 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3385 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3387 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
3388 lsect
->sym_hash
->root
.root
.string
,
3389 (long)ARCH_SIZE
/ 8,
3390 (long)lsect
->sym_hash
->root
.u
.def
.value
);
3396 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3398 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3401 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3402 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3410 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3413 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3416 /* Fill in the address for a pointer generated in alinker section. */
3419 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3422 struct bfd_link_info
*info
;
3423 elf_linker_section_t
*lsect
;
3424 struct elf_link_hash_entry
*h
;
3426 const Elf_Internal_Rela
*rel
;
3429 elf_linker_section_pointers_t
*linker_section_ptr
;
3431 BFD_ASSERT (lsect
!= NULL
);
3433 if (h
!= NULL
) /* global symbol */
3435 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3439 BFD_ASSERT (linker_section_ptr
!= NULL
);
3441 if (! elf_hash_table (info
)->dynamic_sections_created
3444 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3446 /* This is actually a static link, or it is a
3447 -Bsymbolic link and the symbol is defined
3448 locally. We must initialize this entry in the
3451 When doing a dynamic link, we create a .rela.<xxx>
3452 relocation entry to initialize the value. This
3453 is done in the finish_dynamic_symbol routine. */
3454 if (!linker_section_ptr
->written_address_p
)
3456 linker_section_ptr
->written_address_p
= true;
3457 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3458 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3462 else /* local symbol */
3464 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3465 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3466 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3467 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3471 BFD_ASSERT (linker_section_ptr
!= NULL
);
3473 /* Write out pointer if it hasn't been rewritten out before */
3474 if (!linker_section_ptr
->written_address_p
)
3476 linker_section_ptr
->written_address_p
= true;
3477 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3478 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3482 asection
*srel
= lsect
->rel_section
;
3483 Elf_Internal_Rela outrel
;
3485 /* We need to generate a relative reloc for the dynamic linker. */
3487 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3490 BFD_ASSERT (srel
!= NULL
);
3492 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3493 + lsect
->section
->output_offset
3494 + linker_section_ptr
->offset
);
3495 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3496 outrel
.r_addend
= 0;
3497 elf_swap_reloca_out (output_bfd
, &outrel
,
3498 (((Elf_External_Rela
*)
3499 lsect
->section
->contents
)
3500 + lsect
->section
->reloc_count
));
3501 ++lsect
->section
->reloc_count
;
3506 relocation
= (lsect
->section
->output_offset
3507 + linker_section_ptr
->offset
3508 - lsect
->hole_offset
3509 - lsect
->sym_offset
);
3512 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3513 lsect
->name
, (long)relocation
, (long)relocation
);
3516 /* Subtract out the addend, because it will get added back in by the normal
3518 return relocation
- linker_section_ptr
->addend
;