2 Copyright 1995, 1996, 1997 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 static boolean elf_link_add_object_symbols
23 PARAMS ((bfd
*, struct bfd_link_info
*));
24 static boolean elf_link_add_archive_symbols
25 PARAMS ((bfd
*, struct bfd_link_info
*));
26 static boolean elf_export_symbol
27 PARAMS ((struct elf_link_hash_entry
*, PTR
));
28 static boolean elf_adjust_dynamic_symbol
29 PARAMS ((struct elf_link_hash_entry
*, PTR
));
31 /* This struct is used to pass information to routines called via
32 elf_link_hash_traverse which must return failure. */
34 struct elf_info_failed
37 struct bfd_link_info
*info
;
40 /* Given an ELF BFD, add symbols to the global hash table as
44 elf_bfd_link_add_symbols (abfd
, info
)
46 struct bfd_link_info
*info
;
48 switch (bfd_get_format (abfd
))
51 return elf_link_add_object_symbols (abfd
, info
);
53 return elf_link_add_archive_symbols (abfd
, info
);
55 bfd_set_error (bfd_error_wrong_format
);
61 /* Add symbols from an ELF archive file to the linker hash table. We
62 don't use _bfd_generic_link_add_archive_symbols because of a
63 problem which arises on UnixWare. The UnixWare libc.so is an
64 archive which includes an entry libc.so.1 which defines a bunch of
65 symbols. The libc.so archive also includes a number of other
66 object files, which also define symbols, some of which are the same
67 as those defined in libc.so.1. Correct linking requires that we
68 consider each object file in turn, and include it if it defines any
69 symbols we need. _bfd_generic_link_add_archive_symbols does not do
70 this; it looks through the list of undefined symbols, and includes
71 any object file which defines them. When this algorithm is used on
72 UnixWare, it winds up pulling in libc.so.1 early and defining a
73 bunch of symbols. This means that some of the other objects in the
74 archive are not included in the link, which is incorrect since they
75 precede libc.so.1 in the archive.
77 Fortunately, ELF archive handling is simpler than that done by
78 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
79 oddities. In ELF, if we find a symbol in the archive map, and the
80 symbol is currently undefined, we know that we must pull in that
83 Unfortunately, we do have to make multiple passes over the symbol
84 table until nothing further is resolved. */
87 elf_link_add_archive_symbols (abfd
, info
)
89 struct bfd_link_info
*info
;
92 boolean
*defined
= NULL
;
93 boolean
*included
= NULL
;
97 if (! bfd_has_map (abfd
))
99 /* An empty archive is a special case. */
100 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
102 bfd_set_error (bfd_error_no_armap
);
106 /* Keep track of all symbols we know to be already defined, and all
107 files we know to be already included. This is to speed up the
108 second and subsequent passes. */
109 c
= bfd_ardata (abfd
)->symdef_count
;
112 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
113 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
114 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
116 memset (defined
, 0, c
* sizeof (boolean
));
117 memset (included
, 0, c
* sizeof (boolean
));
119 symdefs
= bfd_ardata (abfd
)->symdefs
;
132 symdefend
= symdef
+ c
;
133 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
135 struct elf_link_hash_entry
*h
;
137 struct bfd_link_hash_entry
*undefs_tail
;
140 if (defined
[i
] || included
[i
])
142 if (symdef
->file_offset
== last
)
148 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
149 false, false, false);
150 if (h
== (struct elf_link_hash_entry
*) NULL
)
152 if (h
->root
.type
!= bfd_link_hash_undefined
)
154 if (h
->root
.type
!= bfd_link_hash_undefweak
)
159 /* We need to include this archive member. */
161 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
162 if (element
== (bfd
*) NULL
)
165 if (! bfd_check_format (element
, bfd_object
))
168 /* Doublecheck that we have not included this object
169 already--it should be impossible, but there may be
170 something wrong with the archive. */
171 if (element
->archive_pass
!= 0)
173 bfd_set_error (bfd_error_bad_value
);
176 element
->archive_pass
= 1;
178 undefs_tail
= info
->hash
->undefs_tail
;
180 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
183 if (! elf_link_add_object_symbols (element
, info
))
186 /* If there are any new undefined symbols, we need to make
187 another pass through the archive in order to see whether
188 they can be defined. FIXME: This isn't perfect, because
189 common symbols wind up on undefs_tail and because an
190 undefined symbol which is defined later on in this pass
191 does not require another pass. This isn't a bug, but it
192 does make the code less efficient than it could be. */
193 if (undefs_tail
!= info
->hash
->undefs_tail
)
196 /* Look backward to mark all symbols from this object file
197 which we have already seen in this pass. */
201 included
[mark
] = true;
206 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
208 /* We mark subsequent symbols from this object file as we go
209 on through the loop. */
210 last
= symdef
->file_offset
;
221 if (defined
!= (boolean
*) NULL
)
223 if (included
!= (boolean
*) NULL
)
228 /* Add symbols from an ELF object file to the linker hash table. */
231 elf_link_add_object_symbols (abfd
, info
)
233 struct bfd_link_info
*info
;
235 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
236 const Elf_Internal_Sym
*,
237 const char **, flagword
*,
238 asection
**, bfd_vma
*));
239 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
240 asection
*, const Elf_Internal_Rela
*));
242 Elf_Internal_Shdr
*hdr
;
246 Elf_External_Sym
*buf
= NULL
;
247 struct elf_link_hash_entry
**sym_hash
;
249 Elf_External_Dyn
*dynbuf
= NULL
;
250 struct elf_link_hash_entry
*weaks
;
251 Elf_External_Sym
*esym
;
252 Elf_External_Sym
*esymend
;
254 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
255 collect
= get_elf_backend_data (abfd
)->collect
;
257 /* As a GNU extension, any input sections which are named
258 .gnu.warning.SYMBOL are treated as warning symbols for the given
259 symbol. This differs from .gnu.warning sections, which generate
260 warnings when they are included in an output file. */
265 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
269 name
= bfd_get_section_name (abfd
, s
);
270 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
275 sz
= bfd_section_size (abfd
, s
);
276 msg
= (char *) bfd_alloc (abfd
, sz
);
280 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
283 if (! (_bfd_generic_link_add_one_symbol
285 name
+ sizeof ".gnu.warning." - 1,
286 BSF_WARNING
, s
, (bfd_vma
) 0, msg
, false, collect
,
287 (struct bfd_link_hash_entry
**) NULL
)))
290 if (! info
->relocateable
)
292 /* Clobber the section size so that the warning does
293 not get copied into the output file. */
300 /* A stripped shared library might only have a dynamic symbol table,
301 not a regular symbol table. In that case we can still go ahead
302 and link using the dynamic symbol table. */
303 if (elf_onesymtab (abfd
) == 0
304 && elf_dynsymtab (abfd
) != 0)
306 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
307 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
310 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
311 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
313 /* The sh_info field of the symtab header tells us where the
314 external symbols start. We don't care about the local symbols at
316 if (elf_bad_symtab (abfd
))
318 extsymcount
= symcount
;
323 extsymcount
= symcount
- hdr
->sh_info
;
324 extsymoff
= hdr
->sh_info
;
327 buf
= ((Elf_External_Sym
*)
328 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
329 if (buf
== NULL
&& extsymcount
!= 0)
332 /* We store a pointer to the hash table entry for each external
334 sym_hash
= ((struct elf_link_hash_entry
**)
336 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
337 if (sym_hash
== NULL
)
339 elf_sym_hashes (abfd
) = sym_hash
;
341 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
345 /* If we are creating a shared library, create all the dynamic
346 sections immediately. We need to attach them to something,
347 so we attach them to this BFD, provided it is the right
348 format. FIXME: If there are no input BFD's of the same
349 format as the output, we can't make a shared library. */
351 && ! elf_hash_table (info
)->dynamic_sections_created
352 && abfd
->xvec
== info
->hash
->creator
)
354 if (! elf_link_create_dynamic_sections (abfd
, info
))
363 bfd_size_type oldsize
;
364 bfd_size_type strindex
;
368 /* You can't use -r against a dynamic object. Also, there's no
369 hope of using a dynamic object which does not exactly match
370 the format of the output file. */
371 if (info
->relocateable
372 || info
->hash
->creator
!= abfd
->xvec
)
374 bfd_set_error (bfd_error_invalid_operation
);
378 /* Find the name to use in a DT_NEEDED entry that refers to this
379 object. If the object has a DT_SONAME entry, we use it.
380 Otherwise, if the generic linker stuck something in
381 elf_dt_name, we use that. Otherwise, we just use the file
382 name. If the generic linker put a null string into
383 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
384 there is a DT_SONAME entry. */
386 name
= bfd_get_filename (abfd
);
387 if (elf_dt_name (abfd
) != NULL
)
389 name
= elf_dt_name (abfd
);
393 s
= bfd_get_section_by_name (abfd
, ".dynamic");
396 Elf_External_Dyn
*extdyn
;
397 Elf_External_Dyn
*extdynend
;
401 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
405 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
406 (file_ptr
) 0, s
->_raw_size
))
409 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
412 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
415 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
416 for (; extdyn
< extdynend
; extdyn
++)
418 Elf_Internal_Dyn dyn
;
420 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
421 if (dyn
.d_tag
== DT_SONAME
)
423 name
= bfd_elf_string_from_elf_section (abfd
, link
,
428 if (dyn
.d_tag
== DT_NEEDED
)
430 struct bfd_link_needed_list
*n
, **pn
;
433 n
= ((struct bfd_link_needed_list
*)
434 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
435 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
437 if (n
== NULL
|| fnm
== NULL
)
439 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
446 for (pn
= &elf_hash_table (info
)->needed
;
458 /* We do not want to include any of the sections in a dynamic
459 object in the output file. We hack by simply clobbering the
460 list of sections in the BFD. This could be handled more
461 cleanly by, say, a new section flag; the existing
462 SEC_NEVER_LOAD flag is not the one we want, because that one
463 still implies that the section takes up space in the output
465 abfd
->sections
= NULL
;
466 abfd
->section_count
= 0;
468 /* If this is the first dynamic object found in the link, create
469 the special sections required for dynamic linking. */
470 if (! elf_hash_table (info
)->dynamic_sections_created
)
472 if (! elf_link_create_dynamic_sections (abfd
, info
))
478 /* Add a DT_NEEDED entry for this dynamic object. */
479 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
480 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
482 if (strindex
== (bfd_size_type
) -1)
485 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
488 Elf_External_Dyn
*dyncon
, *dynconend
;
490 /* The hash table size did not change, which means that
491 the dynamic object name was already entered. If we
492 have already included this dynamic object in the
493 link, just ignore it. There is no reason to include
494 a particular dynamic object more than once. */
495 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
497 BFD_ASSERT (sdyn
!= NULL
);
499 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
500 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
502 for (; dyncon
< dynconend
; dyncon
++)
504 Elf_Internal_Dyn dyn
;
506 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
508 if (dyn
.d_tag
== DT_NEEDED
509 && dyn
.d_un
.d_val
== strindex
)
518 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
522 /* Save the SONAME, if there is one, because sometimes the
523 linker emulation code will need to know it. */
525 name
= bfd_get_filename (abfd
);
526 elf_dt_name (abfd
) = name
;
530 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
532 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
533 != extsymcount
* sizeof (Elf_External_Sym
)))
538 esymend
= buf
+ extsymcount
;
539 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
541 Elf_Internal_Sym sym
;
547 struct elf_link_hash_entry
*h
;
549 boolean size_change_ok
, type_change_ok
;
552 elf_swap_symbol_in (abfd
, esym
, &sym
);
554 flags
= BSF_NO_FLAGS
;
556 value
= sym
.st_value
;
559 bind
= ELF_ST_BIND (sym
.st_info
);
560 if (bind
== STB_LOCAL
)
562 /* This should be impossible, since ELF requires that all
563 global symbols follow all local symbols, and that sh_info
564 point to the first global symbol. Unfortunatealy, Irix 5
568 else if (bind
== STB_GLOBAL
)
570 if (sym
.st_shndx
!= SHN_UNDEF
571 && sym
.st_shndx
!= SHN_COMMON
)
576 else if (bind
== STB_WEAK
)
580 /* Leave it up to the processor backend. */
583 if (sym
.st_shndx
== SHN_UNDEF
)
584 sec
= bfd_und_section_ptr
;
585 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
587 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
591 sec
= bfd_abs_section_ptr
;
593 else if (sym
.st_shndx
== SHN_ABS
)
594 sec
= bfd_abs_section_ptr
;
595 else if (sym
.st_shndx
== SHN_COMMON
)
597 sec
= bfd_com_section_ptr
;
598 /* What ELF calls the size we call the value. What ELF
599 calls the value we call the alignment. */
604 /* Leave it up to the processor backend. */
607 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
608 if (name
== (const char *) NULL
)
613 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
617 /* The hook function sets the name to NULL if this symbol
618 should be skipped for some reason. */
619 if (name
== (const char *) NULL
)
623 /* Sanity check that all possibilities were handled. */
624 if (sec
== (asection
*) NULL
)
626 bfd_set_error (bfd_error_bad_value
);
630 if (bfd_is_und_section (sec
)
631 || bfd_is_com_section (sec
))
636 size_change_ok
= false;
637 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
638 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
640 /* We need to look up the symbol now in order to get some of
641 the dynamic object handling right. We pass the hash
642 table entry in to _bfd_generic_link_add_one_symbol so
643 that it does not have to look it up again. */
644 if (! bfd_is_und_section (sec
))
645 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
648 h
= ((struct elf_link_hash_entry
*)
649 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true,
655 if (h
->root
.type
== bfd_link_hash_new
)
656 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
658 while (h
->root
.type
== bfd_link_hash_indirect
659 || h
->root
.type
== bfd_link_hash_warning
)
660 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
662 /* It's OK to change the type if it used to be a weak
664 if (h
->root
.type
== bfd_link_hash_defweak
665 || h
->root
.type
== bfd_link_hash_undefweak
)
666 type_change_ok
= true;
668 /* It's OK to change the size if it used to be a weak
669 definition, or if it used to be undefined, or if we will
670 be overriding an old definition. */
672 || h
->root
.type
== bfd_link_hash_undefined
)
673 size_change_ok
= true;
675 /* If we are looking at a dynamic object, and this is a
676 definition, we need to see if it has already been defined
677 by some other object. If it has, we want to use the
678 existing definition, and we do not want to report a
679 multiple symbol definition error; we do this by
680 clobbering sec to be bfd_und_section_ptr. We treat a
681 common symbol as a definition if the symbol in the shared
682 library is a function, since common symbols always
683 represent variables; this can cause confusion in
684 principle, but any such confusion would seem to indicate
685 an erroneous program or shared library. */
686 if (dynamic
&& definition
)
688 if (h
->root
.type
== bfd_link_hash_defined
689 || h
->root
.type
== bfd_link_hash_defweak
690 || (h
->root
.type
== bfd_link_hash_common
692 || ELF_ST_TYPE (sym
.st_info
) == STT_FUNC
)))
694 sec
= bfd_und_section_ptr
;
696 size_change_ok
= true;
697 if (h
->root
.type
== bfd_link_hash_common
)
698 type_change_ok
= true;
702 /* Similarly, if we are not looking at a dynamic object, and
703 we have a definition, we want to override any definition
704 we may have from a dynamic object. Symbols from regular
705 files always take precedence over symbols from dynamic
706 objects, even if they are defined after the dynamic
707 object in the link. */
710 || (bfd_is_com_section (sec
)
711 && (h
->root
.type
== bfd_link_hash_defweak
712 || h
->type
== STT_FUNC
)))
713 && (h
->root
.type
== bfd_link_hash_defined
714 || h
->root
.type
== bfd_link_hash_defweak
)
715 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
716 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
717 == bfd_target_elf_flavour
)
718 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
721 /* Change the hash table entry to undefined, and let
722 _bfd_generic_link_add_one_symbol do the right thing
723 with the new definition. */
724 h
->root
.type
= bfd_link_hash_undefined
;
725 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
726 size_change_ok
= true;
727 if (bfd_is_com_section (sec
))
728 type_change_ok
= true;
732 if (! (_bfd_generic_link_add_one_symbol
733 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
734 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
738 while (h
->root
.type
== bfd_link_hash_indirect
739 || h
->root
.type
== bfd_link_hash_warning
)
740 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
746 && (flags
& BSF_WEAK
) != 0
747 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
748 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
749 && h
->weakdef
== NULL
)
751 /* Keep a list of all weak defined non function symbols from
752 a dynamic object, using the weakdef field. Later in this
753 function we will set the weakdef field to the correct
754 value. We only put non-function symbols from dynamic
755 objects on this list, because that happens to be the only
756 time we need to know the normal symbol corresponding to a
757 weak symbol, and the information is time consuming to
758 figure out. If the weakdef field is not already NULL,
759 then this symbol was already defined by some previous
760 dynamic object, and we will be using that previous
761 definition anyhow. */
768 /* Get the alignment of a common symbol. */
769 if (sym
.st_shndx
== SHN_COMMON
770 && h
->root
.type
== bfd_link_hash_common
)
771 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
773 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
779 /* Remember the symbol size and type. */
781 && (definition
|| h
->size
== 0))
783 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
784 (*_bfd_error_handler
)
785 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
786 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
787 bfd_get_filename (abfd
));
789 h
->size
= sym
.st_size
;
791 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
792 && (definition
|| h
->type
== STT_NOTYPE
))
794 if (h
->type
!= STT_NOTYPE
795 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
797 (*_bfd_error_handler
)
798 ("Warning: type of symbol `%s' changed from %d to %d in %s",
799 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
800 bfd_get_filename (abfd
));
802 h
->type
= ELF_ST_TYPE (sym
.st_info
);
805 if (sym
.st_other
!= 0
806 && (definition
|| h
->other
== 0))
807 h
->other
= sym
.st_other
;
809 /* Set a flag in the hash table entry indicating the type of
810 reference or definition we just found. Keep a count of
811 the number of dynamic symbols we find. A dynamic symbol
812 is one which is referenced or defined by both a regular
813 object and a shared object. */
814 old_flags
= h
->elf_link_hash_flags
;
819 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
821 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
823 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
824 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
830 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
832 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
833 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
834 | ELF_LINK_HASH_REF_REGULAR
)) != 0
835 || (h
->weakdef
!= NULL
837 && h
->weakdef
->dynindx
!= -1))
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
))
914 /* If the real definition is in the list of dynamic
915 symbols, make sure the weak definition is put there
916 as well. If we don't do this, then the dynamic
917 loader might not merge the entries for the real
918 definition and the weak definition. */
920 && hlook
->dynindx
== -1)
922 if (! _bfd_elf_link_record_dynamic_symbol (info
, hlook
))
937 /* If this object is the same format as the output object, and it is
938 not a shared library, then let the backend look through the
941 This is required to build global offset table entries and to
942 arrange for dynamic relocs. It is not required for the
943 particular common case of linking non PIC code, even when linking
944 against shared libraries, but unfortunately there is no way of
945 knowing whether an object file has been compiled PIC or not.
946 Looking through the relocs is not particularly time consuming.
947 The problem is that we must either (1) keep the relocs in memory,
948 which causes the linker to require additional runtime memory or
949 (2) read the relocs twice from the input file, which wastes time.
950 This would be a good case for using mmap.
952 I have no idea how to handle linking PIC code into a file of a
953 different format. It probably can't be done. */
954 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
956 && abfd
->xvec
== info
->hash
->creator
957 && check_relocs
!= NULL
)
961 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
963 Elf_Internal_Rela
*internal_relocs
;
966 if ((o
->flags
& SEC_RELOC
) == 0
967 || o
->reloc_count
== 0)
970 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
971 (abfd
, o
, (PTR
) NULL
,
972 (Elf_Internal_Rela
*) NULL
,
974 if (internal_relocs
== NULL
)
977 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
979 if (! info
->keep_memory
)
980 free (internal_relocs
);
987 /* If this is a non-traditional, non-relocateable link, try to
988 optimize the handling of the .stab/.stabstr sections. */
990 && ! info
->relocateable
991 && ! info
->traditional_format
992 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
993 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
995 asection
*stab
, *stabstr
;
997 stab
= bfd_get_section_by_name (abfd
, ".stab");
1000 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
1002 if (stabstr
!= NULL
)
1004 struct bfd_elf_section_data
*secdata
;
1006 secdata
= elf_section_data (stab
);
1007 if (! _bfd_link_section_stabs (abfd
,
1008 &elf_hash_table (info
)->stab_info
,
1010 &secdata
->stab_info
))
1026 /* Create some sections which will be filled in with dynamic linking
1027 information. ABFD is an input file which requires dynamic sections
1028 to be created. The dynamic sections take up virtual memory space
1029 when the final executable is run, so we need to create them before
1030 addresses are assigned to the output sections. We work out the
1031 actual contents and size of these sections later. */
1034 elf_link_create_dynamic_sections (abfd
, info
)
1036 struct bfd_link_info
*info
;
1039 register asection
*s
;
1040 struct elf_link_hash_entry
*h
;
1041 struct elf_backend_data
*bed
;
1043 if (elf_hash_table (info
)->dynamic_sections_created
)
1046 /* Make sure that all dynamic sections use the same input BFD. */
1047 if (elf_hash_table (info
)->dynobj
== NULL
)
1048 elf_hash_table (info
)->dynobj
= abfd
;
1050 abfd
= elf_hash_table (info
)->dynobj
;
1052 /* Note that we set the SEC_IN_MEMORY flag for all of these
1054 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1055 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1057 /* A dynamically linked executable has a .interp section, but a
1058 shared library does not. */
1061 s
= bfd_make_section (abfd
, ".interp");
1063 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1067 s
= bfd_make_section (abfd
, ".dynsym");
1069 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1070 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1073 s
= bfd_make_section (abfd
, ".dynstr");
1075 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1078 /* Create a strtab to hold the dynamic symbol names. */
1079 if (elf_hash_table (info
)->dynstr
== NULL
)
1081 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1082 if (elf_hash_table (info
)->dynstr
== NULL
)
1086 s
= bfd_make_section (abfd
, ".dynamic");
1088 || ! bfd_set_section_flags (abfd
, s
, flags
)
1089 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1092 /* The special symbol _DYNAMIC is always set to the start of the
1093 .dynamic section. This call occurs before we have processed the
1094 symbols for any dynamic object, so we don't have to worry about
1095 overriding a dynamic definition. We could set _DYNAMIC in a
1096 linker script, but we only want to define it if we are, in fact,
1097 creating a .dynamic section. We don't want to define it if there
1098 is no .dynamic section, since on some ELF platforms the start up
1099 code examines it to decide how to initialize the process. */
1101 if (! (_bfd_generic_link_add_one_symbol
1102 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1103 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1104 (struct bfd_link_hash_entry
**) &h
)))
1106 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1107 h
->type
= STT_OBJECT
;
1110 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1113 s
= bfd_make_section (abfd
, ".hash");
1115 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1116 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1119 /* Let the backend create the rest of the sections. This lets the
1120 backend set the right flags. The backend will normally create
1121 the .got and .plt sections. */
1122 bed
= get_elf_backend_data (abfd
);
1123 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1126 elf_hash_table (info
)->dynamic_sections_created
= true;
1131 /* Add an entry to the .dynamic table. */
1134 elf_add_dynamic_entry (info
, tag
, val
)
1135 struct bfd_link_info
*info
;
1139 Elf_Internal_Dyn dyn
;
1143 bfd_byte
*newcontents
;
1145 dynobj
= elf_hash_table (info
)->dynobj
;
1147 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1148 BFD_ASSERT (s
!= NULL
);
1150 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1151 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1152 if (newcontents
== NULL
)
1156 dyn
.d_un
.d_val
= val
;
1157 elf_swap_dyn_out (dynobj
, &dyn
,
1158 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1160 s
->_raw_size
= newsize
;
1161 s
->contents
= newcontents
;
1167 /* Read and swap the relocs for a section. They may have been cached.
1168 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1169 they are used as buffers to read into. They are known to be large
1170 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1171 value is allocated using either malloc or bfd_alloc, according to
1172 the KEEP_MEMORY argument. */
1175 NAME(_bfd_elf
,link_read_relocs
) (abfd
, o
, external_relocs
, internal_relocs
,
1179 PTR external_relocs
;
1180 Elf_Internal_Rela
*internal_relocs
;
1181 boolean keep_memory
;
1183 Elf_Internal_Shdr
*rel_hdr
;
1185 Elf_Internal_Rela
*alloc2
= NULL
;
1187 if (elf_section_data (o
)->relocs
!= NULL
)
1188 return elf_section_data (o
)->relocs
;
1190 if (o
->reloc_count
== 0)
1193 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1195 if (internal_relocs
== NULL
)
1199 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1201 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1203 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1204 if (internal_relocs
== NULL
)
1208 if (external_relocs
== NULL
)
1210 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1213 external_relocs
= alloc1
;
1216 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1217 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1218 != rel_hdr
->sh_size
))
1221 /* Swap in the relocs. For convenience, we always produce an
1222 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1224 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1226 Elf_External_Rel
*erel
;
1227 Elf_External_Rel
*erelend
;
1228 Elf_Internal_Rela
*irela
;
1230 erel
= (Elf_External_Rel
*) external_relocs
;
1231 erelend
= erel
+ o
->reloc_count
;
1232 irela
= internal_relocs
;
1233 for (; erel
< erelend
; erel
++, irela
++)
1235 Elf_Internal_Rel irel
;
1237 elf_swap_reloc_in (abfd
, erel
, &irel
);
1238 irela
->r_offset
= irel
.r_offset
;
1239 irela
->r_info
= irel
.r_info
;
1240 irela
->r_addend
= 0;
1245 Elf_External_Rela
*erela
;
1246 Elf_External_Rela
*erelaend
;
1247 Elf_Internal_Rela
*irela
;
1249 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1251 erela
= (Elf_External_Rela
*) external_relocs
;
1252 erelaend
= erela
+ o
->reloc_count
;
1253 irela
= internal_relocs
;
1254 for (; erela
< erelaend
; erela
++, irela
++)
1255 elf_swap_reloca_in (abfd
, erela
, irela
);
1258 /* Cache the results for next time, if we can. */
1260 elf_section_data (o
)->relocs
= internal_relocs
;
1265 /* Don't free alloc2, since if it was allocated we are passing it
1266 back (under the name of internal_relocs). */
1268 return internal_relocs
;
1279 /* Record an assignment to a symbol made by a linker script. We need
1280 this in case some dynamic object refers to this symbol. */
1284 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1286 struct bfd_link_info
*info
;
1290 struct elf_link_hash_entry
*h
;
1292 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1295 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1299 if (h
->root
.type
== bfd_link_hash_new
)
1300 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
1302 /* If this symbol is being provided by the linker script, and it is
1303 currently defined by a dynamic object, but not by a regular
1304 object, then mark it as undefined so that the generic linker will
1305 force the correct value. */
1307 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1308 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1309 h
->root
.type
= bfd_link_hash_undefined
;
1311 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1312 h
->type
= STT_OBJECT
;
1314 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1315 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1317 && h
->dynindx
== -1)
1319 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1322 /* If this is a weak defined symbol, and we know a corresponding
1323 real symbol from the same dynamic object, make sure the real
1324 symbol is also made into a dynamic symbol. */
1325 if (h
->weakdef
!= NULL
1326 && h
->weakdef
->dynindx
== -1)
1328 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1337 /* Array used to determine the number of hash table buckets to use
1338 based on the number of symbols there are. If there are fewer than
1339 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1340 fewer than 37 we use 17 buckets, and so forth. We never use more
1341 than 32771 buckets. */
1343 static const size_t elf_buckets
[] =
1345 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
1349 /* Set up the sizes and contents of the ELF dynamic sections. This is
1350 called by the ELF linker emulation before_allocation routine. We
1351 must set the sizes of the sections before the linker sets the
1352 addresses of the various sections. */
1355 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1356 export_dynamic
, filter_shlib
,
1357 auxiliary_filters
, info
, sinterpptr
)
1361 boolean export_dynamic
;
1362 const char *filter_shlib
;
1363 const char * const *auxiliary_filters
;
1364 struct bfd_link_info
*info
;
1365 asection
**sinterpptr
;
1368 struct elf_backend_data
*bed
;
1372 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1375 /* The backend may have to create some sections regardless of whether
1376 we're dynamic or not. */
1377 bed
= get_elf_backend_data (output_bfd
);
1378 if (bed
->elf_backend_always_size_sections
1379 && ! (*bed
->elf_backend_always_size_sections
) (output_bfd
, info
))
1382 dynobj
= elf_hash_table (info
)->dynobj
;
1384 /* If there were no dynamic objects in the link, there is nothing to
1389 /* If we are supposed to export all symbols into the dynamic symbol
1390 table (this is not the normal case), then do so. */
1393 struct elf_info_failed eif
;
1397 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1403 if (elf_hash_table (info
)->dynamic_sections_created
)
1405 struct elf_info_failed eif
;
1406 struct elf_link_hash_entry
*h
;
1407 bfd_size_type strsize
;
1409 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1410 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1416 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1418 if (indx
== (bfd_size_type
) -1
1419 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1425 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1433 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1435 if (indx
== (bfd_size_type
) -1
1436 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1440 if (filter_shlib
!= NULL
)
1444 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
1445 filter_shlib
, true, true);
1446 if (indx
== (bfd_size_type
) -1
1447 || ! elf_add_dynamic_entry (info
, DT_FILTER
, indx
))
1451 if (auxiliary_filters
!= NULL
)
1453 const char * const *p
;
1455 for (p
= auxiliary_filters
; *p
!= NULL
; p
++)
1459 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
,
1461 if (indx
== (bfd_size_type
) -1
1462 || ! elf_add_dynamic_entry (info
, DT_AUXILIARY
, indx
))
1467 /* Find all symbols which were defined in a dynamic object and make
1468 the backend pick a reasonable value for them. */
1471 elf_link_hash_traverse (elf_hash_table (info
),
1472 elf_adjust_dynamic_symbol
,
1477 /* Add some entries to the .dynamic section. We fill in some of the
1478 values later, in elf_bfd_final_link, but we must add the entries
1479 now so that we know the final size of the .dynamic section. */
1480 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1483 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1484 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1486 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1489 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1492 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1493 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1495 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1498 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1499 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1500 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1501 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1502 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1503 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1504 sizeof (Elf_External_Sym
)))
1508 /* The backend must work out the sizes of all the other dynamic
1510 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1513 if (elf_hash_table (info
)->dynamic_sections_created
)
1518 size_t bucketcount
= 0;
1519 Elf_Internal_Sym isym
;
1521 /* Set the size of the .dynsym and .hash sections. We counted
1522 the number of dynamic symbols in elf_link_add_object_symbols.
1523 We will build the contents of .dynsym and .hash when we build
1524 the final symbol table, because until then we do not know the
1525 correct value to give the symbols. We built the .dynstr
1526 section as we went along in elf_link_add_object_symbols. */
1527 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1528 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1529 BFD_ASSERT (s
!= NULL
);
1530 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1531 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1532 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1535 /* The first entry in .dynsym is a dummy symbol. */
1542 elf_swap_symbol_out (output_bfd
, &isym
,
1543 (PTR
) (Elf_External_Sym
*) s
->contents
);
1545 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1547 bucketcount
= elf_buckets
[i
];
1548 if (dynsymcount
< elf_buckets
[i
+ 1])
1552 s
= bfd_get_section_by_name (dynobj
, ".hash");
1553 BFD_ASSERT (s
!= NULL
);
1554 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1555 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1556 if (s
->contents
== NULL
)
1558 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1560 put_word (output_bfd
, bucketcount
, s
->contents
);
1561 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1563 elf_hash_table (info
)->bucketcount
= bucketcount
;
1565 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1566 BFD_ASSERT (s
!= NULL
);
1567 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1569 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1577 /* This routine is used to export all defined symbols into the dynamic
1578 symbol table. It is called via elf_link_hash_traverse. */
1581 elf_export_symbol (h
, data
)
1582 struct elf_link_hash_entry
*h
;
1585 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1587 if (h
->dynindx
== -1
1588 && (h
->elf_link_hash_flags
1589 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1591 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1602 /* Make the backend pick a good value for a dynamic symbol. This is
1603 called via elf_link_hash_traverse, and also calls itself
1607 elf_adjust_dynamic_symbol (h
, data
)
1608 struct elf_link_hash_entry
*h
;
1611 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1613 struct elf_backend_data
*bed
;
1615 /* If this symbol was mentioned in a non-ELF file, try to set
1616 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1617 permit a non-ELF file to correctly refer to a symbol defined in
1618 an ELF dynamic object. */
1619 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
1621 if (h
->root
.type
!= bfd_link_hash_defined
1622 && h
->root
.type
!= bfd_link_hash_defweak
)
1623 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1626 if (h
->root
.u
.def
.section
->owner
!= NULL
1627 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
1628 == bfd_target_elf_flavour
))
1629 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1631 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1634 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1635 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1637 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1645 /* If this is a final link, and the symbol was defined as a common
1646 symbol in a regular object file, and there was no definition in
1647 any dynamic object, then the linker will have allocated space for
1648 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
1649 flag will not have been set. */
1650 if (h
->root
.type
== bfd_link_hash_defined
1651 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1652 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
1653 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1654 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
1655 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1657 /* If -Bsymbolic was used (which means to bind references to global
1658 symbols to the definition within the shared object), and this
1659 symbol was defined in a regular object, then it actually doesn't
1660 need a PLT entry. */
1661 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1662 && eif
->info
->shared
1663 && eif
->info
->symbolic
1664 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1665 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1667 /* If this symbol does not require a PLT entry, and it is not
1668 defined by a dynamic object, or is not referenced by a regular
1669 object, ignore it. We do have to handle a weak defined symbol,
1670 even if no regular object refers to it, if we decided to add it
1671 to the dynamic symbol table. FIXME: Do we normally need to worry
1672 about symbols which are defined by one dynamic object and
1673 referenced by another one? */
1674 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1675 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1676 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1677 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1678 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1681 /* If we've already adjusted this symbol, don't do it again. This
1682 can happen via a recursive call. */
1683 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1686 /* Don't look at this symbol again. Note that we must set this
1687 after checking the above conditions, because we may look at a
1688 symbol once, decide not to do anything, and then get called
1689 recursively later after REF_REGULAR is set below. */
1690 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1692 /* If this is a weak definition, and we know a real definition, and
1693 the real symbol is not itself defined by a regular object file,
1694 then get a good value for the real definition. We handle the
1695 real symbol first, for the convenience of the backend routine.
1697 Note that there is a confusing case here. If the real definition
1698 is defined by a regular object file, we don't get the real symbol
1699 from the dynamic object, but we do get the weak symbol. If the
1700 processor backend uses a COPY reloc, then if some routine in the
1701 dynamic object changes the real symbol, we will not see that
1702 change in the corresponding weak symbol. This is the way other
1703 ELF linkers work as well, and seems to be a result of the shared
1706 I will clarify this issue. Most SVR4 shared libraries define the
1707 variable _timezone and define timezone as a weak synonym. The
1708 tzset call changes _timezone. If you write
1709 extern int timezone;
1711 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1712 you might expect that, since timezone is a synonym for _timezone,
1713 the same number will print both times. However, if the processor
1714 backend uses a COPY reloc, then actually timezone will be copied
1715 into your process image, and, since you define _timezone
1716 yourself, _timezone will not. Thus timezone and _timezone will
1717 wind up at different memory locations. The tzset call will set
1718 _timezone, leaving timezone unchanged. */
1720 if (h
->weakdef
!= NULL
)
1722 struct elf_link_hash_entry
*weakdef
;
1724 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1725 || h
->root
.type
== bfd_link_hash_defweak
);
1726 weakdef
= h
->weakdef
;
1727 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1728 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1729 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1730 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1732 /* This symbol is defined by a regular object file, so we
1733 will not do anything special. Clear weakdef for the
1734 convenience of the processor backend. */
1739 /* There is an implicit reference by a regular object file
1740 via the weak symbol. */
1741 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1742 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1747 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1748 bed
= get_elf_backend_data (dynobj
);
1749 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1758 /* Final phase of ELF linker. */
1760 /* A structure we use to avoid passing large numbers of arguments. */
1762 struct elf_final_link_info
1764 /* General link information. */
1765 struct bfd_link_info
*info
;
1768 /* Symbol string table. */
1769 struct bfd_strtab_hash
*symstrtab
;
1770 /* .dynsym section. */
1771 asection
*dynsym_sec
;
1772 /* .hash section. */
1774 /* Buffer large enough to hold contents of any section. */
1776 /* Buffer large enough to hold external relocs of any section. */
1777 PTR external_relocs
;
1778 /* Buffer large enough to hold internal relocs of any section. */
1779 Elf_Internal_Rela
*internal_relocs
;
1780 /* Buffer large enough to hold external local symbols of any input
1782 Elf_External_Sym
*external_syms
;
1783 /* Buffer large enough to hold internal local symbols of any input
1785 Elf_Internal_Sym
*internal_syms
;
1786 /* Array large enough to hold a symbol index for each local symbol
1787 of any input BFD. */
1789 /* Array large enough to hold a section pointer for each local
1790 symbol of any input BFD. */
1791 asection
**sections
;
1792 /* Buffer to hold swapped out symbols. */
1793 Elf_External_Sym
*symbuf
;
1794 /* Number of swapped out symbols in buffer. */
1795 size_t symbuf_count
;
1796 /* Number of symbols which fit in symbuf. */
1800 static boolean elf_link_output_sym
1801 PARAMS ((struct elf_final_link_info
*, const char *,
1802 Elf_Internal_Sym
*, asection
*));
1803 static boolean elf_link_flush_output_syms
1804 PARAMS ((struct elf_final_link_info
*));
1805 static boolean elf_link_output_extsym
1806 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1807 static boolean elf_link_input_bfd
1808 PARAMS ((struct elf_final_link_info
*, bfd
*));
1809 static boolean elf_reloc_link_order
1810 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1811 struct bfd_link_order
*));
1813 /* This struct is used to pass information to routines called via
1814 elf_link_hash_traverse which must return failure. */
1816 struct elf_finfo_failed
1819 struct elf_final_link_info
*finfo
;
1822 /* Do the final step of an ELF link. */
1825 elf_bfd_final_link (abfd
, info
)
1827 struct bfd_link_info
*info
;
1831 struct elf_final_link_info finfo
;
1832 register asection
*o
;
1833 register struct bfd_link_order
*p
;
1835 size_t max_contents_size
;
1836 size_t max_external_reloc_size
;
1837 size_t max_internal_reloc_count
;
1838 size_t max_sym_count
;
1840 Elf_Internal_Sym elfsym
;
1842 Elf_Internal_Shdr
*symtab_hdr
;
1843 Elf_Internal_Shdr
*symstrtab_hdr
;
1844 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1845 struct elf_finfo_failed eif
;
1848 abfd
->flags
|= DYNAMIC
;
1850 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1851 dynobj
= elf_hash_table (info
)->dynobj
;
1854 finfo
.output_bfd
= abfd
;
1855 finfo
.symstrtab
= elf_stringtab_init ();
1856 if (finfo
.symstrtab
== NULL
)
1860 finfo
.dynsym_sec
= NULL
;
1861 finfo
.hash_sec
= NULL
;
1865 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1866 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1867 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1869 finfo
.contents
= NULL
;
1870 finfo
.external_relocs
= NULL
;
1871 finfo
.internal_relocs
= NULL
;
1872 finfo
.external_syms
= NULL
;
1873 finfo
.internal_syms
= NULL
;
1874 finfo
.indices
= NULL
;
1875 finfo
.sections
= NULL
;
1876 finfo
.symbuf
= NULL
;
1877 finfo
.symbuf_count
= 0;
1879 /* Count up the number of relocations we will output for each output
1880 section, so that we know the sizes of the reloc sections. We
1881 also figure out some maximum sizes. */
1882 max_contents_size
= 0;
1883 max_external_reloc_size
= 0;
1884 max_internal_reloc_count
= 0;
1886 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1890 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1892 if (p
->type
== bfd_section_reloc_link_order
1893 || p
->type
== bfd_symbol_reloc_link_order
)
1895 else if (p
->type
== bfd_indirect_link_order
)
1899 sec
= p
->u
.indirect
.section
;
1901 /* Mark all sections which are to be included in the
1902 link. This will normally be every section. We need
1903 to do this so that we can identify any sections which
1904 the linker has decided to not include. */
1905 sec
->linker_mark
= true;
1907 if (info
->relocateable
)
1908 o
->reloc_count
+= sec
->reloc_count
;
1910 if (sec
->_raw_size
> max_contents_size
)
1911 max_contents_size
= sec
->_raw_size
;
1912 if (sec
->_cooked_size
> max_contents_size
)
1913 max_contents_size
= sec
->_cooked_size
;
1915 /* We are interested in just local symbols, not all
1917 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1921 if (elf_bad_symtab (sec
->owner
))
1922 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1923 / sizeof (Elf_External_Sym
));
1925 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1927 if (sym_count
> max_sym_count
)
1928 max_sym_count
= sym_count
;
1930 if ((sec
->flags
& SEC_RELOC
) != 0)
1934 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1935 if (ext_size
> max_external_reloc_size
)
1936 max_external_reloc_size
= ext_size
;
1937 if (sec
->reloc_count
> max_internal_reloc_count
)
1938 max_internal_reloc_count
= sec
->reloc_count
;
1944 if (o
->reloc_count
> 0)
1945 o
->flags
|= SEC_RELOC
;
1948 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1949 set it (this is probably a bug) and if it is set
1950 assign_section_numbers will create a reloc section. */
1951 o
->flags
&=~ SEC_RELOC
;
1954 /* If the SEC_ALLOC flag is not set, force the section VMA to
1955 zero. This is done in elf_fake_sections as well, but forcing
1956 the VMA to 0 here will ensure that relocs against these
1957 sections are handled correctly. */
1958 if ((o
->flags
& SEC_ALLOC
) == 0
1959 && ! o
->user_set_vma
)
1963 /* Figure out the file positions for everything but the symbol table
1964 and the relocs. We set symcount to force assign_section_numbers
1965 to create a symbol table. */
1966 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1967 BFD_ASSERT (! abfd
->output_has_begun
);
1968 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1971 /* That created the reloc sections. Set their sizes, and assign
1972 them file positions, and allocate some buffers. */
1973 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1975 if ((o
->flags
& SEC_RELOC
) != 0)
1977 Elf_Internal_Shdr
*rel_hdr
;
1978 register struct elf_link_hash_entry
**p
, **pend
;
1980 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1982 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1984 /* The contents field must last into write_object_contents,
1985 so we allocate it with bfd_alloc rather than malloc. */
1986 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1987 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1990 p
= ((struct elf_link_hash_entry
**)
1991 bfd_malloc (o
->reloc_count
1992 * sizeof (struct elf_link_hash_entry
*)));
1993 if (p
== NULL
&& o
->reloc_count
!= 0)
1995 elf_section_data (o
)->rel_hashes
= p
;
1996 pend
= p
+ o
->reloc_count
;
1997 for (; p
< pend
; p
++)
2000 /* Use the reloc_count field as an index when outputting the
2006 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2008 /* We have now assigned file positions for all the sections except
2009 .symtab and .strtab. We start the .symtab section at the current
2010 file position, and write directly to it. We build the .strtab
2011 section in memory. */
2013 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2014 /* sh_name is set in prep_headers. */
2015 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2016 symtab_hdr
->sh_flags
= 0;
2017 symtab_hdr
->sh_addr
= 0;
2018 symtab_hdr
->sh_size
= 0;
2019 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2020 /* sh_link is set in assign_section_numbers. */
2021 /* sh_info is set below. */
2022 /* sh_offset is set just below. */
2023 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
2025 off
= elf_tdata (abfd
)->next_file_pos
;
2026 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
2028 /* Note that at this point elf_tdata (abfd)->next_file_pos is
2029 incorrect. We do not yet know the size of the .symtab section.
2030 We correct next_file_pos below, after we do know the size. */
2032 /* Allocate a buffer to hold swapped out symbols. This is to avoid
2033 continuously seeking to the right position in the file. */
2034 if (! info
->keep_memory
|| max_sym_count
< 20)
2035 finfo
.symbuf_size
= 20;
2037 finfo
.symbuf_size
= max_sym_count
;
2038 finfo
.symbuf
= ((Elf_External_Sym
*)
2039 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
2040 if (finfo
.symbuf
== NULL
)
2043 /* Start writing out the symbol table. The first symbol is always a
2045 if (info
->strip
!= strip_all
|| info
->relocateable
)
2047 elfsym
.st_value
= 0;
2050 elfsym
.st_other
= 0;
2051 elfsym
.st_shndx
= SHN_UNDEF
;
2052 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2053 &elfsym
, bfd_und_section_ptr
))
2058 /* Some standard ELF linkers do this, but we don't because it causes
2059 bootstrap comparison failures. */
2060 /* Output a file symbol for the output file as the second symbol.
2061 We output this even if we are discarding local symbols, although
2062 I'm not sure if this is correct. */
2063 elfsym
.st_value
= 0;
2065 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2066 elfsym
.st_other
= 0;
2067 elfsym
.st_shndx
= SHN_ABS
;
2068 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
2069 &elfsym
, bfd_abs_section_ptr
))
2073 /* Output a symbol for each section. We output these even if we are
2074 discarding local symbols, since they are used for relocs. These
2075 symbols have no names. We store the index of each one in the
2076 index field of the section, so that we can find it again when
2077 outputting relocs. */
2078 if (info
->strip
!= strip_all
|| info
->relocateable
)
2080 elfsym
.st_value
= 0;
2082 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2083 elfsym
.st_other
= 0;
2084 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2086 o
= section_from_elf_index (abfd
, i
);
2088 o
->target_index
= abfd
->symcount
;
2089 elfsym
.st_shndx
= i
;
2090 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2096 /* Allocate some memory to hold information read in from the input
2098 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
2099 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
2100 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
2101 bfd_malloc (max_internal_reloc_count
2102 * sizeof (Elf_Internal_Rela
)));
2103 finfo
.external_syms
= ((Elf_External_Sym
*)
2104 bfd_malloc (max_sym_count
2105 * sizeof (Elf_External_Sym
)));
2106 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
2107 bfd_malloc (max_sym_count
2108 * sizeof (Elf_Internal_Sym
)));
2109 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
2110 finfo
.sections
= ((asection
**)
2111 bfd_malloc (max_sym_count
* sizeof (asection
*)));
2112 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
2113 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
2114 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
2115 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
2116 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
2117 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
2118 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
2121 /* Since ELF permits relocations to be against local symbols, we
2122 must have the local symbols available when we do the relocations.
2123 Since we would rather only read the local symbols once, and we
2124 would rather not keep them in memory, we handle all the
2125 relocations for a single input file at the same time.
2127 Unfortunately, there is no way to know the total number of local
2128 symbols until we have seen all of them, and the local symbol
2129 indices precede the global symbol indices. This means that when
2130 we are generating relocateable output, and we see a reloc against
2131 a global symbol, we can not know the symbol index until we have
2132 finished examining all the local symbols to see which ones we are
2133 going to output. To deal with this, we keep the relocations in
2134 memory, and don't output them until the end of the link. This is
2135 an unfortunate waste of memory, but I don't see a good way around
2136 it. Fortunately, it only happens when performing a relocateable
2137 link, which is not the common case. FIXME: If keep_memory is set
2138 we could write the relocs out and then read them again; I don't
2139 know how bad the memory loss will be. */
2141 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
2142 sub
->output_has_begun
= false;
2143 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2145 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
2147 if (p
->type
== bfd_indirect_link_order
2148 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2149 == bfd_target_elf_flavour
))
2151 sub
= p
->u
.indirect
.section
->owner
;
2152 if (! sub
->output_has_begun
)
2154 if (! elf_link_input_bfd (&finfo
, sub
))
2156 sub
->output_has_begun
= true;
2159 else if (p
->type
== bfd_section_reloc_link_order
2160 || p
->type
== bfd_symbol_reloc_link_order
)
2162 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2167 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2173 /* That wrote out all the local symbols. Finish up the symbol table
2174 with the global symbols. */
2176 /* The sh_info field records the index of the first non local
2178 symtab_hdr
->sh_info
= abfd
->symcount
;
2180 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2182 /* We get the global symbols from the hash table. */
2185 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2190 /* Flush all symbols to the file. */
2191 if (! elf_link_flush_output_syms (&finfo
))
2194 /* Now we know the size of the symtab section. */
2195 off
+= symtab_hdr
->sh_size
;
2197 /* Finish up and write out the symbol string table (.strtab)
2199 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2200 /* sh_name was set in prep_headers. */
2201 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2202 symstrtab_hdr
->sh_flags
= 0;
2203 symstrtab_hdr
->sh_addr
= 0;
2204 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2205 symstrtab_hdr
->sh_entsize
= 0;
2206 symstrtab_hdr
->sh_link
= 0;
2207 symstrtab_hdr
->sh_info
= 0;
2208 /* sh_offset is set just below. */
2209 symstrtab_hdr
->sh_addralign
= 1;
2211 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2212 elf_tdata (abfd
)->next_file_pos
= off
;
2214 if (abfd
->symcount
> 0)
2216 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2217 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2221 /* Adjust the relocs to have the correct symbol indices. */
2222 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2224 struct elf_link_hash_entry
**rel_hash
;
2225 Elf_Internal_Shdr
*rel_hdr
;
2227 if ((o
->flags
& SEC_RELOC
) == 0)
2230 rel_hash
= elf_section_data (o
)->rel_hashes
;
2231 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2232 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2234 if (*rel_hash
== NULL
)
2237 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2239 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2241 Elf_External_Rel
*erel
;
2242 Elf_Internal_Rel irel
;
2244 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2245 elf_swap_reloc_in (abfd
, erel
, &irel
);
2246 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2247 ELF_R_TYPE (irel
.r_info
));
2248 elf_swap_reloc_out (abfd
, &irel
, erel
);
2252 Elf_External_Rela
*erela
;
2253 Elf_Internal_Rela irela
;
2255 BFD_ASSERT (rel_hdr
->sh_entsize
2256 == sizeof (Elf_External_Rela
));
2258 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2259 elf_swap_reloca_in (abfd
, erela
, &irela
);
2260 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2261 ELF_R_TYPE (irela
.r_info
));
2262 elf_swap_reloca_out (abfd
, &irela
, erela
);
2266 /* Set the reloc_count field to 0 to prevent write_relocs from
2267 trying to swap the relocs out itself. */
2271 /* If we are linking against a dynamic object, or generating a
2272 shared library, finish up the dynamic linking information. */
2275 Elf_External_Dyn
*dyncon
, *dynconend
;
2277 /* Fix up .dynamic entries. */
2278 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2279 BFD_ASSERT (o
!= NULL
);
2281 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2282 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2283 for (; dyncon
< dynconend
; dyncon
++)
2285 Elf_Internal_Dyn dyn
;
2289 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2296 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2297 magic _init and _fini symbols. This is pretty ugly,
2298 but we are compatible. */
2306 struct elf_link_hash_entry
*h
;
2308 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2309 false, false, true);
2311 && (h
->root
.type
== bfd_link_hash_defined
2312 || h
->root
.type
== bfd_link_hash_defweak
))
2314 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2315 o
= h
->root
.u
.def
.section
;
2316 if (o
->output_section
!= NULL
)
2317 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2318 + o
->output_offset
);
2321 /* The symbol is imported from another shared
2322 library and does not apply to this one. */
2326 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2340 o
= bfd_get_section_by_name (abfd
, name
);
2341 BFD_ASSERT (o
!= NULL
);
2342 dyn
.d_un
.d_ptr
= o
->vma
;
2343 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2350 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2355 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2357 Elf_Internal_Shdr
*hdr
;
2359 hdr
= elf_elfsections (abfd
)[i
];
2360 if (hdr
->sh_type
== type
2361 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2363 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2364 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2367 if (dyn
.d_un
.d_val
== 0
2368 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2369 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2373 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2379 /* If we have created any dynamic sections, then output them. */
2382 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2385 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2387 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2388 || o
->_raw_size
== 0)
2390 if ((o
->flags
& SEC_LINKER_CREATED
) == 0)
2392 /* At this point, we are only interested in sections
2393 created by elf_link_create_dynamic_sections. */
2396 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2398 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2400 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2401 o
->contents
, o
->output_offset
,
2409 /* The contents of the .dynstr section are actually in a
2411 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2412 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2413 || ! _bfd_stringtab_emit (abfd
,
2414 elf_hash_table (info
)->dynstr
))
2420 /* If we have optimized stabs strings, output them. */
2421 if (elf_hash_table (info
)->stab_info
!= NULL
)
2423 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
2427 if (finfo
.symstrtab
!= NULL
)
2428 _bfd_stringtab_free (finfo
.symstrtab
);
2429 if (finfo
.contents
!= NULL
)
2430 free (finfo
.contents
);
2431 if (finfo
.external_relocs
!= NULL
)
2432 free (finfo
.external_relocs
);
2433 if (finfo
.internal_relocs
!= NULL
)
2434 free (finfo
.internal_relocs
);
2435 if (finfo
.external_syms
!= NULL
)
2436 free (finfo
.external_syms
);
2437 if (finfo
.internal_syms
!= NULL
)
2438 free (finfo
.internal_syms
);
2439 if (finfo
.indices
!= NULL
)
2440 free (finfo
.indices
);
2441 if (finfo
.sections
!= NULL
)
2442 free (finfo
.sections
);
2443 if (finfo
.symbuf
!= NULL
)
2444 free (finfo
.symbuf
);
2445 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2447 if ((o
->flags
& SEC_RELOC
) != 0
2448 && elf_section_data (o
)->rel_hashes
!= NULL
)
2449 free (elf_section_data (o
)->rel_hashes
);
2452 elf_tdata (abfd
)->linker
= true;
2457 if (finfo
.symstrtab
!= NULL
)
2458 _bfd_stringtab_free (finfo
.symstrtab
);
2459 if (finfo
.contents
!= NULL
)
2460 free (finfo
.contents
);
2461 if (finfo
.external_relocs
!= NULL
)
2462 free (finfo
.external_relocs
);
2463 if (finfo
.internal_relocs
!= NULL
)
2464 free (finfo
.internal_relocs
);
2465 if (finfo
.external_syms
!= NULL
)
2466 free (finfo
.external_syms
);
2467 if (finfo
.internal_syms
!= NULL
)
2468 free (finfo
.internal_syms
);
2469 if (finfo
.indices
!= NULL
)
2470 free (finfo
.indices
);
2471 if (finfo
.sections
!= NULL
)
2472 free (finfo
.sections
);
2473 if (finfo
.symbuf
!= NULL
)
2474 free (finfo
.symbuf
);
2475 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2477 if ((o
->flags
& SEC_RELOC
) != 0
2478 && elf_section_data (o
)->rel_hashes
!= NULL
)
2479 free (elf_section_data (o
)->rel_hashes
);
2485 /* Add a symbol to the output symbol table. */
2488 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2489 struct elf_final_link_info
*finfo
;
2491 Elf_Internal_Sym
*elfsym
;
2492 asection
*input_sec
;
2494 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2495 struct bfd_link_info
*info
,
2500 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2501 elf_backend_link_output_symbol_hook
;
2502 if (output_symbol_hook
!= NULL
)
2504 if (! ((*output_symbol_hook
)
2505 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2509 if (name
== (const char *) NULL
|| *name
== '\0')
2510 elfsym
->st_name
= 0;
2513 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2516 if (elfsym
->st_name
== (unsigned long) -1)
2520 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2522 if (! elf_link_flush_output_syms (finfo
))
2526 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2527 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2528 ++finfo
->symbuf_count
;
2530 ++finfo
->output_bfd
->symcount
;
2535 /* Flush the output symbols to the file. */
2538 elf_link_flush_output_syms (finfo
)
2539 struct elf_final_link_info
*finfo
;
2541 if (finfo
->symbuf_count
> 0)
2543 Elf_Internal_Shdr
*symtab
;
2545 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2547 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2549 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2550 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2551 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2554 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2556 finfo
->symbuf_count
= 0;
2562 /* Add an external symbol to the symbol table. This is called from
2563 the hash table traversal routine. */
2566 elf_link_output_extsym (h
, data
)
2567 struct elf_link_hash_entry
*h
;
2570 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2571 struct elf_final_link_info
*finfo
= eif
->finfo
;
2573 Elf_Internal_Sym sym
;
2574 asection
*input_sec
;
2576 /* If we are not creating a shared library, and this symbol is
2577 referenced by a shared library but is not defined anywhere, then
2578 warn that it is undefined. If we do not do this, the runtime
2579 linker will complain that the symbol is undefined when the
2580 program is run. We don't have to worry about symbols that are
2581 referenced by regular files, because we will already have issued
2582 warnings for them. */
2583 if (! finfo
->info
->relocateable
2584 && ! finfo
->info
->shared
2585 && h
->root
.type
== bfd_link_hash_undefined
2586 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2587 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2589 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2590 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2591 (asection
*) NULL
, 0)))
2598 /* We don't want to output symbols that have never been mentioned by
2599 a regular file, or that we have been told to strip. However, if
2600 h->indx is set to -2, the symbol is used by a reloc and we must
2604 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2605 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2606 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2607 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2609 else if (finfo
->info
->strip
== strip_all
2610 || (finfo
->info
->strip
== strip_some
2611 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2612 h
->root
.root
.string
,
2613 false, false) == NULL
))
2618 /* If we're stripping it, and it's not a dynamic symbol, there's
2619 nothing else to do. */
2620 if (strip
&& h
->dynindx
== -1)
2624 sym
.st_size
= h
->size
;
2625 sym
.st_other
= h
->other
;
2626 if (h
->root
.type
== bfd_link_hash_undefweak
2627 || h
->root
.type
== bfd_link_hash_defweak
)
2628 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2630 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2632 switch (h
->root
.type
)
2635 case bfd_link_hash_new
:
2639 case bfd_link_hash_undefined
:
2640 input_sec
= bfd_und_section_ptr
;
2641 sym
.st_shndx
= SHN_UNDEF
;
2644 case bfd_link_hash_undefweak
:
2645 input_sec
= bfd_und_section_ptr
;
2646 sym
.st_shndx
= SHN_UNDEF
;
2649 case bfd_link_hash_defined
:
2650 case bfd_link_hash_defweak
:
2652 input_sec
= h
->root
.u
.def
.section
;
2653 if (input_sec
->output_section
!= NULL
)
2656 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2657 input_sec
->output_section
);
2658 if (sym
.st_shndx
== (unsigned short) -1)
2664 /* ELF symbols in relocateable files are section relative,
2665 but in nonrelocateable files they are virtual
2667 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2668 if (! finfo
->info
->relocateable
)
2669 sym
.st_value
+= input_sec
->output_section
->vma
;
2673 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2674 == bfd_target_elf_flavour
)
2675 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2676 sym
.st_shndx
= SHN_UNDEF
;
2677 input_sec
= bfd_und_section_ptr
;
2682 case bfd_link_hash_common
:
2683 input_sec
= bfd_com_section_ptr
;
2684 sym
.st_shndx
= SHN_COMMON
;
2685 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2688 case bfd_link_hash_indirect
:
2689 case bfd_link_hash_warning
:
2690 /* We can't represent these symbols in ELF. A warning symbol
2691 may have come from a .gnu.warning.SYMBOL section anyhow. We
2692 just put the target symbol in the hash table. If the target
2693 symbol does not really exist, don't do anything. */
2694 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2696 return (elf_link_output_extsym
2697 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2700 /* If this symbol should be put in the .dynsym section, then put it
2701 there now. We have already know the symbol index. We also fill
2702 in the entry in the .hash section. */
2703 if (h
->dynindx
!= -1
2704 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2706 struct elf_backend_data
*bed
;
2709 bfd_byte
*bucketpos
;
2712 sym
.st_name
= h
->dynstr_index
;
2714 /* Give the processor backend a chance to tweak the symbol
2715 value, and also to finish up anything that needs to be done
2717 bed
= get_elf_backend_data (finfo
->output_bfd
);
2718 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2719 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2725 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2726 (PTR
) (((Elf_External_Sym
*)
2727 finfo
->dynsym_sec
->contents
)
2730 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2731 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2733 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2734 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2735 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2736 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2737 put_word (finfo
->output_bfd
, chain
,
2738 ((bfd_byte
*) finfo
->hash_sec
->contents
2739 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2742 /* If we're stripping it, then it was just a dynamic symbol, and
2743 there's nothing else to do. */
2747 h
->indx
= finfo
->output_bfd
->symcount
;
2749 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2758 /* Link an input file into the linker output file. This function
2759 handles all the sections and relocations of the input file at once.
2760 This is so that we only have to read the local symbols once, and
2761 don't have to keep them in memory. */
2764 elf_link_input_bfd (finfo
, input_bfd
)
2765 struct elf_final_link_info
*finfo
;
2768 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2769 bfd
*, asection
*, bfd_byte
*,
2770 Elf_Internal_Rela
*,
2771 Elf_Internal_Sym
*, asection
**));
2773 Elf_Internal_Shdr
*symtab_hdr
;
2776 Elf_External_Sym
*external_syms
;
2777 Elf_External_Sym
*esym
;
2778 Elf_External_Sym
*esymend
;
2779 Elf_Internal_Sym
*isym
;
2781 asection
**ppsection
;
2784 output_bfd
= finfo
->output_bfd
;
2786 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2788 /* If this is a dynamic object, we don't want to do anything here:
2789 we don't want the local symbols, and we don't want the section
2791 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2794 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2795 if (elf_bad_symtab (input_bfd
))
2797 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2802 locsymcount
= symtab_hdr
->sh_info
;
2803 extsymoff
= symtab_hdr
->sh_info
;
2806 /* Read the local symbols. */
2807 if (symtab_hdr
->contents
!= NULL
)
2808 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
2809 else if (locsymcount
== 0)
2810 external_syms
= NULL
;
2813 external_syms
= finfo
->external_syms
;
2814 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2815 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
2816 locsymcount
, input_bfd
)
2817 != locsymcount
* sizeof (Elf_External_Sym
)))
2821 /* Swap in the local symbols and write out the ones which we know
2822 are going into the output file. */
2823 esym
= external_syms
;
2824 esymend
= esym
+ locsymcount
;
2825 isym
= finfo
->internal_syms
;
2826 pindex
= finfo
->indices
;
2827 ppsection
= finfo
->sections
;
2828 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2832 Elf_Internal_Sym osym
;
2834 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2837 if (elf_bad_symtab (input_bfd
))
2839 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2846 if (isym
->st_shndx
== SHN_UNDEF
)
2847 isec
= bfd_und_section_ptr
;
2848 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2849 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2850 else if (isym
->st_shndx
== SHN_ABS
)
2851 isec
= bfd_abs_section_ptr
;
2852 else if (isym
->st_shndx
== SHN_COMMON
)
2853 isec
= bfd_com_section_ptr
;
2862 /* Don't output the first, undefined, symbol. */
2863 if (esym
== external_syms
)
2866 /* If we are stripping all symbols, we don't want to output this
2868 if (finfo
->info
->strip
== strip_all
)
2871 /* We never output section symbols. Instead, we use the section
2872 symbol of the corresponding section in the output file. */
2873 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2876 /* If we are discarding all local symbols, we don't want to
2877 output this one. If we are generating a relocateable output
2878 file, then some of the local symbols may be required by
2879 relocs; we output them below as we discover that they are
2881 if (finfo
->info
->discard
== discard_all
)
2884 /* Get the name of the symbol. */
2885 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2890 /* See if we are discarding symbols with this name. */
2891 if ((finfo
->info
->strip
== strip_some
2892 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2894 || (finfo
->info
->discard
== discard_l
2895 && strncmp (name
, finfo
->info
->lprefix
,
2896 finfo
->info
->lprefix_len
) == 0))
2899 /* If we get here, we are going to output this symbol. */
2903 /* Adjust the section index for the output file. */
2904 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2905 isec
->output_section
);
2906 if (osym
.st_shndx
== (unsigned short) -1)
2909 *pindex
= output_bfd
->symcount
;
2911 /* ELF symbols in relocateable files are section relative, but
2912 in executable files they are virtual addresses. Note that
2913 this code assumes that all ELF sections have an associated
2914 BFD section with a reasonable value for output_offset; below
2915 we assume that they also have a reasonable value for
2916 output_section. Any special sections must be set up to meet
2917 these requirements. */
2918 osym
.st_value
+= isec
->output_offset
;
2919 if (! finfo
->info
->relocateable
)
2920 osym
.st_value
+= isec
->output_section
->vma
;
2922 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2926 /* Relocate the contents of each section. */
2927 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2931 if (! o
->linker_mark
)
2933 /* This section was omitted from the link. */
2937 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2938 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2941 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
2943 /* Section was created by elf_link_create_dynamic_sections
2948 /* Get the contents of the section. They have been cached by a
2949 relaxation routine. Note that o is a section in an input
2950 file, so the contents field will not have been set by any of
2951 the routines which work on output files. */
2952 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
2953 contents
= elf_section_data (o
)->this_hdr
.contents
;
2956 contents
= finfo
->contents
;
2957 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
2958 (file_ptr
) 0, o
->_raw_size
))
2962 if ((o
->flags
& SEC_RELOC
) != 0)
2964 Elf_Internal_Rela
*internal_relocs
;
2966 /* Get the swapped relocs. */
2967 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
2968 (input_bfd
, o
, finfo
->external_relocs
,
2969 finfo
->internal_relocs
, false));
2970 if (internal_relocs
== NULL
2971 && o
->reloc_count
> 0)
2974 /* Relocate the section by invoking a back end routine.
2976 The back end routine is responsible for adjusting the
2977 section contents as necessary, and (if using Rela relocs
2978 and generating a relocateable output file) adjusting the
2979 reloc addend as necessary.
2981 The back end routine does not have to worry about setting
2982 the reloc address or the reloc symbol index.
2984 The back end routine is given a pointer to the swapped in
2985 internal symbols, and can access the hash table entries
2986 for the external symbols via elf_sym_hashes (input_bfd).
2988 When generating relocateable output, the back end routine
2989 must handle STB_LOCAL/STT_SECTION symbols specially. The
2990 output symbol is going to be a section symbol
2991 corresponding to the output section, which will require
2992 the addend to be adjusted. */
2994 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2995 input_bfd
, o
, contents
,
2997 finfo
->internal_syms
,
3001 if (finfo
->info
->relocateable
)
3003 Elf_Internal_Rela
*irela
;
3004 Elf_Internal_Rela
*irelaend
;
3005 struct elf_link_hash_entry
**rel_hash
;
3006 Elf_Internal_Shdr
*input_rel_hdr
;
3007 Elf_Internal_Shdr
*output_rel_hdr
;
3009 /* Adjust the reloc addresses and symbol indices. */
3011 irela
= internal_relocs
;
3012 irelaend
= irela
+ o
->reloc_count
;
3013 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
3014 + o
->output_section
->reloc_count
);
3015 for (; irela
< irelaend
; irela
++, rel_hash
++)
3017 unsigned long r_symndx
;
3018 Elf_Internal_Sym
*isym
;
3021 irela
->r_offset
+= o
->output_offset
;
3023 r_symndx
= ELF_R_SYM (irela
->r_info
);
3028 if (r_symndx
>= locsymcount
3029 || (elf_bad_symtab (input_bfd
)
3030 && finfo
->sections
[r_symndx
] == NULL
))
3034 /* This is a reloc against a global symbol. We
3035 have not yet output all the local symbols, so
3036 we do not know the symbol index of any global
3037 symbol. We set the rel_hash entry for this
3038 reloc to point to the global hash table entry
3039 for this symbol. The symbol index is then
3040 set at the end of elf_bfd_final_link. */
3041 indx
= r_symndx
- extsymoff
;
3042 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
3044 /* Setting the index to -2 tells
3045 elf_link_output_extsym that this symbol is
3047 BFD_ASSERT ((*rel_hash
)->indx
< 0);
3048 (*rel_hash
)->indx
= -2;
3053 /* This is a reloc against a local symbol. */
3056 isym
= finfo
->internal_syms
+ r_symndx
;
3057 sec
= finfo
->sections
[r_symndx
];
3058 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
3060 /* I suppose the backend ought to fill in the
3061 section of any STT_SECTION symbol against a
3062 processor specific section. */
3063 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3065 else if (sec
== NULL
|| sec
->owner
== NULL
)
3067 bfd_set_error (bfd_error_bad_value
);
3072 r_symndx
= sec
->output_section
->target_index
;
3073 BFD_ASSERT (r_symndx
!= 0);
3078 if (finfo
->indices
[r_symndx
] == -1)
3084 if (finfo
->info
->strip
== strip_all
)
3086 /* You can't do ld -r -s. */
3087 bfd_set_error (bfd_error_invalid_operation
);
3091 /* This symbol was skipped earlier, but
3092 since it is needed by a reloc, we
3093 must output it now. */
3094 link
= symtab_hdr
->sh_link
;
3095 name
= bfd_elf_string_from_elf_section (input_bfd
,
3101 osec
= sec
->output_section
;
3103 _bfd_elf_section_from_bfd_section (output_bfd
,
3105 if (isym
->st_shndx
== (unsigned short) -1)
3108 isym
->st_value
+= sec
->output_offset
;
3109 if (! finfo
->info
->relocateable
)
3110 isym
->st_value
+= osec
->vma
;
3112 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
3114 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
3118 r_symndx
= finfo
->indices
[r_symndx
];
3121 irela
->r_info
= ELF_R_INFO (r_symndx
,
3122 ELF_R_TYPE (irela
->r_info
));
3125 /* Swap out the relocs. */
3126 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
3127 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
3128 BFD_ASSERT (output_rel_hdr
->sh_entsize
3129 == input_rel_hdr
->sh_entsize
);
3130 irela
= internal_relocs
;
3131 irelaend
= irela
+ o
->reloc_count
;
3132 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
3134 Elf_External_Rel
*erel
;
3136 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
3137 + o
->output_section
->reloc_count
);
3138 for (; irela
< irelaend
; irela
++, erel
++)
3140 Elf_Internal_Rel irel
;
3142 irel
.r_offset
= irela
->r_offset
;
3143 irel
.r_info
= irela
->r_info
;
3144 BFD_ASSERT (irela
->r_addend
== 0);
3145 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3150 Elf_External_Rela
*erela
;
3152 BFD_ASSERT (input_rel_hdr
->sh_entsize
3153 == sizeof (Elf_External_Rela
));
3154 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
3155 + o
->output_section
->reloc_count
);
3156 for (; irela
< irelaend
; irela
++, erela
++)
3157 elf_swap_reloca_out (output_bfd
, irela
, erela
);
3160 o
->output_section
->reloc_count
+= o
->reloc_count
;
3164 /* Write out the modified section contents. */
3165 if (elf_section_data (o
)->stab_info
== NULL
)
3167 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
3168 contents
, o
->output_offset
,
3169 (o
->_cooked_size
!= 0
3176 if (! _bfd_write_section_stabs (output_bfd
, o
,
3177 &elf_section_data (o
)->stab_info
,
3186 /* Generate a reloc when linking an ELF file. This is a reloc
3187 requested by the linker, and does come from any input file. This
3188 is used to build constructor and destructor tables when linking
3192 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
3194 struct bfd_link_info
*info
;
3195 asection
*output_section
;
3196 struct bfd_link_order
*link_order
;
3198 reloc_howto_type
*howto
;
3202 struct elf_link_hash_entry
**rel_hash_ptr
;
3203 Elf_Internal_Shdr
*rel_hdr
;
3205 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3208 bfd_set_error (bfd_error_bad_value
);
3212 addend
= link_order
->u
.reloc
.p
->addend
;
3214 /* Figure out the symbol index. */
3215 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3216 + output_section
->reloc_count
);
3217 if (link_order
->type
== bfd_section_reloc_link_order
)
3219 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3220 BFD_ASSERT (indx
!= 0);
3221 *rel_hash_ptr
= NULL
;
3225 struct elf_link_hash_entry
*h
;
3227 /* Treat a reloc against a defined symbol as though it were
3228 actually against the section. */
3229 h
= ((struct elf_link_hash_entry
*)
3230 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3231 link_order
->u
.reloc
.p
->u
.name
,
3232 false, false, true));
3234 && (h
->root
.type
== bfd_link_hash_defined
3235 || h
->root
.type
== bfd_link_hash_defweak
))
3239 section
= h
->root
.u
.def
.section
;
3240 indx
= section
->output_section
->target_index
;
3241 *rel_hash_ptr
= NULL
;
3242 /* It seems that we ought to add the symbol value to the
3243 addend here, but in practice it has already been added
3244 because it was passed to constructor_callback. */
3245 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3249 /* Setting the index to -2 tells elf_link_output_extsym that
3250 this symbol is used by a reloc. */
3257 if (! ((*info
->callbacks
->unattached_reloc
)
3258 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3259 (asection
*) NULL
, (bfd_vma
) 0)))
3265 /* If this is an inplace reloc, we must write the addend into the
3267 if (howto
->partial_inplace
&& addend
!= 0)
3270 bfd_reloc_status_type rstat
;
3274 size
= bfd_get_reloc_size (howto
);
3275 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3276 if (buf
== (bfd_byte
*) NULL
)
3278 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3284 case bfd_reloc_outofrange
:
3286 case bfd_reloc_overflow
:
3287 if (! ((*info
->callbacks
->reloc_overflow
)
3289 (link_order
->type
== bfd_section_reloc_link_order
3290 ? bfd_section_name (output_bfd
,
3291 link_order
->u
.reloc
.p
->u
.section
)
3292 : link_order
->u
.reloc
.p
->u
.name
),
3293 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3301 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3302 (file_ptr
) link_order
->offset
, size
);
3308 /* The address of a reloc is relative to the section in a
3309 relocateable file, and is a virtual address in an executable
3311 offset
= link_order
->offset
;
3312 if (! info
->relocateable
)
3313 offset
+= output_section
->vma
;
3315 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3317 if (rel_hdr
->sh_type
== SHT_REL
)
3319 Elf_Internal_Rel irel
;
3320 Elf_External_Rel
*erel
;
3322 irel
.r_offset
= offset
;
3323 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3324 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3325 + output_section
->reloc_count
);
3326 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3330 Elf_Internal_Rela irela
;
3331 Elf_External_Rela
*erela
;
3333 irela
.r_offset
= offset
;
3334 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3335 irela
.r_addend
= addend
;
3336 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3337 + output_section
->reloc_count
);
3338 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3341 ++output_section
->reloc_count
;
3347 /* Allocate a pointer to live in a linker created section. */
3350 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3352 struct bfd_link_info
*info
;
3353 elf_linker_section_t
*lsect
;
3354 struct elf_link_hash_entry
*h
;
3355 const Elf_Internal_Rela
*rel
;
3357 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3358 elf_linker_section_pointers_t
*linker_section_ptr
;
3359 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3361 BFD_ASSERT (lsect
!= NULL
);
3363 /* Is this a global symbol? */
3366 /* Has this symbol already been allocated, if so, our work is done */
3367 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3372 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3373 /* Make sure this symbol is output as a dynamic symbol. */
3374 if (h
->dynindx
== -1)
3376 if (! elf_link_record_dynamic_symbol (info
, h
))
3380 if (lsect
->rel_section
)
3381 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3384 else /* Allocation of a pointer to a local symbol */
3386 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3388 /* Allocate a table to hold the local symbols if first time */
3391 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3392 register unsigned int i
;
3394 ptr
= (elf_linker_section_pointers_t
**)
3395 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3400 elf_local_ptr_offsets (abfd
) = ptr
;
3401 for (i
= 0; i
< num_symbols
; i
++)
3402 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3405 /* Has this symbol already been allocated, if so, our work is done */
3406 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3411 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3415 /* If we are generating a shared object, we need to
3416 output a R_<xxx>_RELATIVE reloc so that the
3417 dynamic linker can adjust this GOT entry. */
3418 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3419 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3423 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3424 from internal memory. */
3425 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3426 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3427 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3429 if (!linker_section_ptr
)
3432 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3433 linker_section_ptr
->addend
= rel
->r_addend
;
3434 linker_section_ptr
->which
= lsect
->which
;
3435 linker_section_ptr
->written_address_p
= false;
3436 *ptr_linker_section_ptr
= linker_section_ptr
;
3439 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3441 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
3442 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3443 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3444 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3446 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3448 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
3449 lsect
->sym_hash
->root
.root
.string
,
3450 (long)ARCH_SIZE
/ 8,
3451 (long)lsect
->sym_hash
->root
.u
.def
.value
);
3457 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3459 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3462 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3463 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3471 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3474 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3477 /* Fill in the address for a pointer generated in alinker section. */
3480 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3483 struct bfd_link_info
*info
;
3484 elf_linker_section_t
*lsect
;
3485 struct elf_link_hash_entry
*h
;
3487 const Elf_Internal_Rela
*rel
;
3490 elf_linker_section_pointers_t
*linker_section_ptr
;
3492 BFD_ASSERT (lsect
!= NULL
);
3494 if (h
!= NULL
) /* global symbol */
3496 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3500 BFD_ASSERT (linker_section_ptr
!= NULL
);
3502 if (! elf_hash_table (info
)->dynamic_sections_created
3505 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3507 /* This is actually a static link, or it is a
3508 -Bsymbolic link and the symbol is defined
3509 locally. We must initialize this entry in the
3512 When doing a dynamic link, we create a .rela.<xxx>
3513 relocation entry to initialize the value. This
3514 is done in the finish_dynamic_symbol routine. */
3515 if (!linker_section_ptr
->written_address_p
)
3517 linker_section_ptr
->written_address_p
= true;
3518 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3519 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3523 else /* local symbol */
3525 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3526 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3527 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3528 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3532 BFD_ASSERT (linker_section_ptr
!= NULL
);
3534 /* Write out pointer if it hasn't been rewritten out before */
3535 if (!linker_section_ptr
->written_address_p
)
3537 linker_section_ptr
->written_address_p
= true;
3538 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3539 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3543 asection
*srel
= lsect
->rel_section
;
3544 Elf_Internal_Rela outrel
;
3546 /* We need to generate a relative reloc for the dynamic linker. */
3548 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3551 BFD_ASSERT (srel
!= NULL
);
3553 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3554 + lsect
->section
->output_offset
3555 + linker_section_ptr
->offset
);
3556 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3557 outrel
.r_addend
= 0;
3558 elf_swap_reloca_out (output_bfd
, &outrel
,
3559 (((Elf_External_Rela
*)
3560 lsect
->section
->contents
)
3561 + lsect
->section
->reloc_count
));
3562 ++lsect
->section
->reloc_count
;
3567 relocation
= (lsect
->section
->output_offset
3568 + linker_section_ptr
->offset
3569 - lsect
->hole_offset
3570 - lsect
->sym_offset
);
3573 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3574 lsect
->name
, (long)relocation
, (long)relocation
);
3577 /* Subtract out the addend, because it will get added back in by the normal
3579 return relocation
- linker_section_ptr
->addend
;