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
*) malloc (c
* sizeof (boolean
));
114 included
= (boolean
*) malloc (c
* sizeof (boolean
));
115 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
117 bfd_set_error (bfd_error_no_memory
);
120 memset (defined
, 0, c
* sizeof (boolean
));
121 memset (included
, 0, c
* sizeof (boolean
));
123 symdefs
= bfd_ardata (abfd
)->symdefs
;
136 symdefend
= symdef
+ c
;
137 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
139 struct elf_link_hash_entry
*h
;
141 struct bfd_link_hash_entry
*undefs_tail
;
144 if (defined
[i
] || included
[i
])
146 if (symdef
->file_offset
== last
)
152 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
153 false, false, false);
154 if (h
== (struct elf_link_hash_entry
*) NULL
)
156 if (h
->root
.type
!= bfd_link_hash_undefined
)
158 if (h
->root
.type
!= bfd_link_hash_undefweak
)
163 /* We need to include this archive member. */
165 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
166 if (element
== (bfd
*) NULL
)
169 if (! bfd_check_format (element
, bfd_object
))
172 /* Doublecheck that we have not included this object
173 already--it should be impossible, but there may be
174 something wrong with the archive. */
175 if (element
->archive_pass
!= 0)
177 bfd_set_error (bfd_error_bad_value
);
180 element
->archive_pass
= 1;
182 undefs_tail
= info
->hash
->undefs_tail
;
184 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
187 if (! elf_link_add_object_symbols (element
, info
))
190 /* If there are any new undefined symbols, we need to make
191 another pass through the archive in order to see whether
192 they can be defined. FIXME: This isn't perfect, because
193 common symbols wind up on undefs_tail and because an
194 undefined symbol which is defined later on in this pass
195 does not require another pass. This isn't a bug, but it
196 does make the code less efficient than it could be. */
197 if (undefs_tail
!= info
->hash
->undefs_tail
)
200 /* Look backward to mark all symbols from this object file
201 which we have already seen in this pass. */
205 included
[mark
] = true;
210 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
212 /* We mark subsequent symbols from this object file as we go
213 on through the loop. */
214 last
= symdef
->file_offset
;
225 if (defined
!= (boolean
*) NULL
)
227 if (included
!= (boolean
*) NULL
)
232 /* Add symbols from an ELF object file to the linker hash table. */
235 elf_link_add_object_symbols (abfd
, info
)
237 struct bfd_link_info
*info
;
239 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
240 const Elf_Internal_Sym
*,
241 const char **, flagword
*,
242 asection
**, bfd_vma
*));
243 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
244 asection
*, const Elf_Internal_Rela
*));
246 Elf_Internal_Shdr
*hdr
;
250 Elf_External_Sym
*buf
= NULL
;
251 struct elf_link_hash_entry
**sym_hash
;
253 Elf_External_Dyn
*dynbuf
= NULL
;
254 struct elf_link_hash_entry
*weaks
;
255 Elf_External_Sym
*esym
;
256 Elf_External_Sym
*esymend
;
258 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
259 collect
= get_elf_backend_data (abfd
)->collect
;
261 /* As a GNU extension, any input sections which are named
262 .gnu.warning.SYMBOL are treated as warning symbols for the given
263 symbol. This differs from .gnu.warning sections, which generate
264 warnings when they are included in an output file. */
269 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
273 name
= bfd_get_section_name (abfd
, s
);
274 if (strncmp (name
, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
279 sz
= bfd_section_size (abfd
, s
);
280 msg
= (char *) bfd_alloc (abfd
, sz
);
283 bfd_set_error (bfd_error_no_memory
);
287 if (! bfd_get_section_contents (abfd
, s
, msg
, (file_ptr
) 0, sz
))
290 if (! (_bfd_generic_link_add_one_symbol
292 name
+ sizeof ".gnu.warning." - 1,
293 BSF_WARNING
, s
, (bfd_vma
) 0, msg
, false, collect
,
294 (struct bfd_link_hash_entry
**) NULL
)))
297 if (! info
->relocateable
)
299 /* Clobber the section size so that the warning does
300 not get copied into the output file. */
307 /* A stripped shared library might only have a dynamic symbol table,
308 not a regular symbol table. In that case we can still go ahead
309 and link using the dynamic symbol table. */
310 if (elf_onesymtab (abfd
) == 0
311 && elf_dynsymtab (abfd
) != 0)
313 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
314 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
317 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
318 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
320 /* The sh_info field of the symtab header tells us where the
321 external symbols start. We don't care about the local symbols at
323 if (elf_bad_symtab (abfd
))
325 extsymcount
= symcount
;
330 extsymcount
= symcount
- hdr
->sh_info
;
331 extsymoff
= hdr
->sh_info
;
334 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
335 if (buf
== NULL
&& extsymcount
!= 0)
337 bfd_set_error (bfd_error_no_memory
);
341 /* We store a pointer to the hash table entry for each external
343 sym_hash
= ((struct elf_link_hash_entry
**)
345 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
346 if (sym_hash
== NULL
)
348 bfd_set_error (bfd_error_no_memory
);
351 elf_sym_hashes (abfd
) = sym_hash
;
353 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
357 /* If we are creating a shared library, create all the dynamic
358 sections immediately. We need to attach them to something,
359 so we attach them to this BFD, provided it is the right
360 format. FIXME: If there are no input BFD's of the same
361 format as the output, we can't make a shared library. */
363 && ! elf_hash_table (info
)->dynamic_sections_created
364 && abfd
->xvec
== info
->hash
->creator
)
366 if (! elf_link_create_dynamic_sections (abfd
, info
))
375 bfd_size_type oldsize
;
376 bfd_size_type strindex
;
380 /* You can't use -r against a dynamic object. Also, there's no
381 hope of using a dynamic object which does not exactly match
382 the format of the output file. */
383 if (info
->relocateable
384 || info
->hash
->creator
!= abfd
->xvec
)
386 bfd_set_error (bfd_error_invalid_operation
);
390 /* Find the name to use in a DT_NEEDED entry that refers to this
391 object. If the object has a DT_SONAME entry, we use it.
392 Otherwise, if the generic linker stuck something in
393 elf_dt_needed_name, we use that. Otherwise, we just use the
394 file name. If the generic linker put a null string into
395 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
396 even if there is a DT_SONAME entry. */
398 name
= bfd_get_filename (abfd
);
399 if (elf_dt_needed_name (abfd
) != NULL
)
401 name
= elf_dt_needed_name (abfd
);
405 s
= bfd_get_section_by_name (abfd
, ".dynamic");
408 Elf_External_Dyn
*extdyn
;
409 Elf_External_Dyn
*extdynend
;
413 dynbuf
= (Elf_External_Dyn
*) malloc ((size_t) s
->_raw_size
);
416 bfd_set_error (bfd_error_no_memory
);
420 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
421 (file_ptr
) 0, s
->_raw_size
))
424 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
427 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
430 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
431 for (; extdyn
< extdynend
; extdyn
++)
433 Elf_Internal_Dyn dyn
;
435 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
436 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
438 name
= bfd_elf_string_from_elf_section (abfd
, link
,
443 if (dyn
.d_tag
== DT_NEEDED
)
445 struct bfd_elf_link_needed_list
*n
, **pn
;
448 n
= (struct bfd_elf_link_needed_list
*)
450 sizeof (struct bfd_elf_link_needed_list
));
451 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
453 if (n
== NULL
|| fnm
== NULL
)
455 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
462 for (pn
= &elf_hash_table (info
)->needed
;
474 /* We do not want to include any of the sections in a dynamic
475 object in the output file. We hack by simply clobbering the
476 list of sections in the BFD. This could be handled more
477 cleanly by, say, a new section flag; the existing
478 SEC_NEVER_LOAD flag is not the one we want, because that one
479 still implies that the section takes up space in the output
481 abfd
->sections
= NULL
;
483 /* If this is the first dynamic object found in the link, create
484 the special sections required for dynamic linking. */
485 if (! elf_hash_table (info
)->dynamic_sections_created
)
487 if (! elf_link_create_dynamic_sections (abfd
, info
))
493 /* Add a DT_NEEDED entry for this dynamic object. */
494 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
495 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
497 if (strindex
== (bfd_size_type
) -1)
500 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
503 Elf_External_Dyn
*dyncon
, *dynconend
;
505 /* The hash table size did not change, which means that
506 the dynamic object name was already entered. If we
507 have already included this dynamic object in the
508 link, just ignore it. There is no reason to include
509 a particular dynamic object more than once. */
510 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
512 BFD_ASSERT (sdyn
!= NULL
);
514 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
515 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
517 for (; dyncon
< dynconend
; dyncon
++)
519 Elf_Internal_Dyn dyn
;
521 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
523 if (dyn
.d_tag
== DT_NEEDED
524 && dyn
.d_un
.d_val
== strindex
)
533 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
539 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
541 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
542 != extsymcount
* sizeof (Elf_External_Sym
)))
547 esymend
= buf
+ extsymcount
;
548 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
550 Elf_Internal_Sym sym
;
556 struct elf_link_hash_entry
*h
;
560 elf_swap_symbol_in (abfd
, esym
, &sym
);
562 flags
= BSF_NO_FLAGS
;
564 value
= sym
.st_value
;
567 bind
= ELF_ST_BIND (sym
.st_info
);
568 if (bind
== STB_LOCAL
)
570 /* This should be impossible, since ELF requires that all
571 global symbols follow all local symbols, and that sh_info
572 point to the first global symbol. Unfortunatealy, Irix 5
576 else if (bind
== STB_GLOBAL
)
578 if (sym
.st_shndx
!= SHN_UNDEF
579 && sym
.st_shndx
!= SHN_COMMON
)
584 else if (bind
== STB_WEAK
)
588 /* Leave it up to the processor backend. */
591 if (sym
.st_shndx
== SHN_UNDEF
)
592 sec
= bfd_und_section_ptr
;
593 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
595 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
599 sec
= bfd_abs_section_ptr
;
601 else if (sym
.st_shndx
== SHN_ABS
)
602 sec
= bfd_abs_section_ptr
;
603 else if (sym
.st_shndx
== SHN_COMMON
)
605 sec
= bfd_com_section_ptr
;
606 /* What ELF calls the size we call the value. What ELF
607 calls the value we call the alignment. */
612 /* Leave it up to the processor backend. */
615 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
616 if (name
== (const char *) NULL
)
621 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
625 /* The hook function sets the name to NULL if this symbol
626 should be skipped for some reason. */
627 if (name
== (const char *) NULL
)
631 /* Sanity check that all possibilities were handled. */
632 if (sec
== (asection
*) NULL
)
634 bfd_set_error (bfd_error_bad_value
);
638 if (bfd_is_und_section (sec
)
639 || bfd_is_com_section (sec
))
644 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
646 /* We need to look up the symbol now in order to get some of
647 the dynamic object handling right. We pass the hash
648 table entry in to _bfd_generic_link_add_one_symbol so
649 that it does not have to look it up again. */
650 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
656 while (h
->root
.type
== bfd_link_hash_indirect
657 || h
->root
.type
== bfd_link_hash_warning
)
658 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
660 /* If we are looking at a dynamic object, and this is a
661 definition, we need to see if it has already been defined
662 by some other object. If it has, we want to use the
663 existing definition, and we do not want to report a
664 multiple symbol definition error; we do this by
665 clobbering sec to be bfd_und_section_ptr. */
666 if (dynamic
&& definition
)
668 if (h
->root
.type
== bfd_link_hash_defined
669 || h
->root
.type
== bfd_link_hash_defweak
670 || (h
->root
.type
== bfd_link_hash_common
671 && bind
== STB_WEAK
))
673 sec
= bfd_und_section_ptr
;
678 /* Similarly, if we are not looking at a dynamic object, and
679 we have a definition, we want to override any definition
680 we may have from a dynamic object. Symbols from regular
681 files always take precedence over symbols from dynamic
682 objects, even if they are defined after the dynamic
683 object in the link. */
686 && (h
->root
.type
== bfd_link_hash_defined
687 || h
->root
.type
== bfd_link_hash_defweak
)
688 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
689 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
690 == bfd_target_elf_flavour
)
691 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
694 /* Change the hash table entry to undefined, and let
695 _bfd_generic_link_add_one_symbol do the right thing
696 with the new definition. */
697 h
->root
.type
= bfd_link_hash_undefined
;
698 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
702 if (! (_bfd_generic_link_add_one_symbol
703 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
704 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
708 while (h
->root
.type
== bfd_link_hash_indirect
709 || h
->root
.type
== bfd_link_hash_warning
)
710 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
716 && (flags
& BSF_WEAK
) != 0
717 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
718 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
719 && h
->weakdef
== NULL
)
721 /* Keep a list of all weak defined non function symbols from
722 a dynamic object, using the weakdef field. Later in this
723 function we will set the weakdef field to the correct
724 value. We only put non-function symbols from dynamic
725 objects on this list, because that happens to be the only
726 time we need to know the normal symbol corresponding to a
727 weak symbol, and the information is time consuming to
728 figure out. If the weakdef field is not already NULL,
729 then this symbol was already defined by some previous
730 dynamic object, and we will be using that previous
731 definition anyhow. */
738 /* Get the alignment of a common symbol. */
739 if (sym
.st_shndx
== SHN_COMMON
740 && h
->root
.type
== bfd_link_hash_common
)
741 h
->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
743 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
749 /* Remember the symbol size and type. */
751 && (definition
|| h
->size
== 0))
753 if (h
->size
!= 0 && h
->size
!= sym
.st_size
)
754 (*_bfd_error_handler
)
755 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
756 name
, (unsigned long) h
->size
, (unsigned long) sym
.st_size
,
757 bfd_get_filename (abfd
));
759 h
->size
= sym
.st_size
;
761 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
762 && (definition
|| h
->type
== STT_NOTYPE
))
764 if (h
->type
!= STT_NOTYPE
765 && h
->type
!= ELF_ST_TYPE (sym
.st_info
))
766 (*_bfd_error_handler
)
767 ("Warning: type of symbol `%s' changed from %d to %d in %s",
768 name
, h
->type
, ELF_ST_TYPE (sym
.st_info
),
769 bfd_get_filename (abfd
));
771 h
->type
= ELF_ST_TYPE (sym
.st_info
);
774 /* Set a flag in the hash table entry indicating the type of
775 reference or definition we just found. Keep a count of
776 the number of dynamic symbols we find. A dynamic symbol
777 is one which is referenced or defined by both a regular
778 object and a shared object, or one which is referenced or
779 defined by more than one shared object. */
780 old_flags
= h
->elf_link_hash_flags
;
785 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
787 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
789 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
790 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
796 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
798 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
799 if ((old_flags
& new_flag
) != 0
800 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
801 | ELF_LINK_HASH_REF_REGULAR
)) != 0
802 || (h
->weakdef
!= NULL
803 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
804 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
808 h
->elf_link_hash_flags
|= new_flag
;
809 if (dynsym
&& h
->dynindx
== -1)
811 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
813 if (h
->weakdef
!= NULL
815 && h
->weakdef
->dynindx
== -1)
817 if (! _bfd_elf_link_record_dynamic_symbol (info
,
825 /* Now set the weakdefs field correctly for all the weak defined
826 symbols we found. The only way to do this is to search all the
827 symbols. Since we only need the information for non functions in
828 dynamic objects, that's the only time we actually put anything on
829 the list WEAKS. We need this information so that if a regular
830 object refers to a symbol defined weakly in a dynamic object, the
831 real symbol in the dynamic object is also put in the dynamic
832 symbols; we also must arrange for both symbols to point to the
833 same memory location. We could handle the general case of symbol
834 aliasing, but a general symbol alias can only be generated in
835 assembler code, handling it correctly would be very time
836 consuming, and other ELF linkers don't handle general aliasing
838 while (weaks
!= NULL
)
840 struct elf_link_hash_entry
*hlook
;
843 struct elf_link_hash_entry
**hpp
;
844 struct elf_link_hash_entry
**hppend
;
847 weaks
= hlook
->weakdef
;
848 hlook
->weakdef
= NULL
;
850 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
851 || hlook
->root
.type
== bfd_link_hash_defweak
852 || hlook
->root
.type
== bfd_link_hash_common
853 || hlook
->root
.type
== bfd_link_hash_indirect
);
854 slook
= hlook
->root
.u
.def
.section
;
855 vlook
= hlook
->root
.u
.def
.value
;
857 hpp
= elf_sym_hashes (abfd
);
858 hppend
= hpp
+ extsymcount
;
859 for (; hpp
< hppend
; hpp
++)
861 struct elf_link_hash_entry
*h
;
864 if (h
!= NULL
&& h
!= hlook
865 && (h
->root
.type
== bfd_link_hash_defined
866 || h
->root
.type
== bfd_link_hash_defweak
)
867 && h
->root
.u
.def
.section
== slook
868 && h
->root
.u
.def
.value
== vlook
)
872 /* If the weak definition is in the list of dynamic
873 symbols, make sure the real definition is put there
875 if (hlook
->dynindx
!= -1
878 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
893 /* If this object is the same format as the output object, and it is
894 not a shared library, then let the backend look through the
897 This is required to build global offset table entries and to
898 arrange for dynamic relocs. It is not required for the
899 particular common case of linking non PIC code, even when linking
900 against shared libraries, but unfortunately there is no way of
901 knowing whether an object file has been compiled PIC or not.
902 Looking through the relocs is not particularly time consuming.
903 The problem is that we must either (1) keep the relocs in memory,
904 which causes the linker to require additional runtime memory or
905 (2) read the relocs twice from the input file, which wastes time.
906 This would be a good case for using mmap.
908 I have no idea how to handle linking PIC code into a file of a
909 different format. It probably can't be done. */
910 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
912 && abfd
->xvec
== info
->hash
->creator
913 && check_relocs
!= NULL
)
917 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
919 Elf_Internal_Rela
*internal_relocs
;
922 if ((o
->flags
& SEC_RELOC
) == 0
923 || o
->reloc_count
== 0)
926 /* I believe we can ignore the relocs for any section which
927 does not form part of the final process image, such as a
928 debugging section. */
929 if ((o
->flags
& SEC_ALLOC
) == 0)
932 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
933 (Elf_Internal_Rela
*) NULL
,
935 if (internal_relocs
== NULL
)
938 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
940 if (! info
->keep_memory
)
941 free (internal_relocs
);
958 /* Create some sections which will be filled in with dynamic linking
959 information. ABFD is an input file which requires dynamic sections
960 to be created. The dynamic sections take up virtual memory space
961 when the final executable is run, so we need to create them before
962 addresses are assigned to the output sections. We work out the
963 actual contents and size of these sections later. */
966 elf_link_create_dynamic_sections (abfd
, info
)
968 struct bfd_link_info
*info
;
971 register asection
*s
;
972 struct elf_link_hash_entry
*h
;
973 struct elf_backend_data
*bed
;
975 if (elf_hash_table (info
)->dynamic_sections_created
)
978 /* Make sure that all dynamic sections use the same input BFD. */
979 if (elf_hash_table (info
)->dynobj
== NULL
)
980 elf_hash_table (info
)->dynobj
= abfd
;
982 abfd
= elf_hash_table (info
)->dynobj
;
984 /* Note that we set the SEC_IN_MEMORY flag for all of these
986 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
988 /* A dynamically linked executable has a .interp section, but a
989 shared library does not. */
992 s
= bfd_make_section (abfd
, ".interp");
994 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
998 s
= bfd_make_section (abfd
, ".dynsym");
1000 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1001 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1004 s
= bfd_make_section (abfd
, ".dynstr");
1006 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
1009 /* Create a strtab to hold the dynamic symbol names. */
1010 if (elf_hash_table (info
)->dynstr
== NULL
)
1012 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
1013 if (elf_hash_table (info
)->dynstr
== NULL
)
1017 s
= bfd_make_section (abfd
, ".dynamic");
1019 || ! bfd_set_section_flags (abfd
, s
, flags
)
1020 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1023 /* The special symbol _DYNAMIC is always set to the start of the
1024 .dynamic section. This call occurs before we have processed the
1025 symbols for any dynamic object, so we don't have to worry about
1026 overriding a dynamic definition. We could set _DYNAMIC in a
1027 linker script, but we only want to define it if we are, in fact,
1028 creating a .dynamic section. We don't want to define it if there
1029 is no .dynamic section, since on some ELF platforms the start up
1030 code examines it to decide how to initialize the process. */
1032 if (! (_bfd_generic_link_add_one_symbol
1033 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
1034 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
1035 (struct bfd_link_hash_entry
**) &h
)))
1037 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1038 h
->type
= STT_OBJECT
;
1041 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1044 s
= bfd_make_section (abfd
, ".hash");
1046 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
1047 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
1050 /* Let the backend create the rest of the sections. This lets the
1051 backend set the right flags. The backend will normally create
1052 the .got and .plt sections. */
1053 bed
= get_elf_backend_data (abfd
);
1054 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
1057 elf_hash_table (info
)->dynamic_sections_created
= true;
1062 /* Add an entry to the .dynamic table. */
1065 elf_add_dynamic_entry (info
, tag
, val
)
1066 struct bfd_link_info
*info
;
1070 Elf_Internal_Dyn dyn
;
1074 bfd_byte
*newcontents
;
1076 dynobj
= elf_hash_table (info
)->dynobj
;
1078 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1079 BFD_ASSERT (s
!= NULL
);
1081 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1082 if (s
->contents
== NULL
)
1083 newcontents
= (bfd_byte
*) malloc (newsize
);
1085 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
1086 if (newcontents
== NULL
)
1088 bfd_set_error (bfd_error_no_memory
);
1093 dyn
.d_un
.d_val
= val
;
1094 elf_swap_dyn_out (dynobj
, &dyn
,
1095 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1097 s
->_raw_size
= newsize
;
1098 s
->contents
= newcontents
;
1103 /* Read and swap the relocs for a section. They may have been cached.
1104 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1105 they are used as buffers to read into. They are known to be large
1106 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1107 value is allocated using either malloc or bfd_alloc, according to
1108 the KEEP_MEMORY argument. */
1110 static Elf_Internal_Rela
*
1111 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1114 PTR external_relocs
;
1115 Elf_Internal_Rela
*internal_relocs
;
1116 boolean keep_memory
;
1118 Elf_Internal_Shdr
*rel_hdr
;
1120 Elf_Internal_Rela
*alloc2
= NULL
;
1122 if (elf_section_data (o
)->relocs
!= NULL
)
1123 return elf_section_data (o
)->relocs
;
1125 if (o
->reloc_count
== 0)
1128 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1130 if (internal_relocs
== NULL
)
1134 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1136 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1138 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
1139 if (internal_relocs
== NULL
)
1141 bfd_set_error (bfd_error_no_memory
);
1146 if (external_relocs
== NULL
)
1148 alloc1
= (PTR
) malloc ((size_t) rel_hdr
->sh_size
);
1151 bfd_set_error (bfd_error_no_memory
);
1154 external_relocs
= alloc1
;
1157 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1158 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1159 != rel_hdr
->sh_size
))
1162 /* Swap in the relocs. For convenience, we always produce an
1163 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1165 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1167 Elf_External_Rel
*erel
;
1168 Elf_External_Rel
*erelend
;
1169 Elf_Internal_Rela
*irela
;
1171 erel
= (Elf_External_Rel
*) external_relocs
;
1172 erelend
= erel
+ o
->reloc_count
;
1173 irela
= internal_relocs
;
1174 for (; erel
< erelend
; erel
++, irela
++)
1176 Elf_Internal_Rel irel
;
1178 elf_swap_reloc_in (abfd
, erel
, &irel
);
1179 irela
->r_offset
= irel
.r_offset
;
1180 irela
->r_info
= irel
.r_info
;
1181 irela
->r_addend
= 0;
1186 Elf_External_Rela
*erela
;
1187 Elf_External_Rela
*erelaend
;
1188 Elf_Internal_Rela
*irela
;
1190 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1192 erela
= (Elf_External_Rela
*) external_relocs
;
1193 erelaend
= erela
+ o
->reloc_count
;
1194 irela
= internal_relocs
;
1195 for (; erela
< erelaend
; erela
++, irela
++)
1196 elf_swap_reloca_in (abfd
, erela
, irela
);
1199 /* Cache the results for next time, if we can. */
1201 elf_section_data (o
)->relocs
= internal_relocs
;
1206 /* Don't free alloc2, since if it was allocated we are passing it
1207 back (under the name of internal_relocs). */
1209 return internal_relocs
;
1219 /* Record an assignment to a symbol made by a linker script. We need
1220 this in case some dynamic object refers to this symbol. */
1224 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1226 struct bfd_link_info
*info
;
1230 struct elf_link_hash_entry
*h
;
1232 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1235 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1239 /* If this symbol is being provided by the linker script, and it is
1240 currently defined by a dynamic object, but not by a regular
1241 object, then mark it as undefined so that the generic linker will
1242 force the correct value. */
1244 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1245 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1246 h
->root
.type
= bfd_link_hash_undefined
;
1248 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1249 h
->type
= STT_OBJECT
;
1251 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1252 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1254 && h
->dynindx
== -1)
1256 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1259 /* If this is a weak defined symbol, and we know a corresponding
1260 real symbol from the same dynamic object, make sure the real
1261 symbol is also made into a dynamic symbol. */
1262 if (h
->weakdef
!= NULL
1263 && h
->weakdef
->dynindx
== -1)
1265 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1273 /* Array used to determine the number of hash table buckets to use
1274 based on the number of symbols there are. If there are fewer than
1275 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1276 fewer than 37 we use 17 buckets, and so forth. We never use more
1277 than 521 buckets. */
1279 static const size_t elf_buckets
[] =
1281 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1284 /* Set up the sizes and contents of the ELF dynamic sections. This is
1285 called by the ELF linker emulation before_allocation routine. We
1286 must set the sizes of the sections before the linker sets the
1287 addresses of the various sections. */
1290 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1291 export_dynamic
, info
, sinterpptr
)
1295 boolean export_dynamic
;
1296 struct bfd_link_info
*info
;
1297 asection
**sinterpptr
;
1300 struct elf_backend_data
*bed
;
1304 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1307 dynobj
= elf_hash_table (info
)->dynobj
;
1309 /* If there were no dynamic objects in the link, there is nothing to
1314 /* If we are supposed to export all symbols into the dynamic symbol
1315 table (this is not the normal case), then do so. */
1318 struct elf_info_failed eif
;
1322 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1328 if (elf_hash_table (info
)->dynamic_sections_created
)
1330 struct elf_info_failed eif
;
1331 bfd_size_type strsize
;
1333 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1334 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1340 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1342 if (indx
== (bfd_size_type
) -1
1343 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1349 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1357 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1359 if (indx
== (bfd_size_type
) -1
1360 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1364 /* Find all symbols which were defined in a dynamic object and make
1365 the backend pick a reasonable value for them. */
1368 elf_link_hash_traverse (elf_hash_table (info
),
1369 elf_adjust_dynamic_symbol
,
1374 /* Add some entries to the .dynamic section. We fill in some of the
1375 values later, in elf_bfd_final_link, but we must add the entries
1376 now so that we know the final size of the .dynamic section. */
1377 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1378 false, false) != NULL
)
1380 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1383 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1384 false, false) != NULL
)
1386 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1389 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1390 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1391 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1392 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1393 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1394 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1395 sizeof (Elf_External_Sym
)))
1399 /* The backend must work out the sizes of all the other dynamic
1401 bed
= get_elf_backend_data (output_bfd
);
1402 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1405 if (elf_hash_table (info
)->dynamic_sections_created
)
1410 size_t bucketcount
= 0;
1411 Elf_Internal_Sym isym
;
1413 /* Set the size of the .dynsym and .hash sections. We counted
1414 the number of dynamic symbols in elf_link_add_object_symbols.
1415 We will build the contents of .dynsym and .hash when we build
1416 the final symbol table, because until then we do not know the
1417 correct value to give the symbols. We built the .dynstr
1418 section as we went along in elf_link_add_object_symbols. */
1419 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1420 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1421 BFD_ASSERT (s
!= NULL
);
1422 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1423 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1424 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1426 bfd_set_error (bfd_error_no_memory
);
1430 /* The first entry in .dynsym is a dummy symbol. */
1437 elf_swap_symbol_out (output_bfd
, &isym
,
1438 (PTR
) (Elf_External_Sym
*) s
->contents
);
1440 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1442 bucketcount
= elf_buckets
[i
];
1443 if (dynsymcount
< elf_buckets
[i
+ 1])
1447 s
= bfd_get_section_by_name (dynobj
, ".hash");
1448 BFD_ASSERT (s
!= NULL
);
1449 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1450 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1451 if (s
->contents
== NULL
)
1453 bfd_set_error (bfd_error_no_memory
);
1456 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1458 put_word (output_bfd
, bucketcount
, s
->contents
);
1459 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1461 elf_hash_table (info
)->bucketcount
= bucketcount
;
1463 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1464 BFD_ASSERT (s
!= NULL
);
1465 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1467 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1474 /* This routine is used to export all defined symbols into the dynamic
1475 symbol table. It is called via elf_link_hash_traverse. */
1478 elf_export_symbol (h
, data
)
1479 struct elf_link_hash_entry
*h
;
1482 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1484 if (h
->dynindx
== -1
1485 && (h
->elf_link_hash_flags
1486 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1488 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1498 /* Make the backend pick a good value for a dynamic symbol. This is
1499 called via elf_link_hash_traverse, and also calls itself
1503 elf_adjust_dynamic_symbol (h
, data
)
1504 struct elf_link_hash_entry
*h
;
1507 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1509 struct elf_backend_data
*bed
;
1511 /* If -Bsymbolic was used (which means to bind references to global
1512 symbols to the definition within the shared object), and this
1513 symbol was defined in a regular object, then it actually doesn't
1514 need a PLT entry. */
1515 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1516 && eif
->info
->shared
1517 && eif
->info
->symbolic
1518 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1519 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1521 /* If this symbol does not require a PLT entry, and it is not
1522 defined by a dynamic object, or is not referenced by a regular
1523 object, ignore it. We do have to handle a weak defined symbol,
1524 even if no regular object refers to it, if we decided to add it
1525 to the dynamic symbol table. FIXME: Do we normally need to worry
1526 about symbols which are defined by one dynamic object and
1527 referenced by another one? */
1528 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1529 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1530 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1531 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1532 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1535 /* If we've already adjusted this symbol, don't do it again. This
1536 can happen via a recursive call. */
1537 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1540 /* Don't look at this symbol again. Note that we must set this
1541 after checking the above conditions, because we may look at a
1542 symbol once, decide not to do anything, and then get called
1543 recursively later after REF_REGULAR is set below. */
1544 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1546 /* If this is a weak definition, and we know a real definition, and
1547 the real symbol is not itself defined by a regular object file,
1548 then get a good value for the real definition. We handle the
1549 real symbol first, for the convenience of the backend routine.
1551 Note that there is a confusing case here. If the real definition
1552 is defined by a regular object file, we don't get the real symbol
1553 from the dynamic object, but we do get the weak symbol. If the
1554 processor backend uses a COPY reloc, then if some routine in the
1555 dynamic object changes the real symbol, we will not see that
1556 change in the corresponding weak symbol. This is the way other
1557 ELF linkers work as well, and seems to be a result of the shared
1560 I will clarify this issue. Most SVR4 shared libraries define the
1561 variable _timezone and define timezone as a weak synonym. The
1562 tzset call changes _timezone. If you write
1563 extern int timezone;
1565 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1566 you might expect that, since timezone is a synonym for _timezone,
1567 the same number will print both times. However, if the processor
1568 backend uses a COPY reloc, then actually timezone will be copied
1569 into your process image, and, since you define _timezone
1570 yourself, _timezone will not. Thus timezone and _timezone will
1571 wind up at different memory locations. The tzset call will set
1572 _timezone, leaving timezone unchanged. */
1574 if (h
->weakdef
!= NULL
)
1576 struct elf_link_hash_entry
*weakdef
;
1578 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1579 || h
->root
.type
== bfd_link_hash_defweak
);
1580 weakdef
= h
->weakdef
;
1581 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1582 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1583 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1584 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1586 /* This symbol is defined by a regular object file, so we
1587 will not do anything special. Clear weakdef for the
1588 convenience of the processor backend. */
1593 /* There is an implicit reference by a regular object file
1594 via the weak symbol. */
1595 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1596 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1601 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1602 bed
= get_elf_backend_data (dynobj
);
1603 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1612 /* Final phase of ELF linker. */
1614 /* A structure we use to avoid passing large numbers of arguments. */
1616 struct elf_final_link_info
1618 /* General link information. */
1619 struct bfd_link_info
*info
;
1622 /* Symbol string table. */
1623 struct bfd_strtab_hash
*symstrtab
;
1624 /* .dynsym section. */
1625 asection
*dynsym_sec
;
1626 /* .hash section. */
1628 /* Buffer large enough to hold contents of any section. */
1630 /* Buffer large enough to hold external relocs of any section. */
1631 PTR external_relocs
;
1632 /* Buffer large enough to hold internal relocs of any section. */
1633 Elf_Internal_Rela
*internal_relocs
;
1634 /* Buffer large enough to hold external local symbols of any input
1636 Elf_External_Sym
*external_syms
;
1637 /* Buffer large enough to hold internal local symbols of any input
1639 Elf_Internal_Sym
*internal_syms
;
1640 /* Array large enough to hold a symbol index for each local symbol
1641 of any input BFD. */
1643 /* Array large enough to hold a section pointer for each local
1644 symbol of any input BFD. */
1645 asection
**sections
;
1646 /* Buffer to hold swapped out symbols. */
1647 Elf_External_Sym
*symbuf
;
1648 /* Number of swapped out symbols in buffer. */
1649 size_t symbuf_count
;
1650 /* Number of symbols which fit in symbuf. */
1654 static boolean elf_link_output_sym
1655 PARAMS ((struct elf_final_link_info
*, const char *,
1656 Elf_Internal_Sym
*, asection
*));
1657 static boolean elf_link_flush_output_syms
1658 PARAMS ((struct elf_final_link_info
*));
1659 static boolean elf_link_output_extsym
1660 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1661 static boolean elf_link_input_bfd
1662 PARAMS ((struct elf_final_link_info
*, bfd
*));
1663 static boolean elf_reloc_link_order
1664 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1665 struct bfd_link_order
*));
1667 /* This struct is used to pass information to routines called via
1668 elf_link_hash_traverse which must return failure. */
1670 struct elf_finfo_failed
1673 struct elf_final_link_info
*finfo
;
1676 /* Do the final step of an ELF link. */
1679 elf_bfd_final_link (abfd
, info
)
1681 struct bfd_link_info
*info
;
1685 struct elf_final_link_info finfo
;
1686 register asection
*o
;
1687 register struct bfd_link_order
*p
;
1689 size_t max_contents_size
;
1690 size_t max_external_reloc_size
;
1691 size_t max_internal_reloc_count
;
1692 size_t max_sym_count
;
1694 Elf_Internal_Sym elfsym
;
1696 Elf_Internal_Shdr
*symtab_hdr
;
1697 Elf_Internal_Shdr
*symstrtab_hdr
;
1698 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1699 struct elf_finfo_failed eif
;
1702 abfd
->flags
|= DYNAMIC
;
1704 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1705 dynobj
= elf_hash_table (info
)->dynobj
;
1708 finfo
.output_bfd
= abfd
;
1709 finfo
.symstrtab
= elf_stringtab_init ();
1710 if (finfo
.symstrtab
== NULL
)
1714 finfo
.dynsym_sec
= NULL
;
1715 finfo
.hash_sec
= NULL
;
1719 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1720 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1721 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1723 finfo
.contents
= NULL
;
1724 finfo
.external_relocs
= NULL
;
1725 finfo
.internal_relocs
= NULL
;
1726 finfo
.external_syms
= NULL
;
1727 finfo
.internal_syms
= NULL
;
1728 finfo
.indices
= NULL
;
1729 finfo
.sections
= NULL
;
1730 finfo
.symbuf
= NULL
;
1731 finfo
.symbuf_count
= 0;
1733 /* Count up the number of relocations we will output for each output
1734 section, so that we know the sizes of the reloc sections. We
1735 also figure out some maximum sizes. */
1736 max_contents_size
= 0;
1737 max_external_reloc_size
= 0;
1738 max_internal_reloc_count
= 0;
1740 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1744 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1746 if (p
->type
== bfd_section_reloc_link_order
1747 || p
->type
== bfd_symbol_reloc_link_order
)
1749 else if (p
->type
== bfd_indirect_link_order
)
1753 sec
= p
->u
.indirect
.section
;
1755 if (info
->relocateable
)
1756 o
->reloc_count
+= sec
->reloc_count
;
1758 if (sec
->_raw_size
> max_contents_size
)
1759 max_contents_size
= sec
->_raw_size
;
1760 if (sec
->_cooked_size
> max_contents_size
)
1761 max_contents_size
= sec
->_cooked_size
;
1763 /* We are interested in just local symbols, not all
1765 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1769 if (elf_bad_symtab (sec
->owner
))
1770 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1771 / sizeof (Elf_External_Sym
));
1773 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1775 if (sym_count
> max_sym_count
)
1776 max_sym_count
= sym_count
;
1778 if ((sec
->flags
& SEC_RELOC
) != 0)
1782 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1783 if (ext_size
> max_external_reloc_size
)
1784 max_external_reloc_size
= ext_size
;
1785 if (sec
->reloc_count
> max_internal_reloc_count
)
1786 max_internal_reloc_count
= sec
->reloc_count
;
1792 if (o
->reloc_count
> 0)
1793 o
->flags
|= SEC_RELOC
;
1796 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1797 set it (this is probably a bug) and if it is set
1798 assign_section_numbers will create a reloc section. */
1799 o
->flags
&=~ SEC_RELOC
;
1802 /* If the SEC_ALLOC flag is not set, force the section VMA to
1803 zero. This is done in elf_fake_sections as well, but forcing
1804 the VMA to 0 here will ensure that relocs against these
1805 sections are handled correctly. */
1806 if ((o
->flags
& SEC_ALLOC
) == 0)
1810 /* Figure out the file positions for everything but the symbol table
1811 and the relocs. We set symcount to force assign_section_numbers
1812 to create a symbol table. */
1813 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1814 BFD_ASSERT (! abfd
->output_has_begun
);
1815 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1818 /* That created the reloc sections. Set their sizes, and assign
1819 them file positions, and allocate some buffers. */
1820 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1822 if ((o
->flags
& SEC_RELOC
) != 0)
1824 Elf_Internal_Shdr
*rel_hdr
;
1825 register struct elf_link_hash_entry
**p
, **pend
;
1827 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1829 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1831 /* The contents field must last into write_object_contents,
1832 so we allocate it with bfd_alloc rather than malloc. */
1833 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1834 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1836 bfd_set_error (bfd_error_no_memory
);
1840 p
= ((struct elf_link_hash_entry
**)
1841 malloc (o
->reloc_count
1842 * sizeof (struct elf_link_hash_entry
*)));
1843 if (p
== NULL
&& o
->reloc_count
!= 0)
1845 bfd_set_error (bfd_error_no_memory
);
1848 elf_section_data (o
)->rel_hashes
= p
;
1849 pend
= p
+ o
->reloc_count
;
1850 for (; p
< pend
; p
++)
1853 /* Use the reloc_count field as an index when outputting the
1859 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1861 /* We have now assigned file positions for all the sections except
1862 .symtab and .strtab. We start the .symtab section at the current
1863 file position, and write directly to it. We build the .strtab
1864 section in memory. When we add .dynsym support, we will build
1865 that in memory as well (.dynsym is smaller than .symtab). */
1867 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1868 /* sh_name is set in prep_headers. */
1869 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1870 symtab_hdr
->sh_flags
= 0;
1871 symtab_hdr
->sh_addr
= 0;
1872 symtab_hdr
->sh_size
= 0;
1873 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1874 /* sh_link is set in assign_section_numbers. */
1875 /* sh_info is set below. */
1876 /* sh_offset is set just below. */
1877 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1879 off
= elf_tdata (abfd
)->next_file_pos
;
1880 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1882 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1883 incorrect. We do not yet know the size of the .symtab section.
1884 We correct next_file_pos below, after we do know the size. */
1886 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1887 continuously seeking to the right position in the file. */
1888 if (! info
->keep_memory
|| max_sym_count
< 20)
1889 finfo
.symbuf_size
= 20;
1891 finfo
.symbuf_size
= max_sym_count
;
1892 finfo
.symbuf
= ((Elf_External_Sym
*)
1893 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1894 if (finfo
.symbuf
== NULL
)
1896 bfd_set_error (bfd_error_no_memory
);
1900 /* Start writing out the symbol table. The first symbol is always a
1902 elfsym
.st_value
= 0;
1905 elfsym
.st_other
= 0;
1906 elfsym
.st_shndx
= SHN_UNDEF
;
1907 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1908 &elfsym
, bfd_und_section_ptr
))
1912 /* Some standard ELF linkers do this, but we don't because it causes
1913 bootstrap comparison failures. */
1914 /* Output a file symbol for the output file as the second symbol.
1915 We output this even if we are discarding local symbols, although
1916 I'm not sure if this is correct. */
1917 elfsym
.st_value
= 0;
1919 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1920 elfsym
.st_other
= 0;
1921 elfsym
.st_shndx
= SHN_ABS
;
1922 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1923 &elfsym
, bfd_abs_section_ptr
))
1927 /* Output a symbol for each section. We output these even if we are
1928 discarding local symbols, since they are used for relocs. These
1929 symbols have no names. We store the index of each one in the
1930 index field of the section, so that we can find it again when
1931 outputting relocs. */
1932 elfsym
.st_value
= 0;
1934 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1935 elfsym
.st_other
= 0;
1936 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1938 o
= section_from_elf_index (abfd
, i
);
1940 o
->target_index
= abfd
->symcount
;
1941 elfsym
.st_shndx
= i
;
1942 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1947 /* Allocate some memory to hold information read in from the input
1949 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
1950 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
1951 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1952 malloc (max_internal_reloc_count
1953 * sizeof (Elf_Internal_Rela
)));
1954 finfo
.external_syms
= ((Elf_External_Sym
*)
1955 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
1956 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1957 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
1958 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
1959 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
1960 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
1961 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
1962 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
1963 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
1964 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
1965 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
1966 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
1968 bfd_set_error (bfd_error_no_memory
);
1972 /* Since ELF permits relocations to be against local symbols, we
1973 must have the local symbols available when we do the relocations.
1974 Since we would rather only read the local symbols once, and we
1975 would rather not keep them in memory, we handle all the
1976 relocations for a single input file at the same time.
1978 Unfortunately, there is no way to know the total number of local
1979 symbols until we have seen all of them, and the local symbol
1980 indices precede the global symbol indices. This means that when
1981 we are generating relocateable output, and we see a reloc against
1982 a global symbol, we can not know the symbol index until we have
1983 finished examining all the local symbols to see which ones we are
1984 going to output. To deal with this, we keep the relocations in
1985 memory, and don't output them until the end of the link. This is
1986 an unfortunate waste of memory, but I don't see a good way around
1987 it. Fortunately, it only happens when performing a relocateable
1988 link, which is not the common case. FIXME: If keep_memory is set
1989 we could write the relocs out and then read them again; I don't
1990 know how bad the memory loss will be. */
1992 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
1993 sub
->output_has_begun
= false;
1994 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1996 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1998 if (p
->type
== bfd_indirect_link_order
1999 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
2000 == bfd_target_elf_flavour
))
2002 sub
= p
->u
.indirect
.section
->owner
;
2003 if (! sub
->output_has_begun
)
2005 if (! elf_link_input_bfd (&finfo
, sub
))
2007 sub
->output_has_begun
= true;
2010 else if (p
->type
== bfd_section_reloc_link_order
2011 || p
->type
== bfd_symbol_reloc_link_order
)
2013 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
2018 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2024 /* That wrote out all the local symbols. Finish up the symbol table
2025 with the global symbols. */
2027 /* The sh_info field records the index of the first non local
2029 symtab_hdr
->sh_info
= abfd
->symcount
;
2031 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
2033 /* We get the global symbols from the hash table. */
2036 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
2041 /* Flush all symbols to the file. */
2042 if (! elf_link_flush_output_syms (&finfo
))
2045 /* Now we know the size of the symtab section. */
2046 off
+= symtab_hdr
->sh_size
;
2048 /* Finish up and write out the symbol string table (.strtab)
2050 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2051 /* sh_name was set in prep_headers. */
2052 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2053 symstrtab_hdr
->sh_flags
= 0;
2054 symstrtab_hdr
->sh_addr
= 0;
2055 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
2056 symstrtab_hdr
->sh_entsize
= 0;
2057 symstrtab_hdr
->sh_link
= 0;
2058 symstrtab_hdr
->sh_info
= 0;
2059 /* sh_offset is set just below. */
2060 symstrtab_hdr
->sh_addralign
= 1;
2062 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
2063 elf_tdata (abfd
)->next_file_pos
= off
;
2065 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
2066 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
2069 /* Adjust the relocs to have the correct symbol indices. */
2070 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2072 struct elf_link_hash_entry
**rel_hash
;
2073 Elf_Internal_Shdr
*rel_hdr
;
2075 if ((o
->flags
& SEC_RELOC
) == 0)
2078 rel_hash
= elf_section_data (o
)->rel_hashes
;
2079 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2080 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2082 if (*rel_hash
== NULL
)
2085 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2087 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2089 Elf_External_Rel
*erel
;
2090 Elf_Internal_Rel irel
;
2092 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2093 elf_swap_reloc_in (abfd
, erel
, &irel
);
2094 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2095 ELF_R_TYPE (irel
.r_info
));
2096 elf_swap_reloc_out (abfd
, &irel
, erel
);
2100 Elf_External_Rela
*erela
;
2101 Elf_Internal_Rela irela
;
2103 BFD_ASSERT (rel_hdr
->sh_entsize
2104 == sizeof (Elf_External_Rela
));
2106 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2107 elf_swap_reloca_in (abfd
, erela
, &irela
);
2108 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2109 ELF_R_TYPE (irela
.r_info
));
2110 elf_swap_reloca_out (abfd
, &irela
, erela
);
2114 /* Set the reloc_count field to 0 to prevent write_relocs from
2115 trying to swap the relocs out itself. */
2119 /* If we are linking against a dynamic object, or generating a
2120 shared library, finish up the dynamic linking information. */
2123 Elf_External_Dyn
*dyncon
, *dynconend
;
2125 /* Fix up .dynamic entries. */
2126 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2127 BFD_ASSERT (o
!= NULL
);
2129 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2130 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2131 for (; dyncon
< dynconend
; dyncon
++)
2133 Elf_Internal_Dyn dyn
;
2137 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2144 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2145 magic _init and _fini symbols. This is pretty ugly,
2146 but we are compatible. */
2154 struct elf_link_hash_entry
*h
;
2156 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2157 false, false, true);
2159 && (h
->root
.type
== bfd_link_hash_defined
2160 || h
->root
.type
== bfd_link_hash_defweak
))
2162 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2163 o
= h
->root
.u
.def
.section
;
2164 if (o
->output_section
!= NULL
)
2165 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2166 + o
->output_offset
);
2169 /* The symbol is imported from another shared
2170 library and does not apply to this one. */
2174 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2188 o
= bfd_get_section_by_name (abfd
, name
);
2189 BFD_ASSERT (o
!= NULL
);
2190 dyn
.d_un
.d_ptr
= o
->vma
;
2191 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2198 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2203 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2205 Elf_Internal_Shdr
*hdr
;
2207 hdr
= elf_elfsections (abfd
)[i
];
2208 if (hdr
->sh_type
== type
2209 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2211 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2212 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2215 if (dyn
.d_un
.d_val
== 0
2216 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2217 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2221 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2227 /* If we have created any dynamic sections, then output them. */
2230 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2233 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2235 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2236 || o
->_raw_size
== 0)
2238 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2240 /* At this point, we are only interested in sections
2241 created by elf_link_create_dynamic_sections. FIXME:
2242 This test is fragile. */
2245 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2247 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2249 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2250 o
->contents
, o
->output_offset
,
2258 /* The contents of the .dynstr section are actually in a
2260 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2261 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2262 || ! _bfd_stringtab_emit (abfd
,
2263 elf_hash_table (info
)->dynstr
))
2269 if (finfo
.symstrtab
!= NULL
)
2270 _bfd_stringtab_free (finfo
.symstrtab
);
2271 if (finfo
.contents
!= NULL
)
2272 free (finfo
.contents
);
2273 if (finfo
.external_relocs
!= NULL
)
2274 free (finfo
.external_relocs
);
2275 if (finfo
.internal_relocs
!= NULL
)
2276 free (finfo
.internal_relocs
);
2277 if (finfo
.external_syms
!= NULL
)
2278 free (finfo
.external_syms
);
2279 if (finfo
.internal_syms
!= NULL
)
2280 free (finfo
.internal_syms
);
2281 if (finfo
.indices
!= NULL
)
2282 free (finfo
.indices
);
2283 if (finfo
.sections
!= NULL
)
2284 free (finfo
.sections
);
2285 if (finfo
.symbuf
!= NULL
)
2286 free (finfo
.symbuf
);
2287 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2289 if ((o
->flags
& SEC_RELOC
) != 0
2290 && elf_section_data (o
)->rel_hashes
!= NULL
)
2291 free (elf_section_data (o
)->rel_hashes
);
2294 elf_tdata (abfd
)->linker
= true;
2299 if (finfo
.symstrtab
!= NULL
)
2300 _bfd_stringtab_free (finfo
.symstrtab
);
2301 if (finfo
.contents
!= NULL
)
2302 free (finfo
.contents
);
2303 if (finfo
.external_relocs
!= NULL
)
2304 free (finfo
.external_relocs
);
2305 if (finfo
.internal_relocs
!= NULL
)
2306 free (finfo
.internal_relocs
);
2307 if (finfo
.external_syms
!= NULL
)
2308 free (finfo
.external_syms
);
2309 if (finfo
.internal_syms
!= NULL
)
2310 free (finfo
.internal_syms
);
2311 if (finfo
.indices
!= NULL
)
2312 free (finfo
.indices
);
2313 if (finfo
.sections
!= NULL
)
2314 free (finfo
.sections
);
2315 if (finfo
.symbuf
!= NULL
)
2316 free (finfo
.symbuf
);
2317 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2319 if ((o
->flags
& SEC_RELOC
) != 0
2320 && elf_section_data (o
)->rel_hashes
!= NULL
)
2321 free (elf_section_data (o
)->rel_hashes
);
2327 /* Add a symbol to the output symbol table. */
2330 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2331 struct elf_final_link_info
*finfo
;
2333 Elf_Internal_Sym
*elfsym
;
2334 asection
*input_sec
;
2336 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2337 struct bfd_link_info
*info
,
2342 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2343 elf_backend_link_output_symbol_hook
;
2344 if (output_symbol_hook
!= NULL
)
2346 if (! ((*output_symbol_hook
)
2347 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2351 if (name
== (const char *) NULL
|| *name
== '\0')
2352 elfsym
->st_name
= 0;
2355 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2358 if (elfsym
->st_name
== (unsigned long) -1)
2362 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2364 if (! elf_link_flush_output_syms (finfo
))
2368 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2369 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2370 ++finfo
->symbuf_count
;
2372 ++finfo
->output_bfd
->symcount
;
2377 /* Flush the output symbols to the file. */
2380 elf_link_flush_output_syms (finfo
)
2381 struct elf_final_link_info
*finfo
;
2383 Elf_Internal_Shdr
*symtab
;
2385 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2387 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2389 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2390 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2391 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2394 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2396 finfo
->symbuf_count
= 0;
2401 /* Add an external symbol to the symbol table. This is called from
2402 the hash table traversal routine. */
2405 elf_link_output_extsym (h
, data
)
2406 struct elf_link_hash_entry
*h
;
2409 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2410 struct elf_final_link_info
*finfo
= eif
->finfo
;
2412 Elf_Internal_Sym sym
;
2413 asection
*input_sec
;
2415 /* If we are not creating a shared library, and this symbol is
2416 referenced by a shared library but is not defined anywhere, then
2417 warn that it is undefined. If we do not do this, the runtime
2418 linker will complain that the symbol is undefined when the
2419 program is run. We don't have to worry about symbols that are
2420 referenced by regular files, because we will already have issued
2421 warnings for them. */
2422 if (! finfo
->info
->relocateable
2423 && ! finfo
->info
->shared
2424 && h
->root
.type
== bfd_link_hash_undefined
2425 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2426 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2428 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2429 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2430 (asection
*) NULL
, 0)))
2437 /* We don't want to output symbols that have never been mentioned by
2438 a regular file, or that we have been told to strip. However, if
2439 h->indx is set to -2, the symbol is used by a reloc and we must
2443 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2444 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2445 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2446 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2448 else if (finfo
->info
->strip
== strip_all
2449 || (finfo
->info
->strip
== strip_some
2450 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2451 h
->root
.root
.string
,
2452 false, false) == NULL
))
2457 /* If we're stripping it, and it's not a dynamic symbol, there's
2458 nothing else to do. */
2459 if (strip
&& h
->dynindx
== -1)
2463 sym
.st_size
= h
->size
;
2465 if (h
->root
.type
== bfd_link_hash_undefweak
2466 || h
->root
.type
== bfd_link_hash_defweak
)
2467 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2469 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2471 switch (h
->root
.type
)
2474 case bfd_link_hash_new
:
2478 case bfd_link_hash_undefined
:
2479 input_sec
= bfd_und_section_ptr
;
2480 sym
.st_shndx
= SHN_UNDEF
;
2483 case bfd_link_hash_undefweak
:
2484 input_sec
= bfd_und_section_ptr
;
2485 sym
.st_shndx
= SHN_UNDEF
;
2488 case bfd_link_hash_defined
:
2489 case bfd_link_hash_defweak
:
2491 input_sec
= h
->root
.u
.def
.section
;
2492 if (input_sec
->output_section
!= NULL
)
2495 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2496 input_sec
->output_section
);
2497 if (sym
.st_shndx
== (unsigned short) -1)
2503 /* ELF symbols in relocateable files are section relative,
2504 but in nonrelocateable files they are virtual
2506 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2507 if (! finfo
->info
->relocateable
)
2508 sym
.st_value
+= input_sec
->output_section
->vma
;
2512 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2513 == bfd_target_elf_flavour
)
2514 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2515 sym
.st_shndx
= SHN_UNDEF
;
2516 input_sec
= bfd_und_section_ptr
;
2521 case bfd_link_hash_common
:
2522 input_sec
= bfd_com_section_ptr
;
2523 sym
.st_shndx
= SHN_COMMON
;
2524 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2527 case bfd_link_hash_indirect
:
2528 case bfd_link_hash_warning
:
2529 return (elf_link_output_extsym
2530 ((struct elf_link_hash_entry
*) h
->root
.u
.i
.link
, data
));
2533 /* If this symbol should be put in the .dynsym section, then put it
2534 there now. We have already know the symbol index. We also fill
2535 in the entry in the .hash section. */
2536 if (h
->dynindx
!= -1
2537 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2539 struct elf_backend_data
*bed
;
2542 bfd_byte
*bucketpos
;
2545 sym
.st_name
= h
->dynstr_index
;
2547 /* Give the processor backend a chance to tweak the symbol
2548 value, and also to finish up anything that needs to be done
2550 bed
= get_elf_backend_data (finfo
->output_bfd
);
2551 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2552 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2558 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2559 (PTR
) (((Elf_External_Sym
*)
2560 finfo
->dynsym_sec
->contents
)
2563 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2564 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2566 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2567 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2568 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2569 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2570 put_word (finfo
->output_bfd
, chain
,
2571 ((bfd_byte
*) finfo
->hash_sec
->contents
2572 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2575 /* If we're stripping it, then it was just a dynamic symbol, and
2576 there's nothing else to do. */
2580 h
->indx
= finfo
->output_bfd
->symcount
;
2582 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2591 /* Link an input file into the linker output file. This function
2592 handles all the sections and relocations of the input file at once.
2593 This is so that we only have to read the local symbols once, and
2594 don't have to keep them in memory. */
2597 elf_link_input_bfd (finfo
, input_bfd
)
2598 struct elf_final_link_info
*finfo
;
2601 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2602 bfd
*, asection
*, bfd_byte
*,
2603 Elf_Internal_Rela
*,
2604 Elf_Internal_Sym
*, asection
**));
2606 Elf_Internal_Shdr
*symtab_hdr
;
2609 Elf_External_Sym
*esym
;
2610 Elf_External_Sym
*esymend
;
2611 Elf_Internal_Sym
*isym
;
2613 asection
**ppsection
;
2616 output_bfd
= finfo
->output_bfd
;
2618 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2620 /* If this is a dynamic object, we don't want to do anything here:
2621 we don't want the local symbols, and we don't want the section
2623 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2626 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2627 if (elf_bad_symtab (input_bfd
))
2629 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2634 locsymcount
= symtab_hdr
->sh_info
;
2635 extsymoff
= symtab_hdr
->sh_info
;
2638 /* Read the local symbols. */
2640 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2641 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2642 locsymcount
, input_bfd
)
2643 != locsymcount
* sizeof (Elf_External_Sym
))))
2646 /* Swap in the local symbols and write out the ones which we know
2647 are going into the output file. */
2648 esym
= finfo
->external_syms
;
2649 esymend
= esym
+ locsymcount
;
2650 isym
= finfo
->internal_syms
;
2651 pindex
= finfo
->indices
;
2652 ppsection
= finfo
->sections
;
2653 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2657 Elf_Internal_Sym osym
;
2659 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2662 if (elf_bad_symtab (input_bfd
))
2664 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2671 if (isym
->st_shndx
== SHN_UNDEF
)
2672 isec
= bfd_und_section_ptr
;
2673 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2674 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2675 else if (isym
->st_shndx
== SHN_ABS
)
2676 isec
= bfd_abs_section_ptr
;
2677 else if (isym
->st_shndx
== SHN_COMMON
)
2678 isec
= bfd_com_section_ptr
;
2687 /* Don't output the first, undefined, symbol. */
2688 if (esym
== finfo
->external_syms
)
2691 /* If we are stripping all symbols, we don't want to output this
2693 if (finfo
->info
->strip
== strip_all
)
2696 /* We never output section symbols. Instead, we use the section
2697 symbol of the corresponding section in the output file. */
2698 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2701 /* If we are discarding all local symbols, we don't want to
2702 output this one. If we are generating a relocateable output
2703 file, then some of the local symbols may be required by
2704 relocs; we output them below as we discover that they are
2706 if (finfo
->info
->discard
== discard_all
)
2709 /* Get the name of the symbol. */
2710 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2715 /* See if we are discarding symbols with this name. */
2716 if ((finfo
->info
->strip
== strip_some
2717 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2719 || (finfo
->info
->discard
== discard_l
2720 && strncmp (name
, finfo
->info
->lprefix
,
2721 finfo
->info
->lprefix_len
) == 0))
2724 /* If we get here, we are going to output this symbol. */
2728 /* Adjust the section index for the output file. */
2729 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2730 isec
->output_section
);
2731 if (osym
.st_shndx
== (unsigned short) -1)
2734 *pindex
= output_bfd
->symcount
;
2736 /* ELF symbols in relocateable files are section relative, but
2737 in executable files they are virtual addresses. Note that
2738 this code assumes that all ELF sections have an associated
2739 BFD section with a reasonable value for output_offset; below
2740 we assume that they also have a reasonable value for
2741 output_section. Any special sections must be set up to meet
2742 these requirements. */
2743 osym
.st_value
+= isec
->output_offset
;
2744 if (! finfo
->info
->relocateable
)
2745 osym
.st_value
+= isec
->output_section
->vma
;
2747 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2751 /* Relocate the contents of each section. */
2752 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2754 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2757 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2758 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2760 /* Section was created by elf_link_create_dynamic_sections.
2761 FIXME: This test is fragile. */
2765 /* Read the contents of the section. */
2766 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2767 (file_ptr
) 0, o
->_raw_size
))
2770 if ((o
->flags
& SEC_RELOC
) != 0)
2772 Elf_Internal_Rela
*internal_relocs
;
2774 /* Get the swapped relocs. */
2775 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2776 finfo
->external_relocs
,
2777 finfo
->internal_relocs
,
2779 if (internal_relocs
== NULL
2780 && o
->reloc_count
> 0)
2783 /* Relocate the section by invoking a back end routine.
2785 The back end routine is responsible for adjusting the
2786 section contents as necessary, and (if using Rela relocs
2787 and generating a relocateable output file) adjusting the
2788 reloc addend as necessary.
2790 The back end routine does not have to worry about setting
2791 the reloc address or the reloc symbol index.
2793 The back end routine is given a pointer to the swapped in
2794 internal symbols, and can access the hash table entries
2795 for the external symbols via elf_sym_hashes (input_bfd).
2797 When generating relocateable output, the back end routine
2798 must handle STB_LOCAL/STT_SECTION symbols specially. The
2799 output symbol is going to be a section symbol
2800 corresponding to the output section, which will require
2801 the addend to be adjusted. */
2803 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2807 finfo
->internal_syms
,
2811 if (finfo
->info
->relocateable
)
2813 Elf_Internal_Rela
*irela
;
2814 Elf_Internal_Rela
*irelaend
;
2815 struct elf_link_hash_entry
**rel_hash
;
2816 Elf_Internal_Shdr
*input_rel_hdr
;
2817 Elf_Internal_Shdr
*output_rel_hdr
;
2819 /* Adjust the reloc addresses and symbol indices. */
2821 irela
= internal_relocs
;
2822 irelaend
= irela
+ o
->reloc_count
;
2823 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2824 + o
->output_section
->reloc_count
);
2825 for (; irela
< irelaend
; irela
++, rel_hash
++)
2827 unsigned long r_symndx
;
2828 Elf_Internal_Sym
*isym
;
2831 irela
->r_offset
+= o
->output_offset
;
2833 r_symndx
= ELF_R_SYM (irela
->r_info
);
2838 if (r_symndx
>= locsymcount
2839 || (elf_bad_symtab (input_bfd
)
2840 && finfo
->sections
[r_symndx
] == NULL
))
2844 /* This is a reloc against a global symbol. We
2845 have not yet output all the local symbols, so
2846 we do not know the symbol index of any global
2847 symbol. We set the rel_hash entry for this
2848 reloc to point to the global hash table entry
2849 for this symbol. The symbol index is then
2850 set at the end of elf_bfd_final_link. */
2851 indx
= r_symndx
- extsymoff
;
2852 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2854 /* Setting the index to -2 tells
2855 elf_link_output_extsym that this symbol is
2857 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2858 (*rel_hash
)->indx
= -2;
2863 /* This is a reloc against a local symbol. */
2866 isym
= finfo
->internal_syms
+ r_symndx
;
2867 sec
= finfo
->sections
[r_symndx
];
2868 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2870 /* I suppose the backend ought to fill in the
2871 section of any STT_SECTION symbol against a
2872 processor specific section. */
2873 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2875 else if (sec
== NULL
|| sec
->owner
== NULL
)
2877 bfd_set_error (bfd_error_bad_value
);
2882 r_symndx
= sec
->output_section
->target_index
;
2883 BFD_ASSERT (r_symndx
!= 0);
2888 if (finfo
->indices
[r_symndx
] == -1)
2894 if (finfo
->info
->strip
== strip_all
)
2896 /* You can't do ld -r -s. */
2897 bfd_set_error (bfd_error_invalid_operation
);
2901 /* This symbol was skipped earlier, but
2902 since it is needed by a reloc, we
2903 must output it now. */
2904 link
= symtab_hdr
->sh_link
;
2905 name
= bfd_elf_string_from_elf_section (input_bfd
,
2911 osec
= sec
->output_section
;
2913 _bfd_elf_section_from_bfd_section (output_bfd
,
2915 if (isym
->st_shndx
== (unsigned short) -1)
2918 isym
->st_value
+= sec
->output_offset
;
2919 if (! finfo
->info
->relocateable
)
2920 isym
->st_value
+= osec
->vma
;
2922 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2924 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2928 r_symndx
= finfo
->indices
[r_symndx
];
2931 irela
->r_info
= ELF_R_INFO (r_symndx
,
2932 ELF_R_TYPE (irela
->r_info
));
2935 /* Swap out the relocs. */
2936 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2937 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2938 BFD_ASSERT (output_rel_hdr
->sh_entsize
2939 == input_rel_hdr
->sh_entsize
);
2940 irela
= internal_relocs
;
2941 irelaend
= irela
+ o
->reloc_count
;
2942 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2944 Elf_External_Rel
*erel
;
2946 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2947 + o
->output_section
->reloc_count
);
2948 for (; irela
< irelaend
; irela
++, erel
++)
2950 Elf_Internal_Rel irel
;
2952 irel
.r_offset
= irela
->r_offset
;
2953 irel
.r_info
= irela
->r_info
;
2954 BFD_ASSERT (irela
->r_addend
== 0);
2955 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
2960 Elf_External_Rela
*erela
;
2962 BFD_ASSERT (input_rel_hdr
->sh_entsize
2963 == sizeof (Elf_External_Rela
));
2964 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
2965 + o
->output_section
->reloc_count
);
2966 for (; irela
< irelaend
; irela
++, erela
++)
2967 elf_swap_reloca_out (output_bfd
, irela
, erela
);
2970 o
->output_section
->reloc_count
+= o
->reloc_count
;
2974 /* Write out the modified section contents. */
2975 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2976 finfo
->contents
, o
->output_offset
,
2977 (o
->_cooked_size
!= 0
2986 /* Generate a reloc when linking an ELF file. This is a reloc
2987 requested by the linker, and does come from any input file. This
2988 is used to build constructor and destructor tables when linking
2992 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
2994 struct bfd_link_info
*info
;
2995 asection
*output_section
;
2996 struct bfd_link_order
*link_order
;
2998 reloc_howto_type
*howto
;
3001 struct elf_link_hash_entry
**rel_hash_ptr
;
3002 Elf_Internal_Shdr
*rel_hdr
;
3004 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
3007 bfd_set_error (bfd_error_bad_value
);
3011 /* If this is an inplace reloc, we must write the addend into the
3013 if (howto
->partial_inplace
3014 && link_order
->u
.reloc
.p
->addend
!= 0)
3017 bfd_reloc_status_type rstat
;
3021 size
= bfd_get_reloc_size (howto
);
3022 buf
= (bfd_byte
*) bfd_zmalloc (size
);
3023 if (buf
== (bfd_byte
*) NULL
)
3025 bfd_set_error (bfd_error_no_memory
);
3028 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
3029 link_order
->u
.reloc
.p
->addend
, buf
);
3035 case bfd_reloc_outofrange
:
3037 case bfd_reloc_overflow
:
3038 if (! ((*info
->callbacks
->reloc_overflow
)
3040 (link_order
->type
== bfd_section_reloc_link_order
3041 ? bfd_section_name (output_bfd
,
3042 link_order
->u
.reloc
.p
->u
.section
)
3043 : link_order
->u
.reloc
.p
->u
.name
),
3044 howto
->name
, link_order
->u
.reloc
.p
->addend
,
3045 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
3052 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
3053 (file_ptr
) link_order
->offset
, size
);
3059 /* Figure out the symbol index. */
3060 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
3061 + output_section
->reloc_count
);
3062 if (link_order
->type
== bfd_section_reloc_link_order
)
3064 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
3065 BFD_ASSERT (indx
!= 0);
3066 *rel_hash_ptr
= NULL
;
3070 struct elf_link_hash_entry
*h
;
3072 h
= elf_link_hash_lookup (elf_hash_table (info
),
3073 link_order
->u
.reloc
.p
->u
.name
,
3074 false, false, true);
3077 /* Setting the index to -2 tells elf_link_output_extsym that
3078 this symbol is used by a reloc. */
3085 if (! ((*info
->callbacks
->unattached_reloc
)
3086 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3087 (asection
*) NULL
, (bfd_vma
) 0)))
3093 /* The address of a reloc is relative to the section in a
3094 relocateable file, and is a virtual address in an executable
3096 offset
= link_order
->offset
;
3097 if (! info
->relocateable
)
3098 offset
+= output_section
->vma
;
3100 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3102 if (rel_hdr
->sh_type
== SHT_REL
)
3104 Elf_Internal_Rel irel
;
3105 Elf_External_Rel
*erel
;
3107 irel
.r_offset
= offset
;
3108 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3109 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3110 + output_section
->reloc_count
);
3111 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3115 Elf_Internal_Rela irela
;
3116 Elf_External_Rela
*erela
;
3118 irela
.r_offset
= offset
;
3119 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3120 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
3121 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3122 + output_section
->reloc_count
);
3123 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3126 ++output_section
->reloc_count
;