2 Copyright 1995, 1996 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 static boolean elf_link_add_object_symbols
23 PARAMS ((bfd
*, struct bfd_link_info
*));
24 static boolean elf_link_add_archive_symbols
25 PARAMS ((bfd
*, struct bfd_link_info
*));
26 static 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 /* Set a flag in the hash table entry indicating the type of
806 reference or definition we just found. Keep a count of
807 the number of dynamic symbols we find. A dynamic symbol
808 is one which is referenced or defined by both a regular
809 object and a shared object, or one which is referenced or
810 defined by more than one shared object. */
811 old_flags
= h
->elf_link_hash_flags
;
816 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
818 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
820 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
821 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
827 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
829 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
830 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
831 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
835 h
->elf_link_hash_flags
|= new_flag
;
836 if (dynsym
&& h
->dynindx
== -1)
838 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
840 if (h
->weakdef
!= NULL
842 && h
->weakdef
->dynindx
== -1)
844 if (! _bfd_elf_link_record_dynamic_symbol (info
,
852 /* Now set the weakdefs field correctly for all the weak defined
853 symbols we found. The only way to do this is to search all the
854 symbols. Since we only need the information for non functions in
855 dynamic objects, that's the only time we actually put anything on
856 the list WEAKS. We need this information so that if a regular
857 object refers to a symbol defined weakly in a dynamic object, the
858 real symbol in the dynamic object is also put in the dynamic
859 symbols; we also must arrange for both symbols to point to the
860 same memory location. We could handle the general case of symbol
861 aliasing, but a general symbol alias can only be generated in
862 assembler code, handling it correctly would be very time
863 consuming, and other ELF linkers don't handle general aliasing
865 while (weaks
!= NULL
)
867 struct elf_link_hash_entry
*hlook
;
870 struct elf_link_hash_entry
**hpp
;
871 struct elf_link_hash_entry
**hppend
;
874 weaks
= hlook
->weakdef
;
875 hlook
->weakdef
= NULL
;
877 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
878 || hlook
->root
.type
== bfd_link_hash_defweak
879 || hlook
->root
.type
== bfd_link_hash_common
880 || hlook
->root
.type
== bfd_link_hash_indirect
);
881 slook
= hlook
->root
.u
.def
.section
;
882 vlook
= hlook
->root
.u
.def
.value
;
884 hpp
= elf_sym_hashes (abfd
);
885 hppend
= hpp
+ extsymcount
;
886 for (; hpp
< hppend
; hpp
++)
888 struct elf_link_hash_entry
*h
;
891 if (h
!= NULL
&& h
!= hlook
892 && h
->root
.type
== bfd_link_hash_defined
893 && h
->root
.u
.def
.section
== slook
894 && h
->root
.u
.def
.value
== vlook
)
898 /* If the weak definition is in the list of dynamic
899 symbols, make sure the real definition is put there
901 if (hlook
->dynindx
!= -1
904 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
919 /* If this object is the same format as the output object, and it is
920 not a shared library, then let the backend look through the
923 This is required to build global offset table entries and to
924 arrange for dynamic relocs. It is not required for the
925 particular common case of linking non PIC code, even when linking
926 against shared libraries, but unfortunately there is no way of
927 knowing whether an object file has been compiled PIC or not.
928 Looking through the relocs is not particularly time consuming.
929 The problem is that we must either (1) keep the relocs in memory,
930 which causes the linker to require additional runtime memory or
931 (2) read the relocs twice from the input file, which wastes time.
932 This would be a good case for using mmap.
934 I have no idea how to handle linking PIC code into a file of a
935 different format. It probably can't be done. */
936 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
938 && abfd
->xvec
== info
->hash
->creator
939 && check_relocs
!= NULL
)
943 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
945 Elf_Internal_Rela
*internal_relocs
;
948 if ((o
->flags
& SEC_RELOC
) == 0
949 || o
->reloc_count
== 0)
952 /* I believe we can ignore the relocs for any section which
953 does not form part of the final process image, such as a
954 debugging section. */
955 if ((o
->flags
& SEC_ALLOC
) == 0)
958 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
959 (abfd
, o
, (PTR
) NULL
,
960 (Elf_Internal_Rela
*) NULL
,
962 if (internal_relocs
== NULL
)
965 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
967 if (! info
->keep_memory
)
968 free (internal_relocs
);
975 /* If this is a non-traditional, non-relocateable link, try to
976 optimize the handling of the .stab/.stabstr sections. */
978 && ! info
->relocateable
979 && ! info
->traditional_format
980 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
981 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
983 asection
*stab
, *stabstr
;
985 stab
= bfd_get_section_by_name (abfd
, ".stab");
988 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
992 struct bfd_elf_section_data
*secdata
;
994 secdata
= elf_section_data (stab
);
995 if (! _bfd_link_section_stabs (abfd
,
996 &elf_hash_table (info
)->stab_info
,
998 &secdata
->stab_info
))
1014 /* Create some sections which will be filled in with dynamic linking
1015 information. ABFD is an input file which requires dynamic sections
1016 to be created. The dynamic sections take up virtual memory space
1017 when the final executable is run, so we need to create them before
1018 addresses are assigned to the output sections. We work out the
1019 actual contents and size of these sections later. */
1022 elf_link_create_dynamic_sections (abfd
, info
)
1024 struct bfd_link_info
*info
;
1027 register asection
*s
;
1028 struct elf_link_hash_entry
*h
;
1029 struct elf_backend_data
*bed
;
1031 if (elf_hash_table (info
)->dynamic_sections_created
)
1034 /* Make sure that all dynamic sections use the same input BFD. */
1035 if (elf_hash_table (info
)->dynobj
== NULL
)
1036 elf_hash_table (info
)->dynobj
= abfd
;
1038 abfd
= elf_hash_table (info
)->dynobj
;
1040 /* Note that we set the SEC_IN_MEMORY flag for all of these
1042 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1044 /* A dynamically linked executable has a .interp section, but a
1045 shared library does not. */
1048 s
= bfd_make_section (abfd
, ".interp");
1050 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1054 s
= bfd_make_section (abfd
, ".dynsym");
1056 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1057 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1060 s
= bfd_make_section (abfd
, ".dynstr");
1062 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1065 /* Create a strtab to hold the dynamic symbol names. */
1066 if (elf_hash_table (info
)->dynstr
== NULL
)
1068 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1069 if (elf_hash_table (info
)->dynstr
== NULL
)
1073 s
= bfd_make_section (abfd
, ".dynamic");
1075 || ! bfd_set_section_flags (abfd
, s
, flags
)
1076 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1079 /* The special symbol _DYNAMIC is always set to the start of the
1080 .dynamic section. This call occurs before we have processed the
1081 symbols for any dynamic object, so we don't have to worry about
1082 overriding a dynamic definition. We could set _DYNAMIC in a
1083 linker script, but we only want to define it if we are, in fact,
1084 creating a .dynamic section. We don't want to define it if there
1085 is no .dynamic section, since on some ELF platforms the start up
1086 code examines it to decide how to initialize the process. */
1088 if (! (_bfd_generic_link_add_one_symbol
1089 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1090 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1091 (struct bfd_link_hash_entry
**) &h
)))
1093 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1094 h
->type
= STT_OBJECT
;
1097 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1100 s
= bfd_make_section (abfd
, ".hash");
1102 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1103 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1106 /* Let the backend create the rest of the sections. This lets the
1107 backend set the right flags. The backend will normally create
1108 the .got and .plt sections. */
1109 bed
= get_elf_backend_data (abfd
);
1110 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1113 elf_hash_table (info
)->dynamic_sections_created
= true;
1118 /* Add an entry to the .dynamic table. */
1121 elf_add_dynamic_entry (info
, tag
, val
)
1122 struct bfd_link_info
*info
;
1126 Elf_Internal_Dyn dyn
;
1130 bfd_byte
*newcontents
;
1132 dynobj
= elf_hash_table (info
)->dynobj
;
1134 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1135 BFD_ASSERT (s
!= NULL
);
1137 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1138 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1139 if (newcontents
== NULL
)
1143 dyn
.d_un
.d_val
= val
;
1144 elf_swap_dyn_out (dynobj
, &dyn
,
1145 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1147 s
->_raw_size
= newsize
;
1148 s
->contents
= newcontents
;
1154 /* Read and swap the relocs for a section. They may have been cached.
1155 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1156 they are used as buffers to read into. They are known to be large
1157 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1158 value is allocated using either malloc or bfd_alloc, according to
1159 the KEEP_MEMORY argument. */
1162 NAME(_bfd_elf
,link_read_relocs
) (abfd
, o
, external_relocs
, internal_relocs
,
1166 PTR external_relocs
;
1167 Elf_Internal_Rela
*internal_relocs
;
1168 boolean keep_memory
;
1170 Elf_Internal_Shdr
*rel_hdr
;
1172 Elf_Internal_Rela
*alloc2
= NULL
;
1174 if (elf_section_data (o
)->relocs
!= NULL
)
1175 return elf_section_data (o
)->relocs
;
1177 if (o
->reloc_count
== 0)
1180 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1182 if (internal_relocs
== NULL
)
1186 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1188 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1190 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1191 if (internal_relocs
== NULL
)
1195 if (external_relocs
== NULL
)
1197 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1200 external_relocs
= alloc1
;
1203 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1204 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1205 != rel_hdr
->sh_size
))
1208 /* Swap in the relocs. For convenience, we always produce an
1209 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1211 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1213 Elf_External_Rel
*erel
;
1214 Elf_External_Rel
*erelend
;
1215 Elf_Internal_Rela
*irela
;
1217 erel
= (Elf_External_Rel
*) external_relocs
;
1218 erelend
= erel
+ o
->reloc_count
;
1219 irela
= internal_relocs
;
1220 for (; erel
< erelend
; erel
++, irela
++)
1222 Elf_Internal_Rel irel
;
1224 elf_swap_reloc_in (abfd
, erel
, &irel
);
1225 irela
->r_offset
= irel
.r_offset
;
1226 irela
->r_info
= irel
.r_info
;
1227 irela
->r_addend
= 0;
1232 Elf_External_Rela
*erela
;
1233 Elf_External_Rela
*erelaend
;
1234 Elf_Internal_Rela
*irela
;
1236 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1238 erela
= (Elf_External_Rela
*) external_relocs
;
1239 erelaend
= erela
+ o
->reloc_count
;
1240 irela
= internal_relocs
;
1241 for (; erela
< erelaend
; erela
++, irela
++)
1242 elf_swap_reloca_in (abfd
, erela
, irela
);
1245 /* Cache the results for next time, if we can. */
1247 elf_section_data (o
)->relocs
= internal_relocs
;
1252 /* Don't free alloc2, since if it was allocated we are passing it
1253 back (under the name of internal_relocs). */
1255 return internal_relocs
;
1266 /* Record an assignment to a symbol made by a linker script. We need
1267 this in case some dynamic object refers to this symbol. */
1271 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1273 struct bfd_link_info
*info
;
1277 struct elf_link_hash_entry
*h
;
1279 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1282 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1286 if (h
->root
.type
== bfd_link_hash_new
)
1287 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
1289 /* If this symbol is being provided by the linker script, and it is
1290 currently defined by a dynamic object, but not by a regular
1291 object, then mark it as undefined so that the generic linker will
1292 force the correct value. */
1294 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1295 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1296 h
->root
.type
= bfd_link_hash_undefined
;
1298 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1299 h
->type
= STT_OBJECT
;
1301 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1302 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1304 && h
->dynindx
== -1)
1306 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1309 /* If this is a weak defined symbol, and we know a corresponding
1310 real symbol from the same dynamic object, make sure the real
1311 symbol is also made into a dynamic symbol. */
1312 if (h
->weakdef
!= NULL
1313 && h
->weakdef
->dynindx
== -1)
1315 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1324 /* Array used to determine the number of hash table buckets to use
1325 based on the number of symbols there are. If there are fewer than
1326 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1327 fewer than 37 we use 17 buckets, and so forth. We never use more
1328 than 521 buckets. */
1330 static const size_t elf_buckets
[] =
1332 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1335 /* Set up the sizes and contents of the ELF dynamic sections. This is
1336 called by the ELF linker emulation before_allocation routine. We
1337 must set the sizes of the sections before the linker sets the
1338 addresses of the various sections. */
1341 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1342 export_dynamic
, info
, sinterpptr
)
1346 boolean export_dynamic
;
1347 struct bfd_link_info
*info
;
1348 asection
**sinterpptr
;
1351 struct elf_backend_data
*bed
;
1355 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1358 dynobj
= elf_hash_table (info
)->dynobj
;
1360 /* If there were no dynamic objects in the link, there is nothing to
1365 /* If we are supposed to export all symbols into the dynamic symbol
1366 table (this is not the normal case), then do so. */
1369 struct elf_info_failed eif
;
1373 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1379 if (elf_hash_table (info
)->dynamic_sections_created
)
1381 struct elf_info_failed eif
;
1382 struct elf_link_hash_entry
*h
;
1383 bfd_size_type strsize
;
1385 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1386 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1392 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1394 if (indx
== (bfd_size_type
) -1
1395 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1401 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1409 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1411 if (indx
== (bfd_size_type
) -1
1412 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1416 /* Find all symbols which were defined in a dynamic object and make
1417 the backend pick a reasonable value for them. */
1420 elf_link_hash_traverse (elf_hash_table (info
),
1421 elf_adjust_dynamic_symbol
,
1426 /* Add some entries to the .dynamic section. We fill in some of the
1427 values later, in elf_bfd_final_link, but we must add the entries
1428 now so that we know the final size of the .dynamic section. */
1429 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1432 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1433 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1435 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1438 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1441 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1442 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1444 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1447 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1448 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1449 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1450 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1451 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1452 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1453 sizeof (Elf_External_Sym
)))
1457 /* The backend must work out the sizes of all the other dynamic
1459 bed
= get_elf_backend_data (output_bfd
);
1460 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1463 if (elf_hash_table (info
)->dynamic_sections_created
)
1468 size_t bucketcount
= 0;
1469 Elf_Internal_Sym isym
;
1471 /* Set the size of the .dynsym and .hash sections. We counted
1472 the number of dynamic symbols in elf_link_add_object_symbols.
1473 We will build the contents of .dynsym and .hash when we build
1474 the final symbol table, because until then we do not know the
1475 correct value to give the symbols. We built the .dynstr
1476 section as we went along in elf_link_add_object_symbols. */
1477 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1478 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1479 BFD_ASSERT (s
!= NULL
);
1480 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1481 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1482 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1485 /* The first entry in .dynsym is a dummy symbol. */
1492 elf_swap_symbol_out (output_bfd
, &isym
,
1493 (PTR
) (Elf_External_Sym
*) s
->contents
);
1495 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1497 bucketcount
= elf_buckets
[i
];
1498 if (dynsymcount
< elf_buckets
[i
+ 1])
1502 s
= bfd_get_section_by_name (dynobj
, ".hash");
1503 BFD_ASSERT (s
!= NULL
);
1504 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1505 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1506 if (s
->contents
== NULL
)
1508 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1510 put_word (output_bfd
, bucketcount
, s
->contents
);
1511 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1513 elf_hash_table (info
)->bucketcount
= bucketcount
;
1515 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1516 BFD_ASSERT (s
!= NULL
);
1517 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1519 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1527 /* This routine is used to export all defined symbols into the dynamic
1528 symbol table. It is called via elf_link_hash_traverse. */
1531 elf_export_symbol (h
, data
)
1532 struct elf_link_hash_entry
*h
;
1535 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1537 if (h
->dynindx
== -1
1538 && (h
->elf_link_hash_flags
1539 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1541 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1552 /* Make the backend pick a good value for a dynamic symbol. This is
1553 called via elf_link_hash_traverse, and also calls itself
1557 elf_adjust_dynamic_symbol (h
, data
)
1558 struct elf_link_hash_entry
*h
;
1561 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1563 struct elf_backend_data
*bed
;
1565 /* If this symbol was mentioned in a non-ELF file, try to set
1566 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1567 permit a non-ELF file to correctly refer to a symbol defined in
1568 an ELF dynamic object. */
1569 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
1571 if (h
->root
.type
!= bfd_link_hash_defined
1572 && h
->root
.type
!= bfd_link_hash_defweak
)
1573 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1576 if (h
->root
.u
.def
.section
->owner
!= NULL
1577 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
1578 == bfd_target_elf_flavour
))
1579 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1581 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1584 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1585 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1587 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1595 /* If this is a final link, and the symbol was defined as a common
1596 symbol in a regular object file, and there was no definition in
1597 any dynamic object, then the linker will have allocated space for
1598 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
1599 flag will not have been set. */
1600 if (h
->root
.type
== bfd_link_hash_defined
1601 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1602 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
1603 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1604 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
1605 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1607 /* If -Bsymbolic was used (which means to bind references to global
1608 symbols to the definition within the shared object), and this
1609 symbol was defined in a regular object, then it actually doesn't
1610 need a PLT entry. */
1611 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1612 && eif
->info
->shared
1613 && eif
->info
->symbolic
1614 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1615 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1617 /* If this symbol does not require a PLT entry, and it is not
1618 defined by a dynamic object, or is not referenced by a regular
1619 object, ignore it. We do have to handle a weak defined symbol,
1620 even if no regular object refers to it, if we decided to add it
1621 to the dynamic symbol table. FIXME: Do we normally need to worry
1622 about symbols which are defined by one dynamic object and
1623 referenced by another one? */
1624 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1625 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1626 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1627 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1628 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1631 /* If we've already adjusted this symbol, don't do it again. This
1632 can happen via a recursive call. */
1633 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1636 /* Don't look at this symbol again. Note that we must set this
1637 after checking the above conditions, because we may look at a
1638 symbol once, decide not to do anything, and then get called
1639 recursively later after REF_REGULAR is set below. */
1640 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1642 /* If this is a weak definition, and we know a real definition, and
1643 the real symbol is not itself defined by a regular object file,
1644 then get a good value for the real definition. We handle the
1645 real symbol first, for the convenience of the backend routine.
1647 Note that there is a confusing case here. If the real definition
1648 is defined by a regular object file, we don't get the real symbol
1649 from the dynamic object, but we do get the weak symbol. If the
1650 processor backend uses a COPY reloc, then if some routine in the
1651 dynamic object changes the real symbol, we will not see that
1652 change in the corresponding weak symbol. This is the way other
1653 ELF linkers work as well, and seems to be a result of the shared
1656 I will clarify this issue. Most SVR4 shared libraries define the
1657 variable _timezone and define timezone as a weak synonym. The
1658 tzset call changes _timezone. If you write
1659 extern int timezone;
1661 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1662 you might expect that, since timezone is a synonym for _timezone,
1663 the same number will print both times. However, if the processor
1664 backend uses a COPY reloc, then actually timezone will be copied
1665 into your process image, and, since you define _timezone
1666 yourself, _timezone will not. Thus timezone and _timezone will
1667 wind up at different memory locations. The tzset call will set
1668 _timezone, leaving timezone unchanged. */
1670 if (h
->weakdef
!= NULL
)
1672 struct elf_link_hash_entry
*weakdef
;
1674 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1675 || h
->root
.type
== bfd_link_hash_defweak
);
1676 weakdef
= h
->weakdef
;
1677 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1678 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1679 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1680 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1682 /* This symbol is defined by a regular object file, so we
1683 will not do anything special. Clear weakdef for the
1684 convenience of the processor backend. */
1689 /* There is an implicit reference by a regular object file
1690 via the weak symbol. */
1691 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1692 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1697 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1698 bed
= get_elf_backend_data (dynobj
);
1699 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1708 /* Final phase of ELF linker. */
1710 /* A structure we use to avoid passing large numbers of arguments. */
1712 struct elf_final_link_info
1714 /* General link information. */
1715 struct bfd_link_info
*info
;
1718 /* Symbol string table. */
1719 struct bfd_strtab_hash
*symstrtab
;
1720 /* .dynsym section. */
1721 asection
*dynsym_sec
;
1722 /* .hash section. */
1724 /* Buffer large enough to hold contents of any section. */
1726 /* Buffer large enough to hold external relocs of any section. */
1727 PTR external_relocs
;
1728 /* Buffer large enough to hold internal relocs of any section. */
1729 Elf_Internal_Rela
*internal_relocs
;
1730 /* Buffer large enough to hold external local symbols of any input
1732 Elf_External_Sym
*external_syms
;
1733 /* Buffer large enough to hold internal local symbols of any input
1735 Elf_Internal_Sym
*internal_syms
;
1736 /* Array large enough to hold a symbol index for each local symbol
1737 of any input BFD. */
1739 /* Array large enough to hold a section pointer for each local
1740 symbol of any input BFD. */
1741 asection
**sections
;
1742 /* Buffer to hold swapped out symbols. */
1743 Elf_External_Sym
*symbuf
;
1744 /* Number of swapped out symbols in buffer. */
1745 size_t symbuf_count
;
1746 /* Number of symbols which fit in symbuf. */
1750 static boolean elf_link_output_sym
1751 PARAMS ((struct elf_final_link_info
*, const char *,
1752 Elf_Internal_Sym
*, asection
*));
1753 static boolean elf_link_flush_output_syms
1754 PARAMS ((struct elf_final_link_info
*));
1755 static boolean elf_link_output_extsym
1756 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1757 static boolean elf_link_input_bfd
1758 PARAMS ((struct elf_final_link_info
*, bfd
*));
1759 static boolean elf_reloc_link_order
1760 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1761 struct bfd_link_order
*));
1763 /* This struct is used to pass information to routines called via
1764 elf_link_hash_traverse which must return failure. */
1766 struct elf_finfo_failed
1769 struct elf_final_link_info
*finfo
;
1772 /* Do the final step of an ELF link. */
1775 elf_bfd_final_link (abfd
, info
)
1777 struct bfd_link_info
*info
;
1781 struct elf_final_link_info finfo
;
1782 register asection
*o
;
1783 register struct bfd_link_order
*p
;
1785 size_t max_contents_size
;
1786 size_t max_external_reloc_size
;
1787 size_t max_internal_reloc_count
;
1788 size_t max_sym_count
;
1790 Elf_Internal_Sym elfsym
;
1792 Elf_Internal_Shdr
*symtab_hdr
;
1793 Elf_Internal_Shdr
*symstrtab_hdr
;
1794 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1795 struct elf_finfo_failed eif
;
1798 abfd
->flags
|= DYNAMIC
;
1800 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1801 dynobj
= elf_hash_table (info
)->dynobj
;
1804 finfo
.output_bfd
= abfd
;
1805 finfo
.symstrtab
= elf_stringtab_init ();
1806 if (finfo
.symstrtab
== NULL
)
1810 finfo
.dynsym_sec
= NULL
;
1811 finfo
.hash_sec
= NULL
;
1815 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1816 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1817 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1819 finfo
.contents
= NULL
;
1820 finfo
.external_relocs
= NULL
;
1821 finfo
.internal_relocs
= NULL
;
1822 finfo
.external_syms
= NULL
;
1823 finfo
.internal_syms
= NULL
;
1824 finfo
.indices
= NULL
;
1825 finfo
.sections
= NULL
;
1826 finfo
.symbuf
= NULL
;
1827 finfo
.symbuf_count
= 0;
1829 /* Count up the number of relocations we will output for each output
1830 section, so that we know the sizes of the reloc sections. We
1831 also figure out some maximum sizes. */
1832 max_contents_size
= 0;
1833 max_external_reloc_size
= 0;
1834 max_internal_reloc_count
= 0;
1836 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1840 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1842 if (p
->type
== bfd_section_reloc_link_order
1843 || p
->type
== bfd_symbol_reloc_link_order
)
1845 else if (p
->type
== bfd_indirect_link_order
)
1849 sec
= p
->u
.indirect
.section
;
1851 /* Mark all sections which are to be included in the
1852 link. This will normally be every section. We need
1853 to do this so that we can identify any sections which
1854 the linker has decided to not include. */
1855 sec
->linker_mark
= true;
1857 if (info
->relocateable
)
1858 o
->reloc_count
+= sec
->reloc_count
;
1860 if (sec
->_raw_size
> max_contents_size
)
1861 max_contents_size
= sec
->_raw_size
;
1862 if (sec
->_cooked_size
> max_contents_size
)
1863 max_contents_size
= sec
->_cooked_size
;
1865 /* We are interested in just local symbols, not all
1867 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1871 if (elf_bad_symtab (sec
->owner
))
1872 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1873 / sizeof (Elf_External_Sym
));
1875 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1877 if (sym_count
> max_sym_count
)
1878 max_sym_count
= sym_count
;
1880 if ((sec
->flags
& SEC_RELOC
) != 0)
1884 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1885 if (ext_size
> max_external_reloc_size
)
1886 max_external_reloc_size
= ext_size
;
1887 if (sec
->reloc_count
> max_internal_reloc_count
)
1888 max_internal_reloc_count
= sec
->reloc_count
;
1894 if (o
->reloc_count
> 0)
1895 o
->flags
|= SEC_RELOC
;
1898 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1899 set it (this is probably a bug) and if it is set
1900 assign_section_numbers will create a reloc section. */
1901 o
->flags
&=~ SEC_RELOC
;
1904 /* If the SEC_ALLOC flag is not set, force the section VMA to
1905 zero. This is done in elf_fake_sections as well, but forcing
1906 the VMA to 0 here will ensure that relocs against these
1907 sections are handled correctly. */
1908 if ((o
->flags
& SEC_ALLOC
) == 0
1909 && ! o
->user_set_vma
)
1913 /* Figure out the file positions for everything but the symbol table
1914 and the relocs. We set symcount to force assign_section_numbers
1915 to create a symbol table. */
1916 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1917 BFD_ASSERT (! abfd
->output_has_begun
);
1918 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1921 /* That created the reloc sections. Set their sizes, and assign
1922 them file positions, and allocate some buffers. */
1923 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1925 if ((o
->flags
& SEC_RELOC
) != 0)
1927 Elf_Internal_Shdr
*rel_hdr
;
1928 register struct elf_link_hash_entry
**p
, **pend
;
1930 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1932 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1934 /* The contents field must last into write_object_contents,
1935 so we allocate it with bfd_alloc rather than malloc. */
1936 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1937 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1940 p
= ((struct elf_link_hash_entry
**)
1941 bfd_malloc (o
->reloc_count
1942 * sizeof (struct elf_link_hash_entry
*)));
1943 if (p
== NULL
&& o
->reloc_count
!= 0)
1945 elf_section_data (o
)->rel_hashes
= p
;
1946 pend
= p
+ o
->reloc_count
;
1947 for (; p
< pend
; p
++)
1950 /* Use the reloc_count field as an index when outputting the
1956 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1958 /* We have now assigned file positions for all the sections except
1959 .symtab and .strtab. We start the .symtab section at the current
1960 file position, and write directly to it. We build the .strtab
1961 section in memory. */
1963 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1964 /* sh_name is set in prep_headers. */
1965 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1966 symtab_hdr
->sh_flags
= 0;
1967 symtab_hdr
->sh_addr
= 0;
1968 symtab_hdr
->sh_size
= 0;
1969 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1970 /* sh_link is set in assign_section_numbers. */
1971 /* sh_info is set below. */
1972 /* sh_offset is set just below. */
1973 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1975 off
= elf_tdata (abfd
)->next_file_pos
;
1976 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1978 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1979 incorrect. We do not yet know the size of the .symtab section.
1980 We correct next_file_pos below, after we do know the size. */
1982 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1983 continuously seeking to the right position in the file. */
1984 if (! info
->keep_memory
|| max_sym_count
< 20)
1985 finfo
.symbuf_size
= 20;
1987 finfo
.symbuf_size
= max_sym_count
;
1988 finfo
.symbuf
= ((Elf_External_Sym
*)
1989 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1990 if (finfo
.symbuf
== NULL
)
1993 /* Start writing out the symbol table. The first symbol is always a
1995 if (info
->strip
!= strip_all
|| info
->relocateable
)
1997 elfsym
.st_value
= 0;
2000 elfsym
.st_other
= 0;
2001 elfsym
.st_shndx
= SHN_UNDEF
;
2002 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2003 &elfsym
, bfd_und_section_ptr
))
2008 /* Some standard ELF linkers do this, but we don't because it causes
2009 bootstrap comparison failures. */
2010 /* Output a file symbol for the output file as the second symbol.
2011 We output this even if we are discarding local symbols, although
2012 I'm not sure if this is correct. */
2013 elfsym
.st_value
= 0;
2015 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2016 elfsym
.st_other
= 0;
2017 elfsym
.st_shndx
= SHN_ABS
;
2018 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
2019 &elfsym
, bfd_abs_section_ptr
))
2023 /* Output a symbol for each section. We output these even if we are
2024 discarding local symbols, since they are used for relocs. These
2025 symbols have no names. We store the index of each one in the
2026 index field of the section, so that we can find it again when
2027 outputting relocs. */
2028 if (info
->strip
!= strip_all
|| info
->relocateable
)
2030 elfsym
.st_value
= 0;
2032 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2033 elfsym
.st_other
= 0;
2034 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2036 o
= section_from_elf_index (abfd
, i
);
2038 o
->target_index
= abfd
->symcount
;
2039 elfsym
.st_shndx
= i
;
2040 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2046 /* Allocate some memory to hold information read in from the input
2048 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
2049 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
2050 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
2051 bfd_malloc (max_internal_reloc_count
2052 * sizeof (Elf_Internal_Rela
)));
2053 finfo
.external_syms
= ((Elf_External_Sym
*)
2054 bfd_malloc (max_sym_count
2055 * sizeof (Elf_External_Sym
)));
2056 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
2057 bfd_malloc (max_sym_count
2058 * sizeof (Elf_Internal_Sym
)));
2059 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
2060 finfo
.sections
= ((asection
**)
2061 bfd_malloc (max_sym_count
* sizeof (asection
*)));
2062 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
2063 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
2064 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
2065 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
2066 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
2067 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
2068 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
2071 /* Since ELF permits relocations to be against local symbols, we
2072 must have the local symbols available when we do the relocations.
2073 Since we would rather only read the local symbols once, and we
2074 would rather not keep them in memory, we handle all the
2075 relocations for a single input file at the same time.
2077 Unfortunately, there is no way to know the total number of local
2078 symbols until we have seen all of them, and the local symbol
2079 indices precede the global symbol indices. This means that when
2080 we are generating relocateable output, and we see a reloc against
2081 a global symbol, we can not know the symbol index until we have
2082 finished examining all the local symbols to see which ones we are
2083 going to output. To deal with this, we keep the relocations in
2084 memory, and don't output them until the end of the link. This is
2085 an unfortunate waste of memory, but I don't see a good way around
2086 it. Fortunately, it only happens when performing a relocateable
2087 link, which is not the common case. FIXME: If keep_memory is set
2088 we could write the relocs out and then read them again; I don't
2089 know how bad the memory loss will be. */
2091 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
2092 sub
->output_has_begun
= false;
2093 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2095 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
2097 if (p
->type
== bfd_indirect_link_order
2098 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2099 == bfd_target_elf_flavour
))
2101 sub
= p
->u
.indirect
.section
->owner
;
2102 if (! sub
->output_has_begun
)
2104 if (! elf_link_input_bfd (&finfo
, sub
))
2106 sub
->output_has_begun
= true;
2109 else if (p
->type
== bfd_section_reloc_link_order
2110 || p
->type
== bfd_symbol_reloc_link_order
)
2112 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2117 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2123 /* That wrote out all the local symbols. Finish up the symbol table
2124 with the global symbols. */
2126 /* The sh_info field records the index of the first non local
2128 symtab_hdr
->sh_info
= abfd
->symcount
;
2130 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2132 /* We get the global symbols from the hash table. */
2135 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2140 /* Flush all symbols to the file. */
2141 if (! elf_link_flush_output_syms (&finfo
))
2144 /* Now we know the size of the symtab section. */
2145 off
+= symtab_hdr
->sh_size
;
2147 /* Finish up and write out the symbol string table (.strtab)
2149 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2150 /* sh_name was set in prep_headers. */
2151 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2152 symstrtab_hdr
->sh_flags
= 0;
2153 symstrtab_hdr
->sh_addr
= 0;
2154 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2155 symstrtab_hdr
->sh_entsize
= 0;
2156 symstrtab_hdr
->sh_link
= 0;
2157 symstrtab_hdr
->sh_info
= 0;
2158 /* sh_offset is set just below. */
2159 symstrtab_hdr
->sh_addralign
= 1;
2161 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2162 elf_tdata (abfd
)->next_file_pos
= off
;
2164 if (abfd
->symcount
> 0)
2166 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2167 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2171 /* Adjust the relocs to have the correct symbol indices. */
2172 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2174 struct elf_link_hash_entry
**rel_hash
;
2175 Elf_Internal_Shdr
*rel_hdr
;
2177 if ((o
->flags
& SEC_RELOC
) == 0)
2180 rel_hash
= elf_section_data (o
)->rel_hashes
;
2181 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2182 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2184 if (*rel_hash
== NULL
)
2187 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2189 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2191 Elf_External_Rel
*erel
;
2192 Elf_Internal_Rel irel
;
2194 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2195 elf_swap_reloc_in (abfd
, erel
, &irel
);
2196 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2197 ELF_R_TYPE (irel
.r_info
));
2198 elf_swap_reloc_out (abfd
, &irel
, erel
);
2202 Elf_External_Rela
*erela
;
2203 Elf_Internal_Rela irela
;
2205 BFD_ASSERT (rel_hdr
->sh_entsize
2206 == sizeof (Elf_External_Rela
));
2208 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2209 elf_swap_reloca_in (abfd
, erela
, &irela
);
2210 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2211 ELF_R_TYPE (irela
.r_info
));
2212 elf_swap_reloca_out (abfd
, &irela
, erela
);
2216 /* Set the reloc_count field to 0 to prevent write_relocs from
2217 trying to swap the relocs out itself. */
2221 /* If we are linking against a dynamic object, or generating a
2222 shared library, finish up the dynamic linking information. */
2225 Elf_External_Dyn
*dyncon
, *dynconend
;
2227 /* Fix up .dynamic entries. */
2228 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2229 BFD_ASSERT (o
!= NULL
);
2231 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2232 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2233 for (; dyncon
< dynconend
; dyncon
++)
2235 Elf_Internal_Dyn dyn
;
2239 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2246 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2247 magic _init and _fini symbols. This is pretty ugly,
2248 but we are compatible. */
2256 struct elf_link_hash_entry
*h
;
2258 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2259 false, false, true);
2261 && (h
->root
.type
== bfd_link_hash_defined
2262 || h
->root
.type
== bfd_link_hash_defweak
))
2264 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2265 o
= h
->root
.u
.def
.section
;
2266 if (o
->output_section
!= NULL
)
2267 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2268 + o
->output_offset
);
2271 /* The symbol is imported from another shared
2272 library and does not apply to this one. */
2276 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2290 o
= bfd_get_section_by_name (abfd
, name
);
2291 BFD_ASSERT (o
!= NULL
);
2292 dyn
.d_un
.d_ptr
= o
->vma
;
2293 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2300 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2305 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2307 Elf_Internal_Shdr
*hdr
;
2309 hdr
= elf_elfsections (abfd
)[i
];
2310 if (hdr
->sh_type
== type
2311 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2313 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2314 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2317 if (dyn
.d_un
.d_val
== 0
2318 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2319 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2323 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2329 /* If we have created any dynamic sections, then output them. */
2332 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2335 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2337 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2338 || o
->_raw_size
== 0)
2340 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2342 /* At this point, we are only interested in sections
2343 created by elf_link_create_dynamic_sections. FIXME:
2344 This test is fragile. */
2347 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2349 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2351 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2352 o
->contents
, o
->output_offset
,
2360 /* The contents of the .dynstr section are actually in a
2362 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2363 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2364 || ! _bfd_stringtab_emit (abfd
,
2365 elf_hash_table (info
)->dynstr
))
2371 /* If we have optimized stabs strings, output them. */
2372 if (elf_hash_table (info
)->stab_info
!= NULL
)
2374 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
2378 if (finfo
.symstrtab
!= NULL
)
2379 _bfd_stringtab_free (finfo
.symstrtab
);
2380 if (finfo
.contents
!= NULL
)
2381 free (finfo
.contents
);
2382 if (finfo
.external_relocs
!= NULL
)
2383 free (finfo
.external_relocs
);
2384 if (finfo
.internal_relocs
!= NULL
)
2385 free (finfo
.internal_relocs
);
2386 if (finfo
.external_syms
!= NULL
)
2387 free (finfo
.external_syms
);
2388 if (finfo
.internal_syms
!= NULL
)
2389 free (finfo
.internal_syms
);
2390 if (finfo
.indices
!= NULL
)
2391 free (finfo
.indices
);
2392 if (finfo
.sections
!= NULL
)
2393 free (finfo
.sections
);
2394 if (finfo
.symbuf
!= NULL
)
2395 free (finfo
.symbuf
);
2396 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2398 if ((o
->flags
& SEC_RELOC
) != 0
2399 && elf_section_data (o
)->rel_hashes
!= NULL
)
2400 free (elf_section_data (o
)->rel_hashes
);
2403 elf_tdata (abfd
)->linker
= true;
2408 if (finfo
.symstrtab
!= NULL
)
2409 _bfd_stringtab_free (finfo
.symstrtab
);
2410 if (finfo
.contents
!= NULL
)
2411 free (finfo
.contents
);
2412 if (finfo
.external_relocs
!= NULL
)
2413 free (finfo
.external_relocs
);
2414 if (finfo
.internal_relocs
!= NULL
)
2415 free (finfo
.internal_relocs
);
2416 if (finfo
.external_syms
!= NULL
)
2417 free (finfo
.external_syms
);
2418 if (finfo
.internal_syms
!= NULL
)
2419 free (finfo
.internal_syms
);
2420 if (finfo
.indices
!= NULL
)
2421 free (finfo
.indices
);
2422 if (finfo
.sections
!= NULL
)
2423 free (finfo
.sections
);
2424 if (finfo
.symbuf
!= NULL
)
2425 free (finfo
.symbuf
);
2426 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2428 if ((o
->flags
& SEC_RELOC
) != 0
2429 && elf_section_data (o
)->rel_hashes
!= NULL
)
2430 free (elf_section_data (o
)->rel_hashes
);
2436 /* Add a symbol to the output symbol table. */
2439 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2440 struct elf_final_link_info
*finfo
;
2442 Elf_Internal_Sym
*elfsym
;
2443 asection
*input_sec
;
2445 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2446 struct bfd_link_info
*info
,
2451 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2452 elf_backend_link_output_symbol_hook
;
2453 if (output_symbol_hook
!= NULL
)
2455 if (! ((*output_symbol_hook
)
2456 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2460 if (name
== (const char *) NULL
|| *name
== '\0')
2461 elfsym
->st_name
= 0;
2464 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2467 if (elfsym
->st_name
== (unsigned long) -1)
2471 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2473 if (! elf_link_flush_output_syms (finfo
))
2477 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2478 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2479 ++finfo
->symbuf_count
;
2481 ++finfo
->output_bfd
->symcount
;
2486 /* Flush the output symbols to the file. */
2489 elf_link_flush_output_syms (finfo
)
2490 struct elf_final_link_info
*finfo
;
2492 if (finfo
->symbuf_count
> 0)
2494 Elf_Internal_Shdr
*symtab
;
2496 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2498 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2500 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2501 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2502 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2505 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2507 finfo
->symbuf_count
= 0;
2513 /* Add an external symbol to the symbol table. This is called from
2514 the hash table traversal routine. */
2517 elf_link_output_extsym (h
, data
)
2518 struct elf_link_hash_entry
*h
;
2521 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2522 struct elf_final_link_info
*finfo
= eif
->finfo
;
2524 Elf_Internal_Sym sym
;
2525 asection
*input_sec
;
2527 /* If we are not creating a shared library, and this symbol is
2528 referenced by a shared library but is not defined anywhere, then
2529 warn that it is undefined. If we do not do this, the runtime
2530 linker will complain that the symbol is undefined when the
2531 program is run. We don't have to worry about symbols that are
2532 referenced by regular files, because we will already have issued
2533 warnings for them. */
2534 if (! finfo
->info
->relocateable
2535 && ! finfo
->info
->shared
2536 && h
->root
.type
== bfd_link_hash_undefined
2537 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2538 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2540 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2541 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2542 (asection
*) NULL
, 0)))
2549 /* We don't want to output symbols that have never been mentioned by
2550 a regular file, or that we have been told to strip. However, if
2551 h->indx is set to -2, the symbol is used by a reloc and we must
2555 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2556 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2557 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2558 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2560 else if (finfo
->info
->strip
== strip_all
2561 || (finfo
->info
->strip
== strip_some
2562 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2563 h
->root
.root
.string
,
2564 false, false) == NULL
))
2569 /* If we're stripping it, and it's not a dynamic symbol, there's
2570 nothing else to do. */
2571 if (strip
&& h
->dynindx
== -1)
2575 sym
.st_size
= h
->size
;
2577 if (h
->root
.type
== bfd_link_hash_undefweak
2578 || h
->root
.type
== bfd_link_hash_defweak
)
2579 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2581 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2583 switch (h
->root
.type
)
2586 case bfd_link_hash_new
:
2590 case bfd_link_hash_undefined
:
2591 input_sec
= bfd_und_section_ptr
;
2592 sym
.st_shndx
= SHN_UNDEF
;
2595 case bfd_link_hash_undefweak
:
2596 input_sec
= bfd_und_section_ptr
;
2597 sym
.st_shndx
= SHN_UNDEF
;
2600 case bfd_link_hash_defined
:
2601 case bfd_link_hash_defweak
:
2603 input_sec
= h
->root
.u
.def
.section
;
2604 if (input_sec
->output_section
!= NULL
)
2607 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2608 input_sec
->output_section
);
2609 if (sym
.st_shndx
== (unsigned short) -1)
2615 /* ELF symbols in relocateable files are section relative,
2616 but in nonrelocateable files they are virtual
2618 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2619 if (! finfo
->info
->relocateable
)
2620 sym
.st_value
+= input_sec
->output_section
->vma
;
2624 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2625 == bfd_target_elf_flavour
)
2626 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2627 sym
.st_shndx
= SHN_UNDEF
;
2628 input_sec
= bfd_und_section_ptr
;
2633 case bfd_link_hash_common
:
2634 input_sec
= bfd_com_section_ptr
;
2635 sym
.st_shndx
= SHN_COMMON
;
2636 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2639 case bfd_link_hash_indirect
:
2640 case bfd_link_hash_warning
:
2641 /* We can't represent these symbols in ELF. A warning symbol
2642 may have come from a .gnu.warning.SYMBOL section anyhow. We
2643 just put the target symbol in the hash table. If the target
2644 symbol does not really exist, don't do anything. */
2645 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2647 return (elf_link_output_extsym
2648 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2651 /* If this symbol should be put in the .dynsym section, then put it
2652 there now. We have already know the symbol index. We also fill
2653 in the entry in the .hash section. */
2654 if (h
->dynindx
!= -1
2655 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2657 struct elf_backend_data
*bed
;
2660 bfd_byte
*bucketpos
;
2663 sym
.st_name
= h
->dynstr_index
;
2665 /* Give the processor backend a chance to tweak the symbol
2666 value, and also to finish up anything that needs to be done
2668 bed
= get_elf_backend_data (finfo
->output_bfd
);
2669 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2670 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2676 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2677 (PTR
) (((Elf_External_Sym
*)
2678 finfo
->dynsym_sec
->contents
)
2681 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2682 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2684 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2685 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2686 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2687 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2688 put_word (finfo
->output_bfd
, chain
,
2689 ((bfd_byte
*) finfo
->hash_sec
->contents
2690 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2693 /* If we're stripping it, then it was just a dynamic symbol, and
2694 there's nothing else to do. */
2698 h
->indx
= finfo
->output_bfd
->symcount
;
2700 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2709 /* Link an input file into the linker output file. This function
2710 handles all the sections and relocations of the input file at once.
2711 This is so that we only have to read the local symbols once, and
2712 don't have to keep them in memory. */
2715 elf_link_input_bfd (finfo
, input_bfd
)
2716 struct elf_final_link_info
*finfo
;
2719 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2720 bfd
*, asection
*, bfd_byte
*,
2721 Elf_Internal_Rela
*,
2722 Elf_Internal_Sym
*, asection
**));
2724 Elf_Internal_Shdr
*symtab_hdr
;
2727 Elf_External_Sym
*external_syms
;
2728 Elf_External_Sym
*esym
;
2729 Elf_External_Sym
*esymend
;
2730 Elf_Internal_Sym
*isym
;
2732 asection
**ppsection
;
2735 output_bfd
= finfo
->output_bfd
;
2737 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2739 /* If this is a dynamic object, we don't want to do anything here:
2740 we don't want the local symbols, and we don't want the section
2742 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2745 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2746 if (elf_bad_symtab (input_bfd
))
2748 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2753 locsymcount
= symtab_hdr
->sh_info
;
2754 extsymoff
= symtab_hdr
->sh_info
;
2757 /* Read the local symbols. */
2758 if (symtab_hdr
->contents
!= NULL
)
2759 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
2760 else if (locsymcount
== 0)
2761 external_syms
= NULL
;
2764 external_syms
= finfo
->external_syms
;
2765 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2766 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
2767 locsymcount
, input_bfd
)
2768 != locsymcount
* sizeof (Elf_External_Sym
)))
2772 /* Swap in the local symbols and write out the ones which we know
2773 are going into the output file. */
2774 esym
= external_syms
;
2775 esymend
= esym
+ locsymcount
;
2776 isym
= finfo
->internal_syms
;
2777 pindex
= finfo
->indices
;
2778 ppsection
= finfo
->sections
;
2779 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2783 Elf_Internal_Sym osym
;
2785 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2788 if (elf_bad_symtab (input_bfd
))
2790 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2797 if (isym
->st_shndx
== SHN_UNDEF
)
2798 isec
= bfd_und_section_ptr
;
2799 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2800 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2801 else if (isym
->st_shndx
== SHN_ABS
)
2802 isec
= bfd_abs_section_ptr
;
2803 else if (isym
->st_shndx
== SHN_COMMON
)
2804 isec
= bfd_com_section_ptr
;
2813 /* Don't output the first, undefined, symbol. */
2814 if (esym
== external_syms
)
2817 /* If we are stripping all symbols, we don't want to output this
2819 if (finfo
->info
->strip
== strip_all
)
2822 /* We never output section symbols. Instead, we use the section
2823 symbol of the corresponding section in the output file. */
2824 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2827 /* If we are discarding all local symbols, we don't want to
2828 output this one. If we are generating a relocateable output
2829 file, then some of the local symbols may be required by
2830 relocs; we output them below as we discover that they are
2832 if (finfo
->info
->discard
== discard_all
)
2835 /* Get the name of the symbol. */
2836 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2841 /* See if we are discarding symbols with this name. */
2842 if ((finfo
->info
->strip
== strip_some
2843 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2845 || (finfo
->info
->discard
== discard_l
2846 && strncmp (name
, finfo
->info
->lprefix
,
2847 finfo
->info
->lprefix_len
) == 0))
2850 /* If we get here, we are going to output this symbol. */
2854 /* Adjust the section index for the output file. */
2855 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2856 isec
->output_section
);
2857 if (osym
.st_shndx
== (unsigned short) -1)
2860 *pindex
= output_bfd
->symcount
;
2862 /* ELF symbols in relocateable files are section relative, but
2863 in executable files they are virtual addresses. Note that
2864 this code assumes that all ELF sections have an associated
2865 BFD section with a reasonable value for output_offset; below
2866 we assume that they also have a reasonable value for
2867 output_section. Any special sections must be set up to meet
2868 these requirements. */
2869 osym
.st_value
+= isec
->output_offset
;
2870 if (! finfo
->info
->relocateable
)
2871 osym
.st_value
+= isec
->output_section
->vma
;
2873 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2877 /* Relocate the contents of each section. */
2878 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2882 if (! o
->linker_mark
)
2884 /* This section was omitted from the link. */
2888 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2889 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2892 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2893 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2895 /* Section was created by elf_link_create_dynamic_sections.
2896 FIXME: This test is fragile. */
2900 /* Get the contents of the section. They have been cached by a
2901 relaxation routine. Note that o is a section in an input
2902 file, so the contents field will not have been set by any of
2903 the routines which work on output files. */
2904 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
2905 contents
= elf_section_data (o
)->this_hdr
.contents
;
2908 contents
= finfo
->contents
;
2909 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
2910 (file_ptr
) 0, o
->_raw_size
))
2914 if ((o
->flags
& SEC_RELOC
) != 0)
2916 Elf_Internal_Rela
*internal_relocs
;
2918 /* Get the swapped relocs. */
2919 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
2920 (input_bfd
, o
, finfo
->external_relocs
,
2921 finfo
->internal_relocs
, false));
2922 if (internal_relocs
== NULL
2923 && o
->reloc_count
> 0)
2926 /* Relocate the section by invoking a back end routine.
2928 The back end routine is responsible for adjusting the
2929 section contents as necessary, and (if using Rela relocs
2930 and generating a relocateable output file) adjusting the
2931 reloc addend as necessary.
2933 The back end routine does not have to worry about setting
2934 the reloc address or the reloc symbol index.
2936 The back end routine is given a pointer to the swapped in
2937 internal symbols, and can access the hash table entries
2938 for the external symbols via elf_sym_hashes (input_bfd).
2940 When generating relocateable output, the back end routine
2941 must handle STB_LOCAL/STT_SECTION symbols specially. The
2942 output symbol is going to be a section symbol
2943 corresponding to the output section, which will require
2944 the addend to be adjusted. */
2946 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2947 input_bfd
, o
, contents
,
2949 finfo
->internal_syms
,
2953 if (finfo
->info
->relocateable
)
2955 Elf_Internal_Rela
*irela
;
2956 Elf_Internal_Rela
*irelaend
;
2957 struct elf_link_hash_entry
**rel_hash
;
2958 Elf_Internal_Shdr
*input_rel_hdr
;
2959 Elf_Internal_Shdr
*output_rel_hdr
;
2961 /* Adjust the reloc addresses and symbol indices. */
2963 irela
= internal_relocs
;
2964 irelaend
= irela
+ o
->reloc_count
;
2965 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2966 + o
->output_section
->reloc_count
);
2967 for (; irela
< irelaend
; irela
++, rel_hash
++)
2969 unsigned long r_symndx
;
2970 Elf_Internal_Sym
*isym
;
2973 irela
->r_offset
+= o
->output_offset
;
2975 r_symndx
= ELF_R_SYM (irela
->r_info
);
2980 if (r_symndx
>= locsymcount
2981 || (elf_bad_symtab (input_bfd
)
2982 && finfo
->sections
[r_symndx
] == NULL
))
2986 /* This is a reloc against a global symbol. We
2987 have not yet output all the local symbols, so
2988 we do not know the symbol index of any global
2989 symbol. We set the rel_hash entry for this
2990 reloc to point to the global hash table entry
2991 for this symbol. The symbol index is then
2992 set at the end of elf_bfd_final_link. */
2993 indx
= r_symndx
- extsymoff
;
2994 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2996 /* Setting the index to -2 tells
2997 elf_link_output_extsym that this symbol is
2999 BFD_ASSERT ((*rel_hash
)->indx
< 0);
3000 (*rel_hash
)->indx
= -2;
3005 /* This is a reloc against a local symbol. */
3008 isym
= finfo
->internal_syms
+ r_symndx
;
3009 sec
= finfo
->sections
[r_symndx
];
3010 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
3012 /* I suppose the backend ought to fill in the
3013 section of any STT_SECTION symbol against a
3014 processor specific section. */
3015 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3017 else if (sec
== NULL
|| sec
->owner
== NULL
)
3019 bfd_set_error (bfd_error_bad_value
);
3024 r_symndx
= sec
->output_section
->target_index
;
3025 BFD_ASSERT (r_symndx
!= 0);
3030 if (finfo
->indices
[r_symndx
] == -1)
3036 if (finfo
->info
->strip
== strip_all
)
3038 /* You can't do ld -r -s. */
3039 bfd_set_error (bfd_error_invalid_operation
);
3043 /* This symbol was skipped earlier, but
3044 since it is needed by a reloc, we
3045 must output it now. */
3046 link
= symtab_hdr
->sh_link
;
3047 name
= bfd_elf_string_from_elf_section (input_bfd
,
3053 osec
= sec
->output_section
;
3055 _bfd_elf_section_from_bfd_section (output_bfd
,
3057 if (isym
->st_shndx
== (unsigned short) -1)
3060 isym
->st_value
+= sec
->output_offset
;
3061 if (! finfo
->info
->relocateable
)
3062 isym
->st_value
+= osec
->vma
;
3064 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
3066 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
3070 r_symndx
= finfo
->indices
[r_symndx
];
3073 irela
->r_info
= ELF_R_INFO (r_symndx
,
3074 ELF_R_TYPE (irela
->r_info
));
3077 /* Swap out the relocs. */
3078 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
3079 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
3080 BFD_ASSERT (output_rel_hdr
->sh_entsize
3081 == input_rel_hdr
->sh_entsize
);
3082 irela
= internal_relocs
;
3083 irelaend
= irela
+ o
->reloc_count
;
3084 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
3086 Elf_External_Rel
*erel
;
3088 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
3089 + o
->output_section
->reloc_count
);
3090 for (; irela
< irelaend
; irela
++, erel
++)
3092 Elf_Internal_Rel irel
;
3094 irel
.r_offset
= irela
->r_offset
;
3095 irel
.r_info
= irela
->r_info
;
3096 BFD_ASSERT (irela
->r_addend
== 0);
3097 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3102 Elf_External_Rela
*erela
;
3104 BFD_ASSERT (input_rel_hdr
->sh_entsize
3105 == sizeof (Elf_External_Rela
));
3106 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
3107 + o
->output_section
->reloc_count
);
3108 for (; irela
< irelaend
; irela
++, erela
++)
3109 elf_swap_reloca_out (output_bfd
, irela
, erela
);
3112 o
->output_section
->reloc_count
+= o
->reloc_count
;
3116 /* Write out the modified section contents. */
3117 if (elf_section_data (o
)->stab_info
== NULL
)
3119 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
3120 contents
, o
->output_offset
,
3121 (o
->_cooked_size
!= 0
3128 if (! _bfd_write_section_stabs (output_bfd
, o
,
3129 &elf_section_data (o
)->stab_info
,
3138 /* Generate a reloc when linking an ELF file. This is a reloc
3139 requested by the linker, and does come from any input file. This
3140 is used to build constructor and destructor tables when linking
3144 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
3146 struct bfd_link_info
*info
;
3147 asection
*output_section
;
3148 struct bfd_link_order
*link_order
;
3150 reloc_howto_type
*howto
;
3154 struct elf_link_hash_entry
**rel_hash_ptr
;
3155 Elf_Internal_Shdr
*rel_hdr
;
3157 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3160 bfd_set_error (bfd_error_bad_value
);
3164 addend
= link_order
->u
.reloc
.p
->addend
;
3166 /* Figure out the symbol index. */
3167 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3168 + output_section
->reloc_count
);
3169 if (link_order
->type
== bfd_section_reloc_link_order
)
3171 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3172 BFD_ASSERT (indx
!= 0);
3173 *rel_hash_ptr
= NULL
;
3177 struct elf_link_hash_entry
*h
;
3179 /* Treat a reloc against a defined symbol as though it were
3180 actually against the section. */
3181 h
= ((struct elf_link_hash_entry
*)
3182 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3183 link_order
->u
.reloc
.p
->u
.name
,
3184 false, false, true));
3186 && (h
->root
.type
== bfd_link_hash_defined
3187 || h
->root
.type
== bfd_link_hash_defweak
))
3191 section
= h
->root
.u
.def
.section
;
3192 indx
= section
->output_section
->target_index
;
3193 *rel_hash_ptr
= NULL
;
3194 /* It seems that we ought to add the symbol value to the
3195 addend here, but in practice it has already been added
3196 because it was passed to constructor_callback. */
3197 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3201 /* Setting the index to -2 tells elf_link_output_extsym that
3202 this symbol is used by a reloc. */
3209 if (! ((*info
->callbacks
->unattached_reloc
)
3210 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3211 (asection
*) NULL
, (bfd_vma
) 0)))
3217 /* If this is an inplace reloc, we must write the addend into the
3219 if (howto
->partial_inplace
&& addend
!= 0)
3222 bfd_reloc_status_type rstat
;
3226 size
= bfd_get_reloc_size (howto
);
3227 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3228 if (buf
== (bfd_byte
*) NULL
)
3230 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3236 case bfd_reloc_outofrange
:
3238 case bfd_reloc_overflow
:
3239 if (! ((*info
->callbacks
->reloc_overflow
)
3241 (link_order
->type
== bfd_section_reloc_link_order
3242 ? bfd_section_name (output_bfd
,
3243 link_order
->u
.reloc
.p
->u
.section
)
3244 : link_order
->u
.reloc
.p
->u
.name
),
3245 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3253 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3254 (file_ptr
) link_order
->offset
, size
);
3260 /* The address of a reloc is relative to the section in a
3261 relocateable file, and is a virtual address in an executable
3263 offset
= link_order
->offset
;
3264 if (! info
->relocateable
)
3265 offset
+= output_section
->vma
;
3267 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3269 if (rel_hdr
->sh_type
== SHT_REL
)
3271 Elf_Internal_Rel irel
;
3272 Elf_External_Rel
*erel
;
3274 irel
.r_offset
= offset
;
3275 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3276 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3277 + output_section
->reloc_count
);
3278 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3282 Elf_Internal_Rela irela
;
3283 Elf_External_Rela
*erela
;
3285 irela
.r_offset
= offset
;
3286 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3287 irela
.r_addend
= addend
;
3288 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3289 + output_section
->reloc_count
);
3290 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3293 ++output_section
->reloc_count
;
3299 /* Allocate a pointer to live in a linker created section. */
3302 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3304 struct bfd_link_info
*info
;
3305 elf_linker_section_t
*lsect
;
3306 struct elf_link_hash_entry
*h
;
3307 const Elf_Internal_Rela
*rel
;
3309 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3310 elf_linker_section_pointers_t
*linker_section_ptr
;
3311 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3313 BFD_ASSERT (lsect
!= NULL
);
3315 /* Is this a global symbol? */
3318 /* Has this symbol already been allocated, if so, our work is done */
3319 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3324 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3325 /* Make sure this symbol is output as a dynamic symbol. */
3326 if (h
->dynindx
== -1)
3328 if (! elf_link_record_dynamic_symbol (info
, h
))
3332 if (lsect
->rel_section
)
3333 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3336 else /* Allocation of a pointer to a local symbol */
3338 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3340 /* Allocate a table to hold the local symbols if first time */
3343 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3344 register unsigned int i
;
3346 ptr
= (elf_linker_section_pointers_t
**)
3347 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3352 elf_local_ptr_offsets (abfd
) = ptr
;
3353 for (i
= 0; i
< num_symbols
; i
++)
3354 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3357 /* Has this symbol already been allocated, if so, our work is done */
3358 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3363 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3367 /* If we are generating a shared object, we need to
3368 output a R_<xxx>_RELATIVE reloc so that the
3369 dynamic linker can adjust this GOT entry. */
3370 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3371 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3375 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3376 from internal memory. */
3377 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3378 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3379 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3381 if (!linker_section_ptr
)
3384 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3385 linker_section_ptr
->addend
= rel
->r_addend
;
3386 linker_section_ptr
->which
= lsect
->which
;
3387 linker_section_ptr
->written_address_p
= false;
3388 *ptr_linker_section_ptr
= linker_section_ptr
;
3391 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3393 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
3394 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3395 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3396 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3398 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3400 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
3401 lsect
->sym_hash
->root
.root
.string
,
3402 (long)ARCH_SIZE
/ 8,
3403 (long)lsect
->sym_hash
->root
.u
.def
.value
);
3409 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3411 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3414 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3415 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3423 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3426 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3429 /* Fill in the address for a pointer generated in alinker section. */
3432 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3435 struct bfd_link_info
*info
;
3436 elf_linker_section_t
*lsect
;
3437 struct elf_link_hash_entry
*h
;
3439 const Elf_Internal_Rela
*rel
;
3442 elf_linker_section_pointers_t
*linker_section_ptr
;
3444 BFD_ASSERT (lsect
!= NULL
);
3446 if (h
!= NULL
) /* global symbol */
3448 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3452 BFD_ASSERT (linker_section_ptr
!= NULL
);
3454 if (! elf_hash_table (info
)->dynamic_sections_created
3457 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3459 /* This is actually a static link, or it is a
3460 -Bsymbolic link and the symbol is defined
3461 locally. We must initialize this entry in the
3464 When doing a dynamic link, we create a .rela.<xxx>
3465 relocation entry to initialize the value. This
3466 is done in the finish_dynamic_symbol routine. */
3467 if (!linker_section_ptr
->written_address_p
)
3469 linker_section_ptr
->written_address_p
= true;
3470 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3471 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3475 else /* local symbol */
3477 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3478 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3479 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3480 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3484 BFD_ASSERT (linker_section_ptr
!= NULL
);
3486 /* Write out pointer if it hasn't been rewritten out before */
3487 if (!linker_section_ptr
->written_address_p
)
3489 linker_section_ptr
->written_address_p
= true;
3490 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3491 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3495 asection
*srel
= lsect
->rel_section
;
3496 Elf_Internal_Rela outrel
;
3498 /* We need to generate a relative reloc for the dynamic linker. */
3500 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3503 BFD_ASSERT (srel
!= NULL
);
3505 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3506 + lsect
->section
->output_offset
3507 + linker_section_ptr
->offset
);
3508 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3509 outrel
.r_addend
= 0;
3510 elf_swap_reloca_out (output_bfd
, &outrel
,
3511 (((Elf_External_Rela
*)
3512 lsect
->section
->contents
)
3513 + lsect
->section
->reloc_count
));
3514 ++lsect
->section
->reloc_count
;
3519 relocation
= (lsect
->section
->output_offset
3520 + linker_section_ptr
->offset
3521 - lsect
->hole_offset
3522 - lsect
->sym_offset
);
3525 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3526 lsect
->name
, (long)relocation
, (long)relocation
);
3529 /* Subtract out the addend, because it will get added back in by the normal
3531 return relocation
- linker_section_ptr
->addend
;