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
;
51 switch (bfd_get_format (abfd
))
54 return elf_link_add_object_symbols (abfd
, info
);
56 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
59 /* It's OK to have an empty archive. */
62 if (! bfd_check_format (first
, bfd_object
))
64 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
66 /* On Linux, we may have an a.out archive which got
67 recognized as an ELF archive. Therefore, we treat all
68 archives as though they were actually of the flavour of
69 their first element. */
70 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
72 return elf_link_add_archive_symbols (abfd
, info
);
74 bfd_set_error (bfd_error_wrong_format
);
79 /* Add symbols from an ELF archive file to the linker hash table. We
80 don't use _bfd_generic_link_add_archive_symbols because of a
81 problem which arises on UnixWare. The UnixWare libc.so is an
82 archive which includes an entry libc.so.1 which defines a bunch of
83 symbols. The libc.so archive also includes a number of other
84 object files, which also define symbols, some of which are the same
85 as those defined in libc.so.1. Correct linking requires that we
86 consider each object file in turn, and include it if it defines any
87 symbols we need. _bfd_generic_link_add_archive_symbols does not do
88 this; it looks through the list of undefined symbols, and includes
89 any object file which defines them. When this algorithm is used on
90 UnixWare, it winds up pulling in libc.so.1 early and defining a
91 bunch of symbols. This means that some of the other objects in the
92 archive are not included in the link, which is incorrect since they
93 precede libc.so.1 in the archive.
95 Fortunately, ELF archive handling is simpler than that done by
96 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
97 oddities. In ELF, if we find a symbol in the archive map, and the
98 symbol is currently undefined, we know that we must pull in that
101 Unfortunately, we do have to make multiple passes over the symbol
102 table until nothing further is resolved. */
105 elf_link_add_archive_symbols (abfd
, info
)
107 struct bfd_link_info
*info
;
110 boolean
*defined
= NULL
;
111 boolean
*included
= NULL
;
115 if (! bfd_has_map (abfd
))
117 /* An empty archive is a special case. */
118 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
120 bfd_set_error (bfd_error_no_armap
);
124 /* Keep track of all symbols we know to be already defined, and all
125 files we know to be already included. This is to speed up the
126 second and subsequent passes. */
127 c
= bfd_ardata (abfd
)->symdef_count
;
130 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
131 included
= (boolean
*) malloc (c
* sizeof (boolean
));
132 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
134 bfd_set_error (bfd_error_no_memory
);
137 memset (defined
, 0, c
* sizeof (boolean
));
138 memset (included
, 0, c
* sizeof (boolean
));
140 symdefs
= bfd_ardata (abfd
)->symdefs
;
153 symdefend
= symdef
+ c
;
154 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
156 struct elf_link_hash_entry
*h
;
158 struct bfd_link_hash_entry
*undefs_tail
;
161 if (defined
[i
] || included
[i
])
163 if (symdef
->file_offset
== last
)
169 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
170 false, false, false);
171 if (h
== (struct elf_link_hash_entry
*) NULL
)
173 if (h
->root
.type
!= bfd_link_hash_undefined
)
179 /* We need to include this archive member. */
181 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
182 if (element
== (bfd
*) NULL
)
185 if (! bfd_check_format (element
, bfd_object
))
188 /* Doublecheck that we have not included this object
189 already--it should be impossible, but there may be
190 something wrong with the archive. */
191 if (element
->archive_pass
!= 0)
193 bfd_set_error (bfd_error_bad_value
);
196 element
->archive_pass
= 1;
198 undefs_tail
= info
->hash
->undefs_tail
;
200 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
203 if (! elf_link_add_object_symbols (element
, info
))
206 /* If there are any new undefined symbols, we need to make
207 another pass through the archive in order to see whether
208 they can be defined. FIXME: This isn't perfect, because
209 common symbols wind up on undefs_tail and because an
210 undefined symbol which is defined later on in this pass
211 does not require another pass. This isn't a bug, but it
212 does make the code less efficient than it could be. */
213 if (undefs_tail
!= info
->hash
->undefs_tail
)
216 /* Look backward to mark all symbols from this object file
217 which we have already seen in this pass. */
221 included
[mark
] = true;
226 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
228 /* We mark subsequent symbols from this object file as we go
229 on through the loop. */
230 last
= symdef
->file_offset
;
241 if (defined
!= (boolean
*) NULL
)
243 if (included
!= (boolean
*) NULL
)
248 /* Add symbols from an ELF object file to the linker hash table. */
251 elf_link_add_object_symbols (abfd
, info
)
253 struct bfd_link_info
*info
;
255 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
256 const Elf_Internal_Sym
*,
257 const char **, flagword
*,
258 asection
**, bfd_vma
*));
259 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
260 asection
*, const Elf_Internal_Rela
*));
262 Elf_Internal_Shdr
*hdr
;
266 Elf_External_Sym
*buf
= NULL
;
267 struct elf_link_hash_entry
**sym_hash
;
269 Elf_External_Dyn
*dynbuf
= NULL
;
270 struct elf_link_hash_entry
*weaks
;
271 Elf_External_Sym
*esym
;
272 Elf_External_Sym
*esymend
;
274 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
275 collect
= get_elf_backend_data (abfd
)->collect
;
277 /* A stripped shared library might only have a dynamic symbol table,
278 not a regular symbol table. In that case we can still go ahead
279 and link using the dynamic symbol table. */
280 if (elf_onesymtab (abfd
) == 0
281 && elf_dynsymtab (abfd
) != 0)
283 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
284 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
287 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
288 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
290 /* The sh_info field of the symtab header tells us where the
291 external symbols start. We don't care about the local symbols at
293 if (elf_bad_symtab (abfd
))
295 extsymcount
= symcount
;
300 extsymcount
= symcount
- hdr
->sh_info
;
301 extsymoff
= hdr
->sh_info
;
304 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
305 if (buf
== NULL
&& extsymcount
!= 0)
307 bfd_set_error (bfd_error_no_memory
);
311 /* We store a pointer to the hash table entry for each external
313 sym_hash
= ((struct elf_link_hash_entry
**)
315 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
316 if (sym_hash
== NULL
)
318 bfd_set_error (bfd_error_no_memory
);
321 elf_sym_hashes (abfd
) = sym_hash
;
323 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
327 /* If we are creating a shared library, create all the dynamic
328 sections immediately. We need to attach them to something,
329 so we attach them to this BFD, provided it is the right
330 format. FIXME: If there are no input BFD's of the same
331 format as the output, we can't make a shared library. */
333 && ! elf_hash_table (info
)->dynamic_sections_created
334 && abfd
->xvec
== info
->hash
->creator
)
336 if (! elf_link_create_dynamic_sections (abfd
, info
))
345 bfd_size_type oldsize
;
346 bfd_size_type strindex
;
350 /* You can't use -r against a dynamic object. Also, there's no
351 hope of using a dynamic object which does not exactly match
352 the format of the output file. */
353 if (info
->relocateable
354 || info
->hash
->creator
!= abfd
->xvec
)
356 bfd_set_error (bfd_error_invalid_operation
);
360 /* Find the name to use in a DT_NEEDED entry that refers to this
361 object. If the object has a DT_SONAME entry, we use it.
362 Otherwise, if the generic linker stuck something in
363 elf_dt_needed_name, we use that. Otherwise, we just use the
364 file name. If the generic linker put a null string into
365 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
366 even if there is a DT_SONAME entry. */
368 name
= bfd_get_filename (abfd
);
369 if (elf_dt_needed_name (abfd
) != NULL
)
371 name
= elf_dt_needed_name (abfd
);
375 s
= bfd_get_section_by_name (abfd
, ".dynamic");
378 Elf_External_Dyn
*extdyn
;
379 Elf_External_Dyn
*extdynend
;
383 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
386 bfd_set_error (bfd_error_no_memory
);
390 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
391 (file_ptr
) 0, s
->_raw_size
))
394 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
397 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
400 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
401 for (; extdyn
< extdynend
; extdyn
++)
403 Elf_Internal_Dyn dyn
;
405 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
406 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
408 name
= bfd_elf_string_from_elf_section (abfd
, link
,
413 if (dyn
.d_tag
== DT_NEEDED
)
415 struct bfd_elf_link_needed_list
*n
, **pn
;
419 sizeof (struct bfd_elf_link_needed_list
));
420 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
422 if (n
== NULL
|| fnm
== NULL
)
424 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
431 for (pn
= &elf_hash_table (info
)->needed
;
443 /* We do not want to include any of the sections in a dynamic
444 object in the output file. We hack by simply clobbering the
445 list of sections in the BFD. This could be handled more
446 cleanly by, say, a new section flag; the existing
447 SEC_NEVER_LOAD flag is not the one we want, because that one
448 still implies that the section takes up space in the output
450 abfd
->sections
= NULL
;
452 /* If this is the first dynamic object found in the link, create
453 the special sections required for dynamic linking. */
454 if (! elf_hash_table (info
)->dynamic_sections_created
)
456 if (! elf_link_create_dynamic_sections (abfd
, info
))
462 /* Add a DT_NEEDED entry for this dynamic object. */
463 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
464 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
466 if (strindex
== (bfd_size_type
) -1)
469 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
472 Elf_External_Dyn
*dyncon
, *dynconend
;
474 /* The hash table size did not change, which means that
475 the dynamic object name was already entered. If we
476 have already included this dynamic object in the
477 link, just ignore it. There is no reason to include
478 a particular dynamic object more than once. */
479 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
481 BFD_ASSERT (sdyn
!= NULL
);
483 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
484 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
486 for (; dyncon
< dynconend
; dyncon
++)
488 Elf_Internal_Dyn dyn
;
490 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
492 if (dyn
.d_tag
== DT_NEEDED
493 && dyn
.d_un
.d_val
== strindex
)
502 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
508 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
510 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
511 != extsymcount
* sizeof (Elf_External_Sym
)))
516 esymend
= buf
+ extsymcount
;
517 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
519 Elf_Internal_Sym sym
;
525 struct elf_link_hash_entry
*h
= NULL
;
528 elf_swap_symbol_in (abfd
, esym
, &sym
);
530 flags
= BSF_NO_FLAGS
;
532 value
= sym
.st_value
;
535 bind
= ELF_ST_BIND (sym
.st_info
);
536 if (bind
== STB_LOCAL
)
538 /* This should be impossible, since ELF requires that all
539 global symbols follow all local symbols, and that sh_info
540 point to the first global symbol. Unfortunatealy, Irix 5
544 else if (bind
== STB_GLOBAL
)
546 if (sym
.st_shndx
!= SHN_UNDEF
547 && sym
.st_shndx
!= SHN_COMMON
)
552 else if (bind
== STB_WEAK
)
556 /* Leave it up to the processor backend. */
559 if (sym
.st_shndx
== SHN_UNDEF
)
560 sec
= bfd_und_section_ptr
;
561 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
563 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
567 sec
= bfd_abs_section_ptr
;
569 else if (sym
.st_shndx
== SHN_ABS
)
570 sec
= bfd_abs_section_ptr
;
571 else if (sym
.st_shndx
== SHN_COMMON
)
573 sec
= bfd_com_section_ptr
;
574 /* What ELF calls the size we call the value. What ELF
575 calls the value we call the alignment. */
580 /* Leave it up to the processor backend. */
583 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
584 if (name
== (const char *) NULL
)
589 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
593 /* The hook function sets the name to NULL if this symbol
594 should be skipped for some reason. */
595 if (name
== (const char *) NULL
)
599 /* Sanity check that all possibilities were handled. */
600 if (sec
== (asection
*) NULL
)
602 bfd_set_error (bfd_error_bad_value
);
606 if (bfd_is_und_section (sec
)
607 || bfd_is_com_section (sec
))
612 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
614 /* We need to look up the symbol now in order to get some of
615 the dynamic object handling right. We pass the hash
616 table entry in to _bfd_generic_link_add_one_symbol so
617 that it does not have to look it up again. */
618 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
624 /* If we are looking at a dynamic object, and this is a
625 definition, we need to see if it has already been defined
626 by some other object. If it has, we want to use the
627 existing definition, and we do not want to report a
628 multiple symbol definition error; we do this by
629 clobbering sec to be bfd_und_section_ptr. */
630 if (dynamic
&& definition
)
632 if (h
->root
.type
== bfd_link_hash_defined
633 || h
->root
.type
== bfd_link_hash_defweak
)
634 sec
= bfd_und_section_ptr
;
637 /* Similarly, if we are not looking at a dynamic object, and
638 we have a definition, we want to override any definition
639 we may have from a dynamic object. Symbols from regular
640 files always take precedence over symbols from dynamic
641 objects, even if they are defined after the dynamic
642 object in the link. */
645 && (h
->root
.type
== bfd_link_hash_defined
646 || h
->root
.type
== bfd_link_hash_defweak
)
647 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
648 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
649 == bfd_target_elf_flavour
)
650 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
653 /* Change the hash table entry to undefined, and let
654 _bfd_generic_link_add_one_symbol do the right thing
655 with the new definition. */
656 h
->root
.type
= bfd_link_hash_undefined
;
657 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
661 if (! (_bfd_generic_link_add_one_symbol
662 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
663 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
668 && (flags
& BSF_WEAK
) != 0
669 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
670 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
671 && (*sym_hash
)->weakdef
== NULL
)
673 /* Keep a list of all weak defined non function symbols from
674 a dynamic object, using the weakdef field. Later in this
675 function we will set the weakdef field to the correct
676 value. We only put non-function symbols from dynamic
677 objects on this list, because that happens to be the only
678 time we need to know the normal symbol corresponding to a
679 weak symbol, and the information is time consuming to
680 figure out. If the weakdef field is not already NULL,
681 then this symbol was already defined by some previous
682 dynamic object, and we will be using that previous
683 definition anyhow. */
685 (*sym_hash
)->weakdef
= weaks
;
689 /* Get the alignment of a common symbol. */
690 if (sym
.st_shndx
== SHN_COMMON
691 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
692 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
694 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
700 /* Remember the symbol size and type. */
701 if (sym
.st_size
!= 0)
703 /* FIXME: We should probably somehow give a warning if
704 the symbol size changes. */
705 h
->size
= sym
.st_size
;
707 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
709 /* FIXME: We should probably somehow give a warning if
710 the symbol type changes. */
711 h
->type
= ELF_ST_TYPE (sym
.st_info
);
714 /* Set a flag in the hash table entry indicating the type of
715 reference or definition we just found. Keep a count of
716 the number of dynamic symbols we find. A dynamic symbol
717 is one which is referenced or defined by both a regular
718 object and a shared object, or one which is referenced or
719 defined by more than one shared object. */
720 old_flags
= h
->elf_link_hash_flags
;
725 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
727 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
729 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
730 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
736 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
738 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
739 if ((old_flags
& new_flag
) != 0
740 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
741 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
745 h
->elf_link_hash_flags
|= new_flag
;
746 if (dynsym
&& h
->dynindx
== -1)
748 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
754 /* Now set the weakdefs field correctly for all the weak defined
755 symbols we found. The only way to do this is to search all the
756 symbols. Since we only need the information for non functions in
757 dynamic objects, that's the only time we actually put anything on
758 the list WEAKS. We need this information so that if a regular
759 object refers to a symbol defined weakly in a dynamic object, the
760 real symbol in the dynamic object is also put in the dynamic
761 symbols; we also must arrange for both symbols to point to the
762 same memory location. We could handle the general case of symbol
763 aliasing, but a general symbol alias can only be generated in
764 assembler code, handling it correctly would be very time
765 consuming, and other ELF linkers don't handle general aliasing
767 while (weaks
!= NULL
)
769 struct elf_link_hash_entry
*hlook
;
772 struct elf_link_hash_entry
**hpp
;
773 struct elf_link_hash_entry
**hppend
;
776 weaks
= hlook
->weakdef
;
777 hlook
->weakdef
= NULL
;
779 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
780 || hlook
->root
.type
== bfd_link_hash_defweak
781 || hlook
->root
.type
== bfd_link_hash_common
782 || hlook
->root
.type
== bfd_link_hash_indirect
);
783 slook
= hlook
->root
.u
.def
.section
;
784 vlook
= hlook
->root
.u
.def
.value
;
786 hpp
= elf_sym_hashes (abfd
);
787 hppend
= hpp
+ extsymcount
;
788 for (; hpp
< hppend
; hpp
++)
790 struct elf_link_hash_entry
*h
;
793 if (h
!= NULL
&& h
!= hlook
794 && (h
->root
.type
== bfd_link_hash_defined
795 || h
->root
.type
== bfd_link_hash_defweak
)
796 && h
->root
.u
.def
.section
== slook
797 && h
->root
.u
.def
.value
== vlook
)
801 /* If the weak definition is in the list of dynamic
802 symbols, make sure the real definition is put there
804 if (hlook
->dynindx
!= -1
807 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
822 /* If this object is the same format as the output object, and it is
823 not a shared library, then let the backend look through the
826 This is required to build global offset table entries and to
827 arrange for dynamic relocs. It is not required for the
828 particular common case of linking non PIC code, even when linking
829 against shared libraries, but unfortunately there is no way of
830 knowing whether an object file has been compiled PIC or not.
831 Looking through the relocs is not particularly time consuming.
832 The problem is that we must either (1) keep the relocs in memory,
833 which causes the linker to require additional runtime memory or
834 (2) read the relocs twice from the input file, which wastes time.
835 This would be a good case for using mmap.
837 I have no idea how to handle linking PIC code into a file of a
838 different format. It probably can't be done. */
839 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
841 && abfd
->xvec
== info
->hash
->creator
842 && check_relocs
!= NULL
)
846 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
848 Elf_Internal_Rela
*internal_relocs
;
851 if ((o
->flags
& SEC_RELOC
) == 0
852 || o
->reloc_count
== 0)
855 /* I believe we can ignore the relocs for any section which
856 does not form part of the final process image, such as a
857 debugging section. */
858 if ((o
->flags
& SEC_ALLOC
) == 0)
861 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
862 (Elf_Internal_Rela
*) NULL
,
864 if (internal_relocs
== NULL
)
867 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
869 if (! info
->keep_memory
)
870 free (internal_relocs
);
887 /* Create some sections which will be filled in with dynamic linking
888 information. ABFD is an input file which requires dynamic sections
889 to be created. The dynamic sections take up virtual memory space
890 when the final executable is run, so we need to create them before
891 addresses are assigned to the output sections. We work out the
892 actual contents and size of these sections later. */
895 elf_link_create_dynamic_sections (abfd
, info
)
897 struct bfd_link_info
*info
;
900 register asection
*s
;
901 struct elf_link_hash_entry
*h
;
902 struct elf_backend_data
*bed
;
904 if (elf_hash_table (info
)->dynamic_sections_created
)
907 /* Make sure that all dynamic sections use the same input BFD. */
908 if (elf_hash_table (info
)->dynobj
== NULL
)
909 elf_hash_table (info
)->dynobj
= abfd
;
911 abfd
= elf_hash_table (info
)->dynobj
;
913 /* Note that we set the SEC_IN_MEMORY flag for all of these
915 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
917 /* A dynamically linked executable has a .interp section, but a
918 shared library does not. */
921 s
= bfd_make_section (abfd
, ".interp");
923 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
927 s
= bfd_make_section (abfd
, ".dynsym");
929 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
930 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
933 s
= bfd_make_section (abfd
, ".dynstr");
935 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
938 /* Create a strtab to hold the dynamic symbol names. */
939 if (elf_hash_table (info
)->dynstr
== NULL
)
941 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
942 if (elf_hash_table (info
)->dynstr
== NULL
)
946 s
= bfd_make_section (abfd
, ".dynamic");
948 || ! bfd_set_section_flags (abfd
, s
, flags
)
949 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
952 /* The special symbol _DYNAMIC is always set to the start of the
953 .dynamic section. This call occurs before we have processed the
954 symbols for any dynamic object, so we don't have to worry about
955 overriding a dynamic definition. We could set _DYNAMIC in a
956 linker script, but we only want to define it if we are, in fact,
957 creating a .dynamic section. We don't want to define it if there
958 is no .dynamic section, since on some ELF platforms the start up
959 code examines it to decide how to initialize the process. */
961 if (! (_bfd_generic_link_add_one_symbol
962 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
963 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
964 (struct bfd_link_hash_entry
**) &h
)))
966 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
967 h
->type
= STT_OBJECT
;
970 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
973 s
= bfd_make_section (abfd
, ".hash");
975 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
976 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
979 /* Let the backend create the rest of the sections. This lets the
980 backend set the right flags. The backend will normally create
981 the .got and .plt sections. */
982 bed
= get_elf_backend_data (abfd
);
983 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
986 elf_hash_table (info
)->dynamic_sections_created
= true;
991 /* Add an entry to the .dynamic table. */
994 elf_add_dynamic_entry (info
, tag
, val
)
995 struct bfd_link_info
*info
;
999 Elf_Internal_Dyn dyn
;
1003 bfd_byte
*newcontents
;
1005 dynobj
= elf_hash_table (info
)->dynobj
;
1007 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1008 BFD_ASSERT (s
!= NULL
);
1010 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1011 if (s
->contents
== NULL
)
1012 newcontents
= (bfd_byte
*) malloc (newsize
);
1014 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
1015 if (newcontents
== NULL
)
1017 bfd_set_error (bfd_error_no_memory
);
1022 dyn
.d_un
.d_val
= val
;
1023 elf_swap_dyn_out (dynobj
, &dyn
,
1024 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1026 s
->_raw_size
= newsize
;
1027 s
->contents
= newcontents
;
1032 /* Read and swap the relocs for a section. They may have been cached.
1033 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1034 they are used as buffers to read into. They are known to be large
1035 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1036 value is allocated using either malloc or bfd_alloc, according to
1037 the KEEP_MEMORY argument. */
1039 static Elf_Internal_Rela
*
1040 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1043 PTR external_relocs
;
1044 Elf_Internal_Rela
*internal_relocs
;
1045 boolean keep_memory
;
1047 Elf_Internal_Shdr
*rel_hdr
;
1049 Elf_Internal_Rela
*alloc2
= NULL
;
1051 if (elf_section_data (o
)->relocs
!= NULL
)
1052 return elf_section_data (o
)->relocs
;
1054 if (o
->reloc_count
== 0)
1057 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1059 if (internal_relocs
== NULL
)
1063 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1065 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1067 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
1068 if (internal_relocs
== NULL
)
1070 bfd_set_error (bfd_error_no_memory
);
1075 if (external_relocs
== NULL
)
1077 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
1080 bfd_set_error (bfd_error_no_memory
);
1083 external_relocs
= alloc1
;
1086 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1087 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1088 != rel_hdr
->sh_size
))
1091 /* Swap in the relocs. For convenience, we always produce an
1092 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1094 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1096 Elf_External_Rel
*erel
;
1097 Elf_External_Rel
*erelend
;
1098 Elf_Internal_Rela
*irela
;
1100 erel
= (Elf_External_Rel
*) external_relocs
;
1101 erelend
= erel
+ o
->reloc_count
;
1102 irela
= internal_relocs
;
1103 for (; erel
< erelend
; erel
++, irela
++)
1105 Elf_Internal_Rel irel
;
1107 elf_swap_reloc_in (abfd
, erel
, &irel
);
1108 irela
->r_offset
= irel
.r_offset
;
1109 irela
->r_info
= irel
.r_info
;
1110 irela
->r_addend
= 0;
1115 Elf_External_Rela
*erela
;
1116 Elf_External_Rela
*erelaend
;
1117 Elf_Internal_Rela
*irela
;
1119 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1121 erela
= (Elf_External_Rela
*) external_relocs
;
1122 erelaend
= erela
+ o
->reloc_count
;
1123 irela
= internal_relocs
;
1124 for (; erela
< erelaend
; erela
++, irela
++)
1125 elf_swap_reloca_in (abfd
, erela
, irela
);
1128 /* Cache the results for next time, if we can. */
1130 elf_section_data (o
)->relocs
= internal_relocs
;
1135 /* Don't free alloc2, since if it was allocated we are passing it
1136 back (under the name of internal_relocs). */
1138 return internal_relocs
;
1148 /* Record an assignment to a symbol made by a linker script. We need
1149 this in case some dynamic object refers to this symbol. */
1153 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1155 struct bfd_link_info
*info
;
1159 struct elf_link_hash_entry
*h
;
1161 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1164 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1168 /* If this symbol is being provided by the linker script, and it is
1169 currently defined by a dynamic object, but not by a regular
1170 object, then mark it as undefined so that the generic linker will
1171 force the correct value. */
1173 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1174 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1175 h
->root
.type
= bfd_link_hash_undefined
;
1177 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1178 h
->type
= STT_OBJECT
;
1180 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1181 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1183 && h
->dynindx
== -1)
1185 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1188 /* If this is a weak defined symbol, and we know a corresponding
1189 real symbol from the same dynamic object, make sure the real
1190 symbol is also made into a dynamic symbol. */
1191 if (h
->weakdef
!= NULL
1192 && h
->weakdef
->dynindx
== -1)
1194 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1202 /* Array used to determine the number of hash table buckets to use
1203 based on the number of symbols there are. If there are fewer than
1204 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1205 fewer than 37 we use 17 buckets, and so forth. We never use more
1206 than 521 buckets. */
1208 static const size_t elf_buckets
[] =
1210 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1213 /* Set up the sizes and contents of the ELF dynamic sections. This is
1214 called by the ELF linker emulation before_allocation routine. We
1215 must set the sizes of the sections before the linker sets the
1216 addresses of the various sections. */
1219 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1220 export_dynamic
, info
, sinterpptr
)
1224 boolean export_dynamic
;
1225 struct bfd_link_info
*info
;
1226 asection
**sinterpptr
;
1229 struct elf_backend_data
*bed
;
1233 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1236 dynobj
= elf_hash_table (info
)->dynobj
;
1238 /* If there were no dynamic objects in the link, there is nothing to
1243 /* If we are supposed to export all symbols into the dynamic symbol
1244 table (this is not the normal case), then do so. */
1247 struct elf_info_failed eif
;
1251 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1257 if (elf_hash_table (info
)->dynamic_sections_created
)
1259 struct elf_info_failed eif
;
1260 bfd_size_type strsize
;
1262 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1263 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1269 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1271 if (indx
== (bfd_size_type
) -1
1272 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1278 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1286 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1288 if (indx
== (bfd_size_type
) -1
1289 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1293 /* Find all symbols which were defined in a dynamic object and make
1294 the backend pick a reasonable value for them. */
1297 elf_link_hash_traverse (elf_hash_table (info
),
1298 elf_adjust_dynamic_symbol
,
1303 /* Add some entries to the .dynamic section. We fill in some of the
1304 values later, in elf_bfd_final_link, but we must add the entries
1305 now so that we know the final size of the .dynamic section. */
1306 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1307 false, false) != NULL
)
1309 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1312 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1313 false, false) != NULL
)
1315 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1318 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1319 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1320 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1321 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1322 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1323 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1324 sizeof (Elf_External_Sym
)))
1328 /* The backend must work out the sizes of all the other dynamic
1330 bed
= get_elf_backend_data (output_bfd
);
1331 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1334 if (elf_hash_table (info
)->dynamic_sections_created
)
1339 size_t bucketcount
= 0;
1340 Elf_Internal_Sym isym
;
1342 /* Set the size of the .dynsym and .hash sections. We counted
1343 the number of dynamic symbols in elf_link_add_object_symbols.
1344 We will build the contents of .dynsym and .hash when we build
1345 the final symbol table, because until then we do not know the
1346 correct value to give the symbols. We built the .dynstr
1347 section as we went along in elf_link_add_object_symbols. */
1348 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1349 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1350 BFD_ASSERT (s
!= NULL
);
1351 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1352 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1353 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1355 bfd_set_error (bfd_error_no_memory
);
1359 /* The first entry in .dynsym is a dummy symbol. */
1366 elf_swap_symbol_out (output_bfd
, &isym
,
1367 (char *) (Elf_External_Sym
*) s
->contents
);
1369 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1371 bucketcount
= elf_buckets
[i
];
1372 if (dynsymcount
< elf_buckets
[i
+ 1])
1376 s
= bfd_get_section_by_name (dynobj
, ".hash");
1377 BFD_ASSERT (s
!= NULL
);
1378 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1379 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1380 if (s
->contents
== NULL
)
1382 bfd_set_error (bfd_error_no_memory
);
1385 memset (s
->contents
, 0, s
->_raw_size
);
1387 put_word (output_bfd
, bucketcount
, s
->contents
);
1388 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1390 elf_hash_table (info
)->bucketcount
= bucketcount
;
1392 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1393 BFD_ASSERT (s
!= NULL
);
1394 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1396 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1403 /* This routine is used to export all defined symbols into the dynamic
1404 symbol table. It is called via elf_link_hash_traverse. */
1407 elf_export_symbol (h
, data
)
1408 struct elf_link_hash_entry
*h
;
1411 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1413 if (h
->dynindx
== -1
1414 && (h
->elf_link_hash_flags
1415 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1417 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1427 /* Make the backend pick a good value for a dynamic symbol. This is
1428 called via elf_link_hash_traverse, and also calls itself
1432 elf_adjust_dynamic_symbol (h
, data
)
1433 struct elf_link_hash_entry
*h
;
1436 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1438 struct elf_backend_data
*bed
;
1440 /* If -Bsymbolic was used (which means to bind references to global
1441 symbols to the definition within the shared object), and this
1442 symbol was defined in a regular object, then it actually doesn't
1443 need a PLT entry. */
1444 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1445 && eif
->info
->shared
1446 && eif
->info
->symbolic
1447 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1448 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1450 /* If this symbol does not require a PLT entry, and it is not
1451 defined by a dynamic object, or is not referenced by a regular
1452 object, ignore it. FIXME: Do we need to worry about symbols
1453 which are defined by one dynamic object and referenced by another
1455 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1456 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1457 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1458 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
1461 /* If we've already adjusted this symbol, don't do it again. This
1462 can happen via a recursive call. */
1463 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1466 /* Don't look at this symbol again. Note that we must set this
1467 after checking the above conditions, because we may look at a
1468 symbol once, decide not to do anything, and then get called
1469 recursively later after REF_REGULAR is set below. */
1470 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1472 /* If this is a weak definition, and we know a real definition, and
1473 the real symbol is not itself defined by a regular object file,
1474 then get a good value for the real definition. We handle the
1475 real symbol first, for the convenience of the backend routine.
1477 Note that there is a confusing case here. If the real definition
1478 is defined by a regular object file, we don't get the real symbol
1479 from the dynamic object, but we do get the weak symbol. If the
1480 processor backend uses a COPY reloc, then if some routine in the
1481 dynamic object changes the real symbol, we will not see that
1482 change in the corresponding weak symbol. This is the way other
1483 ELF linkers work as well, and seems to be a result of the shared
1486 I will clarify this issue. Most SVR4 shared libraries define the
1487 variable _timezone and define timezone as a weak synonym. The
1488 tzset call changes _timezone. If you write
1489 extern int timezone;
1491 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1492 you might expect that, since timezone is a synonym for _timezone,
1493 the same number will print both times. However, if the processor
1494 backend uses a COPY reloc, then actually timezone will be copied
1495 into your process image, and, since you define _timezone
1496 yourself, _timezone will not. Thus timezone and _timezone will
1497 wind up at different memory locations. The tzset call will set
1498 _timezone, leaving timezone unchanged. */
1500 if (h
->weakdef
!= NULL
)
1502 struct elf_link_hash_entry
*weakdef
;
1504 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1505 || h
->root
.type
== bfd_link_hash_defweak
);
1506 weakdef
= h
->weakdef
;
1507 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1508 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1509 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1510 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1512 /* This symbol is defined by a regular object file, so we
1513 will not do anything special. Clear weakdef for the
1514 convenience of the processor backend. */
1519 /* There is an implicit reference by a regular object file
1520 via the weak symbol. */
1521 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1522 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1527 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1528 bed
= get_elf_backend_data (dynobj
);
1529 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1538 /* Final phase of ELF linker. */
1540 /* A structure we use to avoid passing large numbers of arguments. */
1542 struct elf_final_link_info
1544 /* General link information. */
1545 struct bfd_link_info
*info
;
1548 /* Symbol string table. */
1549 struct bfd_strtab_hash
*symstrtab
;
1550 /* .dynsym section. */
1551 asection
*dynsym_sec
;
1552 /* .hash section. */
1554 /* Buffer large enough to hold contents of any section. */
1556 /* Buffer large enough to hold external relocs of any section. */
1557 PTR external_relocs
;
1558 /* Buffer large enough to hold internal relocs of any section. */
1559 Elf_Internal_Rela
*internal_relocs
;
1560 /* Buffer large enough to hold external local symbols of any input
1562 Elf_External_Sym
*external_syms
;
1563 /* Buffer large enough to hold internal local symbols of any input
1565 Elf_Internal_Sym
*internal_syms
;
1566 /* Array large enough to hold a symbol index for each local symbol
1567 of any input BFD. */
1569 /* Array large enough to hold a section pointer for each local
1570 symbol of any input BFD. */
1571 asection
**sections
;
1572 /* Buffer to hold swapped out symbols. */
1573 Elf_External_Sym
*symbuf
;
1574 /* Number of swapped out symbols in buffer. */
1575 size_t symbuf_count
;
1576 /* Number of symbols which fit in symbuf. */
1580 static boolean elf_link_output_sym
1581 PARAMS ((struct elf_final_link_info
*, const char *,
1582 Elf_Internal_Sym
*, asection
*));
1583 static boolean elf_link_flush_output_syms
1584 PARAMS ((struct elf_final_link_info
*));
1585 static boolean elf_link_output_extsym
1586 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1587 static boolean elf_link_input_bfd
1588 PARAMS ((struct elf_final_link_info
*, bfd
*));
1589 static boolean elf_reloc_link_order
1590 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1591 struct bfd_link_order
*));
1593 /* This struct is used to pass information to routines called via
1594 elf_link_hash_traverse which must return failure. */
1596 struct elf_finfo_failed
1599 struct elf_final_link_info
*finfo
;
1602 /* Do the final step of an ELF link. */
1605 elf_bfd_final_link (abfd
, info
)
1607 struct bfd_link_info
*info
;
1611 struct elf_final_link_info finfo
;
1612 register asection
*o
;
1613 register struct bfd_link_order
*p
;
1615 size_t max_contents_size
;
1616 size_t max_external_reloc_size
;
1617 size_t max_internal_reloc_count
;
1618 size_t max_sym_count
;
1620 Elf_Internal_Sym elfsym
;
1622 Elf_Internal_Shdr
*symtab_hdr
;
1623 Elf_Internal_Shdr
*symstrtab_hdr
;
1624 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1625 struct elf_finfo_failed eif
;
1628 abfd
->flags
|= DYNAMIC
;
1630 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1631 dynobj
= elf_hash_table (info
)->dynobj
;
1634 finfo
.output_bfd
= abfd
;
1635 finfo
.symstrtab
= elf_stringtab_init ();
1636 if (finfo
.symstrtab
== NULL
)
1640 finfo
.dynsym_sec
= NULL
;
1641 finfo
.hash_sec
= NULL
;
1645 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1646 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1647 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1649 finfo
.contents
= NULL
;
1650 finfo
.external_relocs
= NULL
;
1651 finfo
.internal_relocs
= NULL
;
1652 finfo
.external_syms
= NULL
;
1653 finfo
.internal_syms
= NULL
;
1654 finfo
.indices
= NULL
;
1655 finfo
.sections
= NULL
;
1656 finfo
.symbuf
= NULL
;
1657 finfo
.symbuf_count
= 0;
1659 /* Count up the number of relocations we will output for each output
1660 section, so that we know the sizes of the reloc sections. We
1661 also figure out some maximum sizes. */
1662 max_contents_size
= 0;
1663 max_external_reloc_size
= 0;
1664 max_internal_reloc_count
= 0;
1666 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1670 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1672 if (p
->type
== bfd_section_reloc_link_order
1673 || p
->type
== bfd_symbol_reloc_link_order
)
1675 else if (p
->type
== bfd_indirect_link_order
)
1679 sec
= p
->u
.indirect
.section
;
1681 if (info
->relocateable
)
1682 o
->reloc_count
+= sec
->reloc_count
;
1684 if (sec
->_raw_size
> max_contents_size
)
1685 max_contents_size
= sec
->_raw_size
;
1686 if (sec
->_cooked_size
> max_contents_size
)
1687 max_contents_size
= sec
->_cooked_size
;
1689 /* We are interested in just local symbols, not all
1691 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1695 if (elf_bad_symtab (sec
->owner
))
1696 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1697 / sizeof (Elf_External_Sym
));
1699 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1701 if (sym_count
> max_sym_count
)
1702 max_sym_count
= sym_count
;
1704 if ((sec
->flags
& SEC_RELOC
) != 0)
1708 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1709 if (ext_size
> max_external_reloc_size
)
1710 max_external_reloc_size
= ext_size
;
1711 if (sec
->reloc_count
> max_internal_reloc_count
)
1712 max_internal_reloc_count
= sec
->reloc_count
;
1718 if (o
->reloc_count
> 0)
1719 o
->flags
|= SEC_RELOC
;
1722 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1723 set it (this is probably a bug) and if it is set
1724 assign_section_numbers will create a reloc section. */
1725 o
->flags
&=~ SEC_RELOC
;
1728 /* If the SEC_ALLOC flag is not set, force the section VMA to
1729 zero. This is done in elf_fake_sections as well, but forcing
1730 the VMA to 0 here will ensure that relocs against these
1731 sections are handled correctly. */
1732 if ((o
->flags
& SEC_ALLOC
) == 0)
1736 /* Figure out the file positions for everything but the symbol table
1737 and the relocs. We set symcount to force assign_section_numbers
1738 to create a symbol table. */
1739 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1740 BFD_ASSERT (! abfd
->output_has_begun
);
1741 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1744 /* That created the reloc sections. Set their sizes, and assign
1745 them file positions, and allocate some buffers. */
1746 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1748 if ((o
->flags
& SEC_RELOC
) != 0)
1750 Elf_Internal_Shdr
*rel_hdr
;
1751 register struct elf_link_hash_entry
**p
, **pend
;
1753 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1755 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1757 /* The contents field must last into write_object_contents,
1758 so we allocate it with bfd_alloc rather than malloc. */
1759 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1760 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1762 bfd_set_error (bfd_error_no_memory
);
1766 p
= ((struct elf_link_hash_entry
**)
1767 malloc (o
->reloc_count
1768 * sizeof (struct elf_link_hash_entry
*)));
1769 if (p
== NULL
&& o
->reloc_count
!= 0)
1771 bfd_set_error (bfd_error_no_memory
);
1774 elf_section_data (o
)->rel_hashes
= p
;
1775 pend
= p
+ o
->reloc_count
;
1776 for (; p
< pend
; p
++)
1779 /* Use the reloc_count field as an index when outputting the
1785 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1787 /* We have now assigned file positions for all the sections except
1788 .symtab and .strtab. We start the .symtab section at the current
1789 file position, and write directly to it. We build the .strtab
1790 section in memory. When we add .dynsym support, we will build
1791 that in memory as well (.dynsym is smaller than .symtab). */
1793 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1794 /* sh_name is set in prep_headers. */
1795 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1796 symtab_hdr
->sh_flags
= 0;
1797 symtab_hdr
->sh_addr
= 0;
1798 symtab_hdr
->sh_size
= 0;
1799 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1800 /* sh_link is set in assign_section_numbers. */
1801 /* sh_info is set below. */
1802 /* sh_offset is set just below. */
1803 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1805 off
= elf_tdata (abfd
)->next_file_pos
;
1806 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1808 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1809 incorrect. We do not yet know the size of the .symtab section.
1810 We correct next_file_pos below, after we do know the size. */
1812 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1813 continuously seeking to the right position in the file. */
1814 if (! info
->keep_memory
|| max_sym_count
< 20)
1815 finfo
.symbuf_size
= 20;
1817 finfo
.symbuf_size
= max_sym_count
;
1818 finfo
.symbuf
= ((Elf_External_Sym
*)
1819 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1820 if (finfo
.symbuf
== NULL
)
1822 bfd_set_error (bfd_error_no_memory
);
1826 /* Start writing out the symbol table. The first symbol is always a
1828 elfsym
.st_value
= 0;
1831 elfsym
.st_other
= 0;
1832 elfsym
.st_shndx
= SHN_UNDEF
;
1833 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1834 &elfsym
, bfd_und_section_ptr
))
1838 /* Some standard ELF linkers do this, but we don't because it causes
1839 bootstrap comparison failures. */
1840 /* Output a file symbol for the output file as the second symbol.
1841 We output this even if we are discarding local symbols, although
1842 I'm not sure if this is correct. */
1843 elfsym
.st_value
= 0;
1845 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1846 elfsym
.st_other
= 0;
1847 elfsym
.st_shndx
= SHN_ABS
;
1848 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1849 &elfsym
, bfd_abs_section_ptr
))
1853 /* Output a symbol for each section. We output these even if we are
1854 discarding local symbols, since they are used for relocs. These
1855 symbols have no names. We store the index of each one in the
1856 index field of the section, so that we can find it again when
1857 outputting relocs. */
1858 elfsym
.st_value
= 0;
1860 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1861 elfsym
.st_other
= 0;
1862 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1864 o
= section_from_elf_index (abfd
, i
);
1866 o
->target_index
= abfd
->symcount
;
1867 elfsym
.st_shndx
= i
;
1868 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1873 /* Allocate some memory to hold information read in from the input
1875 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
1876 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
1877 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1878 malloc (max_internal_reloc_count
1879 * sizeof (Elf_Internal_Rela
)));
1880 finfo
.external_syms
= ((Elf_External_Sym
*)
1881 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
1882 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1883 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
1884 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
1885 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
1886 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
1887 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
1888 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
1889 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
1890 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
1891 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
1892 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
1894 bfd_set_error (bfd_error_no_memory
);
1898 /* Since ELF permits relocations to be against local symbols, we
1899 must have the local symbols available when we do the relocations.
1900 Since we would rather only read the local symbols once, and we
1901 would rather not keep them in memory, we handle all the
1902 relocations for a single input file at the same time.
1904 Unfortunately, there is no way to know the total number of local
1905 symbols until we have seen all of them, and the local symbol
1906 indices precede the global symbol indices. This means that when
1907 we are generating relocateable output, and we see a reloc against
1908 a global symbol, we can not know the symbol index until we have
1909 finished examining all the local symbols to see which ones we are
1910 going to output. To deal with this, we keep the relocations in
1911 memory, and don't output them until the end of the link. This is
1912 an unfortunate waste of memory, but I don't see a good way around
1913 it. Fortunately, it only happens when performing a relocateable
1914 link, which is not the common case. FIXME: If keep_memory is set
1915 we could write the relocs out and then read them again; I don't
1916 know how bad the memory loss will be. */
1918 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
1919 sub
->output_has_begun
= false;
1920 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1922 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1924 if (p
->type
== bfd_indirect_link_order
1925 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
1926 == bfd_target_elf_flavour
))
1928 sub
= p
->u
.indirect
.section
->owner
;
1929 if (! sub
->output_has_begun
)
1931 if (! elf_link_input_bfd (&finfo
, sub
))
1933 sub
->output_has_begun
= true;
1936 else if (p
->type
== bfd_section_reloc_link_order
1937 || p
->type
== bfd_symbol_reloc_link_order
)
1939 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
1944 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
1950 /* That wrote out all the local symbols. Finish up the symbol table
1951 with the global symbols. */
1953 /* The sh_info field records the index of the first non local
1955 symtab_hdr
->sh_info
= abfd
->symcount
;
1957 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
1959 /* We get the global symbols from the hash table. */
1962 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
1967 /* Flush all symbols to the file. */
1968 if (! elf_link_flush_output_syms (&finfo
))
1971 /* Now we know the size of the symtab section. */
1972 off
+= symtab_hdr
->sh_size
;
1974 /* Finish up and write out the symbol string table (.strtab)
1976 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1977 /* sh_name was set in prep_headers. */
1978 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
1979 symstrtab_hdr
->sh_flags
= 0;
1980 symstrtab_hdr
->sh_addr
= 0;
1981 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
1982 symstrtab_hdr
->sh_entsize
= 0;
1983 symstrtab_hdr
->sh_link
= 0;
1984 symstrtab_hdr
->sh_info
= 0;
1985 /* sh_offset is set just below. */
1986 symstrtab_hdr
->sh_addralign
= 1;
1988 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
1989 elf_tdata (abfd
)->next_file_pos
= off
;
1991 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
1992 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
1995 /* Adjust the relocs to have the correct symbol indices. */
1996 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1998 struct elf_link_hash_entry
**rel_hash
;
1999 Elf_Internal_Shdr
*rel_hdr
;
2001 if ((o
->flags
& SEC_RELOC
) == 0)
2004 rel_hash
= elf_section_data (o
)->rel_hashes
;
2005 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2006 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2008 if (*rel_hash
== NULL
)
2011 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2013 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2015 Elf_External_Rel
*erel
;
2016 Elf_Internal_Rel irel
;
2018 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2019 elf_swap_reloc_in (abfd
, erel
, &irel
);
2020 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2021 ELF_R_TYPE (irel
.r_info
));
2022 elf_swap_reloc_out (abfd
, &irel
, erel
);
2026 Elf_External_Rela
*erela
;
2027 Elf_Internal_Rela irela
;
2029 BFD_ASSERT (rel_hdr
->sh_entsize
2030 == sizeof (Elf_External_Rela
));
2032 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2033 elf_swap_reloca_in (abfd
, erela
, &irela
);
2034 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2035 ELF_R_TYPE (irela
.r_info
));
2036 elf_swap_reloca_out (abfd
, &irela
, erela
);
2040 /* Set the reloc_count field to 0 to prevent write_relocs from
2041 trying to swap the relocs out itself. */
2045 /* If we are linking against a dynamic object, or generating a
2046 shared library, finish up the dynamic linking information. */
2049 Elf_External_Dyn
*dyncon
, *dynconend
;
2051 /* Fix up .dynamic entries. */
2052 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2053 BFD_ASSERT (o
!= NULL
);
2055 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2056 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2057 for (; dyncon
< dynconend
; dyncon
++)
2059 Elf_Internal_Dyn dyn
;
2063 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2070 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2071 magic _init and _fini symbols. This is pretty ugly,
2072 but we are compatible. */
2080 struct elf_link_hash_entry
*h
;
2082 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2083 false, false, true);
2084 BFD_ASSERT (h
!= NULL
);
2085 if (h
->root
.type
== bfd_link_hash_defined
2086 || h
->root
.type
== bfd_link_hash_defweak
)
2088 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2089 o
= h
->root
.u
.def
.section
;
2090 if (o
->output_section
!= NULL
)
2091 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2092 + o
->output_offset
);
2094 /* The symbol is imported from another shared
2095 library and does not apply to this one. */
2098 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2111 o
= bfd_get_section_by_name (abfd
, name
);
2112 BFD_ASSERT (o
!= NULL
);
2113 dyn
.d_un
.d_ptr
= o
->vma
;
2114 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2121 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2126 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2128 Elf_Internal_Shdr
*hdr
;
2130 hdr
= elf_elfsections (abfd
)[i
];
2131 if (hdr
->sh_type
== type
2132 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2134 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2135 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2138 if (dyn
.d_un
.d_val
== 0
2139 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2140 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2144 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2150 /* If we have created any dynamic sections, then output them. */
2153 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2156 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2158 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2159 || o
->_raw_size
== 0)
2161 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2163 /* At this point, we are only interested in sections
2164 created by elf_link_create_dynamic_sections. FIXME:
2165 This test is fragile. */
2168 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2170 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2172 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2173 o
->contents
, o
->output_offset
,
2181 /* The contents of the .dynstr section are actually in a
2183 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2184 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2185 || ! _bfd_stringtab_emit (abfd
,
2186 elf_hash_table (info
)->dynstr
))
2192 if (finfo
.symstrtab
!= NULL
)
2193 _bfd_stringtab_free (finfo
.symstrtab
);
2194 if (finfo
.contents
!= NULL
)
2195 free (finfo
.contents
);
2196 if (finfo
.external_relocs
!= NULL
)
2197 free (finfo
.external_relocs
);
2198 if (finfo
.internal_relocs
!= NULL
)
2199 free (finfo
.internal_relocs
);
2200 if (finfo
.external_syms
!= NULL
)
2201 free (finfo
.external_syms
);
2202 if (finfo
.internal_syms
!= NULL
)
2203 free (finfo
.internal_syms
);
2204 if (finfo
.indices
!= NULL
)
2205 free (finfo
.indices
);
2206 if (finfo
.sections
!= NULL
)
2207 free (finfo
.sections
);
2208 if (finfo
.symbuf
!= NULL
)
2209 free (finfo
.symbuf
);
2210 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2212 if ((o
->flags
& SEC_RELOC
) != 0
2213 && elf_section_data (o
)->rel_hashes
!= NULL
)
2214 free (elf_section_data (o
)->rel_hashes
);
2217 elf_tdata (abfd
)->linker
= true;
2222 if (finfo
.symstrtab
!= NULL
)
2223 _bfd_stringtab_free (finfo
.symstrtab
);
2224 if (finfo
.contents
!= NULL
)
2225 free (finfo
.contents
);
2226 if (finfo
.external_relocs
!= NULL
)
2227 free (finfo
.external_relocs
);
2228 if (finfo
.internal_relocs
!= NULL
)
2229 free (finfo
.internal_relocs
);
2230 if (finfo
.external_syms
!= NULL
)
2231 free (finfo
.external_syms
);
2232 if (finfo
.internal_syms
!= NULL
)
2233 free (finfo
.internal_syms
);
2234 if (finfo
.indices
!= NULL
)
2235 free (finfo
.indices
);
2236 if (finfo
.sections
!= NULL
)
2237 free (finfo
.sections
);
2238 if (finfo
.symbuf
!= NULL
)
2239 free (finfo
.symbuf
);
2240 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2242 if ((o
->flags
& SEC_RELOC
) != 0
2243 && elf_section_data (o
)->rel_hashes
!= NULL
)
2244 free (elf_section_data (o
)->rel_hashes
);
2250 /* Add a symbol to the output symbol table. */
2253 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2254 struct elf_final_link_info
*finfo
;
2256 Elf_Internal_Sym
*elfsym
;
2257 asection
*input_sec
;
2259 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2260 struct bfd_link_info
*info
,
2265 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2266 elf_backend_link_output_symbol_hook
;
2267 if (output_symbol_hook
!= NULL
)
2269 if (! ((*output_symbol_hook
)
2270 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2274 if (name
== (const char *) NULL
|| *name
== '\0')
2275 elfsym
->st_name
= 0;
2278 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2281 if (elfsym
->st_name
== (unsigned long) -1)
2285 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2287 if (! elf_link_flush_output_syms (finfo
))
2291 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2292 (char *) (finfo
->symbuf
+ finfo
->symbuf_count
));
2293 ++finfo
->symbuf_count
;
2295 ++finfo
->output_bfd
->symcount
;
2300 /* Flush the output symbols to the file. */
2303 elf_link_flush_output_syms (finfo
)
2304 struct elf_final_link_info
*finfo
;
2306 Elf_Internal_Shdr
*symtab
;
2308 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2310 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2312 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2313 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2314 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2317 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2319 finfo
->symbuf_count
= 0;
2324 /* Add an external symbol to the symbol table. This is called from
2325 the hash table traversal routine. */
2328 elf_link_output_extsym (h
, data
)
2329 struct elf_link_hash_entry
*h
;
2332 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2333 struct elf_final_link_info
*finfo
= eif
->finfo
;
2335 Elf_Internal_Sym sym
;
2336 asection
*input_sec
;
2338 /* If we are not creating a shared library, and this symbol is
2339 referenced by a shared library but is not defined anywhere, then
2340 warn that it is undefined. If we do not do this, the runtime
2341 linker will complain that the symbol is undefined when the
2342 program is run. We don't have to worry about symbols that are
2343 referenced by regular files, because we will already have issued
2344 warnings for them. */
2345 if (! finfo
->info
->relocateable
2346 && ! finfo
->info
->shared
2347 && h
->root
.type
== bfd_link_hash_undefined
2348 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2349 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2351 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2352 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2353 (asection
*) NULL
, 0)))
2360 /* We don't want to output symbols that have never been mentioned by
2361 a regular file, or that we have been told to strip. However, if
2362 h->indx is set to -2, the symbol is used by a reloc and we must
2366 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2367 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2368 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2369 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2371 else if (finfo
->info
->strip
== strip_all
2372 || (finfo
->info
->strip
== strip_some
2373 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2374 h
->root
.root
.string
,
2375 false, false) == NULL
))
2380 /* If we're stripping it, and it's not a dynamic symbol, there's
2381 nothing else to do. */
2382 if (strip
&& h
->dynindx
== -1)
2386 sym
.st_size
= h
->size
;
2388 if (h
->root
.type
== bfd_link_hash_undefweak
2389 || h
->root
.type
== bfd_link_hash_defweak
)
2390 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2392 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2394 switch (h
->root
.type
)
2397 case bfd_link_hash_new
:
2401 case bfd_link_hash_undefined
:
2402 input_sec
= bfd_und_section_ptr
;
2403 sym
.st_shndx
= SHN_UNDEF
;
2406 case bfd_link_hash_undefweak
:
2407 input_sec
= bfd_und_section_ptr
;
2408 sym
.st_shndx
= SHN_UNDEF
;
2411 case bfd_link_hash_defined
:
2412 case bfd_link_hash_defweak
:
2414 input_sec
= h
->root
.u
.def
.section
;
2415 if (input_sec
->output_section
!= NULL
)
2418 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2419 input_sec
->output_section
);
2420 if (sym
.st_shndx
== (unsigned short) -1)
2426 /* ELF symbols in relocateable files are section relative,
2427 but in nonrelocateable files they are virtual
2429 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2430 if (! finfo
->info
->relocateable
)
2431 sym
.st_value
+= input_sec
->output_section
->vma
;
2435 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2436 == bfd_target_elf_flavour
)
2437 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2438 sym
.st_shndx
= SHN_UNDEF
;
2439 input_sec
= bfd_und_section_ptr
;
2444 case bfd_link_hash_common
:
2445 input_sec
= bfd_com_section_ptr
;
2446 sym
.st_shndx
= SHN_COMMON
;
2447 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2450 case bfd_link_hash_indirect
:
2451 case bfd_link_hash_warning
:
2452 /* I have no idea how these should be handled. */
2456 /* If this symbol should be put in the .dynsym section, then put it
2457 there now. We have already know the symbol index. We also fill
2458 in the entry in the .hash section. */
2459 if (h
->dynindx
!= -1
2460 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2462 struct elf_backend_data
*bed
;
2465 bfd_byte
*bucketpos
;
2468 sym
.st_name
= h
->dynstr_index
;
2470 /* Give the processor backend a chance to tweak the symbol
2471 value, and also to finish up anything that needs to be done
2473 bed
= get_elf_backend_data (finfo
->output_bfd
);
2474 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2475 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2481 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2482 (char *) ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
2485 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2486 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2488 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2489 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2490 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2491 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2492 put_word (finfo
->output_bfd
, chain
,
2493 ((bfd_byte
*) finfo
->hash_sec
->contents
2494 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2497 /* If we're stripping it, then it was just a dynamic symbol, and
2498 there's nothing else to do. */
2502 h
->indx
= finfo
->output_bfd
->symcount
;
2504 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2513 /* Link an input file into the linker output file. This function
2514 handles all the sections and relocations of the input file at once.
2515 This is so that we only have to read the local symbols once, and
2516 don't have to keep them in memory. */
2519 elf_link_input_bfd (finfo
, input_bfd
)
2520 struct elf_final_link_info
*finfo
;
2523 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2524 bfd
*, asection
*, bfd_byte
*,
2525 Elf_Internal_Rela
*,
2526 Elf_Internal_Sym
*, asection
**));
2528 Elf_Internal_Shdr
*symtab_hdr
;
2531 Elf_External_Sym
*esym
;
2532 Elf_External_Sym
*esymend
;
2533 Elf_Internal_Sym
*isym
;
2535 asection
**ppsection
;
2538 output_bfd
= finfo
->output_bfd
;
2540 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2542 /* If this is a dynamic object, we don't want to do anything here:
2543 we don't want the local symbols, and we don't want the section
2545 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2548 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2549 if (elf_bad_symtab (input_bfd
))
2551 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2556 locsymcount
= symtab_hdr
->sh_info
;
2557 extsymoff
= symtab_hdr
->sh_info
;
2560 /* Read the local symbols. */
2562 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2563 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2564 locsymcount
, input_bfd
)
2565 != locsymcount
* sizeof (Elf_External_Sym
))))
2568 /* Swap in the local symbols and write out the ones which we know
2569 are going into the output file. */
2570 esym
= finfo
->external_syms
;
2571 esymend
= esym
+ locsymcount
;
2572 isym
= finfo
->internal_syms
;
2573 pindex
= finfo
->indices
;
2574 ppsection
= finfo
->sections
;
2575 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2579 Elf_Internal_Sym osym
;
2581 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2584 if (elf_bad_symtab (input_bfd
))
2586 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2593 if (isym
->st_shndx
== SHN_UNDEF
)
2594 isec
= bfd_und_section_ptr
;
2595 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2596 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2597 else if (isym
->st_shndx
== SHN_ABS
)
2598 isec
= bfd_abs_section_ptr
;
2599 else if (isym
->st_shndx
== SHN_COMMON
)
2600 isec
= bfd_com_section_ptr
;
2609 /* Don't output the first, undefined, symbol. */
2610 if (esym
== finfo
->external_syms
)
2613 /* If we are stripping all symbols, we don't want to output this
2615 if (finfo
->info
->strip
== strip_all
)
2618 /* We never output section symbols. Instead, we use the section
2619 symbol of the corresponding section in the output file. */
2620 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2623 /* If we are discarding all local symbols, we don't want to
2624 output this one. If we are generating a relocateable output
2625 file, then some of the local symbols may be required by
2626 relocs; we output them below as we discover that they are
2628 if (finfo
->info
->discard
== discard_all
)
2631 /* Get the name of the symbol. */
2632 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2637 /* See if we are discarding symbols with this name. */
2638 if ((finfo
->info
->strip
== strip_some
2639 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2641 || (finfo
->info
->discard
== discard_l
2642 && strncmp (name
, finfo
->info
->lprefix
,
2643 finfo
->info
->lprefix_len
) == 0))
2646 /* If we get here, we are going to output this symbol. */
2650 /* Adjust the section index for the output file. */
2651 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2652 isec
->output_section
);
2653 if (osym
.st_shndx
== (unsigned short) -1)
2656 *pindex
= output_bfd
->symcount
;
2658 /* ELF symbols in relocateable files are section relative, but
2659 in executable files they are virtual addresses. Note that
2660 this code assumes that all ELF sections have an associated
2661 BFD section with a reasonable value for output_offset; below
2662 we assume that they also have a reasonable value for
2663 output_section. Any special sections must be set up to meet
2664 these requirements. */
2665 osym
.st_value
+= isec
->output_offset
;
2666 if (! finfo
->info
->relocateable
)
2667 osym
.st_value
+= isec
->output_section
->vma
;
2669 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2673 /* Relocate the contents of each section. */
2674 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2676 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2679 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2680 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2682 /* Section was created by elf_link_create_dynamic_sections.
2683 FIXME: This test is fragile. */
2687 /* Read the contents of the section. */
2688 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2689 (file_ptr
) 0, o
->_raw_size
))
2692 if ((o
->flags
& SEC_RELOC
) != 0)
2694 Elf_Internal_Rela
*internal_relocs
;
2696 /* Get the swapped relocs. */
2697 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2698 finfo
->external_relocs
,
2699 finfo
->internal_relocs
,
2701 if (internal_relocs
== NULL
2702 && o
->reloc_count
> 0)
2705 /* Relocate the section by invoking a back end routine.
2707 The back end routine is responsible for adjusting the
2708 section contents as necessary, and (if using Rela relocs
2709 and generating a relocateable output file) adjusting the
2710 reloc addend as necessary.
2712 The back end routine does not have to worry about setting
2713 the reloc address or the reloc symbol index.
2715 The back end routine is given a pointer to the swapped in
2716 internal symbols, and can access the hash table entries
2717 for the external symbols via elf_sym_hashes (input_bfd).
2719 When generating relocateable output, the back end routine
2720 must handle STB_LOCAL/STT_SECTION symbols specially. The
2721 output symbol is going to be a section symbol
2722 corresponding to the output section, which will require
2723 the addend to be adjusted. */
2725 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2729 finfo
->internal_syms
,
2733 if (finfo
->info
->relocateable
)
2735 Elf_Internal_Rela
*irela
;
2736 Elf_Internal_Rela
*irelaend
;
2737 struct elf_link_hash_entry
**rel_hash
;
2738 Elf_Internal_Shdr
*input_rel_hdr
;
2739 Elf_Internal_Shdr
*output_rel_hdr
;
2741 /* Adjust the reloc addresses and symbol indices. */
2743 irela
= internal_relocs
;
2744 irelaend
= irela
+ o
->reloc_count
;
2745 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2746 + o
->output_section
->reloc_count
);
2747 for (; irela
< irelaend
; irela
++, rel_hash
++)
2750 Elf_Internal_Sym
*isym
;
2753 irela
->r_offset
+= o
->output_offset
;
2755 r_symndx
= ELF_R_SYM (irela
->r_info
);
2760 if (r_symndx
>= locsymcount
2761 || (elf_bad_symtab (input_bfd
)
2762 && finfo
->sections
[r_symndx
] == NULL
))
2766 /* This is a reloc against a global symbol. We
2767 have not yet output all the local symbols, so
2768 we do not know the symbol index of any global
2769 symbol. We set the rel_hash entry for this
2770 reloc to point to the global hash table entry
2771 for this symbol. The symbol index is then
2772 set at the end of elf_bfd_final_link. */
2773 indx
= r_symndx
- extsymoff
;
2774 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2776 /* Setting the index to -2 tells
2777 elf_link_output_extsym that this symbol is
2779 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2780 (*rel_hash
)->indx
= -2;
2785 /* This is a reloc against a local symbol. */
2788 isym
= finfo
->internal_syms
+ r_symndx
;
2789 sec
= finfo
->sections
[r_symndx
];
2790 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2792 /* I suppose the backend ought to fill in the
2793 section of any STT_SECTION symbol against a
2794 processor specific section. */
2795 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2797 else if (sec
== NULL
|| sec
->owner
== NULL
)
2799 bfd_set_error (bfd_error_bad_value
);
2804 r_symndx
= sec
->output_section
->target_index
;
2805 BFD_ASSERT (r_symndx
!= 0);
2810 if (finfo
->indices
[r_symndx
] == -1)
2816 if (finfo
->info
->strip
== strip_all
)
2818 /* You can't do ld -r -s. */
2819 bfd_set_error (bfd_error_invalid_operation
);
2823 /* This symbol was skipped earlier, but
2824 since it is needed by a reloc, we
2825 must output it now. */
2826 link
= symtab_hdr
->sh_link
;
2827 name
= bfd_elf_string_from_elf_section (input_bfd
,
2833 osec
= sec
->output_section
;
2835 _bfd_elf_section_from_bfd_section (output_bfd
,
2837 if (isym
->st_shndx
== (unsigned short) -1)
2840 isym
->st_value
+= sec
->output_offset
;
2841 if (! finfo
->info
->relocateable
)
2842 isym
->st_value
+= osec
->vma
;
2844 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2846 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2850 r_symndx
= finfo
->indices
[r_symndx
];
2853 irela
->r_info
= ELF_R_INFO (r_symndx
,
2854 ELF_R_TYPE (irela
->r_info
));
2857 /* Swap out the relocs. */
2858 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2859 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2860 BFD_ASSERT (output_rel_hdr
->sh_entsize
2861 == input_rel_hdr
->sh_entsize
);
2862 irela
= internal_relocs
;
2863 irelaend
= irela
+ o
->reloc_count
;
2864 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2866 Elf_External_Rel
*erel
;
2868 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2869 + o
->output_section
->reloc_count
);
2870 for (; irela
< irelaend
; irela
++, erel
++)
2872 Elf_Internal_Rel irel
;
2874 irel
.r_offset
= irela
->r_offset
;
2875 irel
.r_info
= irela
->r_info
;
2876 BFD_ASSERT (irela
->r_addend
== 0);
2877 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
2882 Elf_External_Rela
*erela
;
2884 BFD_ASSERT (input_rel_hdr
->sh_entsize
2885 == sizeof (Elf_External_Rela
));
2886 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
2887 + o
->output_section
->reloc_count
);
2888 for (; irela
< irelaend
; irela
++, erela
++)
2889 elf_swap_reloca_out (output_bfd
, irela
, erela
);
2892 o
->output_section
->reloc_count
+= o
->reloc_count
;
2896 /* Write out the modified section contents. */
2897 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2898 finfo
->contents
, o
->output_offset
,
2899 (o
->_cooked_size
!= 0
2908 /* Generate a reloc when linking an ELF file. This is a reloc
2909 requested by the linker, and does come from any input file. This
2910 is used to build constructor and destructor tables when linking
2914 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
2916 struct bfd_link_info
*info
;
2917 asection
*output_section
;
2918 struct bfd_link_order
*link_order
;
2920 reloc_howto_type
*howto
;
2923 struct elf_link_hash_entry
**rel_hash_ptr
;
2924 Elf_Internal_Shdr
*rel_hdr
;
2926 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2929 bfd_set_error (bfd_error_bad_value
);
2933 /* If this is an inplace reloc, we must write the addend into the
2935 if (howto
->partial_inplace
2936 && link_order
->u
.reloc
.p
->addend
!= 0)
2939 bfd_reloc_status_type rstat
;
2943 size
= bfd_get_reloc_size (howto
);
2944 buf
= (bfd_byte
*) bfd_zmalloc (size
);
2945 if (buf
== (bfd_byte
*) NULL
)
2947 bfd_set_error (bfd_error_no_memory
);
2950 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
2951 link_order
->u
.reloc
.p
->addend
, buf
);
2957 case bfd_reloc_outofrange
:
2959 case bfd_reloc_overflow
:
2960 if (! ((*info
->callbacks
->reloc_overflow
)
2962 (link_order
->type
== bfd_section_reloc_link_order
2963 ? bfd_section_name (output_bfd
,
2964 link_order
->u
.reloc
.p
->u
.section
)
2965 : link_order
->u
.reloc
.p
->u
.name
),
2966 howto
->name
, link_order
->u
.reloc
.p
->addend
,
2967 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
2974 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
2975 (file_ptr
) link_order
->offset
, size
);
2981 /* Figure out the symbol index. */
2982 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
2983 + output_section
->reloc_count
);
2984 if (link_order
->type
== bfd_section_reloc_link_order
)
2986 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
2987 BFD_ASSERT (indx
!= 0);
2988 *rel_hash_ptr
= NULL
;
2992 struct elf_link_hash_entry
*h
;
2994 h
= elf_link_hash_lookup (elf_hash_table (info
),
2995 link_order
->u
.reloc
.p
->u
.name
,
2996 false, false, true);
2999 /* Setting the index to -2 tells elf_link_output_extsym that
3000 this symbol is used by a reloc. */
3007 if (! ((*info
->callbacks
->unattached_reloc
)
3008 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3009 (asection
*) NULL
, (bfd_vma
) 0)))
3015 /* The address of a reloc is relative to the section in a
3016 relocateable file, and is a virtual address in an executable
3018 offset
= link_order
->offset
;
3019 if (! info
->relocateable
)
3020 offset
+= output_section
->vma
;
3022 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3024 if (rel_hdr
->sh_type
== SHT_REL
)
3026 Elf_Internal_Rel irel
;
3027 Elf_External_Rel
*erel
;
3029 irel
.r_offset
= offset
;
3030 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3031 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3032 + output_section
->reloc_count
);
3033 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3037 Elf_Internal_Rela irela
;
3038 Elf_External_Rela
*erela
;
3040 irela
.r_offset
= offset
;
3041 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3042 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
3043 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3044 + output_section
->reloc_count
);
3045 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3048 ++output_section
->reloc_count
;