2 Copyright 1995 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
);
62 /* Add symbols from an ELF archive file to the linker hash table. We
63 don't use _bfd_generic_link_add_archive_symbols because of a
64 problem which arises on UnixWare. The UnixWare libc.so is an
65 archive which includes an entry libc.so.1 which defines a bunch of
66 symbols. The libc.so archive also includes a number of other
67 object files, which also define symbols, some of which are the same
68 as those defined in libc.so.1. Correct linking requires that we
69 consider each object file in turn, and include it if it defines any
70 symbols we need. _bfd_generic_link_add_archive_symbols does not do
71 this; it looks through the list of undefined symbols, and includes
72 any object file which defines them. When this algorithm is used on
73 UnixWare, it winds up pulling in libc.so.1 early and defining a
74 bunch of symbols. This means that some of the other objects in the
75 archive are not included in the link, which is incorrect since they
76 precede libc.so.1 in the archive.
78 Fortunately, ELF archive handling is simpler than that done by
79 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
80 oddities. In ELF, if we find a symbol in the archive map, and the
81 symbol is currently undefined, we know that we must pull in that
84 Unfortunately, we do have to make multiple passes over the symbol
85 table until nothing further is resolved. */
88 elf_link_add_archive_symbols (abfd
, info
)
90 struct bfd_link_info
*info
;
93 boolean
*defined
= NULL
;
94 boolean
*included
= NULL
;
98 if (! bfd_has_map (abfd
))
100 /* An empty archive is a special case. */
101 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
103 bfd_set_error (bfd_error_no_armap
);
107 /* Keep track of all symbols we know to be already defined, and all
108 files we know to be already included. This is to speed up the
109 second and subsequent passes. */
110 c
= bfd_ardata (abfd
)->symdef_count
;
113 defined
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
114 included
= (boolean
*) bfd_malloc (c
* sizeof (boolean
));
115 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
117 memset (defined
, 0, c
* sizeof (boolean
));
118 memset (included
, 0, c
* sizeof (boolean
));
120 symdefs
= bfd_ardata (abfd
)->symdefs
;
133 symdefend
= symdef
+ c
;
134 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
136 struct elf_link_hash_entry
*h
;
138 struct bfd_link_hash_entry
*undefs_tail
;
141 if (defined
[i
] || included
[i
])
143 if (symdef
->file_offset
== last
)
149 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
150 false, false, false);
151 if (h
== (struct elf_link_hash_entry
*) NULL
)
153 if (h
->root
.type
!= bfd_link_hash_undefined
)
155 if (h
->root
.type
!= bfd_link_hash_undefweak
)
160 /* We need to include this archive member. */
162 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
163 if (element
== (bfd
*) NULL
)
166 if (! bfd_check_format (element
, bfd_object
))
169 /* Doublecheck that we have not included this object
170 already--it should be impossible, but there may be
171 something wrong with the archive. */
172 if (element
->archive_pass
!= 0)
174 bfd_set_error (bfd_error_bad_value
);
177 element
->archive_pass
= 1;
179 undefs_tail
= info
->hash
->undefs_tail
;
181 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
184 if (! elf_link_add_object_symbols (element
, info
))
187 /* If there are any new undefined symbols, we need to make
188 another pass through the archive in order to see whether
189 they can be defined. FIXME: This isn't perfect, because
190 common symbols wind up on undefs_tail and because an
191 undefined symbol which is defined later on in this pass
192 does not require another pass. This isn't a bug, but it
193 does make the code less efficient than it could be. */
194 if (undefs_tail
!= info
->hash
->undefs_tail
)
197 /* Look backward to mark all symbols from this object file
198 which we have already seen in this pass. */
202 included
[mark
] = true;
207 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
209 /* We mark subsequent symbols from this object file as we go
210 on through the loop. */
211 last
= symdef
->file_offset
;
222 if (defined
!= (boolean
*) NULL
)
224 if (included
!= (boolean
*) NULL
)
229 /* Add symbols from an ELF object file to the linker hash table. */
232 elf_link_add_object_symbols (abfd
, info
)
234 struct bfd_link_info
*info
;
236 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
237 const Elf_Internal_Sym
*,
238 const char **, flagword
*,
239 asection
**, bfd_vma
*));
240 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
241 asection
*, const Elf_Internal_Rela
*));
243 Elf_Internal_Shdr
*hdr
;
247 Elf_External_Sym
*buf
= NULL
;
248 struct elf_link_hash_entry
**sym_hash
;
250 Elf_External_Dyn
*dynbuf
= NULL
;
251 struct elf_link_hash_entry
*weaks
;
252 Elf_External_Sym
*esym
;
253 Elf_External_Sym
*esymend
;
255 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
256 collect
= get_elf_backend_data (abfd
)->collect
;
258 /* As a GNU extension, any input sections which are named
259 .gnu.warning.SYMBOL are treated as warning symbols for the given
260 symbol. This differs from .gnu.warning sections, which generate
261 warnings when they are included in an output file. */
266 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
270 name
= bfd_get_section_name (abfd
, s
);
271 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
276 sz
= bfd_section_size (abfd
, s
);
277 msg
= (char *) bfd_alloc (abfd
, sz
);
281 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
284 if (! (_bfd_generic_link_add_one_symbol
286 name
+ sizeof ".gnu.warning." - 1,
287 BSF_WARNING
, s
, (bfd_vma
) 0, msg
, false, collect
,
288 (struct bfd_link_hash_entry
**) NULL
)))
291 if (! info
->relocateable
)
293 /* Clobber the section size so that the warning does
294 not get copied into the output file. */
301 /* A stripped shared library might only have a dynamic symbol table,
302 not a regular symbol table. In that case we can still go ahead
303 and link using the dynamic symbol table. */
304 if (elf_onesymtab (abfd
) == 0
305 && elf_dynsymtab (abfd
) != 0)
307 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
308 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
311 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
312 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
314 /* The sh_info field of the symtab header tells us where the
315 external symbols start. We don't care about the local symbols at
317 if (elf_bad_symtab (abfd
))
319 extsymcount
= symcount
;
324 extsymcount
= symcount
- hdr
->sh_info
;
325 extsymoff
= hdr
->sh_info
;
328 buf
= ((Elf_External_Sym
*)
329 bfd_malloc (extsymcount
* sizeof (Elf_External_Sym
)));
330 if (buf
== NULL
&& extsymcount
!= 0)
333 /* We store a pointer to the hash table entry for each external
335 sym_hash
= ((struct elf_link_hash_entry
**)
337 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
338 if (sym_hash
== NULL
)
340 elf_sym_hashes (abfd
) = sym_hash
;
342 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
346 /* If we are creating a shared library, create all the dynamic
347 sections immediately. We need to attach them to something,
348 so we attach them to this BFD, provided it is the right
349 format. FIXME: If there are no input BFD's of the same
350 format as the output, we can't make a shared library. */
352 && ! elf_hash_table (info
)->dynamic_sections_created
353 && abfd
->xvec
== info
->hash
->creator
)
355 if (! elf_link_create_dynamic_sections (abfd
, info
))
364 bfd_size_type oldsize
;
365 bfd_size_type strindex
;
369 /* You can't use -r against a dynamic object. Also, there's no
370 hope of using a dynamic object which does not exactly match
371 the format of the output file. */
372 if (info
->relocateable
373 || info
->hash
->creator
!= abfd
->xvec
)
375 bfd_set_error (bfd_error_invalid_operation
);
379 /* Find the name to use in a DT_NEEDED entry that refers to this
380 object. If the object has a DT_SONAME entry, we use it.
381 Otherwise, if the generic linker stuck something in
382 elf_dt_needed_name, we use that. Otherwise, we just use the
383 file name. If the generic linker put a null string into
384 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
385 even if there is a DT_SONAME entry. */
387 name
= bfd_get_filename (abfd
);
388 if (elf_dt_needed_name (abfd
) != NULL
)
390 name
= elf_dt_needed_name (abfd
);
394 s
= bfd_get_section_by_name (abfd
, ".dynamic");
397 Elf_External_Dyn
*extdyn
;
398 Elf_External_Dyn
*extdynend
;
402 dynbuf
= (Elf_External_Dyn
*) bfd_malloc ((size_t) s
->_raw_size
);
406 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
407 (file_ptr
) 0, s
->_raw_size
))
410 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
413 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
416 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
417 for (; extdyn
< extdynend
; extdyn
++)
419 Elf_Internal_Dyn dyn
;
421 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
422 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
424 name
= bfd_elf_string_from_elf_section (abfd
, link
,
429 if (dyn
.d_tag
== DT_NEEDED
)
431 struct bfd_link_needed_list
*n
, **pn
;
434 n
= ((struct bfd_link_needed_list
*)
435 bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
)));
436 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
438 if (n
== NULL
|| fnm
== NULL
)
440 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
447 for (pn
= &elf_hash_table (info
)->needed
;
459 /* We do not want to include any of the sections in a dynamic
460 object in the output file. We hack by simply clobbering the
461 list of sections in the BFD. This could be handled more
462 cleanly by, say, a new section flag; the existing
463 SEC_NEVER_LOAD flag is not the one we want, because that one
464 still implies that the section takes up space in the output
466 abfd
->sections
= NULL
;
467 abfd
->section_count
= 0;
469 /* If this is the first dynamic object found in the link, create
470 the special sections required for dynamic linking. */
471 if (! elf_hash_table (info
)->dynamic_sections_created
)
473 if (! elf_link_create_dynamic_sections (abfd
, info
))
479 /* Add a DT_NEEDED entry for this dynamic object. */
480 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
481 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
483 if (strindex
== (bfd_size_type
) -1)
486 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
489 Elf_External_Dyn
*dyncon
, *dynconend
;
491 /* The hash table size did not change, which means that
492 the dynamic object name was already entered. If we
493 have already included this dynamic object in the
494 link, just ignore it. There is no reason to include
495 a particular dynamic object more than once. */
496 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
498 BFD_ASSERT (sdyn
!= NULL
);
500 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
501 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
503 for (; dyncon
< dynconend
; dyncon
++)
505 Elf_Internal_Dyn dyn
;
507 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
509 if (dyn
.d_tag
== DT_NEEDED
510 && dyn
.d_un
.d_val
== strindex
)
519 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
525 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
527 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
528 != extsymcount
* sizeof (Elf_External_Sym
)))
533 esymend
= buf
+ extsymcount
;
534 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
536 Elf_Internal_Sym sym
;
542 struct elf_link_hash_entry
*h
;
544 boolean size_change_ok
, type_change_ok
;
547 elf_swap_symbol_in (abfd
, esym
, &sym
);
549 flags
= BSF_NO_FLAGS
;
551 value
= sym
.st_value
;
554 bind
= ELF_ST_BIND (sym
.st_info
);
555 if (bind
== STB_LOCAL
)
557 /* This should be impossible, since ELF requires that all
558 global symbols follow all local symbols, and that sh_info
559 point to the first global symbol. Unfortunatealy, Irix 5
563 else if (bind
== STB_GLOBAL
)
565 if (sym
.st_shndx
!= SHN_UNDEF
566 && sym
.st_shndx
!= SHN_COMMON
)
571 else if (bind
== STB_WEAK
)
575 /* Leave it up to the processor backend. */
578 if (sym
.st_shndx
== SHN_UNDEF
)
579 sec
= bfd_und_section_ptr
;
580 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
582 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
586 sec
= bfd_abs_section_ptr
;
588 else if (sym
.st_shndx
== SHN_ABS
)
589 sec
= bfd_abs_section_ptr
;
590 else if (sym
.st_shndx
== SHN_COMMON
)
592 sec
= bfd_com_section_ptr
;
593 /* What ELF calls the size we call the value. What ELF
594 calls the value we call the alignment. */
599 /* Leave it up to the processor backend. */
602 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
603 if (name
== (const char *) NULL
)
608 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
612 /* The hook function sets the name to NULL if this symbol
613 should be skipped for some reason. */
614 if (name
== (const char *) NULL
)
618 /* Sanity check that all possibilities were handled. */
619 if (sec
== (asection
*) NULL
)
621 bfd_set_error (bfd_error_bad_value
);
625 if (bfd_is_und_section (sec
)
626 || bfd_is_com_section (sec
))
631 size_change_ok
= false;
632 type_change_ok
= false;
633 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
635 /* We need to look up the symbol now in order to get some of
636 the dynamic object handling right. We pass the hash
637 table entry in to _bfd_generic_link_add_one_symbol so
638 that it does not have to look it up again. */
639 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
645 while (h
->root
.type
== bfd_link_hash_indirect
646 || h
->root
.type
== bfd_link_hash_warning
)
647 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
649 /* It's OK to change the type if it used to be a weak
651 type_change_ok
= (h
->root
.type
== bfd_link_hash_defweak
652 || h
->root
.type
== bfd_link_hash_undefweak
);
654 /* It's OK to change the size if it used to be a weak
655 definition, or if it used to be undefined, or if we will
656 be overriding an old definition.
658 size_change_ok
= (type_change_ok
659 || h
->root
.type
== bfd_link_hash_undefined
);
661 /* If we are looking at a dynamic object, and this is a
662 definition, we need to see if it has already been defined
663 by some other object. If it has, we want to use the
664 existing definition, and we do not want to report a
665 multiple symbol definition error; we do this by
666 clobbering sec to be bfd_und_section_ptr. */
667 if (dynamic
&& definition
)
669 if (h
->root
.type
== bfd_link_hash_defined
670 || h
->root
.type
== bfd_link_hash_defweak
671 || (h
->root
.type
== bfd_link_hash_common
672 && bind
== STB_WEAK
))
674 sec
= bfd_und_section_ptr
;
676 size_change_ok
= true;
680 /* Similarly, if we are not looking at a dynamic object, and
681 we have a definition, we want to override any definition
682 we may have from a dynamic object. Symbols from regular
683 files always take precedence over symbols from dynamic
684 objects, even if they are defined after the dynamic
685 object in the link. */
688 && (h
->root
.type
== bfd_link_hash_defined
689 || h
->root
.type
== bfd_link_hash_defweak
)
690 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
691 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
692 == bfd_target_elf_flavour
)
693 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
696 /* Change the hash table entry to undefined, and let
697 _bfd_generic_link_add_one_symbol do the right thing
698 with the new definition. */
699 h
->root
.type
= bfd_link_hash_undefined
;
700 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
701 size_change_ok
= true;
705 if (! (_bfd_generic_link_add_one_symbol
706 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
707 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
711 while (h
->root
.type
== bfd_link_hash_indirect
712 || h
->root
.type
== bfd_link_hash_warning
)
713 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
719 && (flags
& BSF_WEAK
) != 0
720 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
721 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
722 && h
->weakdef
== NULL
)
724 /* Keep a list of all weak defined non function symbols from
725 a dynamic object, using the weakdef field. Later in this
726 function we will set the weakdef field to the correct
727 value. We only put non-function symbols from dynamic
728 objects on this list, because that happens to be the only
729 time we need to know the normal symbol corresponding to a
730 weak symbol, and the information is time consuming to
731 figure out. If the weakdef field is not already NULL,
732 then this symbol was already defined by some previous
733 dynamic object, and we will be using that previous
734 definition anyhow. */
741 /* Get the alignment of a common symbol. */
742 if (sym
.st_shndx
== SHN_COMMON
743 && h
->root
.type
== bfd_link_hash_common
)
744 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
746 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
752 /* Remember the symbol size and type. */
754 && (definition
|| h
->size
== 0))
756 if (h
->size
!= 0 && h
->size
!= sym
.st_size
&& ! size_change_ok
)
757 (*_bfd_error_handler
)
758 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
759 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
760 bfd_get_filename (abfd
));
762 h
->size
= sym
.st_size
;
764 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
765 && (definition
|| h
->type
== STT_NOTYPE
))
767 if (h
->type
!= STT_NOTYPE
768 && h
->type
!= ELF_ST_TYPE (sym
.st_info
)
770 (*_bfd_error_handler
)
771 ("Warning: type of symbol `%s' changed from %d to %d in %s",
772 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
773 bfd_get_filename (abfd
));
775 h
->type
= ELF_ST_TYPE (sym
.st_info
);
778 /* Set a flag in the hash table entry indicating the type of
779 reference or definition we just found. Keep a count of
780 the number of dynamic symbols we find. A dynamic symbol
781 is one which is referenced or defined by both a regular
782 object and a shared object, or one which is referenced or
783 defined by more than one shared object. */
784 old_flags
= h
->elf_link_hash_flags
;
789 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
791 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
793 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
794 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
800 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
802 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
803 if ((old_flags
& new_flag
) != 0
804 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
805 | ELF_LINK_HASH_REF_REGULAR
)) != 0
806 || (h
->weakdef
!= NULL
807 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
808 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
812 h
->elf_link_hash_flags
|= new_flag
;
813 if (dynsym
&& h
->dynindx
== -1)
815 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
817 if (h
->weakdef
!= NULL
819 && h
->weakdef
->dynindx
== -1)
821 if (! _bfd_elf_link_record_dynamic_symbol (info
,
829 /* Now set the weakdefs field correctly for all the weak defined
830 symbols we found. The only way to do this is to search all the
831 symbols. Since we only need the information for non functions in
832 dynamic objects, that's the only time we actually put anything on
833 the list WEAKS. We need this information so that if a regular
834 object refers to a symbol defined weakly in a dynamic object, the
835 real symbol in the dynamic object is also put in the dynamic
836 symbols; we also must arrange for both symbols to point to the
837 same memory location. We could handle the general case of symbol
838 aliasing, but a general symbol alias can only be generated in
839 assembler code, handling it correctly would be very time
840 consuming, and other ELF linkers don't handle general aliasing
842 while (weaks
!= NULL
)
844 struct elf_link_hash_entry
*hlook
;
847 struct elf_link_hash_entry
**hpp
;
848 struct elf_link_hash_entry
**hppend
;
851 weaks
= hlook
->weakdef
;
852 hlook
->weakdef
= NULL
;
854 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
855 || hlook
->root
.type
== bfd_link_hash_defweak
856 || hlook
->root
.type
== bfd_link_hash_common
857 || hlook
->root
.type
== bfd_link_hash_indirect
);
858 slook
= hlook
->root
.u
.def
.section
;
859 vlook
= hlook
->root
.u
.def
.value
;
861 hpp
= elf_sym_hashes (abfd
);
862 hppend
= hpp
+ extsymcount
;
863 for (; hpp
< hppend
; hpp
++)
865 struct elf_link_hash_entry
*h
;
868 if (h
!= NULL
&& h
!= hlook
869 && (h
->root
.type
== bfd_link_hash_defined
870 || h
->root
.type
== bfd_link_hash_defweak
)
871 && h
->root
.u
.def
.section
== slook
872 && h
->root
.u
.def
.value
== vlook
)
876 /* If the weak definition is in the list of dynamic
877 symbols, make sure the real definition is put there
879 if (hlook
->dynindx
!= -1
882 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
897 /* If this object is the same format as the output object, and it is
898 not a shared library, then let the backend look through the
901 This is required to build global offset table entries and to
902 arrange for dynamic relocs. It is not required for the
903 particular common case of linking non PIC code, even when linking
904 against shared libraries, but unfortunately there is no way of
905 knowing whether an object file has been compiled PIC or not.
906 Looking through the relocs is not particularly time consuming.
907 The problem is that we must either (1) keep the relocs in memory,
908 which causes the linker to require additional runtime memory or
909 (2) read the relocs twice from the input file, which wastes time.
910 This would be a good case for using mmap.
912 I have no idea how to handle linking PIC code into a file of a
913 different format. It probably can't be done. */
914 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
916 && abfd
->xvec
== info
->hash
->creator
917 && check_relocs
!= NULL
)
921 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
923 Elf_Internal_Rela
*internal_relocs
;
926 if ((o
->flags
& SEC_RELOC
) == 0
927 || o
->reloc_count
== 0)
930 /* I believe we can ignore the relocs for any section which
931 does not form part of the final process image, such as a
932 debugging section. */
933 if ((o
->flags
& SEC_ALLOC
) == 0)
936 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
937 (Elf_Internal_Rela
*) NULL
,
939 if (internal_relocs
== NULL
)
942 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
944 if (! info
->keep_memory
)
945 free (internal_relocs
);
962 /* Create some sections which will be filled in with dynamic linking
963 information. ABFD is an input file which requires dynamic sections
964 to be created. The dynamic sections take up virtual memory space
965 when the final executable is run, so we need to create them before
966 addresses are assigned to the output sections. We work out the
967 actual contents and size of these sections later. */
970 elf_link_create_dynamic_sections (abfd
, info
)
972 struct bfd_link_info
*info
;
975 register asection
*s
;
976 struct elf_link_hash_entry
*h
;
977 struct elf_backend_data
*bed
;
979 if (elf_hash_table (info
)->dynamic_sections_created
)
982 /* Make sure that all dynamic sections use the same input BFD. */
983 if (elf_hash_table (info
)->dynobj
== NULL
)
984 elf_hash_table (info
)->dynobj
= abfd
;
986 abfd
= elf_hash_table (info
)->dynobj
;
988 /* Note that we set the SEC_IN_MEMORY flag for all of these
990 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
992 /* A dynamically linked executable has a .interp section, but a
993 shared library does not. */
996 s
= bfd_make_section (abfd
, ".interp");
998 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1002 s
= bfd_make_section (abfd
, ".dynsym");
1004 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1005 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1008 s
= bfd_make_section (abfd
, ".dynstr");
1010 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1013 /* Create a strtab to hold the dynamic symbol names. */
1014 if (elf_hash_table (info
)->dynstr
== NULL
)
1016 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1017 if (elf_hash_table (info
)->dynstr
== NULL
)
1021 s
= bfd_make_section (abfd
, ".dynamic");
1023 || ! bfd_set_section_flags (abfd
, s
, flags
)
1024 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1027 /* The special symbol _DYNAMIC is always set to the start of the
1028 .dynamic section. This call occurs before we have processed the
1029 symbols for any dynamic object, so we don't have to worry about
1030 overriding a dynamic definition. We could set _DYNAMIC in a
1031 linker script, but we only want to define it if we are, in fact,
1032 creating a .dynamic section. We don't want to define it if there
1033 is no .dynamic section, since on some ELF platforms the start up
1034 code examines it to decide how to initialize the process. */
1036 if (! (_bfd_generic_link_add_one_symbol
1037 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1038 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1039 (struct bfd_link_hash_entry
**) &h
)))
1041 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1042 h
->type
= STT_OBJECT
;
1045 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1048 s
= bfd_make_section (abfd
, ".hash");
1050 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1051 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1054 /* Let the backend create the rest of the sections. This lets the
1055 backend set the right flags. The backend will normally create
1056 the .got and .plt sections. */
1057 bed
= get_elf_backend_data (abfd
);
1058 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1061 elf_hash_table (info
)->dynamic_sections_created
= true;
1066 /* Add an entry to the .dynamic table. */
1069 elf_add_dynamic_entry (info
, tag
, val
)
1070 struct bfd_link_info
*info
;
1074 Elf_Internal_Dyn dyn
;
1078 bfd_byte
*newcontents
;
1080 dynobj
= elf_hash_table (info
)->dynobj
;
1082 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1083 BFD_ASSERT (s
!= NULL
);
1085 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1086 newcontents
= (bfd_byte
*) bfd_realloc (s
->contents
, newsize
);
1087 if (newcontents
== NULL
)
1091 dyn
.d_un
.d_val
= val
;
1092 elf_swap_dyn_out (dynobj
, &dyn
,
1093 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1095 s
->_raw_size
= newsize
;
1096 s
->contents
= newcontents
;
1101 /* Read and swap the relocs for a section. They may have been cached.
1102 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1103 they are used as buffers to read into. They are known to be large
1104 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1105 value is allocated using either malloc or bfd_alloc, according to
1106 the KEEP_MEMORY argument. */
1108 static Elf_Internal_Rela
*
1109 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1112 PTR external_relocs
;
1113 Elf_Internal_Rela
*internal_relocs
;
1114 boolean keep_memory
;
1116 Elf_Internal_Shdr
*rel_hdr
;
1118 Elf_Internal_Rela
*alloc2
= NULL
;
1120 if (elf_section_data (o
)->relocs
!= NULL
)
1121 return elf_section_data (o
)->relocs
;
1123 if (o
->reloc_count
== 0)
1126 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1128 if (internal_relocs
== NULL
)
1132 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1134 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1136 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) bfd_malloc (size
);
1137 if (internal_relocs
== NULL
)
1141 if (external_relocs
== NULL
)
1143 alloc1
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1146 external_relocs
= alloc1
;
1149 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1150 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1151 != rel_hdr
->sh_size
))
1154 /* Swap in the relocs. For convenience, we always produce an
1155 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1157 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1159 Elf_External_Rel
*erel
;
1160 Elf_External_Rel
*erelend
;
1161 Elf_Internal_Rela
*irela
;
1163 erel
= (Elf_External_Rel
*) external_relocs
;
1164 erelend
= erel
+ o
->reloc_count
;
1165 irela
= internal_relocs
;
1166 for (; erel
< erelend
; erel
++, irela
++)
1168 Elf_Internal_Rel irel
;
1170 elf_swap_reloc_in (abfd
, erel
, &irel
);
1171 irela
->r_offset
= irel
.r_offset
;
1172 irela
->r_info
= irel
.r_info
;
1173 irela
->r_addend
= 0;
1178 Elf_External_Rela
*erela
;
1179 Elf_External_Rela
*erelaend
;
1180 Elf_Internal_Rela
*irela
;
1182 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1184 erela
= (Elf_External_Rela
*) external_relocs
;
1185 erelaend
= erela
+ o
->reloc_count
;
1186 irela
= internal_relocs
;
1187 for (; erela
< erelaend
; erela
++, irela
++)
1188 elf_swap_reloca_in (abfd
, erela
, irela
);
1191 /* Cache the results for next time, if we can. */
1193 elf_section_data (o
)->relocs
= internal_relocs
;
1198 /* Don't free alloc2, since if it was allocated we are passing it
1199 back (under the name of internal_relocs). */
1201 return internal_relocs
;
1211 /* Record an assignment to a symbol made by a linker script. We need
1212 this in case some dynamic object refers to this symbol. */
1216 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1218 struct bfd_link_info
*info
;
1222 struct elf_link_hash_entry
*h
;
1224 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1227 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1231 /* If this symbol is being provided by the linker script, and it is
1232 currently defined by a dynamic object, but not by a regular
1233 object, then mark it as undefined so that the generic linker will
1234 force the correct value. */
1236 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1237 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1238 h
->root
.type
= bfd_link_hash_undefined
;
1240 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1241 h
->type
= STT_OBJECT
;
1243 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1244 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1246 && h
->dynindx
== -1)
1248 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1251 /* If this is a weak defined symbol, and we know a corresponding
1252 real symbol from the same dynamic object, make sure the real
1253 symbol is also made into a dynamic symbol. */
1254 if (h
->weakdef
!= NULL
1255 && h
->weakdef
->dynindx
== -1)
1257 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1265 /* Array used to determine the number of hash table buckets to use
1266 based on the number of symbols there are. If there are fewer than
1267 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1268 fewer than 37 we use 17 buckets, and so forth. We never use more
1269 than 521 buckets. */
1271 static const size_t elf_buckets
[] =
1273 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1276 /* Set up the sizes and contents of the ELF dynamic sections. This is
1277 called by the ELF linker emulation before_allocation routine. We
1278 must set the sizes of the sections before the linker sets the
1279 addresses of the various sections. */
1282 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1283 export_dynamic
, info
, sinterpptr
)
1287 boolean export_dynamic
;
1288 struct bfd_link_info
*info
;
1289 asection
**sinterpptr
;
1292 struct elf_backend_data
*bed
;
1296 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1299 dynobj
= elf_hash_table (info
)->dynobj
;
1301 /* If there were no dynamic objects in the link, there is nothing to
1306 /* If we are supposed to export all symbols into the dynamic symbol
1307 table (this is not the normal case), then do so. */
1310 struct elf_info_failed eif
;
1314 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1320 if (elf_hash_table (info
)->dynamic_sections_created
)
1322 struct elf_info_failed eif
;
1323 struct elf_link_hash_entry
*h
;
1324 bfd_size_type strsize
;
1326 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1327 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1333 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1335 if (indx
== (bfd_size_type
) -1
1336 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1342 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1350 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1352 if (indx
== (bfd_size_type
) -1
1353 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1357 /* Find all symbols which were defined in a dynamic object and make
1358 the backend pick a reasonable value for them. */
1361 elf_link_hash_traverse (elf_hash_table (info
),
1362 elf_adjust_dynamic_symbol
,
1367 /* Add some entries to the .dynamic section. We fill in some of the
1368 values later, in elf_bfd_final_link, but we must add the entries
1369 now so that we know the final size of the .dynamic section. */
1370 h
= elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1373 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1374 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1376 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1379 h
= elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1382 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
1383 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
1385 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1388 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1389 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1390 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1391 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1392 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1393 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1394 sizeof (Elf_External_Sym
)))
1398 /* The backend must work out the sizes of all the other dynamic
1400 bed
= get_elf_backend_data (output_bfd
);
1401 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1404 if (elf_hash_table (info
)->dynamic_sections_created
)
1409 size_t bucketcount
= 0;
1410 Elf_Internal_Sym isym
;
1412 /* Set the size of the .dynsym and .hash sections. We counted
1413 the number of dynamic symbols in elf_link_add_object_symbols.
1414 We will build the contents of .dynsym and .hash when we build
1415 the final symbol table, because until then we do not know the
1416 correct value to give the symbols. We built the .dynstr
1417 section as we went along in elf_link_add_object_symbols. */
1418 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1419 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1420 BFD_ASSERT (s
!= NULL
);
1421 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1422 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1423 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1426 /* The first entry in .dynsym is a dummy symbol. */
1433 elf_swap_symbol_out (output_bfd
, &isym
,
1434 (PTR
) (Elf_External_Sym
*) s
->contents
);
1436 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1438 bucketcount
= elf_buckets
[i
];
1439 if (dynsymcount
< elf_buckets
[i
+ 1])
1443 s
= bfd_get_section_by_name (dynobj
, ".hash");
1444 BFD_ASSERT (s
!= NULL
);
1445 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1446 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1447 if (s
->contents
== NULL
)
1449 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1451 put_word (output_bfd
, bucketcount
, s
->contents
);
1452 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1454 elf_hash_table (info
)->bucketcount
= bucketcount
;
1456 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1457 BFD_ASSERT (s
!= NULL
);
1458 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1460 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1467 /* This routine is used to export all defined symbols into the dynamic
1468 symbol table. It is called via elf_link_hash_traverse. */
1471 elf_export_symbol (h
, data
)
1472 struct elf_link_hash_entry
*h
;
1475 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1477 if (h
->dynindx
== -1
1478 && (h
->elf_link_hash_flags
1479 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1481 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1491 /* Make the backend pick a good value for a dynamic symbol. This is
1492 called via elf_link_hash_traverse, and also calls itself
1496 elf_adjust_dynamic_symbol (h
, data
)
1497 struct elf_link_hash_entry
*h
;
1500 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1502 struct elf_backend_data
*bed
;
1504 /* If -Bsymbolic was used (which means to bind references to global
1505 symbols to the definition within the shared object), and this
1506 symbol was defined in a regular object, then it actually doesn't
1507 need a PLT entry. */
1508 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1509 && eif
->info
->shared
1510 && eif
->info
->symbolic
1511 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1512 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1514 /* If this symbol does not require a PLT entry, and it is not
1515 defined by a dynamic object, or is not referenced by a regular
1516 object, ignore it. We do have to handle a weak defined symbol,
1517 even if no regular object refers to it, if we decided to add it
1518 to the dynamic symbol table. FIXME: Do we normally need to worry
1519 about symbols which are defined by one dynamic object and
1520 referenced by another one? */
1521 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1522 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1523 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1524 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1525 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1528 /* If we've already adjusted this symbol, don't do it again. This
1529 can happen via a recursive call. */
1530 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1533 /* Don't look at this symbol again. Note that we must set this
1534 after checking the above conditions, because we may look at a
1535 symbol once, decide not to do anything, and then get called
1536 recursively later after REF_REGULAR is set below. */
1537 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1539 /* If this is a weak definition, and we know a real definition, and
1540 the real symbol is not itself defined by a regular object file,
1541 then get a good value for the real definition. We handle the
1542 real symbol first, for the convenience of the backend routine.
1544 Note that there is a confusing case here. If the real definition
1545 is defined by a regular object file, we don't get the real symbol
1546 from the dynamic object, but we do get the weak symbol. If the
1547 processor backend uses a COPY reloc, then if some routine in the
1548 dynamic object changes the real symbol, we will not see that
1549 change in the corresponding weak symbol. This is the way other
1550 ELF linkers work as well, and seems to be a result of the shared
1553 I will clarify this issue. Most SVR4 shared libraries define the
1554 variable _timezone and define timezone as a weak synonym. The
1555 tzset call changes _timezone. If you write
1556 extern int timezone;
1558 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1559 you might expect that, since timezone is a synonym for _timezone,
1560 the same number will print both times. However, if the processor
1561 backend uses a COPY reloc, then actually timezone will be copied
1562 into your process image, and, since you define _timezone
1563 yourself, _timezone will not. Thus timezone and _timezone will
1564 wind up at different memory locations. The tzset call will set
1565 _timezone, leaving timezone unchanged. */
1567 if (h
->weakdef
!= NULL
)
1569 struct elf_link_hash_entry
*weakdef
;
1571 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1572 || h
->root
.type
== bfd_link_hash_defweak
);
1573 weakdef
= h
->weakdef
;
1574 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1575 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1576 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1577 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1579 /* This symbol is defined by a regular object file, so we
1580 will not do anything special. Clear weakdef for the
1581 convenience of the processor backend. */
1586 /* There is an implicit reference by a regular object file
1587 via the weak symbol. */
1588 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1589 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1594 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1595 bed
= get_elf_backend_data (dynobj
);
1596 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1605 /* Final phase of ELF linker. */
1607 /* A structure we use to avoid passing large numbers of arguments. */
1609 struct elf_final_link_info
1611 /* General link information. */
1612 struct bfd_link_info
*info
;
1615 /* Symbol string table. */
1616 struct bfd_strtab_hash
*symstrtab
;
1617 /* .dynsym section. */
1618 asection
*dynsym_sec
;
1619 /* .hash section. */
1621 /* Buffer large enough to hold contents of any section. */
1623 /* Buffer large enough to hold external relocs of any section. */
1624 PTR external_relocs
;
1625 /* Buffer large enough to hold internal relocs of any section. */
1626 Elf_Internal_Rela
*internal_relocs
;
1627 /* Buffer large enough to hold external local symbols of any input
1629 Elf_External_Sym
*external_syms
;
1630 /* Buffer large enough to hold internal local symbols of any input
1632 Elf_Internal_Sym
*internal_syms
;
1633 /* Array large enough to hold a symbol index for each local symbol
1634 of any input BFD. */
1636 /* Array large enough to hold a section pointer for each local
1637 symbol of any input BFD. */
1638 asection
**sections
;
1639 /* Buffer to hold swapped out symbols. */
1640 Elf_External_Sym
*symbuf
;
1641 /* Number of swapped out symbols in buffer. */
1642 size_t symbuf_count
;
1643 /* Number of symbols which fit in symbuf. */
1647 static boolean elf_link_output_sym
1648 PARAMS ((struct elf_final_link_info
*, const char *,
1649 Elf_Internal_Sym
*, asection
*));
1650 static boolean elf_link_flush_output_syms
1651 PARAMS ((struct elf_final_link_info
*));
1652 static boolean elf_link_output_extsym
1653 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1654 static boolean elf_link_input_bfd
1655 PARAMS ((struct elf_final_link_info
*, bfd
*));
1656 static boolean elf_reloc_link_order
1657 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1658 struct bfd_link_order
*));
1660 /* This struct is used to pass information to routines called via
1661 elf_link_hash_traverse which must return failure. */
1663 struct elf_finfo_failed
1666 struct elf_final_link_info
*finfo
;
1669 /* Do the final step of an ELF link. */
1672 elf_bfd_final_link (abfd
, info
)
1674 struct bfd_link_info
*info
;
1678 struct elf_final_link_info finfo
;
1679 register asection
*o
;
1680 register struct bfd_link_order
*p
;
1682 size_t max_contents_size
;
1683 size_t max_external_reloc_size
;
1684 size_t max_internal_reloc_count
;
1685 size_t max_sym_count
;
1687 Elf_Internal_Sym elfsym
;
1689 Elf_Internal_Shdr
*symtab_hdr
;
1690 Elf_Internal_Shdr
*symstrtab_hdr
;
1691 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1692 struct elf_finfo_failed eif
;
1695 abfd
->flags
|= DYNAMIC
;
1697 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1698 dynobj
= elf_hash_table (info
)->dynobj
;
1701 finfo
.output_bfd
= abfd
;
1702 finfo
.symstrtab
= elf_stringtab_init ();
1703 if (finfo
.symstrtab
== NULL
)
1707 finfo
.dynsym_sec
= NULL
;
1708 finfo
.hash_sec
= NULL
;
1712 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1713 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1714 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1716 finfo
.contents
= NULL
;
1717 finfo
.external_relocs
= NULL
;
1718 finfo
.internal_relocs
= NULL
;
1719 finfo
.external_syms
= NULL
;
1720 finfo
.internal_syms
= NULL
;
1721 finfo
.indices
= NULL
;
1722 finfo
.sections
= NULL
;
1723 finfo
.symbuf
= NULL
;
1724 finfo
.symbuf_count
= 0;
1726 /* Count up the number of relocations we will output for each output
1727 section, so that we know the sizes of the reloc sections. We
1728 also figure out some maximum sizes. */
1729 max_contents_size
= 0;
1730 max_external_reloc_size
= 0;
1731 max_internal_reloc_count
= 0;
1733 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1737 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1739 if (p
->type
== bfd_section_reloc_link_order
1740 || p
->type
== bfd_symbol_reloc_link_order
)
1742 else if (p
->type
== bfd_indirect_link_order
)
1746 sec
= p
->u
.indirect
.section
;
1748 if (info
->relocateable
)
1749 o
->reloc_count
+= sec
->reloc_count
;
1751 if (sec
->_raw_size
> max_contents_size
)
1752 max_contents_size
= sec
->_raw_size
;
1753 if (sec
->_cooked_size
> max_contents_size
)
1754 max_contents_size
= sec
->_cooked_size
;
1756 /* We are interested in just local symbols, not all
1758 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1762 if (elf_bad_symtab (sec
->owner
))
1763 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1764 / sizeof (Elf_External_Sym
));
1766 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1768 if (sym_count
> max_sym_count
)
1769 max_sym_count
= sym_count
;
1771 if ((sec
->flags
& SEC_RELOC
) != 0)
1775 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1776 if (ext_size
> max_external_reloc_size
)
1777 max_external_reloc_size
= ext_size
;
1778 if (sec
->reloc_count
> max_internal_reloc_count
)
1779 max_internal_reloc_count
= sec
->reloc_count
;
1785 if (o
->reloc_count
> 0)
1786 o
->flags
|= SEC_RELOC
;
1789 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1790 set it (this is probably a bug) and if it is set
1791 assign_section_numbers will create a reloc section. */
1792 o
->flags
&=~ SEC_RELOC
;
1795 /* If the SEC_ALLOC flag is not set, force the section VMA to
1796 zero. This is done in elf_fake_sections as well, but forcing
1797 the VMA to 0 here will ensure that relocs against these
1798 sections are handled correctly. */
1799 if ((o
->flags
& SEC_ALLOC
) == 0)
1803 /* Figure out the file positions for everything but the symbol table
1804 and the relocs. We set symcount to force assign_section_numbers
1805 to create a symbol table. */
1806 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1807 BFD_ASSERT (! abfd
->output_has_begun
);
1808 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1811 /* That created the reloc sections. Set their sizes, and assign
1812 them file positions, and allocate some buffers. */
1813 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1815 if ((o
->flags
& SEC_RELOC
) != 0)
1817 Elf_Internal_Shdr
*rel_hdr
;
1818 register struct elf_link_hash_entry
**p
, **pend
;
1820 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1822 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1824 /* The contents field must last into write_object_contents,
1825 so we allocate it with bfd_alloc rather than malloc. */
1826 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1827 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1830 p
= ((struct elf_link_hash_entry
**)
1831 bfd_malloc (o
->reloc_count
1832 * sizeof (struct elf_link_hash_entry
*)));
1833 if (p
== NULL
&& o
->reloc_count
!= 0)
1835 elf_section_data (o
)->rel_hashes
= p
;
1836 pend
= p
+ o
->reloc_count
;
1837 for (; p
< pend
; p
++)
1840 /* Use the reloc_count field as an index when outputting the
1846 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1848 /* We have now assigned file positions for all the sections except
1849 .symtab and .strtab. We start the .symtab section at the current
1850 file position, and write directly to it. We build the .strtab
1851 section in memory. */
1853 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1854 /* sh_name is set in prep_headers. */
1855 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1856 symtab_hdr
->sh_flags
= 0;
1857 symtab_hdr
->sh_addr
= 0;
1858 symtab_hdr
->sh_size
= 0;
1859 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1860 /* sh_link is set in assign_section_numbers. */
1861 /* sh_info is set below. */
1862 /* sh_offset is set just below. */
1863 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1865 off
= elf_tdata (abfd
)->next_file_pos
;
1866 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1868 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1869 incorrect. We do not yet know the size of the .symtab section.
1870 We correct next_file_pos below, after we do know the size. */
1872 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1873 continuously seeking to the right position in the file. */
1874 if (! info
->keep_memory
|| max_sym_count
< 20)
1875 finfo
.symbuf_size
= 20;
1877 finfo
.symbuf_size
= max_sym_count
;
1878 finfo
.symbuf
= ((Elf_External_Sym
*)
1879 bfd_malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1880 if (finfo
.symbuf
== NULL
)
1883 /* Start writing out the symbol table. The first symbol is always a
1885 elfsym
.st_value
= 0;
1888 elfsym
.st_other
= 0;
1889 elfsym
.st_shndx
= SHN_UNDEF
;
1890 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1891 &elfsym
, bfd_und_section_ptr
))
1895 /* Some standard ELF linkers do this, but we don't because it causes
1896 bootstrap comparison failures. */
1897 /* Output a file symbol for the output file as the second symbol.
1898 We output this even if we are discarding local symbols, although
1899 I'm not sure if this is correct. */
1900 elfsym
.st_value
= 0;
1902 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1903 elfsym
.st_other
= 0;
1904 elfsym
.st_shndx
= SHN_ABS
;
1905 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1906 &elfsym
, bfd_abs_section_ptr
))
1910 /* Output a symbol for each section. We output these even if we are
1911 discarding local symbols, since they are used for relocs. These
1912 symbols have no names. We store the index of each one in the
1913 index field of the section, so that we can find it again when
1914 outputting relocs. */
1915 elfsym
.st_value
= 0;
1917 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1918 elfsym
.st_other
= 0;
1919 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1921 o
= section_from_elf_index (abfd
, i
);
1923 o
->target_index
= abfd
->symcount
;
1924 elfsym
.st_shndx
= i
;
1925 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1930 /* Allocate some memory to hold information read in from the input
1932 finfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
1933 finfo
.external_relocs
= (PTR
) bfd_malloc (max_external_reloc_size
);
1934 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1935 bfd_malloc (max_internal_reloc_count
1936 * sizeof (Elf_Internal_Rela
)));
1937 finfo
.external_syms
= ((Elf_External_Sym
*)
1938 bfd_malloc (max_sym_count
1939 * sizeof (Elf_External_Sym
)));
1940 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1941 bfd_malloc (max_sym_count
1942 * sizeof (Elf_Internal_Sym
)));
1943 finfo
.indices
= (long *) bfd_malloc (max_sym_count
* sizeof (long));
1944 finfo
.sections
= ((asection
**)
1945 bfd_malloc (max_sym_count
* sizeof (asection
*)));
1946 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
1947 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
1948 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
1949 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
1950 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
1951 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
1952 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
1955 /* Since ELF permits relocations to be against local symbols, we
1956 must have the local symbols available when we do the relocations.
1957 Since we would rather only read the local symbols once, and we
1958 would rather not keep them in memory, we handle all the
1959 relocations for a single input file at the same time.
1961 Unfortunately, there is no way to know the total number of local
1962 symbols until we have seen all of them, and the local symbol
1963 indices precede the global symbol indices. This means that when
1964 we are generating relocateable output, and we see a reloc against
1965 a global symbol, we can not know the symbol index until we have
1966 finished examining all the local symbols to see which ones we are
1967 going to output. To deal with this, we keep the relocations in
1968 memory, and don't output them until the end of the link. This is
1969 an unfortunate waste of memory, but I don't see a good way around
1970 it. Fortunately, it only happens when performing a relocateable
1971 link, which is not the common case. FIXME: If keep_memory is set
1972 we could write the relocs out and then read them again; I don't
1973 know how bad the memory loss will be. */
1975 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
1976 sub
->output_has_begun
= false;
1977 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1979 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1981 if (p
->type
== bfd_indirect_link_order
1982 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
1983 == bfd_target_elf_flavour
))
1985 sub
= p
->u
.indirect
.section
->owner
;
1986 if (! sub
->output_has_begun
)
1988 if (! elf_link_input_bfd (&finfo
, sub
))
1990 sub
->output_has_begun
= true;
1993 else if (p
->type
== bfd_section_reloc_link_order
1994 || p
->type
== bfd_symbol_reloc_link_order
)
1996 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2001 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2007 /* That wrote out all the local symbols. Finish up the symbol table
2008 with the global symbols. */
2010 /* The sh_info field records the index of the first non local
2012 symtab_hdr
->sh_info
= abfd
->symcount
;
2014 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2016 /* We get the global symbols from the hash table. */
2019 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2024 /* Flush all symbols to the file. */
2025 if (! elf_link_flush_output_syms (&finfo
))
2028 /* Now we know the size of the symtab section. */
2029 off
+= symtab_hdr
->sh_size
;
2031 /* Finish up and write out the symbol string table (.strtab)
2033 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2034 /* sh_name was set in prep_headers. */
2035 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2036 symstrtab_hdr
->sh_flags
= 0;
2037 symstrtab_hdr
->sh_addr
= 0;
2038 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2039 symstrtab_hdr
->sh_entsize
= 0;
2040 symstrtab_hdr
->sh_link
= 0;
2041 symstrtab_hdr
->sh_info
= 0;
2042 /* sh_offset is set just below. */
2043 symstrtab_hdr
->sh_addralign
= 1;
2045 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2046 elf_tdata (abfd
)->next_file_pos
= off
;
2048 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2049 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2052 /* Adjust the relocs to have the correct symbol indices. */
2053 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2055 struct elf_link_hash_entry
**rel_hash
;
2056 Elf_Internal_Shdr
*rel_hdr
;
2058 if ((o
->flags
& SEC_RELOC
) == 0)
2061 rel_hash
= elf_section_data (o
)->rel_hashes
;
2062 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2063 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2065 if (*rel_hash
== NULL
)
2068 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2070 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2072 Elf_External_Rel
*erel
;
2073 Elf_Internal_Rel irel
;
2075 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2076 elf_swap_reloc_in (abfd
, erel
, &irel
);
2077 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2078 ELF_R_TYPE (irel
.r_info
));
2079 elf_swap_reloc_out (abfd
, &irel
, erel
);
2083 Elf_External_Rela
*erela
;
2084 Elf_Internal_Rela irela
;
2086 BFD_ASSERT (rel_hdr
->sh_entsize
2087 == sizeof (Elf_External_Rela
));
2089 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2090 elf_swap_reloca_in (abfd
, erela
, &irela
);
2091 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2092 ELF_R_TYPE (irela
.r_info
));
2093 elf_swap_reloca_out (abfd
, &irela
, erela
);
2097 /* Set the reloc_count field to 0 to prevent write_relocs from
2098 trying to swap the relocs out itself. */
2102 /* If we are linking against a dynamic object, or generating a
2103 shared library, finish up the dynamic linking information. */
2106 Elf_External_Dyn
*dyncon
, *dynconend
;
2108 /* Fix up .dynamic entries. */
2109 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2110 BFD_ASSERT (o
!= NULL
);
2112 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2113 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2114 for (; dyncon
< dynconend
; dyncon
++)
2116 Elf_Internal_Dyn dyn
;
2120 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2127 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2128 magic _init and _fini symbols. This is pretty ugly,
2129 but we are compatible. */
2137 struct elf_link_hash_entry
*h
;
2139 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2140 false, false, true);
2142 && (h
->root
.type
== bfd_link_hash_defined
2143 || h
->root
.type
== bfd_link_hash_defweak
))
2145 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2146 o
= h
->root
.u
.def
.section
;
2147 if (o
->output_section
!= NULL
)
2148 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2149 + o
->output_offset
);
2152 /* The symbol is imported from another shared
2153 library and does not apply to this one. */
2157 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2171 o
= bfd_get_section_by_name (abfd
, name
);
2172 BFD_ASSERT (o
!= NULL
);
2173 dyn
.d_un
.d_ptr
= o
->vma
;
2174 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2181 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2186 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2188 Elf_Internal_Shdr
*hdr
;
2190 hdr
= elf_elfsections (abfd
)[i
];
2191 if (hdr
->sh_type
== type
2192 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2194 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2195 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2198 if (dyn
.d_un
.d_val
== 0
2199 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2200 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2204 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2210 /* If we have created any dynamic sections, then output them. */
2213 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2216 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2218 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2219 || o
->_raw_size
== 0)
2221 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2223 /* At this point, we are only interested in sections
2224 created by elf_link_create_dynamic_sections. FIXME:
2225 This test is fragile. */
2228 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2230 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2232 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2233 o
->contents
, o
->output_offset
,
2241 /* The contents of the .dynstr section are actually in a
2243 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2244 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2245 || ! _bfd_stringtab_emit (abfd
,
2246 elf_hash_table (info
)->dynstr
))
2252 if (finfo
.symstrtab
!= NULL
)
2253 _bfd_stringtab_free (finfo
.symstrtab
);
2254 if (finfo
.contents
!= NULL
)
2255 free (finfo
.contents
);
2256 if (finfo
.external_relocs
!= NULL
)
2257 free (finfo
.external_relocs
);
2258 if (finfo
.internal_relocs
!= NULL
)
2259 free (finfo
.internal_relocs
);
2260 if (finfo
.external_syms
!= NULL
)
2261 free (finfo
.external_syms
);
2262 if (finfo
.internal_syms
!= NULL
)
2263 free (finfo
.internal_syms
);
2264 if (finfo
.indices
!= NULL
)
2265 free (finfo
.indices
);
2266 if (finfo
.sections
!= NULL
)
2267 free (finfo
.sections
);
2268 if (finfo
.symbuf
!= NULL
)
2269 free (finfo
.symbuf
);
2270 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2272 if ((o
->flags
& SEC_RELOC
) != 0
2273 && elf_section_data (o
)->rel_hashes
!= NULL
)
2274 free (elf_section_data (o
)->rel_hashes
);
2277 elf_tdata (abfd
)->linker
= true;
2282 if (finfo
.symstrtab
!= NULL
)
2283 _bfd_stringtab_free (finfo
.symstrtab
);
2284 if (finfo
.contents
!= NULL
)
2285 free (finfo
.contents
);
2286 if (finfo
.external_relocs
!= NULL
)
2287 free (finfo
.external_relocs
);
2288 if (finfo
.internal_relocs
!= NULL
)
2289 free (finfo
.internal_relocs
);
2290 if (finfo
.external_syms
!= NULL
)
2291 free (finfo
.external_syms
);
2292 if (finfo
.internal_syms
!= NULL
)
2293 free (finfo
.internal_syms
);
2294 if (finfo
.indices
!= NULL
)
2295 free (finfo
.indices
);
2296 if (finfo
.sections
!= NULL
)
2297 free (finfo
.sections
);
2298 if (finfo
.symbuf
!= NULL
)
2299 free (finfo
.symbuf
);
2300 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2302 if ((o
->flags
& SEC_RELOC
) != 0
2303 && elf_section_data (o
)->rel_hashes
!= NULL
)
2304 free (elf_section_data (o
)->rel_hashes
);
2310 /* Add a symbol to the output symbol table. */
2313 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2314 struct elf_final_link_info
*finfo
;
2316 Elf_Internal_Sym
*elfsym
;
2317 asection
*input_sec
;
2319 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2320 struct bfd_link_info
*info
,
2325 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2326 elf_backend_link_output_symbol_hook
;
2327 if (output_symbol_hook
!= NULL
)
2329 if (! ((*output_symbol_hook
)
2330 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2334 if (name
== (const char *) NULL
|| *name
== '\0')
2335 elfsym
->st_name
= 0;
2338 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2341 if (elfsym
->st_name
== (unsigned long) -1)
2345 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2347 if (! elf_link_flush_output_syms (finfo
))
2351 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2352 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2353 ++finfo
->symbuf_count
;
2355 ++finfo
->output_bfd
->symcount
;
2360 /* Flush the output symbols to the file. */
2363 elf_link_flush_output_syms (finfo
)
2364 struct elf_final_link_info
*finfo
;
2366 Elf_Internal_Shdr
*symtab
;
2368 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2370 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2372 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2373 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2374 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2377 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2379 finfo
->symbuf_count
= 0;
2384 /* Add an external symbol to the symbol table. This is called from
2385 the hash table traversal routine. */
2388 elf_link_output_extsym (h
, data
)
2389 struct elf_link_hash_entry
*h
;
2392 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2393 struct elf_final_link_info
*finfo
= eif
->finfo
;
2395 Elf_Internal_Sym sym
;
2396 asection
*input_sec
;
2398 /* If we are not creating a shared library, and this symbol is
2399 referenced by a shared library but is not defined anywhere, then
2400 warn that it is undefined. If we do not do this, the runtime
2401 linker will complain that the symbol is undefined when the
2402 program is run. We don't have to worry about symbols that are
2403 referenced by regular files, because we will already have issued
2404 warnings for them. */
2405 if (! finfo
->info
->relocateable
2406 && ! finfo
->info
->shared
2407 && h
->root
.type
== bfd_link_hash_undefined
2408 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2409 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2411 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2412 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2413 (asection
*) NULL
, 0)))
2420 /* We don't want to output symbols that have never been mentioned by
2421 a regular file, or that we have been told to strip. However, if
2422 h->indx is set to -2, the symbol is used by a reloc and we must
2426 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2427 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2428 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2429 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2431 else if (finfo
->info
->strip
== strip_all
2432 || (finfo
->info
->strip
== strip_some
2433 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2434 h
->root
.root
.string
,
2435 false, false) == NULL
))
2440 /* If we're stripping it, and it's not a dynamic symbol, there's
2441 nothing else to do. */
2442 if (strip
&& h
->dynindx
== -1)
2446 sym
.st_size
= h
->size
;
2448 if (h
->root
.type
== bfd_link_hash_undefweak
2449 || h
->root
.type
== bfd_link_hash_defweak
)
2450 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2452 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2454 switch (h
->root
.type
)
2457 case bfd_link_hash_new
:
2461 case bfd_link_hash_undefined
:
2462 input_sec
= bfd_und_section_ptr
;
2463 sym
.st_shndx
= SHN_UNDEF
;
2466 case bfd_link_hash_undefweak
:
2467 input_sec
= bfd_und_section_ptr
;
2468 sym
.st_shndx
= SHN_UNDEF
;
2471 case bfd_link_hash_defined
:
2472 case bfd_link_hash_defweak
:
2474 input_sec
= h
->root
.u
.def
.section
;
2475 if (input_sec
->output_section
!= NULL
)
2478 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2479 input_sec
->output_section
);
2480 if (sym
.st_shndx
== (unsigned short) -1)
2486 /* ELF symbols in relocateable files are section relative,
2487 but in nonrelocateable files they are virtual
2489 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2490 if (! finfo
->info
->relocateable
)
2491 sym
.st_value
+= input_sec
->output_section
->vma
;
2495 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2496 == bfd_target_elf_flavour
)
2497 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2498 sym
.st_shndx
= SHN_UNDEF
;
2499 input_sec
= bfd_und_section_ptr
;
2504 case bfd_link_hash_common
:
2505 input_sec
= bfd_com_section_ptr
;
2506 sym
.st_shndx
= SHN_COMMON
;
2507 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2510 case bfd_link_hash_indirect
:
2511 case bfd_link_hash_warning
:
2512 /* We can't represent these symbols in ELF. A warning symbol
2513 may have come from a .gnu.warning.SYMBOL section anyhow. We
2514 just put the target symbol in the hash table. If the target
2515 symbol does not really exist, don't do anything. */
2516 if (h
->root
.u
.i
.link
->type
== bfd_link_hash_new
)
2518 return (elf_link_output_extsym
2519 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2522 /* If this symbol should be put in the .dynsym section, then put it
2523 there now. We have already know the symbol index. We also fill
2524 in the entry in the .hash section. */
2525 if (h
->dynindx
!= -1
2526 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2528 struct elf_backend_data
*bed
;
2531 bfd_byte
*bucketpos
;
2534 sym
.st_name
= h
->dynstr_index
;
2536 /* Give the processor backend a chance to tweak the symbol
2537 value, and also to finish up anything that needs to be done
2539 bed
= get_elf_backend_data (finfo
->output_bfd
);
2540 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2541 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2547 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2548 (PTR
) (((Elf_External_Sym
*)
2549 finfo
->dynsym_sec
->contents
)
2552 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2553 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2555 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2556 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2557 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2558 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2559 put_word (finfo
->output_bfd
, chain
,
2560 ((bfd_byte
*) finfo
->hash_sec
->contents
2561 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2564 /* If we're stripping it, then it was just a dynamic symbol, and
2565 there's nothing else to do. */
2569 h
->indx
= finfo
->output_bfd
->symcount
;
2571 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2580 /* Link an input file into the linker output file. This function
2581 handles all the sections and relocations of the input file at once.
2582 This is so that we only have to read the local symbols once, and
2583 don't have to keep them in memory. */
2586 elf_link_input_bfd (finfo
, input_bfd
)
2587 struct elf_final_link_info
*finfo
;
2590 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2591 bfd
*, asection
*, bfd_byte
*,
2592 Elf_Internal_Rela
*,
2593 Elf_Internal_Sym
*, asection
**));
2595 Elf_Internal_Shdr
*symtab_hdr
;
2598 Elf_External_Sym
*esym
;
2599 Elf_External_Sym
*esymend
;
2600 Elf_Internal_Sym
*isym
;
2602 asection
**ppsection
;
2605 output_bfd
= finfo
->output_bfd
;
2607 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2609 /* If this is a dynamic object, we don't want to do anything here:
2610 we don't want the local symbols, and we don't want the section
2612 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2615 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2616 if (elf_bad_symtab (input_bfd
))
2618 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2623 locsymcount
= symtab_hdr
->sh_info
;
2624 extsymoff
= symtab_hdr
->sh_info
;
2627 /* Read the local symbols. */
2629 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2630 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2631 locsymcount
, input_bfd
)
2632 != locsymcount
* sizeof (Elf_External_Sym
))))
2635 /* Swap in the local symbols and write out the ones which we know
2636 are going into the output file. */
2637 esym
= finfo
->external_syms
;
2638 esymend
= esym
+ locsymcount
;
2639 isym
= finfo
->internal_syms
;
2640 pindex
= finfo
->indices
;
2641 ppsection
= finfo
->sections
;
2642 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2646 Elf_Internal_Sym osym
;
2648 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2651 if (elf_bad_symtab (input_bfd
))
2653 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2660 if (isym
->st_shndx
== SHN_UNDEF
)
2661 isec
= bfd_und_section_ptr
;
2662 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2663 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2664 else if (isym
->st_shndx
== SHN_ABS
)
2665 isec
= bfd_abs_section_ptr
;
2666 else if (isym
->st_shndx
== SHN_COMMON
)
2667 isec
= bfd_com_section_ptr
;
2676 /* Don't output the first, undefined, symbol. */
2677 if (esym
== finfo
->external_syms
)
2680 /* If we are stripping all symbols, we don't want to output this
2682 if (finfo
->info
->strip
== strip_all
)
2685 /* We never output section symbols. Instead, we use the section
2686 symbol of the corresponding section in the output file. */
2687 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2690 /* If we are discarding all local symbols, we don't want to
2691 output this one. If we are generating a relocateable output
2692 file, then some of the local symbols may be required by
2693 relocs; we output them below as we discover that they are
2695 if (finfo
->info
->discard
== discard_all
)
2698 /* Get the name of the symbol. */
2699 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2704 /* See if we are discarding symbols with this name. */
2705 if ((finfo
->info
->strip
== strip_some
2706 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2708 || (finfo
->info
->discard
== discard_l
2709 && strncmp (name
, finfo
->info
->lprefix
,
2710 finfo
->info
->lprefix_len
) == 0))
2713 /* If we get here, we are going to output this symbol. */
2717 /* Adjust the section index for the output file. */
2718 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2719 isec
->output_section
);
2720 if (osym
.st_shndx
== (unsigned short) -1)
2723 *pindex
= output_bfd
->symcount
;
2725 /* ELF symbols in relocateable files are section relative, but
2726 in executable files they are virtual addresses. Note that
2727 this code assumes that all ELF sections have an associated
2728 BFD section with a reasonable value for output_offset; below
2729 we assume that they also have a reasonable value for
2730 output_section. Any special sections must be set up to meet
2731 these requirements. */
2732 osym
.st_value
+= isec
->output_offset
;
2733 if (! finfo
->info
->relocateable
)
2734 osym
.st_value
+= isec
->output_section
->vma
;
2736 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2740 /* Relocate the contents of each section. */
2741 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2743 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2746 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2747 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2749 /* Section was created by elf_link_create_dynamic_sections.
2750 FIXME: This test is fragile. */
2754 /* Read the contents of the section. */
2755 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2756 (file_ptr
) 0, o
->_raw_size
))
2759 if ((o
->flags
& SEC_RELOC
) != 0)
2761 Elf_Internal_Rela
*internal_relocs
;
2763 /* Get the swapped relocs. */
2764 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2765 finfo
->external_relocs
,
2766 finfo
->internal_relocs
,
2768 if (internal_relocs
== NULL
2769 && o
->reloc_count
> 0)
2772 /* Relocate the section by invoking a back end routine.
2774 The back end routine is responsible for adjusting the
2775 section contents as necessary, and (if using Rela relocs
2776 and generating a relocateable output file) adjusting the
2777 reloc addend as necessary.
2779 The back end routine does not have to worry about setting
2780 the reloc address or the reloc symbol index.
2782 The back end routine is given a pointer to the swapped in
2783 internal symbols, and can access the hash table entries
2784 for the external symbols via elf_sym_hashes (input_bfd).
2786 When generating relocateable output, the back end routine
2787 must handle STB_LOCAL/STT_SECTION symbols specially. The
2788 output symbol is going to be a section symbol
2789 corresponding to the output section, which will require
2790 the addend to be adjusted. */
2792 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2796 finfo
->internal_syms
,
2800 if (finfo
->info
->relocateable
)
2802 Elf_Internal_Rela
*irela
;
2803 Elf_Internal_Rela
*irelaend
;
2804 struct elf_link_hash_entry
**rel_hash
;
2805 Elf_Internal_Shdr
*input_rel_hdr
;
2806 Elf_Internal_Shdr
*output_rel_hdr
;
2808 /* Adjust the reloc addresses and symbol indices. */
2810 irela
= internal_relocs
;
2811 irelaend
= irela
+ o
->reloc_count
;
2812 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2813 + o
->output_section
->reloc_count
);
2814 for (; irela
< irelaend
; irela
++, rel_hash
++)
2816 unsigned long r_symndx
;
2817 Elf_Internal_Sym
*isym
;
2820 irela
->r_offset
+= o
->output_offset
;
2822 r_symndx
= ELF_R_SYM (irela
->r_info
);
2827 if (r_symndx
>= locsymcount
2828 || (elf_bad_symtab (input_bfd
)
2829 && finfo
->sections
[r_symndx
] == NULL
))
2833 /* This is a reloc against a global symbol. We
2834 have not yet output all the local symbols, so
2835 we do not know the symbol index of any global
2836 symbol. We set the rel_hash entry for this
2837 reloc to point to the global hash table entry
2838 for this symbol. The symbol index is then
2839 set at the end of elf_bfd_final_link. */
2840 indx
= r_symndx
- extsymoff
;
2841 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2843 /* Setting the index to -2 tells
2844 elf_link_output_extsym that this symbol is
2846 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2847 (*rel_hash
)->indx
= -2;
2852 /* This is a reloc against a local symbol. */
2855 isym
= finfo
->internal_syms
+ r_symndx
;
2856 sec
= finfo
->sections
[r_symndx
];
2857 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2859 /* I suppose the backend ought to fill in the
2860 section of any STT_SECTION symbol against a
2861 processor specific section. */
2862 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2864 else if (sec
== NULL
|| sec
->owner
== NULL
)
2866 bfd_set_error (bfd_error_bad_value
);
2871 r_symndx
= sec
->output_section
->target_index
;
2872 BFD_ASSERT (r_symndx
!= 0);
2877 if (finfo
->indices
[r_symndx
] == -1)
2883 if (finfo
->info
->strip
== strip_all
)
2885 /* You can't do ld -r -s. */
2886 bfd_set_error (bfd_error_invalid_operation
);
2890 /* This symbol was skipped earlier, but
2891 since it is needed by a reloc, we
2892 must output it now. */
2893 link
= symtab_hdr
->sh_link
;
2894 name
= bfd_elf_string_from_elf_section (input_bfd
,
2900 osec
= sec
->output_section
;
2902 _bfd_elf_section_from_bfd_section (output_bfd
,
2904 if (isym
->st_shndx
== (unsigned short) -1)
2907 isym
->st_value
+= sec
->output_offset
;
2908 if (! finfo
->info
->relocateable
)
2909 isym
->st_value
+= osec
->vma
;
2911 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2913 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2917 r_symndx
= finfo
->indices
[r_symndx
];
2920 irela
->r_info
= ELF_R_INFO (r_symndx
,
2921 ELF_R_TYPE (irela
->r_info
));
2924 /* Swap out the relocs. */
2925 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2926 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2927 BFD_ASSERT (output_rel_hdr
->sh_entsize
2928 == input_rel_hdr
->sh_entsize
);
2929 irela
= internal_relocs
;
2930 irelaend
= irela
+ o
->reloc_count
;
2931 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2933 Elf_External_Rel
*erel
;
2935 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2936 + o
->output_section
->reloc_count
);
2937 for (; irela
< irelaend
; irela
++, erel
++)
2939 Elf_Internal_Rel irel
;
2941 irel
.r_offset
= irela
->r_offset
;
2942 irel
.r_info
= irela
->r_info
;
2943 BFD_ASSERT (irela
->r_addend
== 0);
2944 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
2949 Elf_External_Rela
*erela
;
2951 BFD_ASSERT (input_rel_hdr
->sh_entsize
2952 == sizeof (Elf_External_Rela
));
2953 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
2954 + o
->output_section
->reloc_count
);
2955 for (; irela
< irelaend
; irela
++, erela
++)
2956 elf_swap_reloca_out (output_bfd
, irela
, erela
);
2959 o
->output_section
->reloc_count
+= o
->reloc_count
;
2963 /* Write out the modified section contents. */
2964 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2965 finfo
->contents
, o
->output_offset
,
2966 (o
->_cooked_size
!= 0
2975 /* Generate a reloc when linking an ELF file. This is a reloc
2976 requested by the linker, and does come from any input file. This
2977 is used to build constructor and destructor tables when linking
2981 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
2983 struct bfd_link_info
*info
;
2984 asection
*output_section
;
2985 struct bfd_link_order
*link_order
;
2987 reloc_howto_type
*howto
;
2990 struct elf_link_hash_entry
**rel_hash_ptr
;
2991 Elf_Internal_Shdr
*rel_hdr
;
2993 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2996 bfd_set_error (bfd_error_bad_value
);
3000 /* If this is an inplace reloc, we must write the addend into the
3002 if (howto
->partial_inplace
3003 && link_order
->u
.reloc
.p
->addend
!= 0)
3006 bfd_reloc_status_type rstat
;
3010 size
= bfd_get_reloc_size (howto
);
3011 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3012 if (buf
== (bfd_byte
*) NULL
)
3014 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
3015 link_order
->u
.reloc
.p
->addend
, buf
);
3021 case bfd_reloc_outofrange
:
3023 case bfd_reloc_overflow
:
3024 if (! ((*info
->callbacks
->reloc_overflow
)
3026 (link_order
->type
== bfd_section_reloc_link_order
3027 ? bfd_section_name (output_bfd
,
3028 link_order
->u
.reloc
.p
->u
.section
)
3029 : link_order
->u
.reloc
.p
->u
.name
),
3030 howto
->name
, link_order
->u
.reloc
.p
->addend
,
3031 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
3038 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3039 (file_ptr
) link_order
->offset
, size
);
3045 /* Figure out the symbol index. */
3046 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3047 + output_section
->reloc_count
);
3048 if (link_order
->type
== bfd_section_reloc_link_order
)
3050 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3051 BFD_ASSERT (indx
!= 0);
3052 *rel_hash_ptr
= NULL
;
3056 struct elf_link_hash_entry
*h
;
3058 h
= elf_link_hash_lookup (elf_hash_table (info
),
3059 link_order
->u
.reloc
.p
->u
.name
,
3060 false, false, true);
3063 /* Setting the index to -2 tells elf_link_output_extsym that
3064 this symbol is used by a reloc. */
3071 if (! ((*info
->callbacks
->unattached_reloc
)
3072 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3073 (asection
*) NULL
, (bfd_vma
) 0)))
3079 /* The address of a reloc is relative to the section in a
3080 relocateable file, and is a virtual address in an executable
3082 offset
= link_order
->offset
;
3083 if (! info
->relocateable
)
3084 offset
+= output_section
->vma
;
3086 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3088 if (rel_hdr
->sh_type
== SHT_REL
)
3090 Elf_Internal_Rel irel
;
3091 Elf_External_Rel
*erel
;
3093 irel
.r_offset
= offset
;
3094 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3095 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3096 + output_section
->reloc_count
);
3097 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3101 Elf_Internal_Rela irela
;
3102 Elf_External_Rela
*erela
;
3104 irela
.r_offset
= offset
;
3105 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3106 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
3107 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3108 + output_section
->reloc_count
);
3109 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3112 ++output_section
->reloc_count
;