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. */
19 /* ELF linker code. */
21 static boolean elf_link_add_object_symbols
22 PARAMS ((bfd
*, struct bfd_link_info
*));
23 static boolean elf_link_add_archive_symbols
24 PARAMS ((bfd
*, struct bfd_link_info
*));
25 static Elf_Internal_Rela
*elf_link_read_relocs
26 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
27 static boolean elf_export_symbol
28 PARAMS ((struct elf_link_hash_entry
*, PTR
));
29 static boolean elf_adjust_dynamic_symbol
30 PARAMS ((struct elf_link_hash_entry
*, PTR
));
32 /* This struct is used to pass information to routines called via
33 elf_link_hash_traverse which must return failure. */
35 struct elf_info_failed
38 struct bfd_link_info
*info
;
41 /* Given an ELF BFD, add symbols to the global hash table as
45 elf_bfd_link_add_symbols (abfd
, info
)
47 struct bfd_link_info
*info
;
49 switch (bfd_get_format (abfd
))
52 return elf_link_add_object_symbols (abfd
, info
);
54 return elf_link_add_archive_symbols (abfd
, info
);
56 bfd_set_error (bfd_error_wrong_format
);
61 /* Add symbols from an ELF archive file to the linker hash table. We
62 don't use _bfd_generic_link_add_archive_symbols because of a
63 problem which arises on UnixWare. The UnixWare libc.so is an
64 archive which includes an entry libc.so.1 which defines a bunch of
65 symbols. The libc.so archive also includes a number of other
66 object files, which also define symbols, some of which are the same
67 as those defined in libc.so.1. Correct linking requires that we
68 consider each object file in turn, and include it if it defines any
69 symbols we need. _bfd_generic_link_add_archive_symbols does not do
70 this; it looks through the list of undefined symbols, and includes
71 any object file which defines them. When this algorithm is used on
72 UnixWare, it winds up pulling in libc.so.1 early and defining a
73 bunch of symbols. This means that some of the other objects in the
74 archive are not included in the link, which is incorrect since they
75 precede libc.so.1 in the archive.
77 Fortunately, ELF archive handling is simpler than that done by
78 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
79 oddities. In ELF, if we find a symbol in the archive map, and the
80 symbol is currently undefined, we know that we must pull in that
83 Unfortunately, we do have to make multiple passes over the symbol
84 table until nothing further is resolved. */
87 elf_link_add_archive_symbols (abfd
, info
)
89 struct bfd_link_info
*info
;
92 boolean
*defined
= NULL
;
93 boolean
*included
= NULL
;
97 if (! bfd_has_map (abfd
))
99 /* An empty archive is a special case. */
100 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
102 bfd_set_error (bfd_error_no_armap
);
106 /* Keep track of all symbols we know to be already defined, and all
107 files we know to be already included. This is to speed up the
108 second and subsequent passes. */
109 c
= bfd_ardata (abfd
)->symdef_count
;
112 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
113 included
= (boolean
*) malloc (c
* sizeof (boolean
));
114 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
116 bfd_set_error (bfd_error_no_memory
);
119 memset (defined
, 0, c
* sizeof (boolean
));
120 memset (included
, 0, c
* sizeof (boolean
));
122 symdefs
= bfd_ardata (abfd
)->symdefs
;
135 symdefend
= symdef
+ c
;
136 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
138 struct elf_link_hash_entry
*h
;
140 struct bfd_link_hash_entry
*undefs_tail
;
143 if (defined
[i
] || included
[i
])
145 if (symdef
->file_offset
== last
)
151 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
152 false, false, false);
153 if (h
== (struct elf_link_hash_entry
*) NULL
)
155 if (h
->root
.type
!= bfd_link_hash_undefined
)
161 /* We need to include this archive member. */
163 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
164 if (element
== (bfd
*) NULL
)
167 if (! bfd_check_format (element
, bfd_object
))
170 /* Doublecheck that we have not included this object
171 already--it should be impossible, but there may be
172 something wrong with the archive. */
173 if (element
->archive_pass
!= 0)
175 bfd_set_error (bfd_error_bad_value
);
178 element
->archive_pass
= 1;
180 undefs_tail
= info
->hash
->undefs_tail
;
182 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
185 if (! elf_link_add_object_symbols (element
, info
))
188 /* If there are any new undefined symbols, we need to make
189 another pass through the archive in order to see whether
190 they can be defined. FIXME: This isn't perfect, because
191 common symbols wind up on undefs_tail and because an
192 undefined symbol which is defined later on in this pass
193 does not require another pass. This isn't a bug, but it
194 does make the code less efficient than it could be. */
195 if (undefs_tail
!= info
->hash
->undefs_tail
)
198 /* Look backward to mark all symbols from this object file
199 which we have already seen in this pass. */
203 included
[mark
] = true;
208 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
210 /* We mark subsequent symbols from this object file as we go
211 on through the loop. */
212 last
= symdef
->file_offset
;
223 if (defined
!= (boolean
*) NULL
)
225 if (included
!= (boolean
*) NULL
)
230 /* Add symbols from an ELF object file to the linker hash table. */
233 elf_link_add_object_symbols (abfd
, info
)
235 struct bfd_link_info
*info
;
237 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
238 const Elf_Internal_Sym
*,
239 const char **, flagword
*,
240 asection
**, bfd_vma
*));
241 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
242 asection
*, const Elf_Internal_Rela
*));
244 Elf_Internal_Shdr
*hdr
;
248 Elf_External_Sym
*buf
= NULL
;
249 struct elf_link_hash_entry
**sym_hash
;
251 Elf_External_Dyn
*dynbuf
= NULL
;
252 struct elf_link_hash_entry
*weaks
;
253 Elf_External_Sym
*esym
;
254 Elf_External_Sym
*esymend
;
256 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
257 collect
= get_elf_backend_data (abfd
)->collect
;
259 /* A stripped shared library might only have a dynamic symbol table,
260 not a regular symbol table. In that case we can still go ahead
261 and link using the dynamic symbol table. */
262 if (elf_onesymtab (abfd
) == 0
263 && elf_dynsymtab (abfd
) != 0)
265 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
266 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
269 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
270 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
272 /* The sh_info field of the symtab header tells us where the
273 external symbols start. We don't care about the local symbols at
275 if (elf_bad_symtab (abfd
))
277 extsymcount
= symcount
;
282 extsymcount
= symcount
- hdr
->sh_info
;
283 extsymoff
= hdr
->sh_info
;
286 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
287 if (buf
== NULL
&& extsymcount
!= 0)
289 bfd_set_error (bfd_error_no_memory
);
293 /* We store a pointer to the hash table entry for each external
295 sym_hash
= ((struct elf_link_hash_entry
**)
297 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
298 if (sym_hash
== NULL
)
300 bfd_set_error (bfd_error_no_memory
);
303 elf_sym_hashes (abfd
) = sym_hash
;
305 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
309 /* If we are creating a shared library, create all the dynamic
310 sections immediately. We need to attach them to something,
311 so we attach them to this BFD, provided it is the right
312 format. FIXME: If there are no input BFD's of the same
313 format as the output, we can't make a shared library. */
315 && ! elf_hash_table (info
)->dynamic_sections_created
316 && abfd
->xvec
== info
->hash
->creator
)
318 if (! elf_link_create_dynamic_sections (abfd
, info
))
327 bfd_size_type oldsize
;
328 bfd_size_type strindex
;
332 /* You can't use -r against a dynamic object. Also, there's no
333 hope of using a dynamic object which does not exactly match
334 the format of the output file. */
335 if (info
->relocateable
336 || info
->hash
->creator
!= abfd
->xvec
)
338 bfd_set_error (bfd_error_invalid_operation
);
342 /* Find the name to use in a DT_NEEDED entry that refers to this
343 object. If the object has a DT_SONAME entry, we use it.
344 Otherwise, if the generic linker stuck something in
345 elf_dt_needed_name, we use that. Otherwise, we just use the
346 file name. If the generic linker put a null string into
347 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
348 even if there is a DT_SONAME entry. */
350 name
= bfd_get_filename (abfd
);
351 if (elf_dt_needed_name (abfd
) != NULL
)
353 name
= elf_dt_needed_name (abfd
);
357 s
= bfd_get_section_by_name (abfd
, ".dynamic");
360 Elf_External_Dyn
*extdyn
;
361 Elf_External_Dyn
*extdynend
;
365 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
368 bfd_set_error (bfd_error_no_memory
);
372 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
373 (file_ptr
) 0, s
->_raw_size
))
376 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
379 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
382 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
383 for (; extdyn
< extdynend
; extdyn
++)
385 Elf_Internal_Dyn dyn
;
387 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
388 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
390 name
= bfd_elf_string_from_elf_section (abfd
, link
,
395 if (dyn
.d_tag
== DT_NEEDED
)
397 struct bfd_elf_link_needed_list
*n
, **pn
;
401 sizeof (struct bfd_elf_link_needed_list
));
402 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
404 if (n
== NULL
|| fnm
== NULL
)
406 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
413 for (pn
= &elf_hash_table (info
)->needed
;
425 /* We do not want to include any of the sections in a dynamic
426 object in the output file. We hack by simply clobbering the
427 list of sections in the BFD. This could be handled more
428 cleanly by, say, a new section flag; the existing
429 SEC_NEVER_LOAD flag is not the one we want, because that one
430 still implies that the section takes up space in the output
432 abfd
->sections
= NULL
;
434 /* If this is the first dynamic object found in the link, create
435 the special sections required for dynamic linking. */
436 if (! elf_hash_table (info
)->dynamic_sections_created
)
438 if (! elf_link_create_dynamic_sections (abfd
, info
))
444 /* Add a DT_NEEDED entry for this dynamic object. */
445 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
446 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
448 if (strindex
== (bfd_size_type
) -1)
451 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
454 Elf_External_Dyn
*dyncon
, *dynconend
;
456 /* The hash table size did not change, which means that
457 the dynamic object name was already entered. If we
458 have already included this dynamic object in the
459 link, just ignore it. There is no reason to include
460 a particular dynamic object more than once. */
461 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
463 BFD_ASSERT (sdyn
!= NULL
);
465 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
466 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
468 for (; dyncon
< dynconend
; dyncon
++)
470 Elf_Internal_Dyn dyn
;
472 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
474 if (dyn
.d_tag
== DT_NEEDED
475 && dyn
.d_un
.d_val
== strindex
)
484 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
490 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
492 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
493 != extsymcount
* sizeof (Elf_External_Sym
)))
498 esymend
= buf
+ extsymcount
;
499 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
501 Elf_Internal_Sym sym
;
507 struct elf_link_hash_entry
*h
= NULL
;
510 elf_swap_symbol_in (abfd
, esym
, &sym
);
512 flags
= BSF_NO_FLAGS
;
514 value
= sym
.st_value
;
517 bind
= ELF_ST_BIND (sym
.st_info
);
518 if (bind
== STB_LOCAL
)
520 /* This should be impossible, since ELF requires that all
521 global symbols follow all local symbols, and that sh_info
522 point to the first global symbol. Unfortunatealy, Irix 5
526 else if (bind
== STB_GLOBAL
)
528 if (sym
.st_shndx
!= SHN_UNDEF
529 && sym
.st_shndx
!= SHN_COMMON
)
534 else if (bind
== STB_WEAK
)
538 /* Leave it up to the processor backend. */
541 if (sym
.st_shndx
== SHN_UNDEF
)
542 sec
= bfd_und_section_ptr
;
543 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
545 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
549 sec
= bfd_abs_section_ptr
;
551 else if (sym
.st_shndx
== SHN_ABS
)
552 sec
= bfd_abs_section_ptr
;
553 else if (sym
.st_shndx
== SHN_COMMON
)
555 sec
= bfd_com_section_ptr
;
556 /* What ELF calls the size we call the value. What ELF
557 calls the value we call the alignment. */
562 /* Leave it up to the processor backend. */
565 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
566 if (name
== (const char *) NULL
)
571 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
575 /* The hook function sets the name to NULL if this symbol
576 should be skipped for some reason. */
577 if (name
== (const char *) NULL
)
581 /* Sanity check that all possibilities were handled. */
582 if (sec
== (asection
*) NULL
)
584 bfd_set_error (bfd_error_bad_value
);
588 if (bfd_is_und_section (sec
)
589 || bfd_is_com_section (sec
))
594 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
596 /* We need to look up the symbol now in order to get some of
597 the dynamic object handling right. We pass the hash
598 table entry in to _bfd_generic_link_add_one_symbol so
599 that it does not have to look it up again. */
600 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
606 /* If we are looking at a dynamic object, and this is a
607 definition, we need to see if it has already been defined
608 by some other object. If it has, we want to use the
609 existing definition, and we do not want to report a
610 multiple symbol definition error; we do this by
611 clobbering sec to be bfd_und_section_ptr. */
612 if (dynamic
&& definition
)
614 if (h
->root
.type
== bfd_link_hash_defined
615 || h
->root
.type
== bfd_link_hash_defweak
)
616 sec
= bfd_und_section_ptr
;
619 /* Similarly, if we are not looking at a dynamic object, and
620 we have a definition, we want to override any definition
621 we may have from a dynamic object. Symbols from regular
622 files always take precedence over symbols from dynamic
623 objects, even if they are defined after the dynamic
624 object in the link. */
627 && (h
->root
.type
== bfd_link_hash_defined
628 || h
->root
.type
== bfd_link_hash_defweak
)
629 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
630 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
631 == bfd_target_elf_flavour
)
632 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
635 /* Change the hash table entry to undefined, and let
636 _bfd_generic_link_add_one_symbol do the right thing
637 with the new definition. */
638 h
->root
.type
= bfd_link_hash_undefined
;
639 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
643 if (! (_bfd_generic_link_add_one_symbol
644 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
645 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
650 && (flags
& BSF_WEAK
) != 0
651 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
652 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
653 && (*sym_hash
)->weakdef
== NULL
)
655 /* Keep a list of all weak defined non function symbols from
656 a dynamic object, using the weakdef field. Later in this
657 function we will set the weakdef field to the correct
658 value. We only put non-function symbols from dynamic
659 objects on this list, because that happens to be the only
660 time we need to know the normal symbol corresponding to a
661 weak symbol, and the information is time consuming to
662 figure out. If the weakdef field is not already NULL,
663 then this symbol was already defined by some previous
664 dynamic object, and we will be using that previous
665 definition anyhow. */
667 (*sym_hash
)->weakdef
= weaks
;
671 /* Get the alignment of a common symbol. */
672 if (sym
.st_shndx
== SHN_COMMON
673 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
674 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
676 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
682 /* Remember the symbol size and type. */
683 if (sym
.st_size
!= 0)
685 /* FIXME: We should probably somehow give a warning if
686 the symbol size changes. */
687 h
->size
= sym
.st_size
;
689 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
691 /* FIXME: We should probably somehow give a warning if
692 the symbol type changes. */
693 h
->type
= ELF_ST_TYPE (sym
.st_info
);
696 /* Set a flag in the hash table entry indicating the type of
697 reference or definition we just found. Keep a count of
698 the number of dynamic symbols we find. A dynamic symbol
699 is one which is referenced or defined by both a regular
700 object and a shared object, or one which is referenced or
701 defined by more than one shared object. */
702 old_flags
= h
->elf_link_hash_flags
;
707 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
709 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
711 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
712 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
718 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
720 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
721 if ((old_flags
& new_flag
) != 0
722 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
723 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
727 h
->elf_link_hash_flags
|= new_flag
;
728 if (dynsym
&& h
->dynindx
== -1)
730 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
736 /* Now set the weakdefs field correctly for all the weak defined
737 symbols we found. The only way to do this is to search all the
738 symbols. Since we only need the information for non functions in
739 dynamic objects, that's the only time we actually put anything on
740 the list WEAKS. We need this information so that if a regular
741 object refers to a symbol defined weakly in a dynamic object, the
742 real symbol in the dynamic object is also put in the dynamic
743 symbols; we also must arrange for both symbols to point to the
744 same memory location. We could handle the general case of symbol
745 aliasing, but a general symbol alias can only be generated in
746 assembler code, handling it correctly would be very time
747 consuming, and other ELF linkers don't handle general aliasing
749 while (weaks
!= NULL
)
751 struct elf_link_hash_entry
*hlook
;
754 struct elf_link_hash_entry
**hpp
;
755 struct elf_link_hash_entry
**hppend
;
758 weaks
= hlook
->weakdef
;
759 hlook
->weakdef
= NULL
;
761 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
762 || hlook
->root
.type
== bfd_link_hash_defweak
763 || hlook
->root
.type
== bfd_link_hash_common
764 || hlook
->root
.type
== bfd_link_hash_indirect
);
765 slook
= hlook
->root
.u
.def
.section
;
766 vlook
= hlook
->root
.u
.def
.value
;
768 hpp
= elf_sym_hashes (abfd
);
769 hppend
= hpp
+ extsymcount
;
770 for (; hpp
< hppend
; hpp
++)
772 struct elf_link_hash_entry
*h
;
775 if (h
!= NULL
&& h
!= hlook
776 && (h
->root
.type
== bfd_link_hash_defined
777 || h
->root
.type
== bfd_link_hash_defweak
)
778 && h
->root
.u
.def
.section
== slook
779 && h
->root
.u
.def
.value
== vlook
)
783 /* If the weak definition is in the list of dynamic
784 symbols, make sure the real definition is put there
786 if (hlook
->dynindx
!= -1
789 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
804 /* If this object is the same format as the output object, and it is
805 not a shared library, then let the backend look through the
808 This is required to build global offset table entries and to
809 arrange for dynamic relocs. It is not required for the
810 particular common case of linking non PIC code, even when linking
811 against shared libraries, but unfortunately there is no way of
812 knowing whether an object file has been compiled PIC or not.
813 Looking through the relocs is not particularly time consuming.
814 The problem is that we must either (1) keep the relocs in memory,
815 which causes the linker to require additional runtime memory or
816 (2) read the relocs twice from the input file, which wastes time.
817 This would be a good case for using mmap.
819 I have no idea how to handle linking PIC code into a file of a
820 different format. It probably can't be done. */
821 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
823 && abfd
->xvec
== info
->hash
->creator
824 && check_relocs
!= NULL
)
828 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
830 Elf_Internal_Rela
*internal_relocs
;
833 if ((o
->flags
& SEC_RELOC
) == 0
834 || o
->reloc_count
== 0)
837 /* I believe we can ignore the relocs for any section which
838 does not form part of the final process image, such as a
839 debugging section. */
840 if ((o
->flags
& SEC_ALLOC
) == 0)
843 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
844 (Elf_Internal_Rela
*) NULL
,
846 if (internal_relocs
== NULL
)
849 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
851 if (! info
->keep_memory
)
852 free (internal_relocs
);
869 /* Create some sections which will be filled in with dynamic linking
870 information. ABFD is an input file which requires dynamic sections
871 to be created. The dynamic sections take up virtual memory space
872 when the final executable is run, so we need to create them before
873 addresses are assigned to the output sections. We work out the
874 actual contents and size of these sections later. */
877 elf_link_create_dynamic_sections (abfd
, info
)
879 struct bfd_link_info
*info
;
882 register asection
*s
;
883 struct elf_link_hash_entry
*h
;
884 struct elf_backend_data
*bed
;
886 if (elf_hash_table (info
)->dynamic_sections_created
)
889 /* Make sure that all dynamic sections use the same input BFD. */
890 if (elf_hash_table (info
)->dynobj
== NULL
)
891 elf_hash_table (info
)->dynobj
= abfd
;
893 abfd
= elf_hash_table (info
)->dynobj
;
895 /* Note that we set the SEC_IN_MEMORY flag for all of these
897 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
899 /* A dynamically linked executable has a .interp section, but a
900 shared library does not. */
903 s
= bfd_make_section (abfd
, ".interp");
905 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
909 s
= bfd_make_section (abfd
, ".dynsym");
911 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
912 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
915 s
= bfd_make_section (abfd
, ".dynstr");
917 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
920 /* Create a strtab to hold the dynamic symbol names. */
921 if (elf_hash_table (info
)->dynstr
== NULL
)
923 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
924 if (elf_hash_table (info
)->dynstr
== NULL
)
928 s
= bfd_make_section (abfd
, ".dynamic");
930 || ! bfd_set_section_flags (abfd
, s
, flags
)
931 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
934 /* The special symbol _DYNAMIC is always set to the start of the
935 .dynamic section. This call occurs before we have processed the
936 symbols for any dynamic object, so we don't have to worry about
937 overriding a dynamic definition. We could set _DYNAMIC in a
938 linker script, but we only want to define it if we are, in fact,
939 creating a .dynamic section. We don't want to define it if there
940 is no .dynamic section, since on some ELF platforms the start up
941 code examines it to decide how to initialize the process. */
943 if (! (_bfd_generic_link_add_one_symbol
944 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
945 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
946 (struct bfd_link_hash_entry
**) &h
)))
948 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
949 h
->type
= STT_OBJECT
;
952 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
955 s
= bfd_make_section (abfd
, ".hash");
957 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
958 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
961 /* Let the backend create the rest of the sections. This lets the
962 backend set the right flags. The backend will normally create
963 the .got and .plt sections. */
964 bed
= get_elf_backend_data (abfd
);
965 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
968 elf_hash_table (info
)->dynamic_sections_created
= true;
973 /* Add an entry to the .dynamic table. */
976 elf_add_dynamic_entry (info
, tag
, val
)
977 struct bfd_link_info
*info
;
981 Elf_Internal_Dyn dyn
;
985 bfd_byte
*newcontents
;
987 dynobj
= elf_hash_table (info
)->dynobj
;
989 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
990 BFD_ASSERT (s
!= NULL
);
992 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
993 if (s
->contents
== NULL
)
994 newcontents
= (bfd_byte
*) malloc (newsize
);
996 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
997 if (newcontents
== NULL
)
999 bfd_set_error (bfd_error_no_memory
);
1004 dyn
.d_un
.d_val
= val
;
1005 elf_swap_dyn_out (dynobj
, &dyn
,
1006 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1008 s
->_raw_size
= newsize
;
1009 s
->contents
= newcontents
;
1014 /* Read and swap the relocs for a section. They may have been cached.
1015 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1016 they are used as buffers to read into. They are known to be large
1017 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1018 value is allocated using either malloc or bfd_alloc, according to
1019 the KEEP_MEMORY argument. */
1021 static Elf_Internal_Rela
*
1022 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1025 PTR external_relocs
;
1026 Elf_Internal_Rela
*internal_relocs
;
1027 boolean keep_memory
;
1029 Elf_Internal_Shdr
*rel_hdr
;
1031 Elf_Internal_Rela
*alloc2
= NULL
;
1033 if (elf_section_data (o
)->relocs
!= NULL
)
1034 return elf_section_data (o
)->relocs
;
1036 if (o
->reloc_count
== 0)
1039 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1041 if (internal_relocs
== NULL
)
1045 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1047 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1049 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
1050 if (internal_relocs
== NULL
)
1052 bfd_set_error (bfd_error_no_memory
);
1057 if (external_relocs
== NULL
)
1059 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
1062 bfd_set_error (bfd_error_no_memory
);
1065 external_relocs
= alloc1
;
1068 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1069 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1070 != rel_hdr
->sh_size
))
1073 /* Swap in the relocs. For convenience, we always produce an
1074 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1076 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1078 Elf_External_Rel
*erel
;
1079 Elf_External_Rel
*erelend
;
1080 Elf_Internal_Rela
*irela
;
1082 erel
= (Elf_External_Rel
*) external_relocs
;
1083 erelend
= erel
+ o
->reloc_count
;
1084 irela
= internal_relocs
;
1085 for (; erel
< erelend
; erel
++, irela
++)
1087 Elf_Internal_Rel irel
;
1089 elf_swap_reloc_in (abfd
, erel
, &irel
);
1090 irela
->r_offset
= irel
.r_offset
;
1091 irela
->r_info
= irel
.r_info
;
1092 irela
->r_addend
= 0;
1097 Elf_External_Rela
*erela
;
1098 Elf_External_Rela
*erelaend
;
1099 Elf_Internal_Rela
*irela
;
1101 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1103 erela
= (Elf_External_Rela
*) external_relocs
;
1104 erelaend
= erela
+ o
->reloc_count
;
1105 irela
= internal_relocs
;
1106 for (; erela
< erelaend
; erela
++, irela
++)
1107 elf_swap_reloca_in (abfd
, erela
, irela
);
1110 /* Cache the results for next time, if we can. */
1112 elf_section_data (o
)->relocs
= internal_relocs
;
1117 /* Don't free alloc2, since if it was allocated we are passing it
1118 back (under the name of internal_relocs). */
1120 return internal_relocs
;
1130 /* Record an assignment to a symbol made by a linker script. We need
1131 this in case some dynamic object refers to this symbol. */
1135 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1137 struct bfd_link_info
*info
;
1141 struct elf_link_hash_entry
*h
;
1143 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1146 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1150 /* If this symbol is being provided by the linker script, and it is
1151 currently defined by a dynamic object, but not by a regular
1152 object, then mark it as undefined so that the generic linker will
1153 force the correct value. */
1155 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1156 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1157 h
->root
.type
= bfd_link_hash_undefined
;
1159 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1160 h
->type
= STT_OBJECT
;
1162 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1163 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1165 && h
->dynindx
== -1)
1167 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1170 /* If this is a weak defined symbol, and we know a corresponding
1171 real symbol from the same dynamic object, make sure the real
1172 symbol is also made into a dynamic symbol. */
1173 if (h
->weakdef
!= NULL
1174 && h
->weakdef
->dynindx
== -1)
1176 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1184 /* Array used to determine the number of hash table buckets to use
1185 based on the number of symbols there are. If there are fewer than
1186 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1187 fewer than 37 we use 17 buckets, and so forth. We never use more
1188 than 521 buckets. */
1190 static const size_t elf_buckets
[] =
1192 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1195 /* Set up the sizes and contents of the ELF dynamic sections. This is
1196 called by the ELF linker emulation before_allocation routine. We
1197 must set the sizes of the sections before the linker sets the
1198 addresses of the various sections. */
1201 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1202 export_dynamic
, info
, sinterpptr
)
1206 boolean export_dynamic
;
1207 struct bfd_link_info
*info
;
1208 asection
**sinterpptr
;
1211 struct elf_backend_data
*bed
;
1215 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1218 dynobj
= elf_hash_table (info
)->dynobj
;
1220 /* If there were no dynamic objects in the link, there is nothing to
1225 /* If we are supposed to export all symbols into the dynamic symbol
1226 table (this is not the normal case), then do so. */
1229 struct elf_info_failed eif
;
1233 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1239 if (elf_hash_table (info
)->dynamic_sections_created
)
1241 struct elf_info_failed eif
;
1242 bfd_size_type strsize
;
1244 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1245 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1251 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1253 if (indx
== (bfd_size_type
) -1
1254 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1260 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1268 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1270 if (indx
== (bfd_size_type
) -1
1271 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1275 /* Find all symbols which were defined in a dynamic object and make
1276 the backend pick a reasonable value for them. */
1279 elf_link_hash_traverse (elf_hash_table (info
),
1280 elf_adjust_dynamic_symbol
,
1285 /* Add some entries to the .dynamic section. We fill in some of the
1286 values later, in elf_bfd_final_link, but we must add the entries
1287 now so that we know the final size of the .dynamic section. */
1288 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1289 false, false) != NULL
)
1291 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1294 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1295 false, false) != NULL
)
1297 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1300 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1301 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1302 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1303 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1304 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1305 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1306 sizeof (Elf_External_Sym
)))
1310 /* The backend must work out the sizes of all the other dynamic
1312 bed
= get_elf_backend_data (output_bfd
);
1313 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1316 if (elf_hash_table (info
)->dynamic_sections_created
)
1321 size_t bucketcount
= 0;
1322 Elf_Internal_Sym isym
;
1324 /* Set the size of the .dynsym and .hash sections. We counted
1325 the number of dynamic symbols in elf_link_add_object_symbols.
1326 We will build the contents of .dynsym and .hash when we build
1327 the final symbol table, because until then we do not know the
1328 correct value to give the symbols. We built the .dynstr
1329 section as we went along in elf_link_add_object_symbols. */
1330 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1331 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1332 BFD_ASSERT (s
!= NULL
);
1333 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1334 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1335 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1337 bfd_set_error (bfd_error_no_memory
);
1341 /* The first entry in .dynsym is a dummy symbol. */
1348 elf_swap_symbol_out (output_bfd
, &isym
,
1349 (PTR
) (Elf_External_Sym
*) s
->contents
);
1351 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1353 bucketcount
= elf_buckets
[i
];
1354 if (dynsymcount
< elf_buckets
[i
+ 1])
1358 s
= bfd_get_section_by_name (dynobj
, ".hash");
1359 BFD_ASSERT (s
!= NULL
);
1360 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1361 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1362 if (s
->contents
== NULL
)
1364 bfd_set_error (bfd_error_no_memory
);
1367 memset (s
->contents
, 0, s
->_raw_size
);
1369 put_word (output_bfd
, bucketcount
, s
->contents
);
1370 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1372 elf_hash_table (info
)->bucketcount
= bucketcount
;
1374 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1375 BFD_ASSERT (s
!= NULL
);
1376 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1378 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1385 /* This routine is used to export all defined symbols into the dynamic
1386 symbol table. It is called via elf_link_hash_traverse. */
1389 elf_export_symbol (h
, data
)
1390 struct elf_link_hash_entry
*h
;
1393 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1395 if (h
->dynindx
== -1
1396 && (h
->elf_link_hash_flags
1397 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1399 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1409 /* Make the backend pick a good value for a dynamic symbol. This is
1410 called via elf_link_hash_traverse, and also calls itself
1414 elf_adjust_dynamic_symbol (h
, data
)
1415 struct elf_link_hash_entry
*h
;
1418 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1420 struct elf_backend_data
*bed
;
1422 /* If -Bsymbolic was used (which means to bind references to global
1423 symbols to the definition within the shared object), and this
1424 symbol was defined in a regular object, then it actually doesn't
1425 need a PLT entry. */
1426 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1427 && eif
->info
->shared
1428 && eif
->info
->symbolic
1429 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1430 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1432 /* If this symbol does not require a PLT entry, and it is not
1433 defined by a dynamic object, or is not referenced by a regular
1434 object, ignore it. FIXME: Do we need to worry about symbols
1435 which are defined by one dynamic object and referenced by another
1437 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1438 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1439 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1440 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
1443 /* If we've already adjusted this symbol, don't do it again. This
1444 can happen via a recursive call. */
1445 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1448 /* Don't look at this symbol again. Note that we must set this
1449 after checking the above conditions, because we may look at a
1450 symbol once, decide not to do anything, and then get called
1451 recursively later after REF_REGULAR is set below. */
1452 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1454 /* If this is a weak definition, and we know a real definition, and
1455 the real symbol is not itself defined by a regular object file,
1456 then get a good value for the real definition. We handle the
1457 real symbol first, for the convenience of the backend routine.
1459 Note that there is a confusing case here. If the real definition
1460 is defined by a regular object file, we don't get the real symbol
1461 from the dynamic object, but we do get the weak symbol. If the
1462 processor backend uses a COPY reloc, then if some routine in the
1463 dynamic object changes the real symbol, we will not see that
1464 change in the corresponding weak symbol. This is the way other
1465 ELF linkers work as well, and seems to be a result of the shared
1468 I will clarify this issue. Most SVR4 shared libraries define the
1469 variable _timezone and define timezone as a weak synonym. The
1470 tzset call changes _timezone. If you write
1471 extern int timezone;
1473 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1474 you might expect that, since timezone is a synonym for _timezone,
1475 the same number will print both times. However, if the processor
1476 backend uses a COPY reloc, then actually timezone will be copied
1477 into your process image, and, since you define _timezone
1478 yourself, _timezone will not. Thus timezone and _timezone will
1479 wind up at different memory locations. The tzset call will set
1480 _timezone, leaving timezone unchanged. */
1482 if (h
->weakdef
!= NULL
)
1484 struct elf_link_hash_entry
*weakdef
;
1486 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1487 || h
->root
.type
== bfd_link_hash_defweak
);
1488 weakdef
= h
->weakdef
;
1489 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1490 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1491 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1492 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1494 /* This symbol is defined by a regular object file, so we
1495 will not do anything special. Clear weakdef for the
1496 convenience of the processor backend. */
1501 /* There is an implicit reference by a regular object file
1502 via the weak symbol. */
1503 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1504 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1509 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1510 bed
= get_elf_backend_data (dynobj
);
1511 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1520 /* Final phase of ELF linker. */
1522 /* A structure we use to avoid passing large numbers of arguments. */
1524 struct elf_final_link_info
1526 /* General link information. */
1527 struct bfd_link_info
*info
;
1530 /* Symbol string table. */
1531 struct bfd_strtab_hash
*symstrtab
;
1532 /* .dynsym section. */
1533 asection
*dynsym_sec
;
1534 /* .hash section. */
1536 /* Buffer large enough to hold contents of any section. */
1538 /* Buffer large enough to hold external relocs of any section. */
1539 PTR external_relocs
;
1540 /* Buffer large enough to hold internal relocs of any section. */
1541 Elf_Internal_Rela
*internal_relocs
;
1542 /* Buffer large enough to hold external local symbols of any input
1544 Elf_External_Sym
*external_syms
;
1545 /* Buffer large enough to hold internal local symbols of any input
1547 Elf_Internal_Sym
*internal_syms
;
1548 /* Array large enough to hold a symbol index for each local symbol
1549 of any input BFD. */
1551 /* Array large enough to hold a section pointer for each local
1552 symbol of any input BFD. */
1553 asection
**sections
;
1554 /* Buffer to hold swapped out symbols. */
1555 Elf_External_Sym
*symbuf
;
1556 /* Number of swapped out symbols in buffer. */
1557 size_t symbuf_count
;
1558 /* Number of symbols which fit in symbuf. */
1562 static boolean elf_link_output_sym
1563 PARAMS ((struct elf_final_link_info
*, const char *,
1564 Elf_Internal_Sym
*, asection
*));
1565 static boolean elf_link_flush_output_syms
1566 PARAMS ((struct elf_final_link_info
*));
1567 static boolean elf_link_output_extsym
1568 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1569 static boolean elf_link_input_bfd
1570 PARAMS ((struct elf_final_link_info
*, bfd
*));
1571 static boolean elf_reloc_link_order
1572 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1573 struct bfd_link_order
*));
1575 /* This struct is used to pass information to routines called via
1576 elf_link_hash_traverse which must return failure. */
1578 struct elf_finfo_failed
1581 struct elf_final_link_info
*finfo
;
1584 /* Do the final step of an ELF link. */
1587 elf_bfd_final_link (abfd
, info
)
1589 struct bfd_link_info
*info
;
1593 struct elf_final_link_info finfo
;
1594 register asection
*o
;
1595 register struct bfd_link_order
*p
;
1597 size_t max_contents_size
;
1598 size_t max_external_reloc_size
;
1599 size_t max_internal_reloc_count
;
1600 size_t max_sym_count
;
1602 Elf_Internal_Sym elfsym
;
1604 Elf_Internal_Shdr
*symtab_hdr
;
1605 Elf_Internal_Shdr
*symstrtab_hdr
;
1606 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1607 struct elf_finfo_failed eif
;
1610 abfd
->flags
|= DYNAMIC
;
1612 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1613 dynobj
= elf_hash_table (info
)->dynobj
;
1616 finfo
.output_bfd
= abfd
;
1617 finfo
.symstrtab
= elf_stringtab_init ();
1618 if (finfo
.symstrtab
== NULL
)
1622 finfo
.dynsym_sec
= NULL
;
1623 finfo
.hash_sec
= NULL
;
1627 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1628 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1629 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1631 finfo
.contents
= NULL
;
1632 finfo
.external_relocs
= NULL
;
1633 finfo
.internal_relocs
= NULL
;
1634 finfo
.external_syms
= NULL
;
1635 finfo
.internal_syms
= NULL
;
1636 finfo
.indices
= NULL
;
1637 finfo
.sections
= NULL
;
1638 finfo
.symbuf
= NULL
;
1639 finfo
.symbuf_count
= 0;
1641 /* Count up the number of relocations we will output for each output
1642 section, so that we know the sizes of the reloc sections. We
1643 also figure out some maximum sizes. */
1644 max_contents_size
= 0;
1645 max_external_reloc_size
= 0;
1646 max_internal_reloc_count
= 0;
1648 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1652 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1654 if (p
->type
== bfd_section_reloc_link_order
1655 || p
->type
== bfd_symbol_reloc_link_order
)
1657 else if (p
->type
== bfd_indirect_link_order
)
1661 sec
= p
->u
.indirect
.section
;
1663 if (info
->relocateable
)
1664 o
->reloc_count
+= sec
->reloc_count
;
1666 if (sec
->_raw_size
> max_contents_size
)
1667 max_contents_size
= sec
->_raw_size
;
1668 if (sec
->_cooked_size
> max_contents_size
)
1669 max_contents_size
= sec
->_cooked_size
;
1671 /* We are interested in just local symbols, not all
1673 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1677 if (elf_bad_symtab (sec
->owner
))
1678 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1679 / sizeof (Elf_External_Sym
));
1681 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1683 if (sym_count
> max_sym_count
)
1684 max_sym_count
= sym_count
;
1686 if ((sec
->flags
& SEC_RELOC
) != 0)
1690 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1691 if (ext_size
> max_external_reloc_size
)
1692 max_external_reloc_size
= ext_size
;
1693 if (sec
->reloc_count
> max_internal_reloc_count
)
1694 max_internal_reloc_count
= sec
->reloc_count
;
1700 if (o
->reloc_count
> 0)
1701 o
->flags
|= SEC_RELOC
;
1704 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1705 set it (this is probably a bug) and if it is set
1706 assign_section_numbers will create a reloc section. */
1707 o
->flags
&=~ SEC_RELOC
;
1710 /* If the SEC_ALLOC flag is not set, force the section VMA to
1711 zero. This is done in elf_fake_sections as well, but forcing
1712 the VMA to 0 here will ensure that relocs against these
1713 sections are handled correctly. */
1714 if ((o
->flags
& SEC_ALLOC
) == 0)
1718 /* Figure out the file positions for everything but the symbol table
1719 and the relocs. We set symcount to force assign_section_numbers
1720 to create a symbol table. */
1721 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1722 BFD_ASSERT (! abfd
->output_has_begun
);
1723 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1726 /* That created the reloc sections. Set their sizes, and assign
1727 them file positions, and allocate some buffers. */
1728 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1730 if ((o
->flags
& SEC_RELOC
) != 0)
1732 Elf_Internal_Shdr
*rel_hdr
;
1733 register struct elf_link_hash_entry
**p
, **pend
;
1735 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1737 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1739 /* The contents field must last into write_object_contents,
1740 so we allocate it with bfd_alloc rather than malloc. */
1741 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1742 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1744 bfd_set_error (bfd_error_no_memory
);
1748 p
= ((struct elf_link_hash_entry
**)
1749 malloc (o
->reloc_count
1750 * sizeof (struct elf_link_hash_entry
*)));
1751 if (p
== NULL
&& o
->reloc_count
!= 0)
1753 bfd_set_error (bfd_error_no_memory
);
1756 elf_section_data (o
)->rel_hashes
= p
;
1757 pend
= p
+ o
->reloc_count
;
1758 for (; p
< pend
; p
++)
1761 /* Use the reloc_count field as an index when outputting the
1767 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1769 /* We have now assigned file positions for all the sections except
1770 .symtab and .strtab. We start the .symtab section at the current
1771 file position, and write directly to it. We build the .strtab
1772 section in memory. When we add .dynsym support, we will build
1773 that in memory as well (.dynsym is smaller than .symtab). */
1775 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1776 /* sh_name is set in prep_headers. */
1777 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1778 symtab_hdr
->sh_flags
= 0;
1779 symtab_hdr
->sh_addr
= 0;
1780 symtab_hdr
->sh_size
= 0;
1781 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1782 /* sh_link is set in assign_section_numbers. */
1783 /* sh_info is set below. */
1784 /* sh_offset is set just below. */
1785 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1787 off
= elf_tdata (abfd
)->next_file_pos
;
1788 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1790 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1791 incorrect. We do not yet know the size of the .symtab section.
1792 We correct next_file_pos below, after we do know the size. */
1794 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1795 continuously seeking to the right position in the file. */
1796 if (! info
->keep_memory
|| max_sym_count
< 20)
1797 finfo
.symbuf_size
= 20;
1799 finfo
.symbuf_size
= max_sym_count
;
1800 finfo
.symbuf
= ((Elf_External_Sym
*)
1801 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1802 if (finfo
.symbuf
== NULL
)
1804 bfd_set_error (bfd_error_no_memory
);
1808 /* Start writing out the symbol table. The first symbol is always a
1810 elfsym
.st_value
= 0;
1813 elfsym
.st_other
= 0;
1814 elfsym
.st_shndx
= SHN_UNDEF
;
1815 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1816 &elfsym
, bfd_und_section_ptr
))
1820 /* Some standard ELF linkers do this, but we don't because it causes
1821 bootstrap comparison failures. */
1822 /* Output a file symbol for the output file as the second symbol.
1823 We output this even if we are discarding local symbols, although
1824 I'm not sure if this is correct. */
1825 elfsym
.st_value
= 0;
1827 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1828 elfsym
.st_other
= 0;
1829 elfsym
.st_shndx
= SHN_ABS
;
1830 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1831 &elfsym
, bfd_abs_section_ptr
))
1835 /* Output a symbol for each section. We output these even if we are
1836 discarding local symbols, since they are used for relocs. These
1837 symbols have no names. We store the index of each one in the
1838 index field of the section, so that we can find it again when
1839 outputting relocs. */
1840 elfsym
.st_value
= 0;
1842 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1843 elfsym
.st_other
= 0;
1844 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1846 o
= section_from_elf_index (abfd
, i
);
1848 o
->target_index
= abfd
->symcount
;
1849 elfsym
.st_shndx
= i
;
1850 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1855 /* Allocate some memory to hold information read in from the input
1857 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
1858 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
1859 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1860 malloc (max_internal_reloc_count
1861 * sizeof (Elf_Internal_Rela
)));
1862 finfo
.external_syms
= ((Elf_External_Sym
*)
1863 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
1864 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1865 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
1866 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
1867 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
1868 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
1869 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
1870 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
1871 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
1872 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
1873 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
1874 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
1876 bfd_set_error (bfd_error_no_memory
);
1880 /* Since ELF permits relocations to be against local symbols, we
1881 must have the local symbols available when we do the relocations.
1882 Since we would rather only read the local symbols once, and we
1883 would rather not keep them in memory, we handle all the
1884 relocations for a single input file at the same time.
1886 Unfortunately, there is no way to know the total number of local
1887 symbols until we have seen all of them, and the local symbol
1888 indices precede the global symbol indices. This means that when
1889 we are generating relocateable output, and we see a reloc against
1890 a global symbol, we can not know the symbol index until we have
1891 finished examining all the local symbols to see which ones we are
1892 going to output. To deal with this, we keep the relocations in
1893 memory, and don't output them until the end of the link. This is
1894 an unfortunate waste of memory, but I don't see a good way around
1895 it. Fortunately, it only happens when performing a relocateable
1896 link, which is not the common case. FIXME: If keep_memory is set
1897 we could write the relocs out and then read them again; I don't
1898 know how bad the memory loss will be. */
1900 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
1901 sub
->output_has_begun
= false;
1902 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1904 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1906 if (p
->type
== bfd_indirect_link_order
1907 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
1908 == bfd_target_elf_flavour
))
1910 sub
= p
->u
.indirect
.section
->owner
;
1911 if (! sub
->output_has_begun
)
1913 if (! elf_link_input_bfd (&finfo
, sub
))
1915 sub
->output_has_begun
= true;
1918 else if (p
->type
== bfd_section_reloc_link_order
1919 || p
->type
== bfd_symbol_reloc_link_order
)
1921 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
1926 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
1932 /* That wrote out all the local symbols. Finish up the symbol table
1933 with the global symbols. */
1935 /* The sh_info field records the index of the first non local
1937 symtab_hdr
->sh_info
= abfd
->symcount
;
1939 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
1941 /* We get the global symbols from the hash table. */
1944 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
1949 /* Flush all symbols to the file. */
1950 if (! elf_link_flush_output_syms (&finfo
))
1953 /* Now we know the size of the symtab section. */
1954 off
+= symtab_hdr
->sh_size
;
1956 /* Finish up and write out the symbol string table (.strtab)
1958 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1959 /* sh_name was set in prep_headers. */
1960 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
1961 symstrtab_hdr
->sh_flags
= 0;
1962 symstrtab_hdr
->sh_addr
= 0;
1963 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
1964 symstrtab_hdr
->sh_entsize
= 0;
1965 symstrtab_hdr
->sh_link
= 0;
1966 symstrtab_hdr
->sh_info
= 0;
1967 /* sh_offset is set just below. */
1968 symstrtab_hdr
->sh_addralign
= 1;
1970 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
1971 elf_tdata (abfd
)->next_file_pos
= off
;
1973 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
1974 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
1977 /* Adjust the relocs to have the correct symbol indices. */
1978 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1980 struct elf_link_hash_entry
**rel_hash
;
1981 Elf_Internal_Shdr
*rel_hdr
;
1983 if ((o
->flags
& SEC_RELOC
) == 0)
1986 rel_hash
= elf_section_data (o
)->rel_hashes
;
1987 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1988 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
1990 if (*rel_hash
== NULL
)
1993 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
1995 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1997 Elf_External_Rel
*erel
;
1998 Elf_Internal_Rel irel
;
2000 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2001 elf_swap_reloc_in (abfd
, erel
, &irel
);
2002 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2003 ELF_R_TYPE (irel
.r_info
));
2004 elf_swap_reloc_out (abfd
, &irel
, erel
);
2008 Elf_External_Rela
*erela
;
2009 Elf_Internal_Rela irela
;
2011 BFD_ASSERT (rel_hdr
->sh_entsize
2012 == sizeof (Elf_External_Rela
));
2014 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2015 elf_swap_reloca_in (abfd
, erela
, &irela
);
2016 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2017 ELF_R_TYPE (irela
.r_info
));
2018 elf_swap_reloca_out (abfd
, &irela
, erela
);
2022 /* Set the reloc_count field to 0 to prevent write_relocs from
2023 trying to swap the relocs out itself. */
2027 /* If we are linking against a dynamic object, or generating a
2028 shared library, finish up the dynamic linking information. */
2031 Elf_External_Dyn
*dyncon
, *dynconend
;
2033 /* Fix up .dynamic entries. */
2034 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2035 BFD_ASSERT (o
!= NULL
);
2037 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2038 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2039 for (; dyncon
< dynconend
; dyncon
++)
2041 Elf_Internal_Dyn dyn
;
2045 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2052 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2053 magic _init and _fini symbols. This is pretty ugly,
2054 but we are compatible. */
2062 struct elf_link_hash_entry
*h
;
2064 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2065 false, false, true);
2066 BFD_ASSERT (h
!= NULL
);
2067 if (h
->root
.type
== bfd_link_hash_defined
2068 || h
->root
.type
== bfd_link_hash_defweak
)
2070 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2071 o
= h
->root
.u
.def
.section
;
2072 if (o
->output_section
!= NULL
)
2073 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2074 + o
->output_offset
);
2076 /* The symbol is imported from another shared
2077 library and does not apply to this one. */
2080 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2093 o
= bfd_get_section_by_name (abfd
, name
);
2094 BFD_ASSERT (o
!= NULL
);
2095 dyn
.d_un
.d_ptr
= o
->vma
;
2096 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2103 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2108 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2110 Elf_Internal_Shdr
*hdr
;
2112 hdr
= elf_elfsections (abfd
)[i
];
2113 if (hdr
->sh_type
== type
2114 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2116 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2117 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2120 if (dyn
.d_un
.d_val
== 0
2121 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2122 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2126 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2132 /* If we have created any dynamic sections, then output them. */
2135 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2138 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2140 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2141 || o
->_raw_size
== 0)
2143 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2145 /* At this point, we are only interested in sections
2146 created by elf_link_create_dynamic_sections. FIXME:
2147 This test is fragile. */
2150 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2152 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2154 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2155 o
->contents
, o
->output_offset
,
2163 /* The contents of the .dynstr section are actually in a
2165 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2166 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2167 || ! _bfd_stringtab_emit (abfd
,
2168 elf_hash_table (info
)->dynstr
))
2174 if (finfo
.symstrtab
!= NULL
)
2175 _bfd_stringtab_free (finfo
.symstrtab
);
2176 if (finfo
.contents
!= NULL
)
2177 free (finfo
.contents
);
2178 if (finfo
.external_relocs
!= NULL
)
2179 free (finfo
.external_relocs
);
2180 if (finfo
.internal_relocs
!= NULL
)
2181 free (finfo
.internal_relocs
);
2182 if (finfo
.external_syms
!= NULL
)
2183 free (finfo
.external_syms
);
2184 if (finfo
.internal_syms
!= NULL
)
2185 free (finfo
.internal_syms
);
2186 if (finfo
.indices
!= NULL
)
2187 free (finfo
.indices
);
2188 if (finfo
.sections
!= NULL
)
2189 free (finfo
.sections
);
2190 if (finfo
.symbuf
!= NULL
)
2191 free (finfo
.symbuf
);
2192 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2194 if ((o
->flags
& SEC_RELOC
) != 0
2195 && elf_section_data (o
)->rel_hashes
!= NULL
)
2196 free (elf_section_data (o
)->rel_hashes
);
2199 elf_tdata (abfd
)->linker
= true;
2204 if (finfo
.symstrtab
!= NULL
)
2205 _bfd_stringtab_free (finfo
.symstrtab
);
2206 if (finfo
.contents
!= NULL
)
2207 free (finfo
.contents
);
2208 if (finfo
.external_relocs
!= NULL
)
2209 free (finfo
.external_relocs
);
2210 if (finfo
.internal_relocs
!= NULL
)
2211 free (finfo
.internal_relocs
);
2212 if (finfo
.external_syms
!= NULL
)
2213 free (finfo
.external_syms
);
2214 if (finfo
.internal_syms
!= NULL
)
2215 free (finfo
.internal_syms
);
2216 if (finfo
.indices
!= NULL
)
2217 free (finfo
.indices
);
2218 if (finfo
.sections
!= NULL
)
2219 free (finfo
.sections
);
2220 if (finfo
.symbuf
!= NULL
)
2221 free (finfo
.symbuf
);
2222 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2224 if ((o
->flags
& SEC_RELOC
) != 0
2225 && elf_section_data (o
)->rel_hashes
!= NULL
)
2226 free (elf_section_data (o
)->rel_hashes
);
2232 /* Add a symbol to the output symbol table. */
2235 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2236 struct elf_final_link_info
*finfo
;
2238 Elf_Internal_Sym
*elfsym
;
2239 asection
*input_sec
;
2241 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2242 struct bfd_link_info
*info
,
2247 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2248 elf_backend_link_output_symbol_hook
;
2249 if (output_symbol_hook
!= NULL
)
2251 if (! ((*output_symbol_hook
)
2252 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2256 if (name
== (const char *) NULL
|| *name
== '\0')
2257 elfsym
->st_name
= 0;
2260 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2263 if (elfsym
->st_name
== (unsigned long) -1)
2267 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2269 if (! elf_link_flush_output_syms (finfo
))
2273 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2274 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2275 ++finfo
->symbuf_count
;
2277 ++finfo
->output_bfd
->symcount
;
2282 /* Flush the output symbols to the file. */
2285 elf_link_flush_output_syms (finfo
)
2286 struct elf_final_link_info
*finfo
;
2288 Elf_Internal_Shdr
*symtab
;
2290 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2292 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2294 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2295 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2296 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2299 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2301 finfo
->symbuf_count
= 0;
2306 /* Add an external symbol to the symbol table. This is called from
2307 the hash table traversal routine. */
2310 elf_link_output_extsym (h
, data
)
2311 struct elf_link_hash_entry
*h
;
2314 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2315 struct elf_final_link_info
*finfo
= eif
->finfo
;
2317 Elf_Internal_Sym sym
;
2318 asection
*input_sec
;
2320 /* If we are not creating a shared library, and this symbol is
2321 referenced by a shared library but is not defined anywhere, then
2322 warn that it is undefined. If we do not do this, the runtime
2323 linker will complain that the symbol is undefined when the
2324 program is run. We don't have to worry about symbols that are
2325 referenced by regular files, because we will already have issued
2326 warnings for them. */
2327 if (! finfo
->info
->relocateable
2328 && ! finfo
->info
->shared
2329 && h
->root
.type
== bfd_link_hash_undefined
2330 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2331 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2333 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2334 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2335 (asection
*) NULL
, 0)))
2342 /* We don't want to output symbols that have never been mentioned by
2343 a regular file, or that we have been told to strip. However, if
2344 h->indx is set to -2, the symbol is used by a reloc and we must
2348 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2349 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2350 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2351 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2353 else if (finfo
->info
->strip
== strip_all
2354 || (finfo
->info
->strip
== strip_some
2355 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2356 h
->root
.root
.string
,
2357 false, false) == NULL
))
2362 /* If we're stripping it, and it's not a dynamic symbol, there's
2363 nothing else to do. */
2364 if (strip
&& h
->dynindx
== -1)
2368 sym
.st_size
= h
->size
;
2370 if (h
->root
.type
== bfd_link_hash_undefweak
2371 || h
->root
.type
== bfd_link_hash_defweak
)
2372 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2374 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2376 switch (h
->root
.type
)
2379 case bfd_link_hash_new
:
2383 case bfd_link_hash_undefined
:
2384 input_sec
= bfd_und_section_ptr
;
2385 sym
.st_shndx
= SHN_UNDEF
;
2388 case bfd_link_hash_undefweak
:
2389 input_sec
= bfd_und_section_ptr
;
2390 sym
.st_shndx
= SHN_UNDEF
;
2393 case bfd_link_hash_defined
:
2394 case bfd_link_hash_defweak
:
2396 input_sec
= h
->root
.u
.def
.section
;
2397 if (input_sec
->output_section
!= NULL
)
2400 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2401 input_sec
->output_section
);
2402 if (sym
.st_shndx
== (unsigned short) -1)
2408 /* ELF symbols in relocateable files are section relative,
2409 but in nonrelocateable files they are virtual
2411 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2412 if (! finfo
->info
->relocateable
)
2413 sym
.st_value
+= input_sec
->output_section
->vma
;
2417 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2418 == bfd_target_elf_flavour
)
2419 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2420 sym
.st_shndx
= SHN_UNDEF
;
2421 input_sec
= bfd_und_section_ptr
;
2426 case bfd_link_hash_common
:
2427 input_sec
= bfd_com_section_ptr
;
2428 sym
.st_shndx
= SHN_COMMON
;
2429 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2432 case bfd_link_hash_indirect
:
2433 case bfd_link_hash_warning
:
2434 /* I have no idea how these should be handled. */
2438 /* If this symbol should be put in the .dynsym section, then put it
2439 there now. We have already know the symbol index. We also fill
2440 in the entry in the .hash section. */
2441 if (h
->dynindx
!= -1
2442 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2444 struct elf_backend_data
*bed
;
2447 bfd_byte
*bucketpos
;
2450 sym
.st_name
= h
->dynstr_index
;
2452 /* Give the processor backend a chance to tweak the symbol
2453 value, and also to finish up anything that needs to be done
2455 bed
= get_elf_backend_data (finfo
->output_bfd
);
2456 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2457 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2463 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2464 (PTR
) (((Elf_External_Sym
*)
2465 finfo
->dynsym_sec
->contents
)
2468 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2469 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2471 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2472 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2473 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2474 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2475 put_word (finfo
->output_bfd
, chain
,
2476 ((bfd_byte
*) finfo
->hash_sec
->contents
2477 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2480 /* If we're stripping it, then it was just a dynamic symbol, and
2481 there's nothing else to do. */
2485 h
->indx
= finfo
->output_bfd
->symcount
;
2487 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2496 /* Link an input file into the linker output file. This function
2497 handles all the sections and relocations of the input file at once.
2498 This is so that we only have to read the local symbols once, and
2499 don't have to keep them in memory. */
2502 elf_link_input_bfd (finfo
, input_bfd
)
2503 struct elf_final_link_info
*finfo
;
2506 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2507 bfd
*, asection
*, bfd_byte
*,
2508 Elf_Internal_Rela
*,
2509 Elf_Internal_Sym
*, asection
**));
2511 Elf_Internal_Shdr
*symtab_hdr
;
2514 Elf_External_Sym
*esym
;
2515 Elf_External_Sym
*esymend
;
2516 Elf_Internal_Sym
*isym
;
2518 asection
**ppsection
;
2521 output_bfd
= finfo
->output_bfd
;
2523 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2525 /* If this is a dynamic object, we don't want to do anything here:
2526 we don't want the local symbols, and we don't want the section
2528 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2531 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2532 if (elf_bad_symtab (input_bfd
))
2534 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2539 locsymcount
= symtab_hdr
->sh_info
;
2540 extsymoff
= symtab_hdr
->sh_info
;
2543 /* Read the local symbols. */
2545 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2546 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2547 locsymcount
, input_bfd
)
2548 != locsymcount
* sizeof (Elf_External_Sym
))))
2551 /* Swap in the local symbols and write out the ones which we know
2552 are going into the output file. */
2553 esym
= finfo
->external_syms
;
2554 esymend
= esym
+ locsymcount
;
2555 isym
= finfo
->internal_syms
;
2556 pindex
= finfo
->indices
;
2557 ppsection
= finfo
->sections
;
2558 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2562 Elf_Internal_Sym osym
;
2564 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2567 if (elf_bad_symtab (input_bfd
))
2569 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2576 if (isym
->st_shndx
== SHN_UNDEF
)
2577 isec
= bfd_und_section_ptr
;
2578 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2579 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2580 else if (isym
->st_shndx
== SHN_ABS
)
2581 isec
= bfd_abs_section_ptr
;
2582 else if (isym
->st_shndx
== SHN_COMMON
)
2583 isec
= bfd_com_section_ptr
;
2592 /* Don't output the first, undefined, symbol. */
2593 if (esym
== finfo
->external_syms
)
2596 /* If we are stripping all symbols, we don't want to output this
2598 if (finfo
->info
->strip
== strip_all
)
2601 /* We never output section symbols. Instead, we use the section
2602 symbol of the corresponding section in the output file. */
2603 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2606 /* If we are discarding all local symbols, we don't want to
2607 output this one. If we are generating a relocateable output
2608 file, then some of the local symbols may be required by
2609 relocs; we output them below as we discover that they are
2611 if (finfo
->info
->discard
== discard_all
)
2614 /* Get the name of the symbol. */
2615 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2620 /* See if we are discarding symbols with this name. */
2621 if ((finfo
->info
->strip
== strip_some
2622 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2624 || (finfo
->info
->discard
== discard_l
2625 && strncmp (name
, finfo
->info
->lprefix
,
2626 finfo
->info
->lprefix_len
) == 0))
2629 /* If we get here, we are going to output this symbol. */
2633 /* Adjust the section index for the output file. */
2634 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2635 isec
->output_section
);
2636 if (osym
.st_shndx
== (unsigned short) -1)
2639 *pindex
= output_bfd
->symcount
;
2641 /* ELF symbols in relocateable files are section relative, but
2642 in executable files they are virtual addresses. Note that
2643 this code assumes that all ELF sections have an associated
2644 BFD section with a reasonable value for output_offset; below
2645 we assume that they also have a reasonable value for
2646 output_section. Any special sections must be set up to meet
2647 these requirements. */
2648 osym
.st_value
+= isec
->output_offset
;
2649 if (! finfo
->info
->relocateable
)
2650 osym
.st_value
+= isec
->output_section
->vma
;
2652 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2656 /* Relocate the contents of each section. */
2657 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2659 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2662 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2663 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2665 /* Section was created by elf_link_create_dynamic_sections.
2666 FIXME: This test is fragile. */
2670 /* Read the contents of the section. */
2671 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2672 (file_ptr
) 0, o
->_raw_size
))
2675 if ((o
->flags
& SEC_RELOC
) != 0)
2677 Elf_Internal_Rela
*internal_relocs
;
2679 /* Get the swapped relocs. */
2680 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2681 finfo
->external_relocs
,
2682 finfo
->internal_relocs
,
2684 if (internal_relocs
== NULL
2685 && o
->reloc_count
> 0)
2688 /* Relocate the section by invoking a back end routine.
2690 The back end routine is responsible for adjusting the
2691 section contents as necessary, and (if using Rela relocs
2692 and generating a relocateable output file) adjusting the
2693 reloc addend as necessary.
2695 The back end routine does not have to worry about setting
2696 the reloc address or the reloc symbol index.
2698 The back end routine is given a pointer to the swapped in
2699 internal symbols, and can access the hash table entries
2700 for the external symbols via elf_sym_hashes (input_bfd).
2702 When generating relocateable output, the back end routine
2703 must handle STB_LOCAL/STT_SECTION symbols specially. The
2704 output symbol is going to be a section symbol
2705 corresponding to the output section, which will require
2706 the addend to be adjusted. */
2708 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2712 finfo
->internal_syms
,
2716 if (finfo
->info
->relocateable
)
2718 Elf_Internal_Rela
*irela
;
2719 Elf_Internal_Rela
*irelaend
;
2720 struct elf_link_hash_entry
**rel_hash
;
2721 Elf_Internal_Shdr
*input_rel_hdr
;
2722 Elf_Internal_Shdr
*output_rel_hdr
;
2724 /* Adjust the reloc addresses and symbol indices. */
2726 irela
= internal_relocs
;
2727 irelaend
= irela
+ o
->reloc_count
;
2728 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2729 + o
->output_section
->reloc_count
);
2730 for (; irela
< irelaend
; irela
++, rel_hash
++)
2733 Elf_Internal_Sym
*isym
;
2736 irela
->r_offset
+= o
->output_offset
;
2738 r_symndx
= ELF_R_SYM (irela
->r_info
);
2743 if (r_symndx
>= locsymcount
2744 || (elf_bad_symtab (input_bfd
)
2745 && finfo
->sections
[r_symndx
] == NULL
))
2749 /* This is a reloc against a global symbol. We
2750 have not yet output all the local symbols, so
2751 we do not know the symbol index of any global
2752 symbol. We set the rel_hash entry for this
2753 reloc to point to the global hash table entry
2754 for this symbol. The symbol index is then
2755 set at the end of elf_bfd_final_link. */
2756 indx
= r_symndx
- extsymoff
;
2757 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2759 /* Setting the index to -2 tells
2760 elf_link_output_extsym that this symbol is
2762 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2763 (*rel_hash
)->indx
= -2;
2768 /* This is a reloc against a local symbol. */
2771 isym
= finfo
->internal_syms
+ r_symndx
;
2772 sec
= finfo
->sections
[r_symndx
];
2773 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2775 /* I suppose the backend ought to fill in the
2776 section of any STT_SECTION symbol against a
2777 processor specific section. */
2778 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2780 else if (sec
== NULL
|| sec
->owner
== NULL
)
2782 bfd_set_error (bfd_error_bad_value
);
2787 r_symndx
= sec
->output_section
->target_index
;
2788 BFD_ASSERT (r_symndx
!= 0);
2793 if (finfo
->indices
[r_symndx
] == -1)
2799 if (finfo
->info
->strip
== strip_all
)
2801 /* You can't do ld -r -s. */
2802 bfd_set_error (bfd_error_invalid_operation
);
2806 /* This symbol was skipped earlier, but
2807 since it is needed by a reloc, we
2808 must output it now. */
2809 link
= symtab_hdr
->sh_link
;
2810 name
= bfd_elf_string_from_elf_section (input_bfd
,
2816 osec
= sec
->output_section
;
2818 _bfd_elf_section_from_bfd_section (output_bfd
,
2820 if (isym
->st_shndx
== (unsigned short) -1)
2823 isym
->st_value
+= sec
->output_offset
;
2824 if (! finfo
->info
->relocateable
)
2825 isym
->st_value
+= osec
->vma
;
2827 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2829 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2833 r_symndx
= finfo
->indices
[r_symndx
];
2836 irela
->r_info
= ELF_R_INFO (r_symndx
,
2837 ELF_R_TYPE (irela
->r_info
));
2840 /* Swap out the relocs. */
2841 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2842 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2843 BFD_ASSERT (output_rel_hdr
->sh_entsize
2844 == input_rel_hdr
->sh_entsize
);
2845 irela
= internal_relocs
;
2846 irelaend
= irela
+ o
->reloc_count
;
2847 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2849 Elf_External_Rel
*erel
;
2851 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2852 + o
->output_section
->reloc_count
);
2853 for (; irela
< irelaend
; irela
++, erel
++)
2855 Elf_Internal_Rel irel
;
2857 irel
.r_offset
= irela
->r_offset
;
2858 irel
.r_info
= irela
->r_info
;
2859 BFD_ASSERT (irela
->r_addend
== 0);
2860 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
2865 Elf_External_Rela
*erela
;
2867 BFD_ASSERT (input_rel_hdr
->sh_entsize
2868 == sizeof (Elf_External_Rela
));
2869 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
2870 + o
->output_section
->reloc_count
);
2871 for (; irela
< irelaend
; irela
++, erela
++)
2872 elf_swap_reloca_out (output_bfd
, irela
, erela
);
2875 o
->output_section
->reloc_count
+= o
->reloc_count
;
2879 /* Write out the modified section contents. */
2880 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2881 finfo
->contents
, o
->output_offset
,
2882 (o
->_cooked_size
!= 0
2891 /* Generate a reloc when linking an ELF file. This is a reloc
2892 requested by the linker, and does come from any input file. This
2893 is used to build constructor and destructor tables when linking
2897 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
2899 struct bfd_link_info
*info
;
2900 asection
*output_section
;
2901 struct bfd_link_order
*link_order
;
2903 reloc_howto_type
*howto
;
2906 struct elf_link_hash_entry
**rel_hash_ptr
;
2907 Elf_Internal_Shdr
*rel_hdr
;
2909 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2912 bfd_set_error (bfd_error_bad_value
);
2916 /* If this is an inplace reloc, we must write the addend into the
2918 if (howto
->partial_inplace
2919 && link_order
->u
.reloc
.p
->addend
!= 0)
2922 bfd_reloc_status_type rstat
;
2926 size
= bfd_get_reloc_size (howto
);
2927 buf
= (bfd_byte
*) bfd_zmalloc (size
);
2928 if (buf
== (bfd_byte
*) NULL
)
2930 bfd_set_error (bfd_error_no_memory
);
2933 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
2934 link_order
->u
.reloc
.p
->addend
, buf
);
2940 case bfd_reloc_outofrange
:
2942 case bfd_reloc_overflow
:
2943 if (! ((*info
->callbacks
->reloc_overflow
)
2945 (link_order
->type
== bfd_section_reloc_link_order
2946 ? bfd_section_name (output_bfd
,
2947 link_order
->u
.reloc
.p
->u
.section
)
2948 : link_order
->u
.reloc
.p
->u
.name
),
2949 howto
->name
, link_order
->u
.reloc
.p
->addend
,
2950 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
2957 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
2958 (file_ptr
) link_order
->offset
, size
);
2964 /* Figure out the symbol index. */
2965 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
2966 + output_section
->reloc_count
);
2967 if (link_order
->type
== bfd_section_reloc_link_order
)
2969 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
2970 BFD_ASSERT (indx
!= 0);
2971 *rel_hash_ptr
= NULL
;
2975 struct elf_link_hash_entry
*h
;
2977 h
= elf_link_hash_lookup (elf_hash_table (info
),
2978 link_order
->u
.reloc
.p
->u
.name
,
2979 false, false, true);
2982 /* Setting the index to -2 tells elf_link_output_extsym that
2983 this symbol is used by a reloc. */
2990 if (! ((*info
->callbacks
->unattached_reloc
)
2991 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
2992 (asection
*) NULL
, (bfd_vma
) 0)))
2998 /* The address of a reloc is relative to the section in a
2999 relocateable file, and is a virtual address in an executable
3001 offset
= link_order
->offset
;
3002 if (! info
->relocateable
)
3003 offset
+= output_section
->vma
;
3005 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3007 if (rel_hdr
->sh_type
== SHT_REL
)
3009 Elf_Internal_Rel irel
;
3010 Elf_External_Rel
*erel
;
3012 irel
.r_offset
= offset
;
3013 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3014 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3015 + output_section
->reloc_count
);
3016 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3020 Elf_Internal_Rela irela
;
3021 Elf_External_Rela
*erela
;
3023 irela
.r_offset
= offset
;
3024 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3025 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
3026 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3027 + output_section
->reloc_count
);
3028 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3031 ++output_section
->reloc_count
;