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 if (sym
.st_other
!= 0
806 && (definition
|| h
->other
== 0))
807 h
->other
= sym
.st_other
;
809 /* Set a flag in the hash table entry indicating the type of
810 reference or definition we just found. Keep a count of
811 the number of dynamic symbols we find. A dynamic symbol
812 is one which is referenced or defined by both a regular
813 object and a shared object, or one which is referenced or
814 defined by more than one shared object. */
815 old_flags
= h
->elf_link_hash_flags
;
820 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
822 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
824 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
825 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
831 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
833 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
834 if ((old_flags
& (ELF_LINK_HASH_DEF_REGULAR
835 | ELF_LINK_HASH_REF_REGULAR
)) != 0
836 || (h
->weakdef
!= NULL
837 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
838 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
842 h
->elf_link_hash_flags
|= new_flag
;
843 if (dynsym
&& h
->dynindx
== -1)
845 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
847 if (h
->weakdef
!= NULL
849 && h
->weakdef
->dynindx
== -1)
851 if (! _bfd_elf_link_record_dynamic_symbol (info
,
859 /* Now set the weakdefs field correctly for all the weak defined
860 symbols we found. The only way to do this is to search all the
861 symbols. Since we only need the information for non functions in
862 dynamic objects, that's the only time we actually put anything on
863 the list WEAKS. We need this information so that if a regular
864 object refers to a symbol defined weakly in a dynamic object, the
865 real symbol in the dynamic object is also put in the dynamic
866 symbols; we also must arrange for both symbols to point to the
867 same memory location. We could handle the general case of symbol
868 aliasing, but a general symbol alias can only be generated in
869 assembler code, handling it correctly would be very time
870 consuming, and other ELF linkers don't handle general aliasing
872 while (weaks
!= NULL
)
874 struct elf_link_hash_entry
*hlook
;
877 struct elf_link_hash_entry
**hpp
;
878 struct elf_link_hash_entry
**hppend
;
881 weaks
= hlook
->weakdef
;
882 hlook
->weakdef
= NULL
;
884 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
885 || hlook
->root
.type
== bfd_link_hash_defweak
886 || hlook
->root
.type
== bfd_link_hash_common
887 || hlook
->root
.type
== bfd_link_hash_indirect
);
888 slook
= hlook
->root
.u
.def
.section
;
889 vlook
= hlook
->root
.u
.def
.value
;
891 hpp
= elf_sym_hashes (abfd
);
892 hppend
= hpp
+ extsymcount
;
893 for (; hpp
< hppend
; hpp
++)
895 struct elf_link_hash_entry
*h
;
898 if (h
!= NULL
&& h
!= hlook
899 && h
->root
.type
== bfd_link_hash_defined
900 && h
->root
.u
.def
.section
== slook
901 && h
->root
.u
.def
.value
== vlook
)
905 /* If the weak definition is in the list of dynamic
906 symbols, make sure the real definition is put there
908 if (hlook
->dynindx
!= -1
911 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
926 /* If this object is the same format as the output object, and it is
927 not a shared library, then let the backend look through the
930 This is required to build global offset table entries and to
931 arrange for dynamic relocs. It is not required for the
932 particular common case of linking non PIC code, even when linking
933 against shared libraries, but unfortunately there is no way of
934 knowing whether an object file has been compiled PIC or not.
935 Looking through the relocs is not particularly time consuming.
936 The problem is that we must either (1) keep the relocs in memory,
937 which causes the linker to require additional runtime memory or
938 (2) read the relocs twice from the input file, which wastes time.
939 This would be a good case for using mmap.
941 I have no idea how to handle linking PIC code into a file of a
942 different format. It probably can't be done. */
943 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
945 && abfd
->xvec
== info
->hash
->creator
946 && check_relocs
!= NULL
)
950 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
952 Elf_Internal_Rela
*internal_relocs
;
955 if ((o
->flags
& SEC_RELOC
) == 0
956 || o
->reloc_count
== 0)
959 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
960 (abfd
, o
, (PTR
) NULL
,
961 (Elf_Internal_Rela
*) NULL
,
963 if (internal_relocs
== NULL
)
966 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
968 if (! info
->keep_memory
)
969 free (internal_relocs
);
976 /* If this is a non-traditional, non-relocateable link, try to
977 optimize the handling of the .stab/.stabstr sections. */
979 && ! info
->relocateable
980 && ! info
->traditional_format
981 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
982 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
984 asection
*stab
, *stabstr
;
986 stab
= bfd_get_section_by_name (abfd
, ".stab");
989 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
993 struct bfd_elf_section_data
*secdata
;
995 secdata
= elf_section_data (stab
);
996 if (! _bfd_link_section_stabs (abfd
,
997 &elf_hash_table (info
)->stab_info
,
999 &secdata
->stab_info
))
1015 /* Create some sections which will be filled in with dynamic linking
1016 information. ABFD is an input file which requires dynamic sections
1017 to be created. The dynamic sections take up virtual memory space
1018 when the final executable is run, so we need to create them before
1019 addresses are assigned to the output sections. We work out the
1020 actual contents and size of these sections later. */
1023 elf_link_create_dynamic_sections (abfd
, info
)
1025 struct bfd_link_info
*info
;
1028 register asection
*s
;
1029 struct elf_link_hash_entry
*h
;
1030 struct elf_backend_data
*bed
;
1032 if (elf_hash_table (info
)->dynamic_sections_created
)
1035 /* Make sure that all dynamic sections use the same input BFD. */
1036 if (elf_hash_table (info
)->dynobj
== NULL
)
1037 elf_hash_table (info
)->dynobj
= abfd
;
1039 abfd
= elf_hash_table (info
)->dynobj
;
1041 /* Note that we set the SEC_IN_MEMORY flag for all of these
1043 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1045 /* A dynamically linked executable has a .interp section, but a
1046 shared library does not. */
1049 s
= bfd_make_section (abfd
, ".interp");
1051 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1055 s
= bfd_make_section (abfd
, ".dynsym");
1057 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1058 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1061 s
= bfd_make_section (abfd
, ".dynstr");
1063 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1066 /* Create a strtab to hold the dynamic symbol names. */
1067 if (elf_hash_table (info
)->dynstr
== NULL
)
1069 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1070 if (elf_hash_table (info
)->dynstr
== NULL
)
1074 s
= bfd_make_section (abfd
, ".dynamic");
1076 || ! bfd_set_section_flags (abfd
, s
, flags
)
1077 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1080 /* The special symbol _DYNAMIC is always set to the start of the
1081 .dynamic section. This call occurs before we have processed the
1082 symbols for any dynamic object, so we don't have to worry about
1083 overriding a dynamic definition. We could set _DYNAMIC in a
1084 linker script, but we only want to define it if we are, in fact,
1085 creating a .dynamic section. We don't want to define it if there
1086 is no .dynamic section, since on some ELF platforms the start up
1087 code examines it to decide how to initialize the process. */
1089 if (! (_bfd_generic_link_add_one_symbol
1090 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1091 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1092 (struct bfd_link_hash_entry
**) &h
)))
1094 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1095 h
->type
= STT_OBJECT
;
1098 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1101 s
= bfd_make_section (abfd
, ".hash");
1103 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1104 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1107 /* Let the backend create the rest of the sections. This lets the
1108 backend set the right flags. The backend will normally create
1109 the .got and .plt sections. */
1110 bed
= get_elf_backend_data (abfd
);
1111 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1114 elf_hash_table (info
)->dynamic_sections_created
= true;
1119 /* Add an entry to the .dynamic table. */
1122 elf_add_dynamic_entry (info
, tag
, val
)
1123 struct bfd_link_info
*info
;
1127 Elf_Internal_Dyn dyn
;
1131 bfd_byte
*newcontents
;
1133 dynobj
= elf_hash_table (info
)->dynobj
;
1135 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1136 BFD_ASSERT (s
!= NULL
);
1138 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1139 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1140 if (newcontents
== NULL
)
1144 dyn
.d_un
.d_val
= val
;
1145 elf_swap_dyn_out (dynobj
, &dyn
,
1146 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1148 s
->_raw_size
= newsize
;
1149 s
->contents
= newcontents
;
1155 /* Read and swap the relocs for a section. They may have been cached.
1156 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1157 they are used as buffers to read into. They are known to be large
1158 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1159 value is allocated using either malloc or bfd_alloc, according to
1160 the KEEP_MEMORY argument. */
1163 NAME(_bfd_elf
,link_read_relocs
) (abfd
, o
, external_relocs
, internal_relocs
,
1167 PTR external_relocs
;
1168 Elf_Internal_Rela
*internal_relocs
;
1169 boolean keep_memory
;
1171 Elf_Internal_Shdr
*rel_hdr
;
1173 Elf_Internal_Rela
*alloc2
= NULL
;
1175 if (elf_section_data (o
)->relocs
!= NULL
)
1176 return elf_section_data (o
)->relocs
;
1178 if (o
->reloc_count
== 0)
1181 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1183 if (internal_relocs
== NULL
)
1187 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1189 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1191 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1192 if (internal_relocs
== NULL
)
1196 if (external_relocs
== NULL
)
1198 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1201 external_relocs
= alloc1
;
1204 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1205 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1206 != rel_hdr
->sh_size
))
1209 /* Swap in the relocs. For convenience, we always produce an
1210 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1212 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1214 Elf_External_Rel
*erel
;
1215 Elf_External_Rel
*erelend
;
1216 Elf_Internal_Rela
*irela
;
1218 erel
= (Elf_External_Rel
*) external_relocs
;
1219 erelend
= erel
+ o
->reloc_count
;
1220 irela
= internal_relocs
;
1221 for (; erel
< erelend
; erel
++, irela
++)
1223 Elf_Internal_Rel irel
;
1225 elf_swap_reloc_in (abfd
, erel
, &irel
);
1226 irela
->r_offset
= irel
.r_offset
;
1227 irela
->r_info
= irel
.r_info
;
1228 irela
->r_addend
= 0;
1233 Elf_External_Rela
*erela
;
1234 Elf_External_Rela
*erelaend
;
1235 Elf_Internal_Rela
*irela
;
1237 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1239 erela
= (Elf_External_Rela
*) external_relocs
;
1240 erelaend
= erela
+ o
->reloc_count
;
1241 irela
= internal_relocs
;
1242 for (; erela
< erelaend
; erela
++, irela
++)
1243 elf_swap_reloca_in (abfd
, erela
, irela
);
1246 /* Cache the results for next time, if we can. */
1248 elf_section_data (o
)->relocs
= internal_relocs
;
1253 /* Don't free alloc2, since if it was allocated we are passing it
1254 back (under the name of internal_relocs). */
1256 return internal_relocs
;
1267 /* Record an assignment to a symbol made by a linker script. We need
1268 this in case some dynamic object refers to this symbol. */
1272 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1274 struct bfd_link_info
*info
;
1278 struct elf_link_hash_entry
*h
;
1280 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1283 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1287 if (h
->root
.type
== bfd_link_hash_new
)
1288 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
1290 /* If this symbol is being provided by the linker script, and it is
1291 currently defined by a dynamic object, but not by a regular
1292 object, then mark it as undefined so that the generic linker will
1293 force the correct value. */
1295 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1296 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1297 h
->root
.type
= bfd_link_hash_undefined
;
1299 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1300 h
->type
= STT_OBJECT
;
1302 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1303 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1305 && h
->dynindx
== -1)
1307 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1310 /* If this is a weak defined symbol, and we know a corresponding
1311 real symbol from the same dynamic object, make sure the real
1312 symbol is also made into a dynamic symbol. */
1313 if (h
->weakdef
!= NULL
1314 && h
->weakdef
->dynindx
== -1)
1316 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1325 /* Array used to determine the number of hash table buckets to use
1326 based on the number of symbols there are. If there are fewer than
1327 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1328 fewer than 37 we use 17 buckets, and so forth. We never use more
1329 than 521 buckets. */
1331 static const size_t elf_buckets
[] =
1333 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1336 /* Set up the sizes and contents of the ELF dynamic sections. This is
1337 called by the ELF linker emulation before_allocation routine. We
1338 must set the sizes of the sections before the linker sets the
1339 addresses of the various sections. */
1342 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1343 export_dynamic
, info
, sinterpptr
)
1347 boolean export_dynamic
;
1348 struct bfd_link_info
*info
;
1349 asection
**sinterpptr
;
1352 struct elf_backend_data
*bed
;
1356 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1359 dynobj
= elf_hash_table (info
)->dynobj
;
1361 /* If there were no dynamic objects in the link, there is nothing to
1366 /* If we are supposed to export all symbols into the dynamic symbol
1367 table (this is not the normal case), then do so. */
1370 struct elf_info_failed eif
;
1374 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1380 if (elf_hash_table (info
)->dynamic_sections_created
)
1382 struct elf_info_failed eif
;
1383 struct elf_link_hash_entry
*h
;
1384 bfd_size_type strsize
;
1386 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1387 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1393 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1395 if (indx
== (bfd_size_type
) -1
1396 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1402 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1410 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1412 if (indx
== (bfd_size_type
) -1
1413 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1417 /* Find all symbols which were defined in a dynamic object and make
1418 the backend pick a reasonable value for them. */
1421 elf_link_hash_traverse (elf_hash_table (info
),
1422 elf_adjust_dynamic_symbol
,
1427 /* Add some entries to the .dynamic section. We fill in some of the
1428 values later, in elf_bfd_final_link, but we must add the entries
1429 now so that we know the final size of the .dynamic section. */
1430 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1433 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1434 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1436 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1439 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1442 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1443 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1445 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1448 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1449 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1450 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1451 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1452 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1453 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1454 sizeof (Elf_External_Sym
)))
1458 /* The backend must work out the sizes of all the other dynamic
1460 bed
= get_elf_backend_data (output_bfd
);
1461 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1464 if (elf_hash_table (info
)->dynamic_sections_created
)
1469 size_t bucketcount
= 0;
1470 Elf_Internal_Sym isym
;
1472 /* Set the size of the .dynsym and .hash sections. We counted
1473 the number of dynamic symbols in elf_link_add_object_symbols.
1474 We will build the contents of .dynsym and .hash when we build
1475 the final symbol table, because until then we do not know the
1476 correct value to give the symbols. We built the .dynstr
1477 section as we went along in elf_link_add_object_symbols. */
1478 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1479 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1480 BFD_ASSERT (s
!= NULL
);
1481 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1482 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1483 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1486 /* The first entry in .dynsym is a dummy symbol. */
1493 elf_swap_symbol_out (output_bfd
, &isym
,
1494 (PTR
) (Elf_External_Sym
*) s
->contents
);
1496 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1498 bucketcount
= elf_buckets
[i
];
1499 if (dynsymcount
< elf_buckets
[i
+ 1])
1503 s
= bfd_get_section_by_name (dynobj
, ".hash");
1504 BFD_ASSERT (s
!= NULL
);
1505 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1506 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1507 if (s
->contents
== NULL
)
1509 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1511 put_word (output_bfd
, bucketcount
, s
->contents
);
1512 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1514 elf_hash_table (info
)->bucketcount
= bucketcount
;
1516 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1517 BFD_ASSERT (s
!= NULL
);
1518 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1520 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1528 /* This routine is used to export all defined symbols into the dynamic
1529 symbol table. It is called via elf_link_hash_traverse. */
1532 elf_export_symbol (h
, data
)
1533 struct elf_link_hash_entry
*h
;
1536 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1538 if (h
->dynindx
== -1
1539 && (h
->elf_link_hash_flags
1540 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1542 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1553 /* Make the backend pick a good value for a dynamic symbol. This is
1554 called via elf_link_hash_traverse, and also calls itself
1558 elf_adjust_dynamic_symbol (h
, data
)
1559 struct elf_link_hash_entry
*h
;
1562 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1564 struct elf_backend_data
*bed
;
1566 /* If this symbol was mentioned in a non-ELF file, try to set
1567 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1568 permit a non-ELF file to correctly refer to a symbol defined in
1569 an ELF dynamic object. */
1570 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
1572 if (h
->root
.type
!= bfd_link_hash_defined
1573 && h
->root
.type
!= bfd_link_hash_defweak
)
1574 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1577 if (h
->root
.u
.def
.section
->owner
!= NULL
1578 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
1579 == bfd_target_elf_flavour
))
1580 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1582 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1585 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1586 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1588 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1596 /* If this is a final link, and the symbol was defined as a common
1597 symbol in a regular object file, and there was no definition in
1598 any dynamic object, then the linker will have allocated space for
1599 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
1600 flag will not have been set. */
1601 if (h
->root
.type
== bfd_link_hash_defined
1602 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1603 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) != 0
1604 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1605 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
1606 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1608 /* If -Bsymbolic was used (which means to bind references to global
1609 symbols to the definition within the shared object), and this
1610 symbol was defined in a regular object, then it actually doesn't
1611 need a PLT entry. */
1612 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1613 && eif
->info
->shared
1614 && eif
->info
->symbolic
1615 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1616 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1618 /* If this symbol does not require a PLT entry, and it is not
1619 defined by a dynamic object, or is not referenced by a regular
1620 object, ignore it. We do have to handle a weak defined symbol,
1621 even if no regular object refers to it, if we decided to add it
1622 to the dynamic symbol table. FIXME: Do we normally need to worry
1623 about symbols which are defined by one dynamic object and
1624 referenced by another one? */
1625 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1626 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1627 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1628 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1629 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1632 /* If we've already adjusted this symbol, don't do it again. This
1633 can happen via a recursive call. */
1634 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1637 /* Don't look at this symbol again. Note that we must set this
1638 after checking the above conditions, because we may look at a
1639 symbol once, decide not to do anything, and then get called
1640 recursively later after REF_REGULAR is set below. */
1641 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1643 /* If this is a weak definition, and we know a real definition, and
1644 the real symbol is not itself defined by a regular object file,
1645 then get a good value for the real definition. We handle the
1646 real symbol first, for the convenience of the backend routine.
1648 Note that there is a confusing case here. If the real definition
1649 is defined by a regular object file, we don't get the real symbol
1650 from the dynamic object, but we do get the weak symbol. If the
1651 processor backend uses a COPY reloc, then if some routine in the
1652 dynamic object changes the real symbol, we will not see that
1653 change in the corresponding weak symbol. This is the way other
1654 ELF linkers work as well, and seems to be a result of the shared
1657 I will clarify this issue. Most SVR4 shared libraries define the
1658 variable _timezone and define timezone as a weak synonym. The
1659 tzset call changes _timezone. If you write
1660 extern int timezone;
1662 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1663 you might expect that, since timezone is a synonym for _timezone,
1664 the same number will print both times. However, if the processor
1665 backend uses a COPY reloc, then actually timezone will be copied
1666 into your process image, and, since you define _timezone
1667 yourself, _timezone will not. Thus timezone and _timezone will
1668 wind up at different memory locations. The tzset call will set
1669 _timezone, leaving timezone unchanged. */
1671 if (h
->weakdef
!= NULL
)
1673 struct elf_link_hash_entry
*weakdef
;
1675 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1676 || h
->root
.type
== bfd_link_hash_defweak
);
1677 weakdef
= h
->weakdef
;
1678 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1679 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1680 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1681 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1683 /* This symbol is defined by a regular object file, so we
1684 will not do anything special. Clear weakdef for the
1685 convenience of the processor backend. */
1690 /* There is an implicit reference by a regular object file
1691 via the weak symbol. */
1692 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1693 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1698 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1699 bed
= get_elf_backend_data (dynobj
);
1700 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1709 /* Final phase of ELF linker. */
1711 /* A structure we use to avoid passing large numbers of arguments. */
1713 struct elf_final_link_info
1715 /* General link information. */
1716 struct bfd_link_info
*info
;
1719 /* Symbol string table. */
1720 struct bfd_strtab_hash
*symstrtab
;
1721 /* .dynsym section. */
1722 asection
*dynsym_sec
;
1723 /* .hash section. */
1725 /* Buffer large enough to hold contents of any section. */
1727 /* Buffer large enough to hold external relocs of any section. */
1728 PTR external_relocs
;
1729 /* Buffer large enough to hold internal relocs of any section. */
1730 Elf_Internal_Rela
*internal_relocs
;
1731 /* Buffer large enough to hold external local symbols of any input
1733 Elf_External_Sym
*external_syms
;
1734 /* Buffer large enough to hold internal local symbols of any input
1736 Elf_Internal_Sym
*internal_syms
;
1737 /* Array large enough to hold a symbol index for each local symbol
1738 of any input BFD. */
1740 /* Array large enough to hold a section pointer for each local
1741 symbol of any input BFD. */
1742 asection
**sections
;
1743 /* Buffer to hold swapped out symbols. */
1744 Elf_External_Sym
*symbuf
;
1745 /* Number of swapped out symbols in buffer. */
1746 size_t symbuf_count
;
1747 /* Number of symbols which fit in symbuf. */
1751 static boolean elf_link_output_sym
1752 PARAMS ((struct elf_final_link_info
*, const char *,
1753 Elf_Internal_Sym
*, asection
*));
1754 static boolean elf_link_flush_output_syms
1755 PARAMS ((struct elf_final_link_info
*));
1756 static boolean elf_link_output_extsym
1757 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1758 static boolean elf_link_input_bfd
1759 PARAMS ((struct elf_final_link_info
*, bfd
*));
1760 static boolean elf_reloc_link_order
1761 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1762 struct bfd_link_order
*));
1764 /* This struct is used to pass information to routines called via
1765 elf_link_hash_traverse which must return failure. */
1767 struct elf_finfo_failed
1770 struct elf_final_link_info
*finfo
;
1773 /* Do the final step of an ELF link. */
1776 elf_bfd_final_link (abfd
, info
)
1778 struct bfd_link_info
*info
;
1782 struct elf_final_link_info finfo
;
1783 register asection
*o
;
1784 register struct bfd_link_order
*p
;
1786 size_t max_contents_size
;
1787 size_t max_external_reloc_size
;
1788 size_t max_internal_reloc_count
;
1789 size_t max_sym_count
;
1791 Elf_Internal_Sym elfsym
;
1793 Elf_Internal_Shdr
*symtab_hdr
;
1794 Elf_Internal_Shdr
*symstrtab_hdr
;
1795 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1796 struct elf_finfo_failed eif
;
1799 abfd
->flags
|= DYNAMIC
;
1801 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1802 dynobj
= elf_hash_table (info
)->dynobj
;
1805 finfo
.output_bfd
= abfd
;
1806 finfo
.symstrtab
= elf_stringtab_init ();
1807 if (finfo
.symstrtab
== NULL
)
1811 finfo
.dynsym_sec
= NULL
;
1812 finfo
.hash_sec
= NULL
;
1816 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1817 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1818 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1820 finfo
.contents
= NULL
;
1821 finfo
.external_relocs
= NULL
;
1822 finfo
.internal_relocs
= NULL
;
1823 finfo
.external_syms
= NULL
;
1824 finfo
.internal_syms
= NULL
;
1825 finfo
.indices
= NULL
;
1826 finfo
.sections
= NULL
;
1827 finfo
.symbuf
= NULL
;
1828 finfo
.symbuf_count
= 0;
1830 /* Count up the number of relocations we will output for each output
1831 section, so that we know the sizes of the reloc sections. We
1832 also figure out some maximum sizes. */
1833 max_contents_size
= 0;
1834 max_external_reloc_size
= 0;
1835 max_internal_reloc_count
= 0;
1837 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1841 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1843 if (p
->type
== bfd_section_reloc_link_order
1844 || p
->type
== bfd_symbol_reloc_link_order
)
1846 else if (p
->type
== bfd_indirect_link_order
)
1850 sec
= p
->u
.indirect
.section
;
1852 /* Mark all sections which are to be included in the
1853 link. This will normally be every section. We need
1854 to do this so that we can identify any sections which
1855 the linker has decided to not include. */
1856 sec
->linker_mark
= true;
1858 if (info
->relocateable
)
1859 o
->reloc_count
+= sec
->reloc_count
;
1861 if (sec
->_raw_size
> max_contents_size
)
1862 max_contents_size
= sec
->_raw_size
;
1863 if (sec
->_cooked_size
> max_contents_size
)
1864 max_contents_size
= sec
->_cooked_size
;
1866 /* We are interested in just local symbols, not all
1868 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1872 if (elf_bad_symtab (sec
->owner
))
1873 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1874 / sizeof (Elf_External_Sym
));
1876 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1878 if (sym_count
> max_sym_count
)
1879 max_sym_count
= sym_count
;
1881 if ((sec
->flags
& SEC_RELOC
) != 0)
1885 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1886 if (ext_size
> max_external_reloc_size
)
1887 max_external_reloc_size
= ext_size
;
1888 if (sec
->reloc_count
> max_internal_reloc_count
)
1889 max_internal_reloc_count
= sec
->reloc_count
;
1895 if (o
->reloc_count
> 0)
1896 o
->flags
|= SEC_RELOC
;
1899 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1900 set it (this is probably a bug) and if it is set
1901 assign_section_numbers will create a reloc section. */
1902 o
->flags
&=~ SEC_RELOC
;
1905 /* If the SEC_ALLOC flag is not set, force the section VMA to
1906 zero. This is done in elf_fake_sections as well, but forcing
1907 the VMA to 0 here will ensure that relocs against these
1908 sections are handled correctly. */
1909 if ((o
->flags
& SEC_ALLOC
) == 0
1910 && ! o
->user_set_vma
)
1914 /* Figure out the file positions for everything but the symbol table
1915 and the relocs. We set symcount to force assign_section_numbers
1916 to create a symbol table. */
1917 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1918 BFD_ASSERT (! abfd
->output_has_begun
);
1919 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1922 /* That created the reloc sections. Set their sizes, and assign
1923 them file positions, and allocate some buffers. */
1924 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1926 if ((o
->flags
& SEC_RELOC
) != 0)
1928 Elf_Internal_Shdr
*rel_hdr
;
1929 register struct elf_link_hash_entry
**p
, **pend
;
1931 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1933 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1935 /* The contents field must last into write_object_contents,
1936 so we allocate it with bfd_alloc rather than malloc. */
1937 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1938 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1941 p
= ((struct elf_link_hash_entry
**)
1942 bfd_malloc (o
->reloc_count
1943 * sizeof (struct elf_link_hash_entry
*)));
1944 if (p
== NULL
&& o
->reloc_count
!= 0)
1946 elf_section_data (o
)->rel_hashes
= p
;
1947 pend
= p
+ o
->reloc_count
;
1948 for (; p
< pend
; p
++)
1951 /* Use the reloc_count field as an index when outputting the
1957 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1959 /* We have now assigned file positions for all the sections except
1960 .symtab and .strtab. We start the .symtab section at the current
1961 file position, and write directly to it. We build the .strtab
1962 section in memory. */
1964 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1965 /* sh_name is set in prep_headers. */
1966 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1967 symtab_hdr
->sh_flags
= 0;
1968 symtab_hdr
->sh_addr
= 0;
1969 symtab_hdr
->sh_size
= 0;
1970 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1971 /* sh_link is set in assign_section_numbers. */
1972 /* sh_info is set below. */
1973 /* sh_offset is set just below. */
1974 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1976 off
= elf_tdata (abfd
)->next_file_pos
;
1977 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1979 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1980 incorrect. We do not yet know the size of the .symtab section.
1981 We correct next_file_pos below, after we do know the size. */
1983 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1984 continuously seeking to the right position in the file. */
1985 if (! info
->keep_memory
|| max_sym_count
< 20)
1986 finfo
.symbuf_size
= 20;
1988 finfo
.symbuf_size
= max_sym_count
;
1989 finfo
.symbuf
= ((Elf_External_Sym
*)
1990 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1991 if (finfo
.symbuf
== NULL
)
1994 /* Start writing out the symbol table. The first symbol is always a
1996 if (info
->strip
!= strip_all
|| info
->relocateable
)
1998 elfsym
.st_value
= 0;
2001 elfsym
.st_other
= 0;
2002 elfsym
.st_shndx
= SHN_UNDEF
;
2003 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2004 &elfsym
, bfd_und_section_ptr
))
2009 /* Some standard ELF linkers do this, but we don't because it causes
2010 bootstrap comparison failures. */
2011 /* Output a file symbol for the output file as the second symbol.
2012 We output this even if we are discarding local symbols, although
2013 I'm not sure if this is correct. */
2014 elfsym
.st_value
= 0;
2016 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2017 elfsym
.st_other
= 0;
2018 elfsym
.st_shndx
= SHN_ABS
;
2019 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
2020 &elfsym
, bfd_abs_section_ptr
))
2024 /* Output a symbol for each section. We output these even if we are
2025 discarding local symbols, since they are used for relocs. These
2026 symbols have no names. We store the index of each one in the
2027 index field of the section, so that we can find it again when
2028 outputting relocs. */
2029 if (info
->strip
!= strip_all
|| info
->relocateable
)
2031 elfsym
.st_value
= 0;
2033 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2034 elfsym
.st_other
= 0;
2035 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2037 o
= section_from_elf_index (abfd
, i
);
2039 o
->target_index
= abfd
->symcount
;
2040 elfsym
.st_shndx
= i
;
2041 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
2047 /* Allocate some memory to hold information read in from the input
2049 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
2050 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
2051 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
2052 bfd_malloc (max_internal_reloc_count
2053 * sizeof (Elf_Internal_Rela
)));
2054 finfo
.external_syms
= ((Elf_External_Sym
*)
2055 bfd_malloc (max_sym_count
2056 * sizeof (Elf_External_Sym
)));
2057 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
2058 bfd_malloc (max_sym_count
2059 * sizeof (Elf_Internal_Sym
)));
2060 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
2061 finfo
.sections
= ((asection
**)
2062 bfd_malloc (max_sym_count
* sizeof (asection
*)));
2063 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
2064 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
2065 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
2066 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
2067 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
2068 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
2069 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
2072 /* Since ELF permits relocations to be against local symbols, we
2073 must have the local symbols available when we do the relocations.
2074 Since we would rather only read the local symbols once, and we
2075 would rather not keep them in memory, we handle all the
2076 relocations for a single input file at the same time.
2078 Unfortunately, there is no way to know the total number of local
2079 symbols until we have seen all of them, and the local symbol
2080 indices precede the global symbol indices. This means that when
2081 we are generating relocateable output, and we see a reloc against
2082 a global symbol, we can not know the symbol index until we have
2083 finished examining all the local symbols to see which ones we are
2084 going to output. To deal with this, we keep the relocations in
2085 memory, and don't output them until the end of the link. This is
2086 an unfortunate waste of memory, but I don't see a good way around
2087 it. Fortunately, it only happens when performing a relocateable
2088 link, which is not the common case. FIXME: If keep_memory is set
2089 we could write the relocs out and then read them again; I don't
2090 know how bad the memory loss will be. */
2092 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
2093 sub
->output_has_begun
= false;
2094 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2096 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
2098 if (p
->type
== bfd_indirect_link_order
2099 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2100 == bfd_target_elf_flavour
))
2102 sub
= p
->u
.indirect
.section
->owner
;
2103 if (! sub
->output_has_begun
)
2105 if (! elf_link_input_bfd (&finfo
, sub
))
2107 sub
->output_has_begun
= true;
2110 else if (p
->type
== bfd_section_reloc_link_order
2111 || p
->type
== bfd_symbol_reloc_link_order
)
2113 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2118 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2124 /* That wrote out all the local symbols. Finish up the symbol table
2125 with the global symbols. */
2127 /* The sh_info field records the index of the first non local
2129 symtab_hdr
->sh_info
= abfd
->symcount
;
2131 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2133 /* We get the global symbols from the hash table. */
2136 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2141 /* Flush all symbols to the file. */
2142 if (! elf_link_flush_output_syms (&finfo
))
2145 /* Now we know the size of the symtab section. */
2146 off
+= symtab_hdr
->sh_size
;
2148 /* Finish up and write out the symbol string table (.strtab)
2150 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2151 /* sh_name was set in prep_headers. */
2152 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2153 symstrtab_hdr
->sh_flags
= 0;
2154 symstrtab_hdr
->sh_addr
= 0;
2155 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2156 symstrtab_hdr
->sh_entsize
= 0;
2157 symstrtab_hdr
->sh_link
= 0;
2158 symstrtab_hdr
->sh_info
= 0;
2159 /* sh_offset is set just below. */
2160 symstrtab_hdr
->sh_addralign
= 1;
2162 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2163 elf_tdata (abfd
)->next_file_pos
= off
;
2165 if (abfd
->symcount
> 0)
2167 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2168 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2172 /* Adjust the relocs to have the correct symbol indices. */
2173 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2175 struct elf_link_hash_entry
**rel_hash
;
2176 Elf_Internal_Shdr
*rel_hdr
;
2178 if ((o
->flags
& SEC_RELOC
) == 0)
2181 rel_hash
= elf_section_data (o
)->rel_hashes
;
2182 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2183 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2185 if (*rel_hash
== NULL
)
2188 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2190 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2192 Elf_External_Rel
*erel
;
2193 Elf_Internal_Rel irel
;
2195 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2196 elf_swap_reloc_in (abfd
, erel
, &irel
);
2197 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2198 ELF_R_TYPE (irel
.r_info
));
2199 elf_swap_reloc_out (abfd
, &irel
, erel
);
2203 Elf_External_Rela
*erela
;
2204 Elf_Internal_Rela irela
;
2206 BFD_ASSERT (rel_hdr
->sh_entsize
2207 == sizeof (Elf_External_Rela
));
2209 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2210 elf_swap_reloca_in (abfd
, erela
, &irela
);
2211 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2212 ELF_R_TYPE (irela
.r_info
));
2213 elf_swap_reloca_out (abfd
, &irela
, erela
);
2217 /* Set the reloc_count field to 0 to prevent write_relocs from
2218 trying to swap the relocs out itself. */
2222 /* If we are linking against a dynamic object, or generating a
2223 shared library, finish up the dynamic linking information. */
2226 Elf_External_Dyn
*dyncon
, *dynconend
;
2228 /* Fix up .dynamic entries. */
2229 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2230 BFD_ASSERT (o
!= NULL
);
2232 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2233 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2234 for (; dyncon
< dynconend
; dyncon
++)
2236 Elf_Internal_Dyn dyn
;
2240 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2247 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2248 magic _init and _fini symbols. This is pretty ugly,
2249 but we are compatible. */
2257 struct elf_link_hash_entry
*h
;
2259 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2260 false, false, true);
2262 && (h
->root
.type
== bfd_link_hash_defined
2263 || h
->root
.type
== bfd_link_hash_defweak
))
2265 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2266 o
= h
->root
.u
.def
.section
;
2267 if (o
->output_section
!= NULL
)
2268 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2269 + o
->output_offset
);
2272 /* The symbol is imported from another shared
2273 library and does not apply to this one. */
2277 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2291 o
= bfd_get_section_by_name (abfd
, name
);
2292 BFD_ASSERT (o
!= NULL
);
2293 dyn
.d_un
.d_ptr
= o
->vma
;
2294 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2301 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2306 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2308 Elf_Internal_Shdr
*hdr
;
2310 hdr
= elf_elfsections (abfd
)[i
];
2311 if (hdr
->sh_type
== type
2312 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2314 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2315 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2318 if (dyn
.d_un
.d_val
== 0
2319 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2320 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2324 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2330 /* If we have created any dynamic sections, then output them. */
2333 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2336 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2338 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2339 || o
->_raw_size
== 0)
2341 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2343 /* At this point, we are only interested in sections
2344 created by elf_link_create_dynamic_sections. FIXME:
2345 This test is fragile. */
2348 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2350 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2352 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2353 o
->contents
, o
->output_offset
,
2361 /* The contents of the .dynstr section are actually in a
2363 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2364 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2365 || ! _bfd_stringtab_emit (abfd
,
2366 elf_hash_table (info
)->dynstr
))
2372 /* If we have optimized stabs strings, output them. */
2373 if (elf_hash_table (info
)->stab_info
!= NULL
)
2375 if (! _bfd_write_stab_strings (abfd
, &elf_hash_table (info
)->stab_info
))
2379 if (finfo
.symstrtab
!= NULL
)
2380 _bfd_stringtab_free (finfo
.symstrtab
);
2381 if (finfo
.contents
!= NULL
)
2382 free (finfo
.contents
);
2383 if (finfo
.external_relocs
!= NULL
)
2384 free (finfo
.external_relocs
);
2385 if (finfo
.internal_relocs
!= NULL
)
2386 free (finfo
.internal_relocs
);
2387 if (finfo
.external_syms
!= NULL
)
2388 free (finfo
.external_syms
);
2389 if (finfo
.internal_syms
!= NULL
)
2390 free (finfo
.internal_syms
);
2391 if (finfo
.indices
!= NULL
)
2392 free (finfo
.indices
);
2393 if (finfo
.sections
!= NULL
)
2394 free (finfo
.sections
);
2395 if (finfo
.symbuf
!= NULL
)
2396 free (finfo
.symbuf
);
2397 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2399 if ((o
->flags
& SEC_RELOC
) != 0
2400 && elf_section_data (o
)->rel_hashes
!= NULL
)
2401 free (elf_section_data (o
)->rel_hashes
);
2404 elf_tdata (abfd
)->linker
= true;
2409 if (finfo
.symstrtab
!= NULL
)
2410 _bfd_stringtab_free (finfo
.symstrtab
);
2411 if (finfo
.contents
!= NULL
)
2412 free (finfo
.contents
);
2413 if (finfo
.external_relocs
!= NULL
)
2414 free (finfo
.external_relocs
);
2415 if (finfo
.internal_relocs
!= NULL
)
2416 free (finfo
.internal_relocs
);
2417 if (finfo
.external_syms
!= NULL
)
2418 free (finfo
.external_syms
);
2419 if (finfo
.internal_syms
!= NULL
)
2420 free (finfo
.internal_syms
);
2421 if (finfo
.indices
!= NULL
)
2422 free (finfo
.indices
);
2423 if (finfo
.sections
!= NULL
)
2424 free (finfo
.sections
);
2425 if (finfo
.symbuf
!= NULL
)
2426 free (finfo
.symbuf
);
2427 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2429 if ((o
->flags
& SEC_RELOC
) != 0
2430 && elf_section_data (o
)->rel_hashes
!= NULL
)
2431 free (elf_section_data (o
)->rel_hashes
);
2437 /* Add a symbol to the output symbol table. */
2440 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2441 struct elf_final_link_info
*finfo
;
2443 Elf_Internal_Sym
*elfsym
;
2444 asection
*input_sec
;
2446 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2447 struct bfd_link_info
*info
,
2452 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2453 elf_backend_link_output_symbol_hook
;
2454 if (output_symbol_hook
!= NULL
)
2456 if (! ((*output_symbol_hook
)
2457 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2461 if (name
== (const char *) NULL
|| *name
== '\0')
2462 elfsym
->st_name
= 0;
2465 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2468 if (elfsym
->st_name
== (unsigned long) -1)
2472 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2474 if (! elf_link_flush_output_syms (finfo
))
2478 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2479 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2480 ++finfo
->symbuf_count
;
2482 ++finfo
->output_bfd
->symcount
;
2487 /* Flush the output symbols to the file. */
2490 elf_link_flush_output_syms (finfo
)
2491 struct elf_final_link_info
*finfo
;
2493 if (finfo
->symbuf_count
> 0)
2495 Elf_Internal_Shdr
*symtab
;
2497 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2499 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2501 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2502 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2503 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2506 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2508 finfo
->symbuf_count
= 0;
2514 /* Add an external symbol to the symbol table. This is called from
2515 the hash table traversal routine. */
2518 elf_link_output_extsym (h
, data
)
2519 struct elf_link_hash_entry
*h
;
2522 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2523 struct elf_final_link_info
*finfo
= eif
->finfo
;
2525 Elf_Internal_Sym sym
;
2526 asection
*input_sec
;
2528 /* If we are not creating a shared library, and this symbol is
2529 referenced by a shared library but is not defined anywhere, then
2530 warn that it is undefined. If we do not do this, the runtime
2531 linker will complain that the symbol is undefined when the
2532 program is run. We don't have to worry about symbols that are
2533 referenced by regular files, because we will already have issued
2534 warnings for them. */
2535 if (! finfo
->info
->relocateable
2536 && ! finfo
->info
->shared
2537 && h
->root
.type
== bfd_link_hash_undefined
2538 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2539 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2541 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2542 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2543 (asection
*) NULL
, 0)))
2550 /* We don't want to output symbols that have never been mentioned by
2551 a regular file, or that we have been told to strip. However, if
2552 h->indx is set to -2, the symbol is used by a reloc and we must
2556 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2557 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2558 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2559 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2561 else if (finfo
->info
->strip
== strip_all
2562 || (finfo
->info
->strip
== strip_some
2563 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2564 h
->root
.root
.string
,
2565 false, false) == NULL
))
2570 /* If we're stripping it, and it's not a dynamic symbol, there's
2571 nothing else to do. */
2572 if (strip
&& h
->dynindx
== -1)
2576 sym
.st_size
= h
->size
;
2577 sym
.st_other
= h
->other
;
2578 if (h
->root
.type
== bfd_link_hash_undefweak
2579 || h
->root
.type
== bfd_link_hash_defweak
)
2580 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2582 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2584 switch (h
->root
.type
)
2587 case bfd_link_hash_new
:
2591 case bfd_link_hash_undefined
:
2592 input_sec
= bfd_und_section_ptr
;
2593 sym
.st_shndx
= SHN_UNDEF
;
2596 case bfd_link_hash_undefweak
:
2597 input_sec
= bfd_und_section_ptr
;
2598 sym
.st_shndx
= SHN_UNDEF
;
2601 case bfd_link_hash_defined
:
2602 case bfd_link_hash_defweak
:
2604 input_sec
= h
->root
.u
.def
.section
;
2605 if (input_sec
->output_section
!= NULL
)
2608 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2609 input_sec
->output_section
);
2610 if (sym
.st_shndx
== (unsigned short) -1)
2616 /* ELF symbols in relocateable files are section relative,
2617 but in nonrelocateable files they are virtual
2619 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2620 if (! finfo
->info
->relocateable
)
2621 sym
.st_value
+= input_sec
->output_section
->vma
;
2625 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2626 == bfd_target_elf_flavour
)
2627 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2628 sym
.st_shndx
= SHN_UNDEF
;
2629 input_sec
= bfd_und_section_ptr
;
2634 case bfd_link_hash_common
:
2635 input_sec
= bfd_com_section_ptr
;
2636 sym
.st_shndx
= SHN_COMMON
;
2637 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2640 case bfd_link_hash_indirect
:
2641 case bfd_link_hash_warning
:
2642 /* We can't represent these symbols in ELF. A warning symbol
2643 may have come from a .gnu.warning.SYMBOL section anyhow. We
2644 just put the target symbol in the hash table. If the target
2645 symbol does not really exist, don't do anything. */
2646 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2648 return (elf_link_output_extsym
2649 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2652 /* If this symbol should be put in the .dynsym section, then put it
2653 there now. We have already know the symbol index. We also fill
2654 in the entry in the .hash section. */
2655 if (h
->dynindx
!= -1
2656 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2658 struct elf_backend_data
*bed
;
2661 bfd_byte
*bucketpos
;
2664 sym
.st_name
= h
->dynstr_index
;
2666 /* Give the processor backend a chance to tweak the symbol
2667 value, and also to finish up anything that needs to be done
2669 bed
= get_elf_backend_data (finfo
->output_bfd
);
2670 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2671 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2677 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2678 (PTR
) (((Elf_External_Sym
*)
2679 finfo
->dynsym_sec
->contents
)
2682 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2683 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2685 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2686 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2687 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2688 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2689 put_word (finfo
->output_bfd
, chain
,
2690 ((bfd_byte
*) finfo
->hash_sec
->contents
2691 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2694 /* If we're stripping it, then it was just a dynamic symbol, and
2695 there's nothing else to do. */
2699 h
->indx
= finfo
->output_bfd
->symcount
;
2701 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2710 /* Link an input file into the linker output file. This function
2711 handles all the sections and relocations of the input file at once.
2712 This is so that we only have to read the local symbols once, and
2713 don't have to keep them in memory. */
2716 elf_link_input_bfd (finfo
, input_bfd
)
2717 struct elf_final_link_info
*finfo
;
2720 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2721 bfd
*, asection
*, bfd_byte
*,
2722 Elf_Internal_Rela
*,
2723 Elf_Internal_Sym
*, asection
**));
2725 Elf_Internal_Shdr
*symtab_hdr
;
2728 Elf_External_Sym
*external_syms
;
2729 Elf_External_Sym
*esym
;
2730 Elf_External_Sym
*esymend
;
2731 Elf_Internal_Sym
*isym
;
2733 asection
**ppsection
;
2736 output_bfd
= finfo
->output_bfd
;
2738 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2740 /* If this is a dynamic object, we don't want to do anything here:
2741 we don't want the local symbols, and we don't want the section
2743 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2746 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2747 if (elf_bad_symtab (input_bfd
))
2749 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2754 locsymcount
= symtab_hdr
->sh_info
;
2755 extsymoff
= symtab_hdr
->sh_info
;
2758 /* Read the local symbols. */
2759 if (symtab_hdr
->contents
!= NULL
)
2760 external_syms
= (Elf_External_Sym
*) symtab_hdr
->contents
;
2761 else if (locsymcount
== 0)
2762 external_syms
= NULL
;
2765 external_syms
= finfo
->external_syms
;
2766 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2767 || (bfd_read (external_syms
, sizeof (Elf_External_Sym
),
2768 locsymcount
, input_bfd
)
2769 != locsymcount
* sizeof (Elf_External_Sym
)))
2773 /* Swap in the local symbols and write out the ones which we know
2774 are going into the output file. */
2775 esym
= external_syms
;
2776 esymend
= esym
+ locsymcount
;
2777 isym
= finfo
->internal_syms
;
2778 pindex
= finfo
->indices
;
2779 ppsection
= finfo
->sections
;
2780 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2784 Elf_Internal_Sym osym
;
2786 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2789 if (elf_bad_symtab (input_bfd
))
2791 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2798 if (isym
->st_shndx
== SHN_UNDEF
)
2799 isec
= bfd_und_section_ptr
;
2800 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2801 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2802 else if (isym
->st_shndx
== SHN_ABS
)
2803 isec
= bfd_abs_section_ptr
;
2804 else if (isym
->st_shndx
== SHN_COMMON
)
2805 isec
= bfd_com_section_ptr
;
2814 /* Don't output the first, undefined, symbol. */
2815 if (esym
== external_syms
)
2818 /* If we are stripping all symbols, we don't want to output this
2820 if (finfo
->info
->strip
== strip_all
)
2823 /* We never output section symbols. Instead, we use the section
2824 symbol of the corresponding section in the output file. */
2825 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2828 /* If we are discarding all local symbols, we don't want to
2829 output this one. If we are generating a relocateable output
2830 file, then some of the local symbols may be required by
2831 relocs; we output them below as we discover that they are
2833 if (finfo
->info
->discard
== discard_all
)
2836 /* Get the name of the symbol. */
2837 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2842 /* See if we are discarding symbols with this name. */
2843 if ((finfo
->info
->strip
== strip_some
2844 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2846 || (finfo
->info
->discard
== discard_l
2847 && strncmp (name
, finfo
->info
->lprefix
,
2848 finfo
->info
->lprefix_len
) == 0))
2851 /* If we get here, we are going to output this symbol. */
2855 /* Adjust the section index for the output file. */
2856 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2857 isec
->output_section
);
2858 if (osym
.st_shndx
== (unsigned short) -1)
2861 *pindex
= output_bfd
->symcount
;
2863 /* ELF symbols in relocateable files are section relative, but
2864 in executable files they are virtual addresses. Note that
2865 this code assumes that all ELF sections have an associated
2866 BFD section with a reasonable value for output_offset; below
2867 we assume that they also have a reasonable value for
2868 output_section. Any special sections must be set up to meet
2869 these requirements. */
2870 osym
.st_value
+= isec
->output_offset
;
2871 if (! finfo
->info
->relocateable
)
2872 osym
.st_value
+= isec
->output_section
->vma
;
2874 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2878 /* Relocate the contents of each section. */
2879 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2883 if (! o
->linker_mark
)
2885 /* This section was omitted from the link. */
2889 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2890 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2893 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2894 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2896 /* Section was created by elf_link_create_dynamic_sections.
2897 FIXME: This test is fragile. */
2901 /* Get the contents of the section. They have been cached by a
2902 relaxation routine. Note that o is a section in an input
2903 file, so the contents field will not have been set by any of
2904 the routines which work on output files. */
2905 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
2906 contents
= elf_section_data (o
)->this_hdr
.contents
;
2909 contents
= finfo
->contents
;
2910 if (! bfd_get_section_contents (input_bfd
, o
, contents
,
2911 (file_ptr
) 0, o
->_raw_size
))
2915 if ((o
->flags
& SEC_RELOC
) != 0)
2917 Elf_Internal_Rela
*internal_relocs
;
2919 /* Get the swapped relocs. */
2920 internal_relocs
= (NAME(_bfd_elf
,link_read_relocs
)
2921 (input_bfd
, o
, finfo
->external_relocs
,
2922 finfo
->internal_relocs
, false));
2923 if (internal_relocs
== NULL
2924 && o
->reloc_count
> 0)
2927 /* Relocate the section by invoking a back end routine.
2929 The back end routine is responsible for adjusting the
2930 section contents as necessary, and (if using Rela relocs
2931 and generating a relocateable output file) adjusting the
2932 reloc addend as necessary.
2934 The back end routine does not have to worry about setting
2935 the reloc address or the reloc symbol index.
2937 The back end routine is given a pointer to the swapped in
2938 internal symbols, and can access the hash table entries
2939 for the external symbols via elf_sym_hashes (input_bfd).
2941 When generating relocateable output, the back end routine
2942 must handle STB_LOCAL/STT_SECTION symbols specially. The
2943 output symbol is going to be a section symbol
2944 corresponding to the output section, which will require
2945 the addend to be adjusted. */
2947 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2948 input_bfd
, o
, contents
,
2950 finfo
->internal_syms
,
2954 if (finfo
->info
->relocateable
)
2956 Elf_Internal_Rela
*irela
;
2957 Elf_Internal_Rela
*irelaend
;
2958 struct elf_link_hash_entry
**rel_hash
;
2959 Elf_Internal_Shdr
*input_rel_hdr
;
2960 Elf_Internal_Shdr
*output_rel_hdr
;
2962 /* Adjust the reloc addresses and symbol indices. */
2964 irela
= internal_relocs
;
2965 irelaend
= irela
+ o
->reloc_count
;
2966 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2967 + o
->output_section
->reloc_count
);
2968 for (; irela
< irelaend
; irela
++, rel_hash
++)
2970 unsigned long r_symndx
;
2971 Elf_Internal_Sym
*isym
;
2974 irela
->r_offset
+= o
->output_offset
;
2976 r_symndx
= ELF_R_SYM (irela
->r_info
);
2981 if (r_symndx
>= locsymcount
2982 || (elf_bad_symtab (input_bfd
)
2983 && finfo
->sections
[r_symndx
] == NULL
))
2987 /* This is a reloc against a global symbol. We
2988 have not yet output all the local symbols, so
2989 we do not know the symbol index of any global
2990 symbol. We set the rel_hash entry for this
2991 reloc to point to the global hash table entry
2992 for this symbol. The symbol index is then
2993 set at the end of elf_bfd_final_link. */
2994 indx
= r_symndx
- extsymoff
;
2995 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2997 /* Setting the index to -2 tells
2998 elf_link_output_extsym that this symbol is
3000 BFD_ASSERT ((*rel_hash
)->indx
< 0);
3001 (*rel_hash
)->indx
= -2;
3006 /* This is a reloc against a local symbol. */
3009 isym
= finfo
->internal_syms
+ r_symndx
;
3010 sec
= finfo
->sections
[r_symndx
];
3011 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
3013 /* I suppose the backend ought to fill in the
3014 section of any STT_SECTION symbol against a
3015 processor specific section. */
3016 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3018 else if (sec
== NULL
|| sec
->owner
== NULL
)
3020 bfd_set_error (bfd_error_bad_value
);
3025 r_symndx
= sec
->output_section
->target_index
;
3026 BFD_ASSERT (r_symndx
!= 0);
3031 if (finfo
->indices
[r_symndx
] == -1)
3037 if (finfo
->info
->strip
== strip_all
)
3039 /* You can't do ld -r -s. */
3040 bfd_set_error (bfd_error_invalid_operation
);
3044 /* This symbol was skipped earlier, but
3045 since it is needed by a reloc, we
3046 must output it now. */
3047 link
= symtab_hdr
->sh_link
;
3048 name
= bfd_elf_string_from_elf_section (input_bfd
,
3054 osec
= sec
->output_section
;
3056 _bfd_elf_section_from_bfd_section (output_bfd
,
3058 if (isym
->st_shndx
== (unsigned short) -1)
3061 isym
->st_value
+= sec
->output_offset
;
3062 if (! finfo
->info
->relocateable
)
3063 isym
->st_value
+= osec
->vma
;
3065 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
3067 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
3071 r_symndx
= finfo
->indices
[r_symndx
];
3074 irela
->r_info
= ELF_R_INFO (r_symndx
,
3075 ELF_R_TYPE (irela
->r_info
));
3078 /* Swap out the relocs. */
3079 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
3080 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
3081 BFD_ASSERT (output_rel_hdr
->sh_entsize
3082 == input_rel_hdr
->sh_entsize
);
3083 irela
= internal_relocs
;
3084 irelaend
= irela
+ o
->reloc_count
;
3085 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
3087 Elf_External_Rel
*erel
;
3089 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
3090 + o
->output_section
->reloc_count
);
3091 for (; irela
< irelaend
; irela
++, erel
++)
3093 Elf_Internal_Rel irel
;
3095 irel
.r_offset
= irela
->r_offset
;
3096 irel
.r_info
= irela
->r_info
;
3097 BFD_ASSERT (irela
->r_addend
== 0);
3098 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3103 Elf_External_Rela
*erela
;
3105 BFD_ASSERT (input_rel_hdr
->sh_entsize
3106 == sizeof (Elf_External_Rela
));
3107 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
3108 + o
->output_section
->reloc_count
);
3109 for (; irela
< irelaend
; irela
++, erela
++)
3110 elf_swap_reloca_out (output_bfd
, irela
, erela
);
3113 o
->output_section
->reloc_count
+= o
->reloc_count
;
3117 /* Write out the modified section contents. */
3118 if (elf_section_data (o
)->stab_info
== NULL
)
3120 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
3121 contents
, o
->output_offset
,
3122 (o
->_cooked_size
!= 0
3129 if (! _bfd_write_section_stabs (output_bfd
, o
,
3130 &elf_section_data (o
)->stab_info
,
3139 /* Generate a reloc when linking an ELF file. This is a reloc
3140 requested by the linker, and does come from any input file. This
3141 is used to build constructor and destructor tables when linking
3145 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
3147 struct bfd_link_info
*info
;
3148 asection
*output_section
;
3149 struct bfd_link_order
*link_order
;
3151 reloc_howto_type
*howto
;
3155 struct elf_link_hash_entry
**rel_hash_ptr
;
3156 Elf_Internal_Shdr
*rel_hdr
;
3158 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3161 bfd_set_error (bfd_error_bad_value
);
3165 addend
= link_order
->u
.reloc
.p
->addend
;
3167 /* Figure out the symbol index. */
3168 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3169 + output_section
->reloc_count
);
3170 if (link_order
->type
== bfd_section_reloc_link_order
)
3172 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3173 BFD_ASSERT (indx
!= 0);
3174 *rel_hash_ptr
= NULL
;
3178 struct elf_link_hash_entry
*h
;
3180 /* Treat a reloc against a defined symbol as though it were
3181 actually against the section. */
3182 h
= ((struct elf_link_hash_entry
*)
3183 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
3184 link_order
->u
.reloc
.p
->u
.name
,
3185 false, false, true));
3187 && (h
->root
.type
== bfd_link_hash_defined
3188 || h
->root
.type
== bfd_link_hash_defweak
))
3192 section
= h
->root
.u
.def
.section
;
3193 indx
= section
->output_section
->target_index
;
3194 *rel_hash_ptr
= NULL
;
3195 /* It seems that we ought to add the symbol value to the
3196 addend here, but in practice it has already been added
3197 because it was passed to constructor_callback. */
3198 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3202 /* Setting the index to -2 tells elf_link_output_extsym that
3203 this symbol is used by a reloc. */
3210 if (! ((*info
->callbacks
->unattached_reloc
)
3211 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3212 (asection
*) NULL
, (bfd_vma
) 0)))
3218 /* If this is an inplace reloc, we must write the addend into the
3220 if (howto
->partial_inplace
&& addend
!= 0)
3223 bfd_reloc_status_type rstat
;
3227 size
= bfd_get_reloc_size (howto
);
3228 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3229 if (buf
== (bfd_byte
*) NULL
)
3231 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3237 case bfd_reloc_outofrange
:
3239 case bfd_reloc_overflow
:
3240 if (! ((*info
->callbacks
->reloc_overflow
)
3242 (link_order
->type
== bfd_section_reloc_link_order
3243 ? bfd_section_name (output_bfd
,
3244 link_order
->u
.reloc
.p
->u
.section
)
3245 : link_order
->u
.reloc
.p
->u
.name
),
3246 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3254 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3255 (file_ptr
) link_order
->offset
, size
);
3261 /* The address of a reloc is relative to the section in a
3262 relocateable file, and is a virtual address in an executable
3264 offset
= link_order
->offset
;
3265 if (! info
->relocateable
)
3266 offset
+= output_section
->vma
;
3268 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3270 if (rel_hdr
->sh_type
== SHT_REL
)
3272 Elf_Internal_Rel irel
;
3273 Elf_External_Rel
*erel
;
3275 irel
.r_offset
= offset
;
3276 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3277 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3278 + output_section
->reloc_count
);
3279 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3283 Elf_Internal_Rela irela
;
3284 Elf_External_Rela
*erela
;
3286 irela
.r_offset
= offset
;
3287 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3288 irela
.r_addend
= addend
;
3289 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3290 + output_section
->reloc_count
);
3291 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3294 ++output_section
->reloc_count
;
3300 /* Allocate a pointer to live in a linker created section. */
3303 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3305 struct bfd_link_info
*info
;
3306 elf_linker_section_t
*lsect
;
3307 struct elf_link_hash_entry
*h
;
3308 const Elf_Internal_Rela
*rel
;
3310 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3311 elf_linker_section_pointers_t
*linker_section_ptr
;
3312 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3314 BFD_ASSERT (lsect
!= NULL
);
3316 /* Is this a global symbol? */
3319 /* Has this symbol already been allocated, if so, our work is done */
3320 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3325 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3326 /* Make sure this symbol is output as a dynamic symbol. */
3327 if (h
->dynindx
== -1)
3329 if (! elf_link_record_dynamic_symbol (info
, h
))
3333 if (lsect
->rel_section
)
3334 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3337 else /* Allocation of a pointer to a local symbol */
3339 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3341 /* Allocate a table to hold the local symbols if first time */
3344 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3345 register unsigned int i
;
3347 ptr
= (elf_linker_section_pointers_t
**)
3348 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3353 elf_local_ptr_offsets (abfd
) = ptr
;
3354 for (i
= 0; i
< num_symbols
; i
++)
3355 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3358 /* Has this symbol already been allocated, if so, our work is done */
3359 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3364 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3368 /* If we are generating a shared object, we need to
3369 output a R_<xxx>_RELATIVE reloc so that the
3370 dynamic linker can adjust this GOT entry. */
3371 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3372 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3376 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3377 from internal memory. */
3378 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3379 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3380 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3382 if (!linker_section_ptr
)
3385 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3386 linker_section_ptr
->addend
= rel
->r_addend
;
3387 linker_section_ptr
->which
= lsect
->which
;
3388 linker_section_ptr
->written_address_p
= false;
3389 *ptr_linker_section_ptr
= linker_section_ptr
;
3392 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3394 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
+ (ARCH_SIZE
/ 8);
3395 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3396 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3397 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3399 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3401 fprintf (stderr
, "Bump up %s by %ld, current value = %ld\n",
3402 lsect
->sym_hash
->root
.root
.string
,
3403 (long)ARCH_SIZE
/ 8,
3404 (long)lsect
->sym_hash
->root
.u
.def
.value
);
3410 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3412 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3415 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3416 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3424 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3427 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3430 /* Fill in the address for a pointer generated in alinker section. */
3433 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3436 struct bfd_link_info
*info
;
3437 elf_linker_section_t
*lsect
;
3438 struct elf_link_hash_entry
*h
;
3440 const Elf_Internal_Rela
*rel
;
3443 elf_linker_section_pointers_t
*linker_section_ptr
;
3445 BFD_ASSERT (lsect
!= NULL
);
3447 if (h
!= NULL
) /* global symbol */
3449 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3453 BFD_ASSERT (linker_section_ptr
!= NULL
);
3455 if (! elf_hash_table (info
)->dynamic_sections_created
3458 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3460 /* This is actually a static link, or it is a
3461 -Bsymbolic link and the symbol is defined
3462 locally. We must initialize this entry in the
3465 When doing a dynamic link, we create a .rela.<xxx>
3466 relocation entry to initialize the value. This
3467 is done in the finish_dynamic_symbol routine. */
3468 if (!linker_section_ptr
->written_address_p
)
3470 linker_section_ptr
->written_address_p
= true;
3471 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3472 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3476 else /* local symbol */
3478 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3479 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3480 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3481 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3485 BFD_ASSERT (linker_section_ptr
!= NULL
);
3487 /* Write out pointer if it hasn't been rewritten out before */
3488 if (!linker_section_ptr
->written_address_p
)
3490 linker_section_ptr
->written_address_p
= true;
3491 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3492 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3496 asection
*srel
= lsect
->rel_section
;
3497 Elf_Internal_Rela outrel
;
3499 /* We need to generate a relative reloc for the dynamic linker. */
3501 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3504 BFD_ASSERT (srel
!= NULL
);
3506 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3507 + lsect
->section
->output_offset
3508 + linker_section_ptr
->offset
);
3509 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3510 outrel
.r_addend
= 0;
3511 elf_swap_reloca_out (output_bfd
, &outrel
,
3512 (((Elf_External_Rela
*)
3513 lsect
->section
->contents
)
3514 + lsect
->section
->reloc_count
));
3515 ++lsect
->section
->reloc_count
;
3520 relocation
= (lsect
->section
->output_offset
3521 + linker_section_ptr
->offset
3522 - lsect
->hole_offset
3523 - lsect
->sym_offset
);
3526 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3527 lsect
->name
, (long)relocation
, (long)relocation
);
3530 /* Subtract out the addend, because it will get added back in by the normal
3532 return relocation
- linker_section_ptr
->addend
;