2 Copyright 1995, 1996 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 static boolean elf_link_add_object_symbols
23 PARAMS ((bfd
*, struct bfd_link_info
*));
24 static boolean elf_link_add_archive_symbols
25 PARAMS ((bfd
*, struct bfd_link_info
*));
26 static Elf_Internal_Rela
*elf_link_read_relocs
27 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
28 static boolean elf_export_symbol
29 PARAMS ((struct elf_link_hash_entry
*, PTR
));
30 static boolean elf_adjust_dynamic_symbol
31 PARAMS ((struct elf_link_hash_entry
*, PTR
));
33 /* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
36 struct elf_info_failed
39 struct bfd_link_info
*info
;
42 /* Given an ELF BFD, add symbols to the global hash table as
46 elf_bfd_link_add_symbols (abfd
, info
)
48 struct bfd_link_info
*info
;
50 switch (bfd_get_format (abfd
))
53 return elf_link_add_object_symbols (abfd
, info
);
55 return elf_link_add_archive_symbols (abfd
, info
);
57 bfd_set_error (bfd_error_wrong_format
);
63 /* Add symbols from an ELF archive file to the linker hash table. We
64 don't use _bfd_generic_link_add_archive_symbols because of a
65 problem which arises on UnixWare. The UnixWare libc.so is an
66 archive which includes an entry libc.so.1 which defines a bunch of
67 symbols. The libc.so archive also includes a number of other
68 object files, which also define symbols, some of which are the same
69 as those defined in libc.so.1. Correct linking requires that we
70 consider each object file in turn, and include it if it defines any
71 symbols we need. _bfd_generic_link_add_archive_symbols does not do
72 this; it looks through the list of undefined symbols, and includes
73 any object file which defines them. When this algorithm is used on
74 UnixWare, it winds up pulling in libc.so.1 early and defining a
75 bunch of symbols. This means that some of the other objects in the
76 archive are not included in the link, which is incorrect since they
77 precede libc.so.1 in the archive.
79 Fortunately, ELF archive handling is simpler than that done by
80 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
81 oddities. In ELF, if we find a symbol in the archive map, and the
82 symbol is currently undefined, we know that we must pull in that
85 Unfortunately, we do have to make multiple passes over the symbol
86 table until nothing further is resolved. */
89 elf_link_add_archive_symbols (abfd
, info
)
91 struct bfd_link_info
*info
;
94 boolean
*defined
= NULL
;
95 boolean
*included
= NULL
;
99 if (! bfd_has_map (abfd
))
101 /* An empty archive is a special case. */
102 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
104 bfd_set_error (bfd_error_no_armap
);
108 /* Keep track of all symbols we know to be already defined, and all
109 files we know to be already included. This is to speed up the
110 second and subsequent passes. */
111 c
= bfd_ardata (abfd
)->symdef_count
;
114 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
115 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
116 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
118 memset (defined
, 0, c
* sizeof (boolean
));
119 memset (included
, 0, c
* sizeof (boolean
));
121 symdefs
= bfd_ardata (abfd
)->symdefs
;
134 symdefend
= symdef
+ c
;
135 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
137 struct elf_link_hash_entry
*h
;
139 struct bfd_link_hash_entry
*undefs_tail
;
142 if (defined
[i
] || included
[i
])
144 if (symdef
->file_offset
== last
)
150 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
151 false, false, false);
152 if (h
== (struct elf_link_hash_entry
*) NULL
)
154 if (h
->root
.type
!= bfd_link_hash_undefined
)
156 if (h
->root
.type
!= bfd_link_hash_undefweak
)
161 /* We need to include this archive member. */
163 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
164 if (element
== (bfd
*) NULL
)
167 if (! bfd_check_format (element
, bfd_object
))
170 /* Doublecheck that we have not included this object
171 already--it should be impossible, but there may be
172 something wrong with the archive. */
173 if (element
->archive_pass
!= 0)
175 bfd_set_error (bfd_error_bad_value
);
178 element
->archive_pass
= 1;
180 undefs_tail
= info
->hash
->undefs_tail
;
182 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
185 if (! elf_link_add_object_symbols (element
, info
))
188 /* If there are any new undefined symbols, we need to make
189 another pass through the archive in order to see whether
190 they can be defined. FIXME: This isn't perfect, because
191 common symbols wind up on undefs_tail and because an
192 undefined symbol which is defined later on in this pass
193 does not require another pass. This isn't a bug, but it
194 does make the code less efficient than it could be. */
195 if (undefs_tail
!= info
->hash
->undefs_tail
)
198 /* Look backward to mark all symbols from this object file
199 which we have already seen in this pass. */
203 included
[mark
] = true;
208 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
210 /* We mark subsequent symbols from this object file as we go
211 on through the loop. */
212 last
= symdef
->file_offset
;
223 if (defined
!= (boolean
*) NULL
)
225 if (included
!= (boolean
*) NULL
)
230 /* Add symbols from an ELF object file to the linker hash table. */
233 elf_link_add_object_symbols (abfd
, info
)
235 struct bfd_link_info
*info
;
237 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
238 const Elf_Internal_Sym
*,
239 const char **, flagword
*,
240 asection
**, bfd_vma
*));
241 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
242 asection
*, const Elf_Internal_Rela
*));
244 Elf_Internal_Shdr
*hdr
;
248 Elf_External_Sym
*buf
= NULL
;
249 struct elf_link_hash_entry
**sym_hash
;
251 Elf_External_Dyn
*dynbuf
= NULL
;
252 struct elf_link_hash_entry
*weaks
;
253 Elf_External_Sym
*esym
;
254 Elf_External_Sym
*esymend
;
256 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
257 collect
= get_elf_backend_data (abfd
)->collect
;
259 /* As a GNU extension, any input sections which are named
260 .gnu.warning.SYMBOL are treated as warning symbols for the given
261 symbol. This differs from .gnu.warning sections, which generate
262 warnings when they are included in an output file. */
267 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
271 name
= bfd_get_section_name (abfd
, s
);
272 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
277 sz
= bfd_section_size (abfd
, s
);
278 msg
= (char *) bfd_alloc (abfd
, sz
);
282 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
285 if (! (_bfd_generic_link_add_one_symbol
287 name
+ sizeof ".gnu.warning." - 1,
288 BSF_WARNING
, s
, (bfd_vma
) 0, msg
, false, collect
,
289 (struct bfd_link_hash_entry
**) NULL
)))
292 if (! info
->relocateable
)
294 /* Clobber the section size so that the warning does
295 not get copied into the output file. */
302 /* A stripped shared library might only have a dynamic symbol table,
303 not a regular symbol table. In that case we can still go ahead
304 and link using the dynamic symbol table. */
305 if (elf_onesymtab (abfd
) == 0
306 && elf_dynsymtab (abfd
) != 0)
308 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
309 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
312 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
313 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
315 /* The sh_info field of the symtab header tells us where the
316 external symbols start. We don't care about the local symbols at
318 if (elf_bad_symtab (abfd
))
320 extsymcount
= symcount
;
325 extsymcount
= symcount
- hdr
->sh_info
;
326 extsymoff
= hdr
->sh_info
;
329 buf
= ((Elf_External_Sym
*)
330 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
331 if (buf
== NULL
&& extsymcount
!= 0)
334 /* We store a pointer to the hash table entry for each external
336 sym_hash
= ((struct elf_link_hash_entry
**)
338 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
339 if (sym_hash
== NULL
)
341 elf_sym_hashes (abfd
) = sym_hash
;
343 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
347 /* If we are creating a shared library, create all the dynamic
348 sections immediately. We need to attach them to something,
349 so we attach them to this BFD, provided it is the right
350 format. FIXME: If there are no input BFD's of the same
351 format as the output, we can't make a shared library. */
353 && ! elf_hash_table (info
)->dynamic_sections_created
354 && abfd
->xvec
== info
->hash
->creator
)
356 if (! elf_link_create_dynamic_sections (abfd
, info
))
365 bfd_size_type oldsize
;
366 bfd_size_type strindex
;
370 /* You can't use -r against a dynamic object. Also, there's no
371 hope of using a dynamic object which does not exactly match
372 the format of the output file. */
373 if (info
->relocateable
374 || info
->hash
->creator
!= abfd
->xvec
)
376 bfd_set_error (bfd_error_invalid_operation
);
380 /* Find the name to use in a DT_NEEDED entry that refers to this
381 object. If the object has a DT_SONAME entry, we use it.
382 Otherwise, if the generic linker stuck something in
383 elf_dt_name, we use that. Otherwise, we just use the file
384 name. If the generic linker put a null string into
385 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
386 there is a DT_SONAME entry. */
388 name
= bfd_get_filename (abfd
);
389 if (elf_dt_name (abfd
) != NULL
)
391 name
= elf_dt_name (abfd
);
395 s
= bfd_get_section_by_name (abfd
, ".dynamic");
398 Elf_External_Dyn
*extdyn
;
399 Elf_External_Dyn
*extdynend
;
403 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
407 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
408 (file_ptr
) 0, s
->_raw_size
))
411 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
414 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
417 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
418 for (; extdyn
< extdynend
; extdyn
++)
420 Elf_Internal_Dyn dyn
;
422 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
423 if (dyn
.d_tag
== DT_SONAME
)
425 name
= bfd_elf_string_from_elf_section (abfd
, link
,
430 if (dyn
.d_tag
== DT_NEEDED
)
432 struct bfd_link_needed_list
*n
, **pn
;
435 n
= ((struct bfd_link_needed_list
*)
436 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
437 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
439 if (n
== NULL
|| fnm
== NULL
)
441 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
448 for (pn
= &elf_hash_table (info
)->needed
;
460 /* We do not want to include any of the sections in a dynamic
461 object in the output file. We hack by simply clobbering the
462 list of sections in the BFD. This could be handled more
463 cleanly by, say, a new section flag; the existing
464 SEC_NEVER_LOAD flag is not the one we want, because that one
465 still implies that the section takes up space in the output
467 abfd
->sections
= NULL
;
468 abfd
->section_count
= 0;
470 /* If this is the first dynamic object found in the link, create
471 the special sections required for dynamic linking. */
472 if (! elf_hash_table (info
)->dynamic_sections_created
)
474 if (! elf_link_create_dynamic_sections (abfd
, info
))
480 /* Add a DT_NEEDED entry for this dynamic object. */
481 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
482 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
484 if (strindex
== (bfd_size_type
) -1)
487 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
490 Elf_External_Dyn
*dyncon
, *dynconend
;
492 /* The hash table size did not change, which means that
493 the dynamic object name was already entered. If we
494 have already included this dynamic object in the
495 link, just ignore it. There is no reason to include
496 a particular dynamic object more than once. */
497 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
499 BFD_ASSERT (sdyn
!= NULL
);
501 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
502 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
504 for (; dyncon
< dynconend
; dyncon
++)
506 Elf_Internal_Dyn dyn
;
508 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
510 if (dyn
.d_tag
== DT_NEEDED
511 && dyn
.d_un
.d_val
== strindex
)
520 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
524 /* Save the SONAME, if there is one, because sometimes the
525 linker emulation code will need to know it. */
527 name
= bfd_get_filename (abfd
);
528 elf_dt_name (abfd
) = name
;
532 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
534 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
535 != extsymcount
* sizeof (Elf_External_Sym
)))
540 esymend
= buf
+ extsymcount
;
541 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
543 Elf_Internal_Sym sym
;
549 struct elf_link_hash_entry
*h
;
551 boolean size_change_ok
, type_change_ok
;
554 elf_swap_symbol_in (abfd
, esym
, &sym
);
556 flags
= BSF_NO_FLAGS
;
558 value
= sym
.st_value
;
561 bind
= ELF_ST_BIND (sym
.st_info
);
562 if (bind
== STB_LOCAL
)
564 /* This should be impossible, since ELF requires that all
565 global symbols follow all local symbols, and that sh_info
566 point to the first global symbol. Unfortunatealy, Irix 5
570 else if (bind
== STB_GLOBAL
)
572 if (sym
.st_shndx
!= SHN_UNDEF
573 && sym
.st_shndx
!= SHN_COMMON
)
578 else if (bind
== STB_WEAK
)
582 /* Leave it up to the processor backend. */
585 if (sym
.st_shndx
== SHN_UNDEF
)
586 sec
= bfd_und_section_ptr
;
587 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
589 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
593 sec
= bfd_abs_section_ptr
;
595 else if (sym
.st_shndx
== SHN_ABS
)
596 sec
= bfd_abs_section_ptr
;
597 else if (sym
.st_shndx
== SHN_COMMON
)
599 sec
= bfd_com_section_ptr
;
600 /* What ELF calls the size we call the value. What ELF
601 calls the value we call the alignment. */
606 /* Leave it up to the processor backend. */
609 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
610 if (name
== (const char *) NULL
)
615 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
619 /* The hook function sets the name to NULL if this symbol
620 should be skipped for some reason. */
621 if (name
== (const char *) NULL
)
625 /* Sanity check that all possibilities were handled. */
626 if (sec
== (asection
*) NULL
)
628 bfd_set_error (bfd_error_bad_value
);
632 if (bfd_is_und_section (sec
)
633 || bfd_is_com_section (sec
))
638 size_change_ok
= false;
639 type_change_ok
= get_elf_backend_data (abfd
)->type_change_ok
;
640 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
642 /* We need to look up the symbol now in order to get some of
643 the dynamic object handling right. We pass the hash
644 table entry in to _bfd_generic_link_add_one_symbol so
645 that it does not have to look it up again. */
646 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
652 if (h
->root
.type
== bfd_link_hash_new
)
653 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
655 while (h
->root
.type
== bfd_link_hash_indirect
656 || h
->root
.type
== bfd_link_hash_warning
)
657 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
659 /* It's OK to change the type if it used to be a weak
661 if (h
->root
.type
== bfd_link_hash_defweak
662 || h
->root
.type
== bfd_link_hash_undefweak
)
663 type_change_ok
= true;
665 /* It's OK to change the size if it used to be a weak
666 definition, or if it used to be undefined, or if we will
667 be overriding an old definition. */
669 || h
->root
.type
== bfd_link_hash_undefined
)
670 size_change_ok
= true;
672 /* If we are looking at a dynamic object, and this is a
673 definition, we need to see if it has already been defined
674 by some other object. If it has, we want to use the
675 existing definition, and we do not want to report a
676 multiple symbol definition error; we do this by
677 clobbering sec to be bfd_und_section_ptr. */
678 if (dynamic
&& definition
)
680 if (h
->root
.type
== bfd_link_hash_defined
681 || h
->root
.type
== bfd_link_hash_defweak
682 || (h
->root
.type
== bfd_link_hash_common
683 && bind
== STB_WEAK
))
685 sec
= bfd_und_section_ptr
;
687 size_change_ok
= true;
691 /* Similarly, if we are not looking at a dynamic object, and
692 we have a definition, we want to override any definition
693 we may have from a dynamic object. Symbols from regular
694 files always take precedence over symbols from dynamic
695 objects, even if they are defined after the dynamic
696 object in the link. */
699 && (h
->root
.type
== bfd_link_hash_defined
700 || h
->root
.type
== bfd_link_hash_defweak
)
701 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
702 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
703 == bfd_target_elf_flavour
)
704 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
707 /* Change the hash table entry to undefined, and let
708 _bfd_generic_link_add_one_symbol do the right thing
709 with the new definition. */
710 h
->root
.type
= bfd_link_hash_undefined
;
711 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
712 size_change_ok
= true;
716 if (! (_bfd_generic_link_add_one_symbol
717 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
718 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
722 while (h
->root
.type
== bfd_link_hash_indirect
723 || h
->root
.type
== bfd_link_hash_warning
)
724 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
730 && (flags
& BSF_WEAK
) != 0
731 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
732 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
733 && h
->weakdef
== NULL
)
735 /* Keep a list of all weak defined non function symbols from
736 a dynamic object, using the weakdef field. Later in this
737 function we will set the weakdef field to the correct
738 value. We only put non-function symbols from dynamic
739 objects on this list, because that happens to be the only
740 time we need to know the normal symbol corresponding to a
741 weak symbol, and the information is time consuming to
742 figure out. If the weakdef field is not already NULL,
743 then this symbol was already defined by some previous
744 dynamic object, and we will be using that previous
745 definition anyhow. */
752 /* Get the alignment of a common symbol. */
753 if (sym
.st_shndx
== SHN_COMMON
754 && h
->root
.type
== bfd_link_hash_common
)
755 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
757 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
763 /* Remember the symbol size and type. */
765 && (definition
|| h
->size
== 0))
767 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
768 (*_bfd_error_handler
)
769 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
770 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
771 bfd_get_filename (abfd
));
773 h
->size
= sym
.st_size
;
775 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
776 && (definition
|| h
->type
== STT_NOTYPE
))
778 if (h
->type
!= STT_NOTYPE
779 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
781 (*_bfd_error_handler
)
782 ("Warning: type of symbol `%s' changed from %d to %d in %s",
783 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
784 bfd_get_filename (abfd
));
786 h
->type
= ELF_ST_TYPE (sym
.st_info
);
789 /* Set a flag in the hash table entry indicating the type of
790 reference or definition we just found. Keep a count of
791 the number of dynamic symbols we find. A dynamic symbol
792 is one which is referenced or defined by both a regular
793 object and a shared object, or one which is referenced or
794 defined by more than one shared object. */
795 old_flags
= h
->elf_link_hash_flags
;
800 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
802 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
804 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
805 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
811 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
813 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
814 if ((old_flags
& new_flag
) != 0
815 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
816 | ELF_LINK_HASH_REF_REGULAR
)) != 0
817 || (h
->weakdef
!= NULL
818 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
819 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
823 h
->elf_link_hash_flags
|= new_flag
;
824 if (dynsym
&& h
->dynindx
== -1)
826 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
828 if (h
->weakdef
!= NULL
830 && h
->weakdef
->dynindx
== -1)
832 if (! _bfd_elf_link_record_dynamic_symbol (info
,
840 /* Now set the weakdefs field correctly for all the weak defined
841 symbols we found. The only way to do this is to search all the
842 symbols. Since we only need the information for non functions in
843 dynamic objects, that's the only time we actually put anything on
844 the list WEAKS. We need this information so that if a regular
845 object refers to a symbol defined weakly in a dynamic object, the
846 real symbol in the dynamic object is also put in the dynamic
847 symbols; we also must arrange for both symbols to point to the
848 same memory location. We could handle the general case of symbol
849 aliasing, but a general symbol alias can only be generated in
850 assembler code, handling it correctly would be very time
851 consuming, and other ELF linkers don't handle general aliasing
853 while (weaks
!= NULL
)
855 struct elf_link_hash_entry
*hlook
;
858 struct elf_link_hash_entry
**hpp
;
859 struct elf_link_hash_entry
**hppend
;
862 weaks
= hlook
->weakdef
;
863 hlook
->weakdef
= NULL
;
865 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
866 || hlook
->root
.type
== bfd_link_hash_defweak
867 || hlook
->root
.type
== bfd_link_hash_common
868 || hlook
->root
.type
== bfd_link_hash_indirect
);
869 slook
= hlook
->root
.u
.def
.section
;
870 vlook
= hlook
->root
.u
.def
.value
;
872 hpp
= elf_sym_hashes (abfd
);
873 hppend
= hpp
+ extsymcount
;
874 for (; hpp
< hppend
; hpp
++)
876 struct elf_link_hash_entry
*h
;
879 if (h
!= NULL
&& h
!= hlook
880 && h
->root
.type
== bfd_link_hash_defined
881 && h
->root
.u
.def
.section
== slook
882 && h
->root
.u
.def
.value
== vlook
)
886 /* If the weak definition is in the list of dynamic
887 symbols, make sure the real definition is put there
889 if (hlook
->dynindx
!= -1
892 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
907 /* If this object is the same format as the output object, and it is
908 not a shared library, then let the backend look through the
911 This is required to build global offset table entries and to
912 arrange for dynamic relocs. It is not required for the
913 particular common case of linking non PIC code, even when linking
914 against shared libraries, but unfortunately there is no way of
915 knowing whether an object file has been compiled PIC or not.
916 Looking through the relocs is not particularly time consuming.
917 The problem is that we must either (1) keep the relocs in memory,
918 which causes the linker to require additional runtime memory or
919 (2) read the relocs twice from the input file, which wastes time.
920 This would be a good case for using mmap.
922 I have no idea how to handle linking PIC code into a file of a
923 different format. It probably can't be done. */
924 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
926 && abfd
->xvec
== info
->hash
->creator
927 && check_relocs
!= NULL
)
931 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
933 Elf_Internal_Rela
*internal_relocs
;
936 if ((o
->flags
& SEC_RELOC
) == 0
937 || o
->reloc_count
== 0)
940 /* I believe we can ignore the relocs for any section which
941 does not form part of the final process image, such as a
942 debugging section. */
943 if ((o
->flags
& SEC_ALLOC
) == 0)
946 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
947 (Elf_Internal_Rela
*) NULL
,
949 if (internal_relocs
== NULL
)
952 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
954 if (! info
->keep_memory
)
955 free (internal_relocs
);
972 /* Create some sections which will be filled in with dynamic linking
973 information. ABFD is an input file which requires dynamic sections
974 to be created. The dynamic sections take up virtual memory space
975 when the final executable is run, so we need to create them before
976 addresses are assigned to the output sections. We work out the
977 actual contents and size of these sections later. */
980 elf_link_create_dynamic_sections (abfd
, info
)
982 struct bfd_link_info
*info
;
985 register asection
*s
;
986 struct elf_link_hash_entry
*h
;
987 struct elf_backend_data
*bed
;
989 if (elf_hash_table (info
)->dynamic_sections_created
)
992 /* Make sure that all dynamic sections use the same input BFD. */
993 if (elf_hash_table (info
)->dynobj
== NULL
)
994 elf_hash_table (info
)->dynobj
= abfd
;
996 abfd
= elf_hash_table (info
)->dynobj
;
998 /* Note that we set the SEC_IN_MEMORY flag for all of these
1000 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
1002 /* A dynamically linked executable has a .interp section, but a
1003 shared library does not. */
1006 s
= bfd_make_section (abfd
, ".interp");
1008 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1012 s
= bfd_make_section (abfd
, ".dynsym");
1014 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1015 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1018 s
= bfd_make_section (abfd
, ".dynstr");
1020 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1023 /* Create a strtab to hold the dynamic symbol names. */
1024 if (elf_hash_table (info
)->dynstr
== NULL
)
1026 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1027 if (elf_hash_table (info
)->dynstr
== NULL
)
1031 s
= bfd_make_section (abfd
, ".dynamic");
1033 || ! bfd_set_section_flags (abfd
, s
, flags
)
1034 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1037 /* The special symbol _DYNAMIC is always set to the start of the
1038 .dynamic section. This call occurs before we have processed the
1039 symbols for any dynamic object, so we don't have to worry about
1040 overriding a dynamic definition. We could set _DYNAMIC in a
1041 linker script, but we only want to define it if we are, in fact,
1042 creating a .dynamic section. We don't want to define it if there
1043 is no .dynamic section, since on some ELF platforms the start up
1044 code examines it to decide how to initialize the process. */
1046 if (! (_bfd_generic_link_add_one_symbol
1047 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1048 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1049 (struct bfd_link_hash_entry
**) &h
)))
1051 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1052 h
->type
= STT_OBJECT
;
1055 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1058 s
= bfd_make_section (abfd
, ".hash");
1060 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1061 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1064 /* Let the backend create the rest of the sections. This lets the
1065 backend set the right flags. The backend will normally create
1066 the .got and .plt sections. */
1067 bed
= get_elf_backend_data (abfd
);
1068 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1071 elf_hash_table (info
)->dynamic_sections_created
= true;
1076 /* Add an entry to the .dynamic table. */
1079 elf_add_dynamic_entry (info
, tag
, val
)
1080 struct bfd_link_info
*info
;
1084 Elf_Internal_Dyn dyn
;
1088 bfd_byte
*newcontents
;
1090 dynobj
= elf_hash_table (info
)->dynobj
;
1092 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1093 BFD_ASSERT (s
!= NULL
);
1095 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1096 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1097 if (newcontents
== NULL
)
1101 dyn
.d_un
.d_val
= val
;
1102 elf_swap_dyn_out (dynobj
, &dyn
,
1103 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1105 s
->_raw_size
= newsize
;
1106 s
->contents
= newcontents
;
1112 /* Read and swap the relocs for a section. They may have been cached.
1113 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1114 they are used as buffers to read into. They are known to be large
1115 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1116 value is allocated using either malloc or bfd_alloc, according to
1117 the KEEP_MEMORY argument. */
1119 static Elf_Internal_Rela
*
1120 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1123 PTR external_relocs
;
1124 Elf_Internal_Rela
*internal_relocs
;
1125 boolean keep_memory
;
1127 Elf_Internal_Shdr
*rel_hdr
;
1129 Elf_Internal_Rela
*alloc2
= NULL
;
1131 if (elf_section_data (o
)->relocs
!= NULL
)
1132 return elf_section_data (o
)->relocs
;
1134 if (o
->reloc_count
== 0)
1137 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1139 if (internal_relocs
== NULL
)
1143 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1145 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1147 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1148 if (internal_relocs
== NULL
)
1152 if (external_relocs
== NULL
)
1154 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1157 external_relocs
= alloc1
;
1160 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1161 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1162 != rel_hdr
->sh_size
))
1165 /* Swap in the relocs. For convenience, we always produce an
1166 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1168 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1170 Elf_External_Rel
*erel
;
1171 Elf_External_Rel
*erelend
;
1172 Elf_Internal_Rela
*irela
;
1174 erel
= (Elf_External_Rel
*) external_relocs
;
1175 erelend
= erel
+ o
->reloc_count
;
1176 irela
= internal_relocs
;
1177 for (; erel
< erelend
; erel
++, irela
++)
1179 Elf_Internal_Rel irel
;
1181 elf_swap_reloc_in (abfd
, erel
, &irel
);
1182 irela
->r_offset
= irel
.r_offset
;
1183 irela
->r_info
= irel
.r_info
;
1184 irela
->r_addend
= 0;
1189 Elf_External_Rela
*erela
;
1190 Elf_External_Rela
*erelaend
;
1191 Elf_Internal_Rela
*irela
;
1193 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1195 erela
= (Elf_External_Rela
*) external_relocs
;
1196 erelaend
= erela
+ o
->reloc_count
;
1197 irela
= internal_relocs
;
1198 for (; erela
< erelaend
; erela
++, irela
++)
1199 elf_swap_reloca_in (abfd
, erela
, irela
);
1202 /* Cache the results for next time, if we can. */
1204 elf_section_data (o
)->relocs
= internal_relocs
;
1209 /* Don't free alloc2, since if it was allocated we are passing it
1210 back (under the name of internal_relocs). */
1212 return internal_relocs
;
1223 /* Record an assignment to a symbol made by a linker script. We need
1224 this in case some dynamic object refers to this symbol. */
1228 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1230 struct bfd_link_info
*info
;
1234 struct elf_link_hash_entry
*h
;
1236 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1239 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1243 if (h
->root
.type
== bfd_link_hash_new
)
1244 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
1246 /* If this symbol is being provided by the linker script, and it is
1247 currently defined by a dynamic object, but not by a regular
1248 object, then mark it as undefined so that the generic linker will
1249 force the correct value. */
1251 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1252 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1253 h
->root
.type
= bfd_link_hash_undefined
;
1255 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1256 h
->type
= STT_OBJECT
;
1258 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1259 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1261 && h
->dynindx
== -1)
1263 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1266 /* If this is a weak defined symbol, and we know a corresponding
1267 real symbol from the same dynamic object, make sure the real
1268 symbol is also made into a dynamic symbol. */
1269 if (h
->weakdef
!= NULL
1270 && h
->weakdef
->dynindx
== -1)
1272 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1281 /* Array used to determine the number of hash table buckets to use
1282 based on the number of symbols there are. If there are fewer than
1283 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1284 fewer than 37 we use 17 buckets, and so forth. We never use more
1285 than 521 buckets. */
1287 static const size_t elf_buckets
[] =
1289 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1292 /* Set up the sizes and contents of the ELF dynamic sections. This is
1293 called by the ELF linker emulation before_allocation routine. We
1294 must set the sizes of the sections before the linker sets the
1295 addresses of the various sections. */
1298 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1299 export_dynamic
, info
, sinterpptr
)
1303 boolean export_dynamic
;
1304 struct bfd_link_info
*info
;
1305 asection
**sinterpptr
;
1308 struct elf_backend_data
*bed
;
1312 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1315 dynobj
= elf_hash_table (info
)->dynobj
;
1317 /* If there were no dynamic objects in the link, there is nothing to
1322 /* If we are supposed to export all symbols into the dynamic symbol
1323 table (this is not the normal case), then do so. */
1326 struct elf_info_failed eif
;
1330 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1336 if (elf_hash_table (info
)->dynamic_sections_created
)
1338 struct elf_info_failed eif
;
1339 struct elf_link_hash_entry
*h
;
1340 bfd_size_type strsize
;
1342 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1343 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1349 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1351 if (indx
== (bfd_size_type
) -1
1352 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1358 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1366 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1368 if (indx
== (bfd_size_type
) -1
1369 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1373 /* Find all symbols which were defined in a dynamic object and make
1374 the backend pick a reasonable value for them. */
1377 elf_link_hash_traverse (elf_hash_table (info
),
1378 elf_adjust_dynamic_symbol
,
1383 /* Add some entries to the .dynamic section. We fill in some of the
1384 values later, in elf_bfd_final_link, but we must add the entries
1385 now so that we know the final size of the .dynamic section. */
1386 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1389 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1390 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1392 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1395 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1398 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1399 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1401 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1404 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1405 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1406 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1407 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1408 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1409 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1410 sizeof (Elf_External_Sym
)))
1414 /* The backend must work out the sizes of all the other dynamic
1416 bed
= get_elf_backend_data (output_bfd
);
1417 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1420 if (elf_hash_table (info
)->dynamic_sections_created
)
1425 size_t bucketcount
= 0;
1426 Elf_Internal_Sym isym
;
1428 /* Set the size of the .dynsym and .hash sections. We counted
1429 the number of dynamic symbols in elf_link_add_object_symbols.
1430 We will build the contents of .dynsym and .hash when we build
1431 the final symbol table, because until then we do not know the
1432 correct value to give the symbols. We built the .dynstr
1433 section as we went along in elf_link_add_object_symbols. */
1434 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1435 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1436 BFD_ASSERT (s
!= NULL
);
1437 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1438 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1439 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1442 /* The first entry in .dynsym is a dummy symbol. */
1449 elf_swap_symbol_out (output_bfd
, &isym
,
1450 (PTR
) (Elf_External_Sym
*) s
->contents
);
1452 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1454 bucketcount
= elf_buckets
[i
];
1455 if (dynsymcount
< elf_buckets
[i
+ 1])
1459 s
= bfd_get_section_by_name (dynobj
, ".hash");
1460 BFD_ASSERT (s
!= NULL
);
1461 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1462 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1463 if (s
->contents
== NULL
)
1465 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1467 put_word (output_bfd
, bucketcount
, s
->contents
);
1468 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1470 elf_hash_table (info
)->bucketcount
= bucketcount
;
1472 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1473 BFD_ASSERT (s
!= NULL
);
1474 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1476 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1484 /* This routine is used to export all defined symbols into the dynamic
1485 symbol table. It is called via elf_link_hash_traverse. */
1488 elf_export_symbol (h
, data
)
1489 struct elf_link_hash_entry
*h
;
1492 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1494 if (h
->dynindx
== -1
1495 && (h
->elf_link_hash_flags
1496 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1498 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1509 /* Make the backend pick a good value for a dynamic symbol. This is
1510 called via elf_link_hash_traverse, and also calls itself
1514 elf_adjust_dynamic_symbol (h
, data
)
1515 struct elf_link_hash_entry
*h
;
1518 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1520 struct elf_backend_data
*bed
;
1522 /* If this symbol was mentioned in a non-ELF file, try to set
1523 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1524 permit a non-ELF file to correctly refer to a symbol defined in
1525 an ELF dynamic object. */
1526 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_ELF
) != 0)
1528 if (h
->root
.type
!= bfd_link_hash_defined
1529 && h
->root
.type
!= bfd_link_hash_defweak
)
1530 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1533 if (h
->root
.u
.def
.section
->owner
!= NULL
1534 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
1535 == bfd_target_elf_flavour
))
1536 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1538 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1541 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1542 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1544 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1552 /* If -Bsymbolic was used (which means to bind references to global
1553 symbols to the definition within the shared object), and this
1554 symbol was defined in a regular object, then it actually doesn't
1555 need a PLT entry. */
1556 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1557 && eif
->info
->shared
1558 && eif
->info
->symbolic
1559 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1560 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1562 /* If this symbol does not require a PLT entry, and it is not
1563 defined by a dynamic object, or is not referenced by a regular
1564 object, ignore it. We do have to handle a weak defined symbol,
1565 even if no regular object refers to it, if we decided to add it
1566 to the dynamic symbol table. FIXME: Do we normally need to worry
1567 about symbols which are defined by one dynamic object and
1568 referenced by another one? */
1569 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1570 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1571 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1572 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1573 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1576 /* If we've already adjusted this symbol, don't do it again. This
1577 can happen via a recursive call. */
1578 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1581 /* Don't look at this symbol again. Note that we must set this
1582 after checking the above conditions, because we may look at a
1583 symbol once, decide not to do anything, and then get called
1584 recursively later after REF_REGULAR is set below. */
1585 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1587 /* If this is a weak definition, and we know a real definition, and
1588 the real symbol is not itself defined by a regular object file,
1589 then get a good value for the real definition. We handle the
1590 real symbol first, for the convenience of the backend routine.
1592 Note that there is a confusing case here. If the real definition
1593 is defined by a regular object file, we don't get the real symbol
1594 from the dynamic object, but we do get the weak symbol. If the
1595 processor backend uses a COPY reloc, then if some routine in the
1596 dynamic object changes the real symbol, we will not see that
1597 change in the corresponding weak symbol. This is the way other
1598 ELF linkers work as well, and seems to be a result of the shared
1601 I will clarify this issue. Most SVR4 shared libraries define the
1602 variable _timezone and define timezone as a weak synonym. The
1603 tzset call changes _timezone. If you write
1604 extern int timezone;
1606 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1607 you might expect that, since timezone is a synonym for _timezone,
1608 the same number will print both times. However, if the processor
1609 backend uses a COPY reloc, then actually timezone will be copied
1610 into your process image, and, since you define _timezone
1611 yourself, _timezone will not. Thus timezone and _timezone will
1612 wind up at different memory locations. The tzset call will set
1613 _timezone, leaving timezone unchanged. */
1615 if (h
->weakdef
!= NULL
)
1617 struct elf_link_hash_entry
*weakdef
;
1619 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1620 || h
->root
.type
== bfd_link_hash_defweak
);
1621 weakdef
= h
->weakdef
;
1622 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1623 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1624 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1625 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1627 /* This symbol is defined by a regular object file, so we
1628 will not do anything special. Clear weakdef for the
1629 convenience of the processor backend. */
1634 /* There is an implicit reference by a regular object file
1635 via the weak symbol. */
1636 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1637 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1642 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1643 bed
= get_elf_backend_data (dynobj
);
1644 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1653 /* Final phase of ELF linker. */
1655 /* A structure we use to avoid passing large numbers of arguments. */
1657 struct elf_final_link_info
1659 /* General link information. */
1660 struct bfd_link_info
*info
;
1663 /* Symbol string table. */
1664 struct bfd_strtab_hash
*symstrtab
;
1665 /* .dynsym section. */
1666 asection
*dynsym_sec
;
1667 /* .hash section. */
1669 /* Buffer large enough to hold contents of any section. */
1671 /* Buffer large enough to hold external relocs of any section. */
1672 PTR external_relocs
;
1673 /* Buffer large enough to hold internal relocs of any section. */
1674 Elf_Internal_Rela
*internal_relocs
;
1675 /* Buffer large enough to hold external local symbols of any input
1677 Elf_External_Sym
*external_syms
;
1678 /* Buffer large enough to hold internal local symbols of any input
1680 Elf_Internal_Sym
*internal_syms
;
1681 /* Array large enough to hold a symbol index for each local symbol
1682 of any input BFD. */
1684 /* Array large enough to hold a section pointer for each local
1685 symbol of any input BFD. */
1686 asection
**sections
;
1687 /* Buffer to hold swapped out symbols. */
1688 Elf_External_Sym
*symbuf
;
1689 /* Number of swapped out symbols in buffer. */
1690 size_t symbuf_count
;
1691 /* Number of symbols which fit in symbuf. */
1695 static boolean elf_link_output_sym
1696 PARAMS ((struct elf_final_link_info
*, const char *,
1697 Elf_Internal_Sym
*, asection
*));
1698 static boolean elf_link_flush_output_syms
1699 PARAMS ((struct elf_final_link_info
*));
1700 static boolean elf_link_output_extsym
1701 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1702 static boolean elf_link_input_bfd
1703 PARAMS ((struct elf_final_link_info
*, bfd
*));
1704 static boolean elf_reloc_link_order
1705 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1706 struct bfd_link_order
*));
1708 /* This struct is used to pass information to routines called via
1709 elf_link_hash_traverse which must return failure. */
1711 struct elf_finfo_failed
1714 struct elf_final_link_info
*finfo
;
1717 /* Do the final step of an ELF link. */
1720 elf_bfd_final_link (abfd
, info
)
1722 struct bfd_link_info
*info
;
1726 struct elf_final_link_info finfo
;
1727 register asection
*o
;
1728 register struct bfd_link_order
*p
;
1730 size_t max_contents_size
;
1731 size_t max_external_reloc_size
;
1732 size_t max_internal_reloc_count
;
1733 size_t max_sym_count
;
1735 Elf_Internal_Sym elfsym
;
1737 Elf_Internal_Shdr
*symtab_hdr
;
1738 Elf_Internal_Shdr
*symstrtab_hdr
;
1739 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1740 struct elf_finfo_failed eif
;
1743 abfd
->flags
|= DYNAMIC
;
1745 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1746 dynobj
= elf_hash_table (info
)->dynobj
;
1749 finfo
.output_bfd
= abfd
;
1750 finfo
.symstrtab
= elf_stringtab_init ();
1751 if (finfo
.symstrtab
== NULL
)
1755 finfo
.dynsym_sec
= NULL
;
1756 finfo
.hash_sec
= NULL
;
1760 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1761 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1762 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1764 finfo
.contents
= NULL
;
1765 finfo
.external_relocs
= NULL
;
1766 finfo
.internal_relocs
= NULL
;
1767 finfo
.external_syms
= NULL
;
1768 finfo
.internal_syms
= NULL
;
1769 finfo
.indices
= NULL
;
1770 finfo
.sections
= NULL
;
1771 finfo
.symbuf
= NULL
;
1772 finfo
.symbuf_count
= 0;
1774 /* Count up the number of relocations we will output for each output
1775 section, so that we know the sizes of the reloc sections. We
1776 also figure out some maximum sizes. */
1777 max_contents_size
= 0;
1778 max_external_reloc_size
= 0;
1779 max_internal_reloc_count
= 0;
1781 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1785 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1787 if (p
->type
== bfd_section_reloc_link_order
1788 || p
->type
== bfd_symbol_reloc_link_order
)
1790 else if (p
->type
== bfd_indirect_link_order
)
1794 sec
= p
->u
.indirect
.section
;
1796 if (info
->relocateable
)
1797 o
->reloc_count
+= sec
->reloc_count
;
1799 if (sec
->_raw_size
> max_contents_size
)
1800 max_contents_size
= sec
->_raw_size
;
1801 if (sec
->_cooked_size
> max_contents_size
)
1802 max_contents_size
= sec
->_cooked_size
;
1804 /* We are interested in just local symbols, not all
1806 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1810 if (elf_bad_symtab (sec
->owner
))
1811 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1812 / sizeof (Elf_External_Sym
));
1814 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1816 if (sym_count
> max_sym_count
)
1817 max_sym_count
= sym_count
;
1819 if ((sec
->flags
& SEC_RELOC
) != 0)
1823 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1824 if (ext_size
> max_external_reloc_size
)
1825 max_external_reloc_size
= ext_size
;
1826 if (sec
->reloc_count
> max_internal_reloc_count
)
1827 max_internal_reloc_count
= sec
->reloc_count
;
1833 if (o
->reloc_count
> 0)
1834 o
->flags
|= SEC_RELOC
;
1837 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1838 set it (this is probably a bug) and if it is set
1839 assign_section_numbers will create a reloc section. */
1840 o
->flags
&=~ SEC_RELOC
;
1843 /* If the SEC_ALLOC flag is not set, force the section VMA to
1844 zero. This is done in elf_fake_sections as well, but forcing
1845 the VMA to 0 here will ensure that relocs against these
1846 sections are handled correctly. */
1847 if ((o
->flags
& SEC_ALLOC
) == 0)
1851 /* Figure out the file positions for everything but the symbol table
1852 and the relocs. We set symcount to force assign_section_numbers
1853 to create a symbol table. */
1854 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1855 BFD_ASSERT (! abfd
->output_has_begun
);
1856 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1859 /* That created the reloc sections. Set their sizes, and assign
1860 them file positions, and allocate some buffers. */
1861 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1863 if ((o
->flags
& SEC_RELOC
) != 0)
1865 Elf_Internal_Shdr
*rel_hdr
;
1866 register struct elf_link_hash_entry
**p
, **pend
;
1868 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1870 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1872 /* The contents field must last into write_object_contents,
1873 so we allocate it with bfd_alloc rather than malloc. */
1874 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1875 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1878 p
= ((struct elf_link_hash_entry
**)
1879 bfd_malloc (o
->reloc_count
1880 * sizeof (struct elf_link_hash_entry
*)));
1881 if (p
== NULL
&& o
->reloc_count
!= 0)
1883 elf_section_data (o
)->rel_hashes
= p
;
1884 pend
= p
+ o
->reloc_count
;
1885 for (; p
< pend
; p
++)
1888 /* Use the reloc_count field as an index when outputting the
1894 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1896 /* We have now assigned file positions for all the sections except
1897 .symtab and .strtab. We start the .symtab section at the current
1898 file position, and write directly to it. We build the .strtab
1899 section in memory. */
1901 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1902 /* sh_name is set in prep_headers. */
1903 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1904 symtab_hdr
->sh_flags
= 0;
1905 symtab_hdr
->sh_addr
= 0;
1906 symtab_hdr
->sh_size
= 0;
1907 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1908 /* sh_link is set in assign_section_numbers. */
1909 /* sh_info is set below. */
1910 /* sh_offset is set just below. */
1911 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1913 off
= elf_tdata (abfd
)->next_file_pos
;
1914 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1916 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1917 incorrect. We do not yet know the size of the .symtab section.
1918 We correct next_file_pos below, after we do know the size. */
1920 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1921 continuously seeking to the right position in the file. */
1922 if (! info
->keep_memory
|| max_sym_count
< 20)
1923 finfo
.symbuf_size
= 20;
1925 finfo
.symbuf_size
= max_sym_count
;
1926 finfo
.symbuf
= ((Elf_External_Sym
*)
1927 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1928 if (finfo
.symbuf
== NULL
)
1931 /* Start writing out the symbol table. The first symbol is always a
1933 if (info
->strip
!= strip_all
|| info
->relocateable
)
1935 elfsym
.st_value
= 0;
1938 elfsym
.st_other
= 0;
1939 elfsym
.st_shndx
= SHN_UNDEF
;
1940 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1941 &elfsym
, bfd_und_section_ptr
))
1946 /* Some standard ELF linkers do this, but we don't because it causes
1947 bootstrap comparison failures. */
1948 /* Output a file symbol for the output file as the second symbol.
1949 We output this even if we are discarding local symbols, although
1950 I'm not sure if this is correct. */
1951 elfsym
.st_value
= 0;
1953 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1954 elfsym
.st_other
= 0;
1955 elfsym
.st_shndx
= SHN_ABS
;
1956 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1957 &elfsym
, bfd_abs_section_ptr
))
1961 /* Output a symbol for each section. We output these even if we are
1962 discarding local symbols, since they are used for relocs. These
1963 symbols have no names. We store the index of each one in the
1964 index field of the section, so that we can find it again when
1965 outputting relocs. */
1966 if (info
->strip
!= strip_all
|| info
->relocateable
)
1968 elfsym
.st_value
= 0;
1970 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1971 elfsym
.st_other
= 0;
1972 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1974 o
= section_from_elf_index (abfd
, i
);
1976 o
->target_index
= abfd
->symcount
;
1977 elfsym
.st_shndx
= i
;
1978 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1984 /* Allocate some memory to hold information read in from the input
1986 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
1987 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
1988 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1989 bfd_malloc (max_internal_reloc_count
1990 * sizeof (Elf_Internal_Rela
)));
1991 finfo
.external_syms
= ((Elf_External_Sym
*)
1992 bfd_malloc (max_sym_count
1993 * sizeof (Elf_External_Sym
)));
1994 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1995 bfd_malloc (max_sym_count
1996 * sizeof (Elf_Internal_Sym
)));
1997 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
1998 finfo
.sections
= ((asection
**)
1999 bfd_malloc (max_sym_count
* sizeof (asection
*)));
2000 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
2001 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
2002 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
2003 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
2004 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
2005 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
2006 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
2009 /* Since ELF permits relocations to be against local symbols, we
2010 must have the local symbols available when we do the relocations.
2011 Since we would rather only read the local symbols once, and we
2012 would rather not keep them in memory, we handle all the
2013 relocations for a single input file at the same time.
2015 Unfortunately, there is no way to know the total number of local
2016 symbols until we have seen all of them, and the local symbol
2017 indices precede the global symbol indices. This means that when
2018 we are generating relocateable output, and we see a reloc against
2019 a global symbol, we can not know the symbol index until we have
2020 finished examining all the local symbols to see which ones we are
2021 going to output. To deal with this, we keep the relocations in
2022 memory, and don't output them until the end of the link. This is
2023 an unfortunate waste of memory, but I don't see a good way around
2024 it. Fortunately, it only happens when performing a relocateable
2025 link, which is not the common case. FIXME: If keep_memory is set
2026 we could write the relocs out and then read them again; I don't
2027 know how bad the memory loss will be. */
2029 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
2030 sub
->output_has_begun
= false;
2031 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2033 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
2035 if (p
->type
== bfd_indirect_link_order
2036 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2037 == bfd_target_elf_flavour
))
2039 sub
= p
->u
.indirect
.section
->owner
;
2040 if (! sub
->output_has_begun
)
2042 if (! elf_link_input_bfd (&finfo
, sub
))
2044 sub
->output_has_begun
= true;
2047 else if (p
->type
== bfd_section_reloc_link_order
2048 || p
->type
== bfd_symbol_reloc_link_order
)
2050 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2055 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2061 /* That wrote out all the local symbols. Finish up the symbol table
2062 with the global symbols. */
2064 /* The sh_info field records the index of the first non local
2066 symtab_hdr
->sh_info
= abfd
->symcount
;
2068 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2070 /* We get the global symbols from the hash table. */
2073 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2078 /* Flush all symbols to the file. */
2079 if (! elf_link_flush_output_syms (&finfo
))
2082 /* Now we know the size of the symtab section. */
2083 off
+= symtab_hdr
->sh_size
;
2085 /* Finish up and write out the symbol string table (.strtab)
2087 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2088 /* sh_name was set in prep_headers. */
2089 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2090 symstrtab_hdr
->sh_flags
= 0;
2091 symstrtab_hdr
->sh_addr
= 0;
2092 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2093 symstrtab_hdr
->sh_entsize
= 0;
2094 symstrtab_hdr
->sh_link
= 0;
2095 symstrtab_hdr
->sh_info
= 0;
2096 /* sh_offset is set just below. */
2097 symstrtab_hdr
->sh_addralign
= 1;
2099 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2100 elf_tdata (abfd
)->next_file_pos
= off
;
2102 if (abfd
->symcount
> 0)
2104 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2105 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2109 /* Adjust the relocs to have the correct symbol indices. */
2110 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2112 struct elf_link_hash_entry
**rel_hash
;
2113 Elf_Internal_Shdr
*rel_hdr
;
2115 if ((o
->flags
& SEC_RELOC
) == 0)
2118 rel_hash
= elf_section_data (o
)->rel_hashes
;
2119 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2120 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2122 if (*rel_hash
== NULL
)
2125 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2127 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2129 Elf_External_Rel
*erel
;
2130 Elf_Internal_Rel irel
;
2132 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2133 elf_swap_reloc_in (abfd
, erel
, &irel
);
2134 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2135 ELF_R_TYPE (irel
.r_info
));
2136 elf_swap_reloc_out (abfd
, &irel
, erel
);
2140 Elf_External_Rela
*erela
;
2141 Elf_Internal_Rela irela
;
2143 BFD_ASSERT (rel_hdr
->sh_entsize
2144 == sizeof (Elf_External_Rela
));
2146 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2147 elf_swap_reloca_in (abfd
, erela
, &irela
);
2148 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2149 ELF_R_TYPE (irela
.r_info
));
2150 elf_swap_reloca_out (abfd
, &irela
, erela
);
2154 /* Set the reloc_count field to 0 to prevent write_relocs from
2155 trying to swap the relocs out itself. */
2159 /* If we are linking against a dynamic object, or generating a
2160 shared library, finish up the dynamic linking information. */
2163 Elf_External_Dyn
*dyncon
, *dynconend
;
2165 /* Fix up .dynamic entries. */
2166 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2167 BFD_ASSERT (o
!= NULL
);
2169 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2170 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2171 for (; dyncon
< dynconend
; dyncon
++)
2173 Elf_Internal_Dyn dyn
;
2177 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2184 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2185 magic _init and _fini symbols. This is pretty ugly,
2186 but we are compatible. */
2194 struct elf_link_hash_entry
*h
;
2196 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2197 false, false, true);
2199 && (h
->root
.type
== bfd_link_hash_defined
2200 || h
->root
.type
== bfd_link_hash_defweak
))
2202 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2203 o
= h
->root
.u
.def
.section
;
2204 if (o
->output_section
!= NULL
)
2205 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2206 + o
->output_offset
);
2209 /* The symbol is imported from another shared
2210 library and does not apply to this one. */
2214 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2228 o
= bfd_get_section_by_name (abfd
, name
);
2229 BFD_ASSERT (o
!= NULL
);
2230 dyn
.d_un
.d_ptr
= o
->vma
;
2231 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2238 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2243 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2245 Elf_Internal_Shdr
*hdr
;
2247 hdr
= elf_elfsections (abfd
)[i
];
2248 if (hdr
->sh_type
== type
2249 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2251 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2252 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2255 if (dyn
.d_un
.d_val
== 0
2256 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2257 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2261 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2267 /* If we have created any dynamic sections, then output them. */
2270 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2273 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2275 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2276 || o
->_raw_size
== 0)
2278 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2280 /* At this point, we are only interested in sections
2281 created by elf_link_create_dynamic_sections. FIXME:
2282 This test is fragile. */
2285 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2287 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2289 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2290 o
->contents
, o
->output_offset
,
2298 /* The contents of the .dynstr section are actually in a
2300 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2301 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2302 || ! _bfd_stringtab_emit (abfd
,
2303 elf_hash_table (info
)->dynstr
))
2309 if (finfo
.symstrtab
!= NULL
)
2310 _bfd_stringtab_free (finfo
.symstrtab
);
2311 if (finfo
.contents
!= NULL
)
2312 free (finfo
.contents
);
2313 if (finfo
.external_relocs
!= NULL
)
2314 free (finfo
.external_relocs
);
2315 if (finfo
.internal_relocs
!= NULL
)
2316 free (finfo
.internal_relocs
);
2317 if (finfo
.external_syms
!= NULL
)
2318 free (finfo
.external_syms
);
2319 if (finfo
.internal_syms
!= NULL
)
2320 free (finfo
.internal_syms
);
2321 if (finfo
.indices
!= NULL
)
2322 free (finfo
.indices
);
2323 if (finfo
.sections
!= NULL
)
2324 free (finfo
.sections
);
2325 if (finfo
.symbuf
!= NULL
)
2326 free (finfo
.symbuf
);
2327 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2329 if ((o
->flags
& SEC_RELOC
) != 0
2330 && elf_section_data (o
)->rel_hashes
!= NULL
)
2331 free (elf_section_data (o
)->rel_hashes
);
2334 elf_tdata (abfd
)->linker
= true;
2339 if (finfo
.symstrtab
!= NULL
)
2340 _bfd_stringtab_free (finfo
.symstrtab
);
2341 if (finfo
.contents
!= NULL
)
2342 free (finfo
.contents
);
2343 if (finfo
.external_relocs
!= NULL
)
2344 free (finfo
.external_relocs
);
2345 if (finfo
.internal_relocs
!= NULL
)
2346 free (finfo
.internal_relocs
);
2347 if (finfo
.external_syms
!= NULL
)
2348 free (finfo
.external_syms
);
2349 if (finfo
.internal_syms
!= NULL
)
2350 free (finfo
.internal_syms
);
2351 if (finfo
.indices
!= NULL
)
2352 free (finfo
.indices
);
2353 if (finfo
.sections
!= NULL
)
2354 free (finfo
.sections
);
2355 if (finfo
.symbuf
!= NULL
)
2356 free (finfo
.symbuf
);
2357 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2359 if ((o
->flags
& SEC_RELOC
) != 0
2360 && elf_section_data (o
)->rel_hashes
!= NULL
)
2361 free (elf_section_data (o
)->rel_hashes
);
2367 /* Add a symbol to the output symbol table. */
2370 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2371 struct elf_final_link_info
*finfo
;
2373 Elf_Internal_Sym
*elfsym
;
2374 asection
*input_sec
;
2376 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2377 struct bfd_link_info
*info
,
2382 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2383 elf_backend_link_output_symbol_hook
;
2384 if (output_symbol_hook
!= NULL
)
2386 if (! ((*output_symbol_hook
)
2387 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2391 if (name
== (const char *) NULL
|| *name
== '\0')
2392 elfsym
->st_name
= 0;
2395 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2398 if (elfsym
->st_name
== (unsigned long) -1)
2402 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2404 if (! elf_link_flush_output_syms (finfo
))
2408 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2409 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2410 ++finfo
->symbuf_count
;
2412 ++finfo
->output_bfd
->symcount
;
2417 /* Flush the output symbols to the file. */
2420 elf_link_flush_output_syms (finfo
)
2421 struct elf_final_link_info
*finfo
;
2423 if (finfo
->symbuf_count
> 0)
2425 Elf_Internal_Shdr
*symtab
;
2427 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2429 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2431 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2432 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2433 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2436 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2438 finfo
->symbuf_count
= 0;
2444 /* Add an external symbol to the symbol table. This is called from
2445 the hash table traversal routine. */
2448 elf_link_output_extsym (h
, data
)
2449 struct elf_link_hash_entry
*h
;
2452 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2453 struct elf_final_link_info
*finfo
= eif
->finfo
;
2455 Elf_Internal_Sym sym
;
2456 asection
*input_sec
;
2458 /* If we are not creating a shared library, and this symbol is
2459 referenced by a shared library but is not defined anywhere, then
2460 warn that it is undefined. If we do not do this, the runtime
2461 linker will complain that the symbol is undefined when the
2462 program is run. We don't have to worry about symbols that are
2463 referenced by regular files, because we will already have issued
2464 warnings for them. */
2465 if (! finfo
->info
->relocateable
2466 && ! finfo
->info
->shared
2467 && h
->root
.type
== bfd_link_hash_undefined
2468 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2469 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2471 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2472 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2473 (asection
*) NULL
, 0)))
2480 /* We don't want to output symbols that have never been mentioned by
2481 a regular file, or that we have been told to strip. However, if
2482 h->indx is set to -2, the symbol is used by a reloc and we must
2486 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2487 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2488 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2489 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2491 else if (finfo
->info
->strip
== strip_all
2492 || (finfo
->info
->strip
== strip_some
2493 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2494 h
->root
.root
.string
,
2495 false, false) == NULL
))
2500 /* If we're stripping it, and it's not a dynamic symbol, there's
2501 nothing else to do. */
2502 if (strip
&& h
->dynindx
== -1)
2506 sym
.st_size
= h
->size
;
2508 if (h
->root
.type
== bfd_link_hash_undefweak
2509 || h
->root
.type
== bfd_link_hash_defweak
)
2510 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2512 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2514 switch (h
->root
.type
)
2517 case bfd_link_hash_new
:
2521 case bfd_link_hash_undefined
:
2522 input_sec
= bfd_und_section_ptr
;
2523 sym
.st_shndx
= SHN_UNDEF
;
2526 case bfd_link_hash_undefweak
:
2527 input_sec
= bfd_und_section_ptr
;
2528 sym
.st_shndx
= SHN_UNDEF
;
2531 case bfd_link_hash_defined
:
2532 case bfd_link_hash_defweak
:
2534 input_sec
= h
->root
.u
.def
.section
;
2535 if (input_sec
->output_section
!= NULL
)
2538 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2539 input_sec
->output_section
);
2540 if (sym
.st_shndx
== (unsigned short) -1)
2546 /* ELF symbols in relocateable files are section relative,
2547 but in nonrelocateable files they are virtual
2549 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2550 if (! finfo
->info
->relocateable
)
2551 sym
.st_value
+= input_sec
->output_section
->vma
;
2555 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2556 == bfd_target_elf_flavour
)
2557 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2558 sym
.st_shndx
= SHN_UNDEF
;
2559 input_sec
= bfd_und_section_ptr
;
2564 case bfd_link_hash_common
:
2565 input_sec
= bfd_com_section_ptr
;
2566 sym
.st_shndx
= SHN_COMMON
;
2567 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2570 case bfd_link_hash_indirect
:
2571 case bfd_link_hash_warning
:
2572 /* We can't represent these symbols in ELF. A warning symbol
2573 may have come from a .gnu.warning.SYMBOL section anyhow. We
2574 just put the target symbol in the hash table. If the target
2575 symbol does not really exist, don't do anything. */
2576 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2578 return (elf_link_output_extsym
2579 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2582 /* If this symbol should be put in the .dynsym section, then put it
2583 there now. We have already know the symbol index. We also fill
2584 in the entry in the .hash section. */
2585 if (h
->dynindx
!= -1
2586 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2588 struct elf_backend_data
*bed
;
2591 bfd_byte
*bucketpos
;
2594 sym
.st_name
= h
->dynstr_index
;
2596 /* Give the processor backend a chance to tweak the symbol
2597 value, and also to finish up anything that needs to be done
2599 bed
= get_elf_backend_data (finfo
->output_bfd
);
2600 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2601 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2607 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2608 (PTR
) (((Elf_External_Sym
*)
2609 finfo
->dynsym_sec
->contents
)
2612 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2613 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2615 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2616 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2617 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2618 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2619 put_word (finfo
->output_bfd
, chain
,
2620 ((bfd_byte
*) finfo
->hash_sec
->contents
2621 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2624 /* If we're stripping it, then it was just a dynamic symbol, and
2625 there's nothing else to do. */
2629 h
->indx
= finfo
->output_bfd
->symcount
;
2631 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2640 /* Link an input file into the linker output file. This function
2641 handles all the sections and relocations of the input file at once.
2642 This is so that we only have to read the local symbols once, and
2643 don't have to keep them in memory. */
2646 elf_link_input_bfd (finfo
, input_bfd
)
2647 struct elf_final_link_info
*finfo
;
2650 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2651 bfd
*, asection
*, bfd_byte
*,
2652 Elf_Internal_Rela
*,
2653 Elf_Internal_Sym
*, asection
**));
2655 Elf_Internal_Shdr
*symtab_hdr
;
2658 Elf_External_Sym
*esym
;
2659 Elf_External_Sym
*esymend
;
2660 Elf_Internal_Sym
*isym
;
2662 asection
**ppsection
;
2665 output_bfd
= finfo
->output_bfd
;
2667 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2669 /* If this is a dynamic object, we don't want to do anything here:
2670 we don't want the local symbols, and we don't want the section
2672 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2675 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2676 if (elf_bad_symtab (input_bfd
))
2678 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2683 locsymcount
= symtab_hdr
->sh_info
;
2684 extsymoff
= symtab_hdr
->sh_info
;
2687 /* Read the local symbols. */
2689 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2690 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2691 locsymcount
, input_bfd
)
2692 != locsymcount
* sizeof (Elf_External_Sym
))))
2695 /* Swap in the local symbols and write out the ones which we know
2696 are going into the output file. */
2697 esym
= finfo
->external_syms
;
2698 esymend
= esym
+ locsymcount
;
2699 isym
= finfo
->internal_syms
;
2700 pindex
= finfo
->indices
;
2701 ppsection
= finfo
->sections
;
2702 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2706 Elf_Internal_Sym osym
;
2708 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2711 if (elf_bad_symtab (input_bfd
))
2713 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2720 if (isym
->st_shndx
== SHN_UNDEF
)
2721 isec
= bfd_und_section_ptr
;
2722 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2723 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2724 else if (isym
->st_shndx
== SHN_ABS
)
2725 isec
= bfd_abs_section_ptr
;
2726 else if (isym
->st_shndx
== SHN_COMMON
)
2727 isec
= bfd_com_section_ptr
;
2736 /* Don't output the first, undefined, symbol. */
2737 if (esym
== finfo
->external_syms
)
2740 /* If we are stripping all symbols, we don't want to output this
2742 if (finfo
->info
->strip
== strip_all
)
2745 /* We never output section symbols. Instead, we use the section
2746 symbol of the corresponding section in the output file. */
2747 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2750 /* If we are discarding all local symbols, we don't want to
2751 output this one. If we are generating a relocateable output
2752 file, then some of the local symbols may be required by
2753 relocs; we output them below as we discover that they are
2755 if (finfo
->info
->discard
== discard_all
)
2758 /* Get the name of the symbol. */
2759 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2764 /* See if we are discarding symbols with this name. */
2765 if ((finfo
->info
->strip
== strip_some
2766 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2768 || (finfo
->info
->discard
== discard_l
2769 && strncmp (name
, finfo
->info
->lprefix
,
2770 finfo
->info
->lprefix_len
) == 0))
2773 /* If we get here, we are going to output this symbol. */
2777 /* Adjust the section index for the output file. */
2778 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2779 isec
->output_section
);
2780 if (osym
.st_shndx
== (unsigned short) -1)
2783 *pindex
= output_bfd
->symcount
;
2785 /* ELF symbols in relocateable files are section relative, but
2786 in executable files they are virtual addresses. Note that
2787 this code assumes that all ELF sections have an associated
2788 BFD section with a reasonable value for output_offset; below
2789 we assume that they also have a reasonable value for
2790 output_section. Any special sections must be set up to meet
2791 these requirements. */
2792 osym
.st_value
+= isec
->output_offset
;
2793 if (! finfo
->info
->relocateable
)
2794 osym
.st_value
+= isec
->output_section
->vma
;
2796 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2800 /* Relocate the contents of each section. */
2801 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2803 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2806 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2807 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2809 /* Section was created by elf_link_create_dynamic_sections.
2810 FIXME: This test is fragile. */
2814 /* Read the contents of the section. */
2815 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2816 (file_ptr
) 0, o
->_raw_size
))
2819 if ((o
->flags
& SEC_RELOC
) != 0)
2821 Elf_Internal_Rela
*internal_relocs
;
2823 /* Get the swapped relocs. */
2824 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2825 finfo
->external_relocs
,
2826 finfo
->internal_relocs
,
2828 if (internal_relocs
== NULL
2829 && o
->reloc_count
> 0)
2832 /* Relocate the section by invoking a back end routine.
2834 The back end routine is responsible for adjusting the
2835 section contents as necessary, and (if using Rela relocs
2836 and generating a relocateable output file) adjusting the
2837 reloc addend as necessary.
2839 The back end routine does not have to worry about setting
2840 the reloc address or the reloc symbol index.
2842 The back end routine is given a pointer to the swapped in
2843 internal symbols, and can access the hash table entries
2844 for the external symbols via elf_sym_hashes (input_bfd).
2846 When generating relocateable output, the back end routine
2847 must handle STB_LOCAL/STT_SECTION symbols specially. The
2848 output symbol is going to be a section symbol
2849 corresponding to the output section, which will require
2850 the addend to be adjusted. */
2852 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2856 finfo
->internal_syms
,
2860 if (finfo
->info
->relocateable
)
2862 Elf_Internal_Rela
*irela
;
2863 Elf_Internal_Rela
*irelaend
;
2864 struct elf_link_hash_entry
**rel_hash
;
2865 Elf_Internal_Shdr
*input_rel_hdr
;
2866 Elf_Internal_Shdr
*output_rel_hdr
;
2868 /* Adjust the reloc addresses and symbol indices. */
2870 irela
= internal_relocs
;
2871 irelaend
= irela
+ o
->reloc_count
;
2872 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2873 + o
->output_section
->reloc_count
);
2874 for (; irela
< irelaend
; irela
++, rel_hash
++)
2876 unsigned long r_symndx
;
2877 Elf_Internal_Sym
*isym
;
2880 irela
->r_offset
+= o
->output_offset
;
2882 r_symndx
= ELF_R_SYM (irela
->r_info
);
2887 if (r_symndx
>= locsymcount
2888 || (elf_bad_symtab (input_bfd
)
2889 && finfo
->sections
[r_symndx
] == NULL
))
2893 /* This is a reloc against a global symbol. We
2894 have not yet output all the local symbols, so
2895 we do not know the symbol index of any global
2896 symbol. We set the rel_hash entry for this
2897 reloc to point to the global hash table entry
2898 for this symbol. The symbol index is then
2899 set at the end of elf_bfd_final_link. */
2900 indx
= r_symndx
- extsymoff
;
2901 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2903 /* Setting the index to -2 tells
2904 elf_link_output_extsym that this symbol is
2906 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2907 (*rel_hash
)->indx
= -2;
2912 /* This is a reloc against a local symbol. */
2915 isym
= finfo
->internal_syms
+ r_symndx
;
2916 sec
= finfo
->sections
[r_symndx
];
2917 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2919 /* I suppose the backend ought to fill in the
2920 section of any STT_SECTION symbol against a
2921 processor specific section. */
2922 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2924 else if (sec
== NULL
|| sec
->owner
== NULL
)
2926 bfd_set_error (bfd_error_bad_value
);
2931 r_symndx
= sec
->output_section
->target_index
;
2932 BFD_ASSERT (r_symndx
!= 0);
2937 if (finfo
->indices
[r_symndx
] == -1)
2943 if (finfo
->info
->strip
== strip_all
)
2945 /* You can't do ld -r -s. */
2946 bfd_set_error (bfd_error_invalid_operation
);
2950 /* This symbol was skipped earlier, but
2951 since it is needed by a reloc, we
2952 must output it now. */
2953 link
= symtab_hdr
->sh_link
;
2954 name
= bfd_elf_string_from_elf_section (input_bfd
,
2960 osec
= sec
->output_section
;
2962 _bfd_elf_section_from_bfd_section (output_bfd
,
2964 if (isym
->st_shndx
== (unsigned short) -1)
2967 isym
->st_value
+= sec
->output_offset
;
2968 if (! finfo
->info
->relocateable
)
2969 isym
->st_value
+= osec
->vma
;
2971 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2973 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2977 r_symndx
= finfo
->indices
[r_symndx
];
2980 irela
->r_info
= ELF_R_INFO (r_symndx
,
2981 ELF_R_TYPE (irela
->r_info
));
2984 /* Swap out the relocs. */
2985 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2986 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2987 BFD_ASSERT (output_rel_hdr
->sh_entsize
2988 == input_rel_hdr
->sh_entsize
);
2989 irela
= internal_relocs
;
2990 irelaend
= irela
+ o
->reloc_count
;
2991 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2993 Elf_External_Rel
*erel
;
2995 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2996 + o
->output_section
->reloc_count
);
2997 for (; irela
< irelaend
; irela
++, erel
++)
2999 Elf_Internal_Rel irel
;
3001 irel
.r_offset
= irela
->r_offset
;
3002 irel
.r_info
= irela
->r_info
;
3003 BFD_ASSERT (irela
->r_addend
== 0);
3004 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3009 Elf_External_Rela
*erela
;
3011 BFD_ASSERT (input_rel_hdr
->sh_entsize
3012 == sizeof (Elf_External_Rela
));
3013 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
3014 + o
->output_section
->reloc_count
);
3015 for (; irela
< irelaend
; irela
++, erela
++)
3016 elf_swap_reloca_out (output_bfd
, irela
, erela
);
3019 o
->output_section
->reloc_count
+= o
->reloc_count
;
3023 /* Write out the modified section contents. */
3024 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
3025 finfo
->contents
, o
->output_offset
,
3026 (o
->_cooked_size
!= 0
3035 /* Generate a reloc when linking an ELF file. This is a reloc
3036 requested by the linker, and does come from any input file. This
3037 is used to build constructor and destructor tables when linking
3041 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
3043 struct bfd_link_info
*info
;
3044 asection
*output_section
;
3045 struct bfd_link_order
*link_order
;
3047 reloc_howto_type
*howto
;
3051 struct elf_link_hash_entry
**rel_hash_ptr
;
3052 Elf_Internal_Shdr
*rel_hdr
;
3054 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3057 bfd_set_error (bfd_error_bad_value
);
3061 addend
= link_order
->u
.reloc
.p
->addend
;
3063 /* Figure out the symbol index. */
3064 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3065 + output_section
->reloc_count
);
3066 if (link_order
->type
== bfd_section_reloc_link_order
)
3068 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3069 BFD_ASSERT (indx
!= 0);
3070 *rel_hash_ptr
= NULL
;
3074 struct elf_link_hash_entry
*h
;
3076 /* Treat a reloc against a defined symbol as though it were
3077 actually against the section. */
3078 h
= elf_link_hash_lookup (elf_hash_table (info
),
3079 link_order
->u
.reloc
.p
->u
.name
,
3080 false, false, true);
3082 && (h
->root
.type
== bfd_link_hash_defined
3083 || h
->root
.type
== bfd_link_hash_defweak
))
3087 section
= h
->root
.u
.def
.section
;
3088 indx
= section
->output_section
->target_index
;
3089 *rel_hash_ptr
= NULL
;
3090 /* It seems that we ought to add the symbol value to the
3091 addend here, but in practice it has already been added
3092 because it was passed to constructor_callback. */
3093 addend
+= section
->output_section
->vma
+ section
->output_offset
;
3097 /* Setting the index to -2 tells elf_link_output_extsym that
3098 this symbol is used by a reloc. */
3105 if (! ((*info
->callbacks
->unattached_reloc
)
3106 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3107 (asection
*) NULL
, (bfd_vma
) 0)))
3113 /* If this is an inplace reloc, we must write the addend into the
3115 if (howto
->partial_inplace
&& addend
!= 0)
3118 bfd_reloc_status_type rstat
;
3122 size
= bfd_get_reloc_size (howto
);
3123 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3124 if (buf
== (bfd_byte
*) NULL
)
3126 rstat
= _bfd_relocate_contents (howto
, output_bfd
, addend
, buf
);
3132 case bfd_reloc_outofrange
:
3134 case bfd_reloc_overflow
:
3135 if (! ((*info
->callbacks
->reloc_overflow
)
3137 (link_order
->type
== bfd_section_reloc_link_order
3138 ? bfd_section_name (output_bfd
,
3139 link_order
->u
.reloc
.p
->u
.section
)
3140 : link_order
->u
.reloc
.p
->u
.name
),
3141 howto
->name
, addend
, (bfd
*) NULL
, (asection
*) NULL
,
3149 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3150 (file_ptr
) link_order
->offset
, size
);
3156 /* The address of a reloc is relative to the section in a
3157 relocateable file, and is a virtual address in an executable
3159 offset
= link_order
->offset
;
3160 if (! info
->relocateable
)
3161 offset
+= output_section
->vma
;
3163 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3165 if (rel_hdr
->sh_type
== SHT_REL
)
3167 Elf_Internal_Rel irel
;
3168 Elf_External_Rel
*erel
;
3170 irel
.r_offset
= offset
;
3171 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3172 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3173 + output_section
->reloc_count
);
3174 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3178 Elf_Internal_Rela irela
;
3179 Elf_External_Rela
*erela
;
3181 irela
.r_offset
= offset
;
3182 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3183 irela
.r_addend
= addend
;
3184 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3185 + output_section
->reloc_count
);
3186 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3189 ++output_section
->reloc_count
;
3195 /* Allocate a pointer to live in a linker created section. */
3198 elf_create_pointer_linker_section (abfd
, info
, lsect
, h
, rel
)
3200 struct bfd_link_info
*info
;
3201 elf_linker_section_t
*lsect
;
3202 struct elf_link_hash_entry
*h
;
3203 const Elf_Internal_Rela
*rel
;
3205 elf_linker_section_pointers_t
**ptr_linker_section_ptr
= NULL
;
3206 elf_linker_section_pointers_t
*linker_section_ptr
;
3207 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);;
3209 BFD_ASSERT (lsect
!= NULL
);
3211 /* Is this a global symbol? */
3214 /* Has this symbol already been allocated, if so, our work is done */
3215 if (_bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3220 ptr_linker_section_ptr
= &h
->linker_section_pointer
;
3221 /* Make sure this symbol is output as a dynamic symbol. */
3222 if (h
->dynindx
== -1)
3224 if (! elf_link_record_dynamic_symbol (info
, h
))
3228 if (lsect
->rel_section
)
3229 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3232 else /* Allocation of a pointer to a local symbol */
3234 elf_linker_section_pointers_t
**ptr
= elf_local_ptr_offsets (abfd
);
3236 /* Allocate a table to hold the local symbols if first time */
3239 int num_symbols
= elf_tdata (abfd
)->symtab_hdr
.sh_info
;
3240 register unsigned int i
;
3242 ptr
= (elf_linker_section_pointers_t
**)
3243 bfd_alloc (abfd
, num_symbols
* sizeof (elf_linker_section_pointers_t
*));
3248 elf_local_ptr_offsets (abfd
) = ptr
;
3249 for (i
= 0; i
< num_symbols
; i
++)
3250 ptr
[i
] = (elf_linker_section_pointers_t
*)0;
3253 /* Has this symbol already been allocated, if so, our work is done */
3254 if (_bfd_elf_find_pointer_linker_section (ptr
[r_symndx
],
3259 ptr_linker_section_ptr
= &ptr
[r_symndx
];
3263 /* If we are generating a shared object, we need to
3264 output a R_<xxx>_RELATIVE reloc so that the
3265 dynamic linker can adjust this GOT entry. */
3266 BFD_ASSERT (lsect
->rel_section
!= NULL
);
3267 lsect
->rel_section
->_raw_size
+= sizeof (Elf_External_Rela
);
3271 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3272 from internal memory. */
3273 BFD_ASSERT (ptr_linker_section_ptr
!= NULL
);
3274 linker_section_ptr
= (elf_linker_section_pointers_t
*)
3275 bfd_alloc (abfd
, sizeof (elf_linker_section_pointers_t
));
3277 if (!linker_section_ptr
)
3280 linker_section_ptr
->next
= *ptr_linker_section_ptr
;
3281 linker_section_ptr
->addend
= rel
->r_addend
;
3282 linker_section_ptr
->which
= lsect
->which
;
3283 linker_section_ptr
->written_address_p
= false;
3284 *ptr_linker_section_ptr
= linker_section_ptr
;
3286 if (lsect
->hole_size
&& lsect
->hole_offset
< lsect
->max_hole_offset
)
3288 linker_section_ptr
->offset
= lsect
->section
->_raw_size
- lsect
->hole_size
;
3289 lsect
->hole_offset
+= ARCH_SIZE
/ 8;
3290 lsect
->sym_offset
+= ARCH_SIZE
/ 8;
3291 if (lsect
->sym_hash
) /* Bump up symbol value if needed */
3292 lsect
->sym_hash
->root
.u
.def
.value
+= ARCH_SIZE
/ 8;
3295 linker_section_ptr
->offset
= lsect
->section
->_raw_size
;
3297 lsect
->section
->_raw_size
+= ARCH_SIZE
/ 8;
3300 fprintf (stderr
, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3301 lsect
->name
, (long)linker_section_ptr
->offset
, (long)lsect
->section
->_raw_size
);
3309 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3312 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3315 /* Fill in the address for a pointer generated in alinker section. */
3318 elf_finish_pointer_linker_section (output_bfd
, input_bfd
, info
, lsect
, h
, relocation
, rel
, relative_reloc
)
3321 struct bfd_link_info
*info
;
3322 elf_linker_section_t
*lsect
;
3323 struct elf_link_hash_entry
*h
;
3325 const Elf_Internal_Rela
*rel
;
3328 elf_linker_section_pointers_t
*linker_section_ptr
;
3330 BFD_ASSERT (lsect
!= NULL
);
3332 if (h
!= NULL
) /* global symbol */
3334 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (h
->linker_section_pointer
,
3338 BFD_ASSERT (linker_section_ptr
!= NULL
);
3340 if (! elf_hash_table (info
)->dynamic_sections_created
3343 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3345 /* This is actually a static link, or it is a
3346 -Bsymbolic link and the symbol is defined
3347 locally. We must initialize this entry in the
3350 When doing a dynamic link, we create a .rela.<xxx>
3351 relocation entry to initialize the value. This
3352 is done in the finish_dynamic_symbol routine. */
3353 if (!linker_section_ptr
->written_address_p
)
3355 linker_section_ptr
->written_address_p
= true;
3356 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3357 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3361 else /* local symbol */
3363 unsigned long r_symndx
= ELF_R_SYM (rel
->r_info
);
3364 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
) != NULL
);
3365 BFD_ASSERT (elf_local_ptr_offsets (input_bfd
)[r_symndx
] != NULL
);
3366 linker_section_ptr
= _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd
)[r_symndx
],
3370 BFD_ASSERT (linker_section_ptr
!= NULL
);
3372 /* Write out pointer if it hasn't been rewritten out before */
3373 if (!linker_section_ptr
->written_address_p
)
3375 linker_section_ptr
->written_address_p
= true;
3376 bfd_put_ptr (output_bfd
, relocation
+ linker_section_ptr
->addend
,
3377 lsect
->section
->contents
+ linker_section_ptr
->offset
);
3381 asection
*srel
= lsect
->rel_section
;
3382 Elf_Internal_Rela outrel
;
3384 /* We need to generate a relative reloc for the dynamic linker. */
3386 lsect
->rel_section
= srel
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
3389 BFD_ASSERT (srel
!= NULL
);
3391 outrel
.r_offset
= (lsect
->section
->output_section
->vma
3392 + lsect
->section
->output_offset
3393 + linker_section_ptr
->offset
);
3394 outrel
.r_info
= ELF_R_INFO (0, relative_reloc
);
3395 outrel
.r_addend
= 0;
3396 elf_swap_reloca_out (output_bfd
, &outrel
,
3397 (((Elf_External_Rela
*)
3398 lsect
->section
->contents
)
3399 + lsect
->section
->reloc_count
));
3400 ++lsect
->section
->reloc_count
;
3405 relocation
= (lsect
->section
->output_offset
3406 + linker_section_ptr
->offset
3407 - lsect
->hole_offset
3408 - lsect
->sym_offset
);
3411 fprintf (stderr
, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3412 lsect
->name
, (long)relocation
, (long)relocation
);
3415 /* Subtract out the addend, because it will get added back in by the normal
3417 return relocation
- linker_section_ptr
->addend
;