2 Copyright 1995 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 static boolean elf_link_add_object_symbols
23 PARAMS ((bfd
*, struct bfd_link_info
*));
24 static boolean elf_link_add_archive_symbols
25 PARAMS ((bfd
*, struct bfd_link_info
*));
26 static Elf_Internal_Rela
*elf_link_read_relocs
27 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
28 static boolean elf_export_symbol
29 PARAMS ((struct elf_link_hash_entry
*, PTR
));
30 static boolean elf_adjust_dynamic_symbol
31 PARAMS ((struct elf_link_hash_entry
*, PTR
));
33 /* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
36 struct elf_info_failed
39 struct bfd_link_info
*info
;
42 /* Given an ELF BFD, add symbols to the global hash table as
46 elf_bfd_link_add_symbols (abfd
, info
)
48 struct bfd_link_info
*info
;
50 switch (bfd_get_format (abfd
))
53 return elf_link_add_object_symbols (abfd
, info
);
55 return elf_link_add_archive_symbols (abfd
, info
);
57 bfd_set_error (bfd_error_wrong_format
);
62 /* Add symbols from an ELF archive file to the linker hash table. We
63 don't use _bfd_generic_link_add_archive_symbols because of a
64 problem which arises on UnixWare. The UnixWare libc.so is an
65 archive which includes an entry libc.so.1 which defines a bunch of
66 symbols. The libc.so archive also includes a number of other
67 object files, which also define symbols, some of which are the same
68 as those defined in libc.so.1. Correct linking requires that we
69 consider each object file in turn, and include it if it defines any
70 symbols we need. _bfd_generic_link_add_archive_symbols does not do
71 this; it looks through the list of undefined symbols, and includes
72 any object file which defines them. When this algorithm is used on
73 UnixWare, it winds up pulling in libc.so.1 early and defining a
74 bunch of symbols. This means that some of the other objects in the
75 archive are not included in the link, which is incorrect since they
76 precede libc.so.1 in the archive.
78 Fortunately, ELF archive handling is simpler than that done by
79 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
80 oddities. In ELF, if we find a symbol in the archive map, and the
81 symbol is currently undefined, we know that we must pull in that
84 Unfortunately, we do have to make multiple passes over the symbol
85 table until nothing further is resolved. */
88 elf_link_add_archive_symbols (abfd
, info
)
90 struct bfd_link_info
*info
;
93 boolean
*defined
= NULL
;
94 boolean
*included
= NULL
;
98 if (! bfd_has_map (abfd
))
100 /* An empty archive is a special case. */
101 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
103 bfd_set_error (bfd_error_no_armap
);
107 /* Keep track of all symbols we know to be already defined, and all
108 files we know to be already included. This is to speed up the
109 second and subsequent passes. */
110 c
= bfd_ardata (abfd
)->symdef_count
;
113 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
114 included
= (boolean
*) malloc (c
* sizeof (boolean
));
115 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
117 bfd_set_error (bfd_error_no_memory
);
120 memset (defined
, 0, c
* sizeof (boolean
));
121 memset (included
, 0, c
* sizeof (boolean
));
123 symdefs
= bfd_ardata (abfd
)->symdefs
;
136 symdefend
= symdef
+ c
;
137 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
139 struct elf_link_hash_entry
*h
;
141 struct bfd_link_hash_entry
*undefs_tail
;
144 if (defined
[i
] || included
[i
])
146 if (symdef
->file_offset
== last
)
152 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
153 false, false, false);
154 if (h
== (struct elf_link_hash_entry
*) NULL
)
156 if (h
->root
.type
!= bfd_link_hash_undefined
)
158 if (h
->root
.type
!= bfd_link_hash_undefweak
)
163 /* We need to include this archive member. */
165 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
166 if (element
== (bfd
*) NULL
)
169 if (! bfd_check_format (element
, bfd_object
))
172 /* Doublecheck that we have not included this object
173 already--it should be impossible, but there may be
174 something wrong with the archive. */
175 if (element
->archive_pass
!= 0)
177 bfd_set_error (bfd_error_bad_value
);
180 element
->archive_pass
= 1;
182 undefs_tail
= info
->hash
->undefs_tail
;
184 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
187 if (! elf_link_add_object_symbols (element
, info
))
190 /* If there are any new undefined symbols, we need to make
191 another pass through the archive in order to see whether
192 they can be defined. FIXME: This isn't perfect, because
193 common symbols wind up on undefs_tail and because an
194 undefined symbol which is defined later on in this pass
195 does not require another pass. This isn't a bug, but it
196 does make the code less efficient than it could be. */
197 if (undefs_tail
!= info
->hash
->undefs_tail
)
200 /* Look backward to mark all symbols from this object file
201 which we have already seen in this pass. */
205 included
[mark
] = true;
210 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
212 /* We mark subsequent symbols from this object file as we go
213 on through the loop. */
214 last
= symdef
->file_offset
;
225 if (defined
!= (boolean
*) NULL
)
227 if (included
!= (boolean
*) NULL
)
232 /* Add symbols from an ELF object file to the linker hash table. */
235 elf_link_add_object_symbols (abfd
, info
)
237 struct bfd_link_info
*info
;
239 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
240 const Elf_Internal_Sym
*,
241 const char **, flagword
*,
242 asection
**, bfd_vma
*));
243 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
244 asection
*, const Elf_Internal_Rela
*));
246 Elf_Internal_Shdr
*hdr
;
250 Elf_External_Sym
*buf
= NULL
;
251 struct elf_link_hash_entry
**sym_hash
;
253 Elf_External_Dyn
*dynbuf
= NULL
;
254 struct elf_link_hash_entry
*weaks
;
255 Elf_External_Sym
*esym
;
256 Elf_External_Sym
*esymend
;
258 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
259 collect
= get_elf_backend_data (abfd
)->collect
;
261 /* A stripped shared library might only have a dynamic symbol table,
262 not a regular symbol table. In that case we can still go ahead
263 and link using the dynamic symbol table. */
264 if (elf_onesymtab (abfd
) == 0
265 && elf_dynsymtab (abfd
) != 0)
267 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
268 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
271 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
272 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
274 /* The sh_info field of the symtab header tells us where the
275 external symbols start. We don't care about the local symbols at
277 if (elf_bad_symtab (abfd
))
279 extsymcount
= symcount
;
284 extsymcount
= symcount
- hdr
->sh_info
;
285 extsymoff
= hdr
->sh_info
;
288 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
289 if (buf
== NULL
&& extsymcount
!= 0)
291 bfd_set_error (bfd_error_no_memory
);
295 /* We store a pointer to the hash table entry for each external
297 sym_hash
= ((struct elf_link_hash_entry
**)
299 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
300 if (sym_hash
== NULL
)
302 bfd_set_error (bfd_error_no_memory
);
305 elf_sym_hashes (abfd
) = sym_hash
;
307 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
311 /* If we are creating a shared library, create all the dynamic
312 sections immediately. We need to attach them to something,
313 so we attach them to this BFD, provided it is the right
314 format. FIXME: If there are no input BFD's of the same
315 format as the output, we can't make a shared library. */
317 && ! elf_hash_table (info
)->dynamic_sections_created
318 && abfd
->xvec
== info
->hash
->creator
)
320 if (! elf_link_create_dynamic_sections (abfd
, info
))
329 bfd_size_type oldsize
;
330 bfd_size_type strindex
;
334 /* You can't use -r against a dynamic object. Also, there's no
335 hope of using a dynamic object which does not exactly match
336 the format of the output file. */
337 if (info
->relocateable
338 || info
->hash
->creator
!= abfd
->xvec
)
340 bfd_set_error (bfd_error_invalid_operation
);
344 /* Find the name to use in a DT_NEEDED entry that refers to this
345 object. If the object has a DT_SONAME entry, we use it.
346 Otherwise, if the generic linker stuck something in
347 elf_dt_needed_name, we use that. Otherwise, we just use the
348 file name. If the generic linker put a null string into
349 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
350 even if there is a DT_SONAME entry. */
352 name
= bfd_get_filename (abfd
);
353 if (elf_dt_needed_name (abfd
) != NULL
)
355 name
= elf_dt_needed_name (abfd
);
359 s
= bfd_get_section_by_name (abfd
, ".dynamic");
362 Elf_External_Dyn
*extdyn
;
363 Elf_External_Dyn
*extdynend
;
367 dynbuf
= (Elf_External_Dyn
*) malloc ((size_t) s
->_raw_size
);
370 bfd_set_error (bfd_error_no_memory
);
374 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
375 (file_ptr
) 0, s
->_raw_size
))
378 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
381 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
384 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
385 for (; extdyn
< extdynend
; extdyn
++)
387 Elf_Internal_Dyn dyn
;
389 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
390 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
392 name
= bfd_elf_string_from_elf_section (abfd
, link
,
397 if (dyn
.d_tag
== DT_NEEDED
)
399 struct bfd_elf_link_needed_list
*n
, **pn
;
402 n
= (struct bfd_elf_link_needed_list
*)
404 sizeof (struct bfd_elf_link_needed_list
));
405 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
407 if (n
== NULL
|| fnm
== NULL
)
409 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
416 for (pn
= &elf_hash_table (info
)->needed
;
428 /* We do not want to include any of the sections in a dynamic
429 object in the output file. We hack by simply clobbering the
430 list of sections in the BFD. This could be handled more
431 cleanly by, say, a new section flag; the existing
432 SEC_NEVER_LOAD flag is not the one we want, because that one
433 still implies that the section takes up space in the output
435 abfd
->sections
= NULL
;
437 /* If this is the first dynamic object found in the link, create
438 the special sections required for dynamic linking. */
439 if (! elf_hash_table (info
)->dynamic_sections_created
)
441 if (! elf_link_create_dynamic_sections (abfd
, info
))
447 /* Add a DT_NEEDED entry for this dynamic object. */
448 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
449 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
451 if (strindex
== (bfd_size_type
) -1)
454 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
457 Elf_External_Dyn
*dyncon
, *dynconend
;
459 /* The hash table size did not change, which means that
460 the dynamic object name was already entered. If we
461 have already included this dynamic object in the
462 link, just ignore it. There is no reason to include
463 a particular dynamic object more than once. */
464 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
466 BFD_ASSERT (sdyn
!= NULL
);
468 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
469 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
471 for (; dyncon
< dynconend
; dyncon
++)
473 Elf_Internal_Dyn dyn
;
475 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
477 if (dyn
.d_tag
== DT_NEEDED
478 && dyn
.d_un
.d_val
== strindex
)
487 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
493 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
495 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
496 != extsymcount
* sizeof (Elf_External_Sym
)))
501 esymend
= buf
+ extsymcount
;
502 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
504 Elf_Internal_Sym sym
;
510 struct elf_link_hash_entry
*h
= NULL
;
514 elf_swap_symbol_in (abfd
, esym
, &sym
);
516 flags
= BSF_NO_FLAGS
;
518 value
= sym
.st_value
;
521 bind
= ELF_ST_BIND (sym
.st_info
);
522 if (bind
== STB_LOCAL
)
524 /* This should be impossible, since ELF requires that all
525 global symbols follow all local symbols, and that sh_info
526 point to the first global symbol. Unfortunatealy, Irix 5
530 else if (bind
== STB_GLOBAL
)
532 if (sym
.st_shndx
!= SHN_UNDEF
533 && sym
.st_shndx
!= SHN_COMMON
)
538 else if (bind
== STB_WEAK
)
542 /* Leave it up to the processor backend. */
545 if (sym
.st_shndx
== SHN_UNDEF
)
546 sec
= bfd_und_section_ptr
;
547 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
549 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
553 sec
= bfd_abs_section_ptr
;
555 else if (sym
.st_shndx
== SHN_ABS
)
556 sec
= bfd_abs_section_ptr
;
557 else if (sym
.st_shndx
== SHN_COMMON
)
559 sec
= bfd_com_section_ptr
;
560 /* What ELF calls the size we call the value. What ELF
561 calls the value we call the alignment. */
566 /* Leave it up to the processor backend. */
569 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
570 if (name
== (const char *) NULL
)
575 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
579 /* The hook function sets the name to NULL if this symbol
580 should be skipped for some reason. */
581 if (name
== (const char *) NULL
)
585 /* Sanity check that all possibilities were handled. */
586 if (sec
== (asection
*) NULL
)
588 bfd_set_error (bfd_error_bad_value
);
592 if (bfd_is_und_section (sec
)
593 || bfd_is_com_section (sec
))
598 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
600 /* We need to look up the symbol now in order to get some of
601 the dynamic object handling right. We pass the hash
602 table entry in to _bfd_generic_link_add_one_symbol so
603 that it does not have to look it up again. */
604 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
610 /* If we are looking at a dynamic object, and this is a
611 definition, we need to see if it has already been defined
612 by some other object. If it has, we want to use the
613 existing definition, and we do not want to report a
614 multiple symbol definition error; we do this by
615 clobbering sec to be bfd_und_section_ptr. */
616 if (dynamic
&& definition
)
618 if (h
->root
.type
== bfd_link_hash_defined
619 || h
->root
.type
== bfd_link_hash_defweak
)
620 sec
= bfd_und_section_ptr
;
623 /* Similarly, if we are not looking at a dynamic object, and
624 we have a definition, we want to override any definition
625 we may have from a dynamic object. Symbols from regular
626 files always take precedence over symbols from dynamic
627 objects, even if they are defined after the dynamic
628 object in the link. */
631 && (h
->root
.type
== bfd_link_hash_defined
632 || h
->root
.type
== bfd_link_hash_defweak
)
633 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
634 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
635 == bfd_target_elf_flavour
)
636 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
639 /* Change the hash table entry to undefined, and let
640 _bfd_generic_link_add_one_symbol do the right thing
641 with the new definition. */
642 h
->root
.type
= bfd_link_hash_undefined
;
643 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
647 if (! (_bfd_generic_link_add_one_symbol
648 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
649 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
655 && (flags
& BSF_WEAK
) != 0
656 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
657 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
658 && (*sym_hash
)->weakdef
== NULL
)
660 /* Keep a list of all weak defined non function symbols from
661 a dynamic object, using the weakdef field. Later in this
662 function we will set the weakdef field to the correct
663 value. We only put non-function symbols from dynamic
664 objects on this list, because that happens to be the only
665 time we need to know the normal symbol corresponding to a
666 weak symbol, and the information is time consuming to
667 figure out. If the weakdef field is not already NULL,
668 then this symbol was already defined by some previous
669 dynamic object, and we will be using that previous
670 definition anyhow. */
672 (*sym_hash
)->weakdef
= weaks
;
677 /* Get the alignment of a common symbol. */
678 if (sym
.st_shndx
== SHN_COMMON
679 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
680 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
682 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
688 /* Remember the symbol size and type. */
689 if (sym
.st_size
!= 0)
691 /* FIXME: We should probably somehow give a warning if
692 the symbol size changes. */
693 h
->size
= sym
.st_size
;
695 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
697 /* FIXME: We should probably somehow give a warning if
698 the symbol type changes. */
699 h
->type
= ELF_ST_TYPE (sym
.st_info
);
702 /* Set a flag in the hash table entry indicating the type of
703 reference or definition we just found. Keep a count of
704 the number of dynamic symbols we find. A dynamic symbol
705 is one which is referenced or defined by both a regular
706 object and a shared object, or one which is referenced or
707 defined by more than one shared object. */
708 old_flags
= h
->elf_link_hash_flags
;
713 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
715 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
717 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
718 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
724 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
726 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
727 if ((old_flags
& new_flag
) != 0
728 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
729 | ELF_LINK_HASH_REF_REGULAR
)) != 0
730 || (h
->weakdef
!= NULL
731 && (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
732 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0))
736 h
->elf_link_hash_flags
|= new_flag
;
737 if (dynsym
&& h
->dynindx
== -1)
739 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
741 if (h
->weakdef
!= NULL
743 && h
->weakdef
->dynindx
== -1)
745 if (! _bfd_elf_link_record_dynamic_symbol (info
,
753 /* Now set the weakdefs field correctly for all the weak defined
754 symbols we found. The only way to do this is to search all the
755 symbols. Since we only need the information for non functions in
756 dynamic objects, that's the only time we actually put anything on
757 the list WEAKS. We need this information so that if a regular
758 object refers to a symbol defined weakly in a dynamic object, the
759 real symbol in the dynamic object is also put in the dynamic
760 symbols; we also must arrange for both symbols to point to the
761 same memory location. We could handle the general case of symbol
762 aliasing, but a general symbol alias can only be generated in
763 assembler code, handling it correctly would be very time
764 consuming, and other ELF linkers don't handle general aliasing
766 while (weaks
!= NULL
)
768 struct elf_link_hash_entry
*hlook
;
771 struct elf_link_hash_entry
**hpp
;
772 struct elf_link_hash_entry
**hppend
;
775 weaks
= hlook
->weakdef
;
776 hlook
->weakdef
= NULL
;
778 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
779 || hlook
->root
.type
== bfd_link_hash_defweak
780 || hlook
->root
.type
== bfd_link_hash_common
781 || hlook
->root
.type
== bfd_link_hash_indirect
);
782 slook
= hlook
->root
.u
.def
.section
;
783 vlook
= hlook
->root
.u
.def
.value
;
785 hpp
= elf_sym_hashes (abfd
);
786 hppend
= hpp
+ extsymcount
;
787 for (; hpp
< hppend
; hpp
++)
789 struct elf_link_hash_entry
*h
;
792 if (h
!= NULL
&& h
!= hlook
793 && (h
->root
.type
== bfd_link_hash_defined
794 || h
->root
.type
== bfd_link_hash_defweak
)
795 && h
->root
.u
.def
.section
== slook
796 && h
->root
.u
.def
.value
== vlook
)
800 /* If the weak definition is in the list of dynamic
801 symbols, make sure the real definition is put there
803 if (hlook
->dynindx
!= -1
806 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
821 /* If this object is the same format as the output object, and it is
822 not a shared library, then let the backend look through the
825 This is required to build global offset table entries and to
826 arrange for dynamic relocs. It is not required for the
827 particular common case of linking non PIC code, even when linking
828 against shared libraries, but unfortunately there is no way of
829 knowing whether an object file has been compiled PIC or not.
830 Looking through the relocs is not particularly time consuming.
831 The problem is that we must either (1) keep the relocs in memory,
832 which causes the linker to require additional runtime memory or
833 (2) read the relocs twice from the input file, which wastes time.
834 This would be a good case for using mmap.
836 I have no idea how to handle linking PIC code into a file of a
837 different format. It probably can't be done. */
838 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
840 && abfd
->xvec
== info
->hash
->creator
841 && check_relocs
!= NULL
)
845 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
847 Elf_Internal_Rela
*internal_relocs
;
850 if ((o
->flags
& SEC_RELOC
) == 0
851 || o
->reloc_count
== 0)
854 /* I believe we can ignore the relocs for any section which
855 does not form part of the final process image, such as a
856 debugging section. */
857 if ((o
->flags
& SEC_ALLOC
) == 0)
860 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
861 (Elf_Internal_Rela
*) NULL
,
863 if (internal_relocs
== NULL
)
866 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
868 if (! info
->keep_memory
)
869 free (internal_relocs
);
886 /* Create some sections which will be filled in with dynamic linking
887 information. ABFD is an input file which requires dynamic sections
888 to be created. The dynamic sections take up virtual memory space
889 when the final executable is run, so we need to create them before
890 addresses are assigned to the output sections. We work out the
891 actual contents and size of these sections later. */
894 elf_link_create_dynamic_sections (abfd
, info
)
896 struct bfd_link_info
*info
;
899 register asection
*s
;
900 struct elf_link_hash_entry
*h
;
901 struct elf_backend_data
*bed
;
903 if (elf_hash_table (info
)->dynamic_sections_created
)
906 /* Make sure that all dynamic sections use the same input BFD. */
907 if (elf_hash_table (info
)->dynobj
== NULL
)
908 elf_hash_table (info
)->dynobj
= abfd
;
910 abfd
= elf_hash_table (info
)->dynobj
;
912 /* Note that we set the SEC_IN_MEMORY flag for all of these
914 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
916 /* A dynamically linked executable has a .interp section, but a
917 shared library does not. */
920 s
= bfd_make_section (abfd
, ".interp");
922 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
926 s
= bfd_make_section (abfd
, ".dynsym");
928 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
929 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
932 s
= bfd_make_section (abfd
, ".dynstr");
934 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
937 /* Create a strtab to hold the dynamic symbol names. */
938 if (elf_hash_table (info
)->dynstr
== NULL
)
940 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
941 if (elf_hash_table (info
)->dynstr
== NULL
)
945 s
= bfd_make_section (abfd
, ".dynamic");
947 || ! bfd_set_section_flags (abfd
, s
, flags
)
948 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
951 /* The special symbol _DYNAMIC is always set to the start of the
952 .dynamic section. This call occurs before we have processed the
953 symbols for any dynamic object, so we don't have to worry about
954 overriding a dynamic definition. We could set _DYNAMIC in a
955 linker script, but we only want to define it if we are, in fact,
956 creating a .dynamic section. We don't want to define it if there
957 is no .dynamic section, since on some ELF platforms the start up
958 code examines it to decide how to initialize the process. */
960 if (! (_bfd_generic_link_add_one_symbol
961 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
962 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
963 (struct bfd_link_hash_entry
**) &h
)))
965 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
966 h
->type
= STT_OBJECT
;
969 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
972 s
= bfd_make_section (abfd
, ".hash");
974 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
975 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
978 /* Let the backend create the rest of the sections. This lets the
979 backend set the right flags. The backend will normally create
980 the .got and .plt sections. */
981 bed
= get_elf_backend_data (abfd
);
982 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
985 elf_hash_table (info
)->dynamic_sections_created
= true;
990 /* Add an entry to the .dynamic table. */
993 elf_add_dynamic_entry (info
, tag
, val
)
994 struct bfd_link_info
*info
;
998 Elf_Internal_Dyn dyn
;
1002 bfd_byte
*newcontents
;
1004 dynobj
= elf_hash_table (info
)->dynobj
;
1006 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1007 BFD_ASSERT (s
!= NULL
);
1009 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
1010 if (s
->contents
== NULL
)
1011 newcontents
= (bfd_byte
*) malloc (newsize
);
1013 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
1014 if (newcontents
== NULL
)
1016 bfd_set_error (bfd_error_no_memory
);
1021 dyn
.d_un
.d_val
= val
;
1022 elf_swap_dyn_out (dynobj
, &dyn
,
1023 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1025 s
->_raw_size
= newsize
;
1026 s
->contents
= newcontents
;
1031 /* Read and swap the relocs for a section. They may have been cached.
1032 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1033 they are used as buffers to read into. They are known to be large
1034 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1035 value is allocated using either malloc or bfd_alloc, according to
1036 the KEEP_MEMORY argument. */
1038 static Elf_Internal_Rela
*
1039 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1042 PTR external_relocs
;
1043 Elf_Internal_Rela
*internal_relocs
;
1044 boolean keep_memory
;
1046 Elf_Internal_Shdr
*rel_hdr
;
1048 Elf_Internal_Rela
*alloc2
= NULL
;
1050 if (elf_section_data (o
)->relocs
!= NULL
)
1051 return elf_section_data (o
)->relocs
;
1053 if (o
->reloc_count
== 0)
1056 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1058 if (internal_relocs
== NULL
)
1062 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1064 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1066 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
1067 if (internal_relocs
== NULL
)
1069 bfd_set_error (bfd_error_no_memory
);
1074 if (external_relocs
== NULL
)
1076 alloc1
= (PTR
) malloc ((size_t) rel_hdr
->sh_size
);
1079 bfd_set_error (bfd_error_no_memory
);
1082 external_relocs
= alloc1
;
1085 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1086 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1087 != rel_hdr
->sh_size
))
1090 /* Swap in the relocs. For convenience, we always produce an
1091 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1093 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1095 Elf_External_Rel
*erel
;
1096 Elf_External_Rel
*erelend
;
1097 Elf_Internal_Rela
*irela
;
1099 erel
= (Elf_External_Rel
*) external_relocs
;
1100 erelend
= erel
+ o
->reloc_count
;
1101 irela
= internal_relocs
;
1102 for (; erel
< erelend
; erel
++, irela
++)
1104 Elf_Internal_Rel irel
;
1106 elf_swap_reloc_in (abfd
, erel
, &irel
);
1107 irela
->r_offset
= irel
.r_offset
;
1108 irela
->r_info
= irel
.r_info
;
1109 irela
->r_addend
= 0;
1114 Elf_External_Rela
*erela
;
1115 Elf_External_Rela
*erelaend
;
1116 Elf_Internal_Rela
*irela
;
1118 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1120 erela
= (Elf_External_Rela
*) external_relocs
;
1121 erelaend
= erela
+ o
->reloc_count
;
1122 irela
= internal_relocs
;
1123 for (; erela
< erelaend
; erela
++, irela
++)
1124 elf_swap_reloca_in (abfd
, erela
, irela
);
1127 /* Cache the results for next time, if we can. */
1129 elf_section_data (o
)->relocs
= internal_relocs
;
1134 /* Don't free alloc2, since if it was allocated we are passing it
1135 back (under the name of internal_relocs). */
1137 return internal_relocs
;
1147 /* Record an assignment to a symbol made by a linker script. We need
1148 this in case some dynamic object refers to this symbol. */
1152 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1154 struct bfd_link_info
*info
;
1158 struct elf_link_hash_entry
*h
;
1160 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1163 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1167 /* If this symbol is being provided by the linker script, and it is
1168 currently defined by a dynamic object, but not by a regular
1169 object, then mark it as undefined so that the generic linker will
1170 force the correct value. */
1172 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1173 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1174 h
->root
.type
= bfd_link_hash_undefined
;
1176 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1177 h
->type
= STT_OBJECT
;
1179 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1180 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1182 && h
->dynindx
== -1)
1184 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1187 /* If this is a weak defined symbol, and we know a corresponding
1188 real symbol from the same dynamic object, make sure the real
1189 symbol is also made into a dynamic symbol. */
1190 if (h
->weakdef
!= NULL
1191 && h
->weakdef
->dynindx
== -1)
1193 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1201 /* Array used to determine the number of hash table buckets to use
1202 based on the number of symbols there are. If there are fewer than
1203 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1204 fewer than 37 we use 17 buckets, and so forth. We never use more
1205 than 521 buckets. */
1207 static const size_t elf_buckets
[] =
1209 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1212 /* Set up the sizes and contents of the ELF dynamic sections. This is
1213 called by the ELF linker emulation before_allocation routine. We
1214 must set the sizes of the sections before the linker sets the
1215 addresses of the various sections. */
1218 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1219 export_dynamic
, info
, sinterpptr
)
1223 boolean export_dynamic
;
1224 struct bfd_link_info
*info
;
1225 asection
**sinterpptr
;
1228 struct elf_backend_data
*bed
;
1232 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1235 dynobj
= elf_hash_table (info
)->dynobj
;
1237 /* If there were no dynamic objects in the link, there is nothing to
1242 /* If we are supposed to export all symbols into the dynamic symbol
1243 table (this is not the normal case), then do so. */
1246 struct elf_info_failed eif
;
1250 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1256 if (elf_hash_table (info
)->dynamic_sections_created
)
1258 struct elf_info_failed eif
;
1259 bfd_size_type strsize
;
1261 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1262 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1268 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1270 if (indx
== (bfd_size_type
) -1
1271 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1277 if (! elf_add_dynamic_entry (info
, DT_SYMBOLIC
, 0))
1285 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1287 if (indx
== (bfd_size_type
) -1
1288 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1292 /* Find all symbols which were defined in a dynamic object and make
1293 the backend pick a reasonable value for them. */
1296 elf_link_hash_traverse (elf_hash_table (info
),
1297 elf_adjust_dynamic_symbol
,
1302 /* Add some entries to the .dynamic section. We fill in some of the
1303 values later, in elf_bfd_final_link, but we must add the entries
1304 now so that we know the final size of the .dynamic section. */
1305 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1306 false, false) != NULL
)
1308 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1311 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1312 false, false) != NULL
)
1314 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1317 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1318 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1319 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1320 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1321 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1322 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1323 sizeof (Elf_External_Sym
)))
1327 /* The backend must work out the sizes of all the other dynamic
1329 bed
= get_elf_backend_data (output_bfd
);
1330 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1333 if (elf_hash_table (info
)->dynamic_sections_created
)
1338 size_t bucketcount
= 0;
1339 Elf_Internal_Sym isym
;
1341 /* Set the size of the .dynsym and .hash sections. We counted
1342 the number of dynamic symbols in elf_link_add_object_symbols.
1343 We will build the contents of .dynsym and .hash when we build
1344 the final symbol table, because until then we do not know the
1345 correct value to give the symbols. We built the .dynstr
1346 section as we went along in elf_link_add_object_symbols. */
1347 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1348 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1349 BFD_ASSERT (s
!= NULL
);
1350 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1351 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1352 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1354 bfd_set_error (bfd_error_no_memory
);
1358 /* The first entry in .dynsym is a dummy symbol. */
1365 elf_swap_symbol_out (output_bfd
, &isym
,
1366 (PTR
) (Elf_External_Sym
*) s
->contents
);
1368 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1370 bucketcount
= elf_buckets
[i
];
1371 if (dynsymcount
< elf_buckets
[i
+ 1])
1375 s
= bfd_get_section_by_name (dynobj
, ".hash");
1376 BFD_ASSERT (s
!= NULL
);
1377 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1378 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1379 if (s
->contents
== NULL
)
1381 bfd_set_error (bfd_error_no_memory
);
1384 memset (s
->contents
, 0, (size_t) s
->_raw_size
);
1386 put_word (output_bfd
, bucketcount
, s
->contents
);
1387 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1389 elf_hash_table (info
)->bucketcount
= bucketcount
;
1391 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1392 BFD_ASSERT (s
!= NULL
);
1393 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1395 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1402 /* This routine is used to export all defined symbols into the dynamic
1403 symbol table. It is called via elf_link_hash_traverse. */
1406 elf_export_symbol (h
, data
)
1407 struct elf_link_hash_entry
*h
;
1410 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1412 if (h
->dynindx
== -1
1413 && (h
->elf_link_hash_flags
1414 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1416 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1426 /* Make the backend pick a good value for a dynamic symbol. This is
1427 called via elf_link_hash_traverse, and also calls itself
1431 elf_adjust_dynamic_symbol (h
, data
)
1432 struct elf_link_hash_entry
*h
;
1435 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1437 struct elf_backend_data
*bed
;
1439 /* If -Bsymbolic was used (which means to bind references to global
1440 symbols to the definition within the shared object), and this
1441 symbol was defined in a regular object, then it actually doesn't
1442 need a PLT entry. */
1443 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1444 && eif
->info
->shared
1445 && eif
->info
->symbolic
1446 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1447 h
->elf_link_hash_flags
&=~ ELF_LINK_HASH_NEEDS_PLT
;
1449 /* If this symbol does not require a PLT entry, and it is not
1450 defined by a dynamic object, or is not referenced by a regular
1451 object, ignore it. We do have to handle a weak defined symbol,
1452 even if no regular object refers to it, if we decided to add it
1453 to the dynamic symbol table. FIXME: Do we normally need to worry
1454 about symbols which are defined by one dynamic object and
1455 referenced by another one? */
1456 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1457 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1458 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1459 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0
1460 && (h
->weakdef
== NULL
|| h
->weakdef
->dynindx
== -1))))
1463 /* If we've already adjusted this symbol, don't do it again. This
1464 can happen via a recursive call. */
1465 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1468 /* Don't look at this symbol again. Note that we must set this
1469 after checking the above conditions, because we may look at a
1470 symbol once, decide not to do anything, and then get called
1471 recursively later after REF_REGULAR is set below. */
1472 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1474 /* If this is a weak definition, and we know a real definition, and
1475 the real symbol is not itself defined by a regular object file,
1476 then get a good value for the real definition. We handle the
1477 real symbol first, for the convenience of the backend routine.
1479 Note that there is a confusing case here. If the real definition
1480 is defined by a regular object file, we don't get the real symbol
1481 from the dynamic object, but we do get the weak symbol. If the
1482 processor backend uses a COPY reloc, then if some routine in the
1483 dynamic object changes the real symbol, we will not see that
1484 change in the corresponding weak symbol. This is the way other
1485 ELF linkers work as well, and seems to be a result of the shared
1488 I will clarify this issue. Most SVR4 shared libraries define the
1489 variable _timezone and define timezone as a weak synonym. The
1490 tzset call changes _timezone. If you write
1491 extern int timezone;
1493 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1494 you might expect that, since timezone is a synonym for _timezone,
1495 the same number will print both times. However, if the processor
1496 backend uses a COPY reloc, then actually timezone will be copied
1497 into your process image, and, since you define _timezone
1498 yourself, _timezone will not. Thus timezone and _timezone will
1499 wind up at different memory locations. The tzset call will set
1500 _timezone, leaving timezone unchanged. */
1502 if (h
->weakdef
!= NULL
)
1504 struct elf_link_hash_entry
*weakdef
;
1506 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1507 || h
->root
.type
== bfd_link_hash_defweak
);
1508 weakdef
= h
->weakdef
;
1509 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1510 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1511 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1512 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1514 /* This symbol is defined by a regular object file, so we
1515 will not do anything special. Clear weakdef for the
1516 convenience of the processor backend. */
1521 /* There is an implicit reference by a regular object file
1522 via the weak symbol. */
1523 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1524 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1529 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1530 bed
= get_elf_backend_data (dynobj
);
1531 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1540 /* Final phase of ELF linker. */
1542 /* A structure we use to avoid passing large numbers of arguments. */
1544 struct elf_final_link_info
1546 /* General link information. */
1547 struct bfd_link_info
*info
;
1550 /* Symbol string table. */
1551 struct bfd_strtab_hash
*symstrtab
;
1552 /* .dynsym section. */
1553 asection
*dynsym_sec
;
1554 /* .hash section. */
1556 /* Buffer large enough to hold contents of any section. */
1558 /* Buffer large enough to hold external relocs of any section. */
1559 PTR external_relocs
;
1560 /* Buffer large enough to hold internal relocs of any section. */
1561 Elf_Internal_Rela
*internal_relocs
;
1562 /* Buffer large enough to hold external local symbols of any input
1564 Elf_External_Sym
*external_syms
;
1565 /* Buffer large enough to hold internal local symbols of any input
1567 Elf_Internal_Sym
*internal_syms
;
1568 /* Array large enough to hold a symbol index for each local symbol
1569 of any input BFD. */
1571 /* Array large enough to hold a section pointer for each local
1572 symbol of any input BFD. */
1573 asection
**sections
;
1574 /* Buffer to hold swapped out symbols. */
1575 Elf_External_Sym
*symbuf
;
1576 /* Number of swapped out symbols in buffer. */
1577 size_t symbuf_count
;
1578 /* Number of symbols which fit in symbuf. */
1582 static boolean elf_link_output_sym
1583 PARAMS ((struct elf_final_link_info
*, const char *,
1584 Elf_Internal_Sym
*, asection
*));
1585 static boolean elf_link_flush_output_syms
1586 PARAMS ((struct elf_final_link_info
*));
1587 static boolean elf_link_output_extsym
1588 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1589 static boolean elf_link_input_bfd
1590 PARAMS ((struct elf_final_link_info
*, bfd
*));
1591 static boolean elf_reloc_link_order
1592 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1593 struct bfd_link_order
*));
1595 /* This struct is used to pass information to routines called via
1596 elf_link_hash_traverse which must return failure. */
1598 struct elf_finfo_failed
1601 struct elf_final_link_info
*finfo
;
1604 /* Do the final step of an ELF link. */
1607 elf_bfd_final_link (abfd
, info
)
1609 struct bfd_link_info
*info
;
1613 struct elf_final_link_info finfo
;
1614 register asection
*o
;
1615 register struct bfd_link_order
*p
;
1617 size_t max_contents_size
;
1618 size_t max_external_reloc_size
;
1619 size_t max_internal_reloc_count
;
1620 size_t max_sym_count
;
1622 Elf_Internal_Sym elfsym
;
1624 Elf_Internal_Shdr
*symtab_hdr
;
1625 Elf_Internal_Shdr
*symstrtab_hdr
;
1626 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1627 struct elf_finfo_failed eif
;
1630 abfd
->flags
|= DYNAMIC
;
1632 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1633 dynobj
= elf_hash_table (info
)->dynobj
;
1636 finfo
.output_bfd
= abfd
;
1637 finfo
.symstrtab
= elf_stringtab_init ();
1638 if (finfo
.symstrtab
== NULL
)
1642 finfo
.dynsym_sec
= NULL
;
1643 finfo
.hash_sec
= NULL
;
1647 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1648 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1649 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1651 finfo
.contents
= NULL
;
1652 finfo
.external_relocs
= NULL
;
1653 finfo
.internal_relocs
= NULL
;
1654 finfo
.external_syms
= NULL
;
1655 finfo
.internal_syms
= NULL
;
1656 finfo
.indices
= NULL
;
1657 finfo
.sections
= NULL
;
1658 finfo
.symbuf
= NULL
;
1659 finfo
.symbuf_count
= 0;
1661 /* Count up the number of relocations we will output for each output
1662 section, so that we know the sizes of the reloc sections. We
1663 also figure out some maximum sizes. */
1664 max_contents_size
= 0;
1665 max_external_reloc_size
= 0;
1666 max_internal_reloc_count
= 0;
1668 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1672 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1674 if (p
->type
== bfd_section_reloc_link_order
1675 || p
->type
== bfd_symbol_reloc_link_order
)
1677 else if (p
->type
== bfd_indirect_link_order
)
1681 sec
= p
->u
.indirect
.section
;
1683 if (info
->relocateable
)
1684 o
->reloc_count
+= sec
->reloc_count
;
1686 if (sec
->_raw_size
> max_contents_size
)
1687 max_contents_size
= sec
->_raw_size
;
1688 if (sec
->_cooked_size
> max_contents_size
)
1689 max_contents_size
= sec
->_cooked_size
;
1691 /* We are interested in just local symbols, not all
1693 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1697 if (elf_bad_symtab (sec
->owner
))
1698 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1699 / sizeof (Elf_External_Sym
));
1701 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1703 if (sym_count
> max_sym_count
)
1704 max_sym_count
= sym_count
;
1706 if ((sec
->flags
& SEC_RELOC
) != 0)
1710 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1711 if (ext_size
> max_external_reloc_size
)
1712 max_external_reloc_size
= ext_size
;
1713 if (sec
->reloc_count
> max_internal_reloc_count
)
1714 max_internal_reloc_count
= sec
->reloc_count
;
1720 if (o
->reloc_count
> 0)
1721 o
->flags
|= SEC_RELOC
;
1724 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1725 set it (this is probably a bug) and if it is set
1726 assign_section_numbers will create a reloc section. */
1727 o
->flags
&=~ SEC_RELOC
;
1730 /* If the SEC_ALLOC flag is not set, force the section VMA to
1731 zero. This is done in elf_fake_sections as well, but forcing
1732 the VMA to 0 here will ensure that relocs against these
1733 sections are handled correctly. */
1734 if ((o
->flags
& SEC_ALLOC
) == 0)
1738 /* Figure out the file positions for everything but the symbol table
1739 and the relocs. We set symcount to force assign_section_numbers
1740 to create a symbol table. */
1741 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1742 BFD_ASSERT (! abfd
->output_has_begun
);
1743 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1746 /* That created the reloc sections. Set their sizes, and assign
1747 them file positions, and allocate some buffers. */
1748 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1750 if ((o
->flags
& SEC_RELOC
) != 0)
1752 Elf_Internal_Shdr
*rel_hdr
;
1753 register struct elf_link_hash_entry
**p
, **pend
;
1755 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1757 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1759 /* The contents field must last into write_object_contents,
1760 so we allocate it with bfd_alloc rather than malloc. */
1761 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1762 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1764 bfd_set_error (bfd_error_no_memory
);
1768 p
= ((struct elf_link_hash_entry
**)
1769 malloc (o
->reloc_count
1770 * sizeof (struct elf_link_hash_entry
*)));
1771 if (p
== NULL
&& o
->reloc_count
!= 0)
1773 bfd_set_error (bfd_error_no_memory
);
1776 elf_section_data (o
)->rel_hashes
= p
;
1777 pend
= p
+ o
->reloc_count
;
1778 for (; p
< pend
; p
++)
1781 /* Use the reloc_count field as an index when outputting the
1787 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1789 /* We have now assigned file positions for all the sections except
1790 .symtab and .strtab. We start the .symtab section at the current
1791 file position, and write directly to it. We build the .strtab
1792 section in memory. When we add .dynsym support, we will build
1793 that in memory as well (.dynsym is smaller than .symtab). */
1795 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1796 /* sh_name is set in prep_headers. */
1797 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1798 symtab_hdr
->sh_flags
= 0;
1799 symtab_hdr
->sh_addr
= 0;
1800 symtab_hdr
->sh_size
= 0;
1801 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1802 /* sh_link is set in assign_section_numbers. */
1803 /* sh_info is set below. */
1804 /* sh_offset is set just below. */
1805 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1807 off
= elf_tdata (abfd
)->next_file_pos
;
1808 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1810 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1811 incorrect. We do not yet know the size of the .symtab section.
1812 We correct next_file_pos below, after we do know the size. */
1814 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1815 continuously seeking to the right position in the file. */
1816 if (! info
->keep_memory
|| max_sym_count
< 20)
1817 finfo
.symbuf_size
= 20;
1819 finfo
.symbuf_size
= max_sym_count
;
1820 finfo
.symbuf
= ((Elf_External_Sym
*)
1821 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1822 if (finfo
.symbuf
== NULL
)
1824 bfd_set_error (bfd_error_no_memory
);
1828 /* Start writing out the symbol table. The first symbol is always a
1830 elfsym
.st_value
= 0;
1833 elfsym
.st_other
= 0;
1834 elfsym
.st_shndx
= SHN_UNDEF
;
1835 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1836 &elfsym
, bfd_und_section_ptr
))
1840 /* Some standard ELF linkers do this, but we don't because it causes
1841 bootstrap comparison failures. */
1842 /* Output a file symbol for the output file as the second symbol.
1843 We output this even if we are discarding local symbols, although
1844 I'm not sure if this is correct. */
1845 elfsym
.st_value
= 0;
1847 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1848 elfsym
.st_other
= 0;
1849 elfsym
.st_shndx
= SHN_ABS
;
1850 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1851 &elfsym
, bfd_abs_section_ptr
))
1855 /* Output a symbol for each section. We output these even if we are
1856 discarding local symbols, since they are used for relocs. These
1857 symbols have no names. We store the index of each one in the
1858 index field of the section, so that we can find it again when
1859 outputting relocs. */
1860 elfsym
.st_value
= 0;
1862 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1863 elfsym
.st_other
= 0;
1864 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1866 o
= section_from_elf_index (abfd
, i
);
1868 o
->target_index
= abfd
->symcount
;
1869 elfsym
.st_shndx
= i
;
1870 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1875 /* Allocate some memory to hold information read in from the input
1877 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
1878 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
1879 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1880 malloc (max_internal_reloc_count
1881 * sizeof (Elf_Internal_Rela
)));
1882 finfo
.external_syms
= ((Elf_External_Sym
*)
1883 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
1884 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1885 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
1886 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
1887 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
1888 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
1889 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
1890 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
1891 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
1892 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
1893 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
1894 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
1896 bfd_set_error (bfd_error_no_memory
);
1900 /* Since ELF permits relocations to be against local symbols, we
1901 must have the local symbols available when we do the relocations.
1902 Since we would rather only read the local symbols once, and we
1903 would rather not keep them in memory, we handle all the
1904 relocations for a single input file at the same time.
1906 Unfortunately, there is no way to know the total number of local
1907 symbols until we have seen all of them, and the local symbol
1908 indices precede the global symbol indices. This means that when
1909 we are generating relocateable output, and we see a reloc against
1910 a global symbol, we can not know the symbol index until we have
1911 finished examining all the local symbols to see which ones we are
1912 going to output. To deal with this, we keep the relocations in
1913 memory, and don't output them until the end of the link. This is
1914 an unfortunate waste of memory, but I don't see a good way around
1915 it. Fortunately, it only happens when performing a relocateable
1916 link, which is not the common case. FIXME: If keep_memory is set
1917 we could write the relocs out and then read them again; I don't
1918 know how bad the memory loss will be. */
1920 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
1921 sub
->output_has_begun
= false;
1922 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1924 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1926 if (p
->type
== bfd_indirect_link_order
1927 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
1928 == bfd_target_elf_flavour
))
1930 sub
= p
->u
.indirect
.section
->owner
;
1931 if (! sub
->output_has_begun
)
1933 if (! elf_link_input_bfd (&finfo
, sub
))
1935 sub
->output_has_begun
= true;
1938 else if (p
->type
== bfd_section_reloc_link_order
1939 || p
->type
== bfd_symbol_reloc_link_order
)
1941 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
1946 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
1952 /* That wrote out all the local symbols. Finish up the symbol table
1953 with the global symbols. */
1955 /* The sh_info field records the index of the first non local
1957 symtab_hdr
->sh_info
= abfd
->symcount
;
1959 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
1961 /* We get the global symbols from the hash table. */
1964 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
1969 /* Flush all symbols to the file. */
1970 if (! elf_link_flush_output_syms (&finfo
))
1973 /* Now we know the size of the symtab section. */
1974 off
+= symtab_hdr
->sh_size
;
1976 /* Finish up and write out the symbol string table (.strtab)
1978 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1979 /* sh_name was set in prep_headers. */
1980 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
1981 symstrtab_hdr
->sh_flags
= 0;
1982 symstrtab_hdr
->sh_addr
= 0;
1983 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
1984 symstrtab_hdr
->sh_entsize
= 0;
1985 symstrtab_hdr
->sh_link
= 0;
1986 symstrtab_hdr
->sh_info
= 0;
1987 /* sh_offset is set just below. */
1988 symstrtab_hdr
->sh_addralign
= 1;
1990 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
1991 elf_tdata (abfd
)->next_file_pos
= off
;
1993 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
1994 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
1997 /* Adjust the relocs to have the correct symbol indices. */
1998 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2000 struct elf_link_hash_entry
**rel_hash
;
2001 Elf_Internal_Shdr
*rel_hdr
;
2003 if ((o
->flags
& SEC_RELOC
) == 0)
2006 rel_hash
= elf_section_data (o
)->rel_hashes
;
2007 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2008 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
2010 if (*rel_hash
== NULL
)
2013 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
2015 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2017 Elf_External_Rel
*erel
;
2018 Elf_Internal_Rel irel
;
2020 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
2021 elf_swap_reloc_in (abfd
, erel
, &irel
);
2022 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2023 ELF_R_TYPE (irel
.r_info
));
2024 elf_swap_reloc_out (abfd
, &irel
, erel
);
2028 Elf_External_Rela
*erela
;
2029 Elf_Internal_Rela irela
;
2031 BFD_ASSERT (rel_hdr
->sh_entsize
2032 == sizeof (Elf_External_Rela
));
2034 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
2035 elf_swap_reloca_in (abfd
, erela
, &irela
);
2036 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2037 ELF_R_TYPE (irela
.r_info
));
2038 elf_swap_reloca_out (abfd
, &irela
, erela
);
2042 /* Set the reloc_count field to 0 to prevent write_relocs from
2043 trying to swap the relocs out itself. */
2047 /* If we are linking against a dynamic object, or generating a
2048 shared library, finish up the dynamic linking information. */
2051 Elf_External_Dyn
*dyncon
, *dynconend
;
2053 /* Fix up .dynamic entries. */
2054 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2055 BFD_ASSERT (o
!= NULL
);
2057 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2058 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2059 for (; dyncon
< dynconend
; dyncon
++)
2061 Elf_Internal_Dyn dyn
;
2065 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2072 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2073 magic _init and _fini symbols. This is pretty ugly,
2074 but we are compatible. */
2082 struct elf_link_hash_entry
*h
;
2084 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2085 false, false, true);
2086 BFD_ASSERT (h
!= NULL
);
2087 if (h
->root
.type
== bfd_link_hash_defined
2088 || h
->root
.type
== bfd_link_hash_defweak
)
2090 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2091 o
= h
->root
.u
.def
.section
;
2092 if (o
->output_section
!= NULL
)
2093 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2094 + o
->output_offset
);
2096 /* The symbol is imported from another shared
2097 library and does not apply to this one. */
2100 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2113 o
= bfd_get_section_by_name (abfd
, name
);
2114 BFD_ASSERT (o
!= NULL
);
2115 dyn
.d_un
.d_ptr
= o
->vma
;
2116 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2123 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2128 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2130 Elf_Internal_Shdr
*hdr
;
2132 hdr
= elf_elfsections (abfd
)[i
];
2133 if (hdr
->sh_type
== type
2134 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2136 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2137 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2140 if (dyn
.d_un
.d_val
== 0
2141 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2142 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2146 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2152 /* If we have created any dynamic sections, then output them. */
2155 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2158 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2160 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2161 || o
->_raw_size
== 0)
2163 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2165 /* At this point, we are only interested in sections
2166 created by elf_link_create_dynamic_sections. FIXME:
2167 This test is fragile. */
2170 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2172 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2174 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2175 o
->contents
, o
->output_offset
,
2183 /* The contents of the .dynstr section are actually in a
2185 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2186 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2187 || ! _bfd_stringtab_emit (abfd
,
2188 elf_hash_table (info
)->dynstr
))
2194 if (finfo
.symstrtab
!= NULL
)
2195 _bfd_stringtab_free (finfo
.symstrtab
);
2196 if (finfo
.contents
!= NULL
)
2197 free (finfo
.contents
);
2198 if (finfo
.external_relocs
!= NULL
)
2199 free (finfo
.external_relocs
);
2200 if (finfo
.internal_relocs
!= NULL
)
2201 free (finfo
.internal_relocs
);
2202 if (finfo
.external_syms
!= NULL
)
2203 free (finfo
.external_syms
);
2204 if (finfo
.internal_syms
!= NULL
)
2205 free (finfo
.internal_syms
);
2206 if (finfo
.indices
!= NULL
)
2207 free (finfo
.indices
);
2208 if (finfo
.sections
!= NULL
)
2209 free (finfo
.sections
);
2210 if (finfo
.symbuf
!= NULL
)
2211 free (finfo
.symbuf
);
2212 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2214 if ((o
->flags
& SEC_RELOC
) != 0
2215 && elf_section_data (o
)->rel_hashes
!= NULL
)
2216 free (elf_section_data (o
)->rel_hashes
);
2219 elf_tdata (abfd
)->linker
= true;
2224 if (finfo
.symstrtab
!= NULL
)
2225 _bfd_stringtab_free (finfo
.symstrtab
);
2226 if (finfo
.contents
!= NULL
)
2227 free (finfo
.contents
);
2228 if (finfo
.external_relocs
!= NULL
)
2229 free (finfo
.external_relocs
);
2230 if (finfo
.internal_relocs
!= NULL
)
2231 free (finfo
.internal_relocs
);
2232 if (finfo
.external_syms
!= NULL
)
2233 free (finfo
.external_syms
);
2234 if (finfo
.internal_syms
!= NULL
)
2235 free (finfo
.internal_syms
);
2236 if (finfo
.indices
!= NULL
)
2237 free (finfo
.indices
);
2238 if (finfo
.sections
!= NULL
)
2239 free (finfo
.sections
);
2240 if (finfo
.symbuf
!= NULL
)
2241 free (finfo
.symbuf
);
2242 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2244 if ((o
->flags
& SEC_RELOC
) != 0
2245 && elf_section_data (o
)->rel_hashes
!= NULL
)
2246 free (elf_section_data (o
)->rel_hashes
);
2252 /* Add a symbol to the output symbol table. */
2255 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2256 struct elf_final_link_info
*finfo
;
2258 Elf_Internal_Sym
*elfsym
;
2259 asection
*input_sec
;
2261 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2262 struct bfd_link_info
*info
,
2267 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2268 elf_backend_link_output_symbol_hook
;
2269 if (output_symbol_hook
!= NULL
)
2271 if (! ((*output_symbol_hook
)
2272 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2276 if (name
== (const char *) NULL
|| *name
== '\0')
2277 elfsym
->st_name
= 0;
2280 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2283 if (elfsym
->st_name
== (unsigned long) -1)
2287 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2289 if (! elf_link_flush_output_syms (finfo
))
2293 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2294 (PTR
) (finfo
->symbuf
+ finfo
->symbuf_count
));
2295 ++finfo
->symbuf_count
;
2297 ++finfo
->output_bfd
->symcount
;
2302 /* Flush the output symbols to the file. */
2305 elf_link_flush_output_syms (finfo
)
2306 struct elf_final_link_info
*finfo
;
2308 Elf_Internal_Shdr
*symtab
;
2310 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2312 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2314 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2315 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2316 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2319 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2321 finfo
->symbuf_count
= 0;
2326 /* Add an external symbol to the symbol table. This is called from
2327 the hash table traversal routine. */
2330 elf_link_output_extsym (h
, data
)
2331 struct elf_link_hash_entry
*h
;
2334 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2335 struct elf_final_link_info
*finfo
= eif
->finfo
;
2337 Elf_Internal_Sym sym
;
2338 asection
*input_sec
;
2340 /* If we are not creating a shared library, and this symbol is
2341 referenced by a shared library but is not defined anywhere, then
2342 warn that it is undefined. If we do not do this, the runtime
2343 linker will complain that the symbol is undefined when the
2344 program is run. We don't have to worry about symbols that are
2345 referenced by regular files, because we will already have issued
2346 warnings for them. */
2347 if (! finfo
->info
->relocateable
2348 && ! finfo
->info
->shared
2349 && h
->root
.type
== bfd_link_hash_undefined
2350 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2351 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2353 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2354 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2355 (asection
*) NULL
, 0)))
2362 /* We don't want to output symbols that have never been mentioned by
2363 a regular file, or that we have been told to strip. However, if
2364 h->indx is set to -2, the symbol is used by a reloc and we must
2368 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2369 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2370 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2371 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2373 else if (finfo
->info
->strip
== strip_all
2374 || (finfo
->info
->strip
== strip_some
2375 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2376 h
->root
.root
.string
,
2377 false, false) == NULL
))
2382 /* If we're stripping it, and it's not a dynamic symbol, there's
2383 nothing else to do. */
2384 if (strip
&& h
->dynindx
== -1)
2388 sym
.st_size
= h
->size
;
2390 if (h
->root
.type
== bfd_link_hash_undefweak
2391 || h
->root
.type
== bfd_link_hash_defweak
)
2392 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2394 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2396 switch (h
->root
.type
)
2399 case bfd_link_hash_new
:
2403 case bfd_link_hash_undefined
:
2404 input_sec
= bfd_und_section_ptr
;
2405 sym
.st_shndx
= SHN_UNDEF
;
2408 case bfd_link_hash_undefweak
:
2409 input_sec
= bfd_und_section_ptr
;
2410 sym
.st_shndx
= SHN_UNDEF
;
2413 case bfd_link_hash_defined
:
2414 case bfd_link_hash_defweak
:
2416 input_sec
= h
->root
.u
.def
.section
;
2417 if (input_sec
->output_section
!= NULL
)
2420 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2421 input_sec
->output_section
);
2422 if (sym
.st_shndx
== (unsigned short) -1)
2428 /* ELF symbols in relocateable files are section relative,
2429 but in nonrelocateable files they are virtual
2431 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2432 if (! finfo
->info
->relocateable
)
2433 sym
.st_value
+= input_sec
->output_section
->vma
;
2437 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2438 == bfd_target_elf_flavour
)
2439 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2440 sym
.st_shndx
= SHN_UNDEF
;
2441 input_sec
= bfd_und_section_ptr
;
2446 case bfd_link_hash_common
:
2447 input_sec
= bfd_com_section_ptr
;
2448 sym
.st_shndx
= SHN_COMMON
;
2449 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2452 case bfd_link_hash_indirect
:
2453 case bfd_link_hash_warning
:
2454 /* I have no idea how these should be handled. */
2458 /* If this symbol should be put in the .dynsym section, then put it
2459 there now. We have already know the symbol index. We also fill
2460 in the entry in the .hash section. */
2461 if (h
->dynindx
!= -1
2462 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2464 struct elf_backend_data
*bed
;
2467 bfd_byte
*bucketpos
;
2470 sym
.st_name
= h
->dynstr_index
;
2472 /* Give the processor backend a chance to tweak the symbol
2473 value, and also to finish up anything that needs to be done
2475 bed
= get_elf_backend_data (finfo
->output_bfd
);
2476 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2477 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2483 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2484 (PTR
) (((Elf_External_Sym
*)
2485 finfo
->dynsym_sec
->contents
)
2488 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2489 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2491 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2492 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2493 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2494 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2495 put_word (finfo
->output_bfd
, chain
,
2496 ((bfd_byte
*) finfo
->hash_sec
->contents
2497 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2500 /* If we're stripping it, then it was just a dynamic symbol, and
2501 there's nothing else to do. */
2505 h
->indx
= finfo
->output_bfd
->symcount
;
2507 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2516 /* Link an input file into the linker output file. This function
2517 handles all the sections and relocations of the input file at once.
2518 This is so that we only have to read the local symbols once, and
2519 don't have to keep them in memory. */
2522 elf_link_input_bfd (finfo
, input_bfd
)
2523 struct elf_final_link_info
*finfo
;
2526 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2527 bfd
*, asection
*, bfd_byte
*,
2528 Elf_Internal_Rela
*,
2529 Elf_Internal_Sym
*, asection
**));
2531 Elf_Internal_Shdr
*symtab_hdr
;
2534 Elf_External_Sym
*esym
;
2535 Elf_External_Sym
*esymend
;
2536 Elf_Internal_Sym
*isym
;
2538 asection
**ppsection
;
2541 output_bfd
= finfo
->output_bfd
;
2543 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2545 /* If this is a dynamic object, we don't want to do anything here:
2546 we don't want the local symbols, and we don't want the section
2548 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2551 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2552 if (elf_bad_symtab (input_bfd
))
2554 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2559 locsymcount
= symtab_hdr
->sh_info
;
2560 extsymoff
= symtab_hdr
->sh_info
;
2563 /* Read the local symbols. */
2565 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2566 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2567 locsymcount
, input_bfd
)
2568 != locsymcount
* sizeof (Elf_External_Sym
))))
2571 /* Swap in the local symbols and write out the ones which we know
2572 are going into the output file. */
2573 esym
= finfo
->external_syms
;
2574 esymend
= esym
+ locsymcount
;
2575 isym
= finfo
->internal_syms
;
2576 pindex
= finfo
->indices
;
2577 ppsection
= finfo
->sections
;
2578 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2582 Elf_Internal_Sym osym
;
2584 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2587 if (elf_bad_symtab (input_bfd
))
2589 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2596 if (isym
->st_shndx
== SHN_UNDEF
)
2597 isec
= bfd_und_section_ptr
;
2598 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2599 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2600 else if (isym
->st_shndx
== SHN_ABS
)
2601 isec
= bfd_abs_section_ptr
;
2602 else if (isym
->st_shndx
== SHN_COMMON
)
2603 isec
= bfd_com_section_ptr
;
2612 /* Don't output the first, undefined, symbol. */
2613 if (esym
== finfo
->external_syms
)
2616 /* If we are stripping all symbols, we don't want to output this
2618 if (finfo
->info
->strip
== strip_all
)
2621 /* We never output section symbols. Instead, we use the section
2622 symbol of the corresponding section in the output file. */
2623 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2626 /* If we are discarding all local symbols, we don't want to
2627 output this one. If we are generating a relocateable output
2628 file, then some of the local symbols may be required by
2629 relocs; we output them below as we discover that they are
2631 if (finfo
->info
->discard
== discard_all
)
2634 /* Get the name of the symbol. */
2635 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2640 /* See if we are discarding symbols with this name. */
2641 if ((finfo
->info
->strip
== strip_some
2642 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2644 || (finfo
->info
->discard
== discard_l
2645 && strncmp (name
, finfo
->info
->lprefix
,
2646 finfo
->info
->lprefix_len
) == 0))
2649 /* If we get here, we are going to output this symbol. */
2653 /* Adjust the section index for the output file. */
2654 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2655 isec
->output_section
);
2656 if (osym
.st_shndx
== (unsigned short) -1)
2659 *pindex
= output_bfd
->symcount
;
2661 /* ELF symbols in relocateable files are section relative, but
2662 in executable files they are virtual addresses. Note that
2663 this code assumes that all ELF sections have an associated
2664 BFD section with a reasonable value for output_offset; below
2665 we assume that they also have a reasonable value for
2666 output_section. Any special sections must be set up to meet
2667 these requirements. */
2668 osym
.st_value
+= isec
->output_offset
;
2669 if (! finfo
->info
->relocateable
)
2670 osym
.st_value
+= isec
->output_section
->vma
;
2672 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2676 /* Relocate the contents of each section. */
2677 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2679 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2682 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2683 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2685 /* Section was created by elf_link_create_dynamic_sections.
2686 FIXME: This test is fragile. */
2690 /* Read the contents of the section. */
2691 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2692 (file_ptr
) 0, o
->_raw_size
))
2695 if ((o
->flags
& SEC_RELOC
) != 0)
2697 Elf_Internal_Rela
*internal_relocs
;
2699 /* Get the swapped relocs. */
2700 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2701 finfo
->external_relocs
,
2702 finfo
->internal_relocs
,
2704 if (internal_relocs
== NULL
2705 && o
->reloc_count
> 0)
2708 /* Relocate the section by invoking a back end routine.
2710 The back end routine is responsible for adjusting the
2711 section contents as necessary, and (if using Rela relocs
2712 and generating a relocateable output file) adjusting the
2713 reloc addend as necessary.
2715 The back end routine does not have to worry about setting
2716 the reloc address or the reloc symbol index.
2718 The back end routine is given a pointer to the swapped in
2719 internal symbols, and can access the hash table entries
2720 for the external symbols via elf_sym_hashes (input_bfd).
2722 When generating relocateable output, the back end routine
2723 must handle STB_LOCAL/STT_SECTION symbols specially. The
2724 output symbol is going to be a section symbol
2725 corresponding to the output section, which will require
2726 the addend to be adjusted. */
2728 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2732 finfo
->internal_syms
,
2736 if (finfo
->info
->relocateable
)
2738 Elf_Internal_Rela
*irela
;
2739 Elf_Internal_Rela
*irelaend
;
2740 struct elf_link_hash_entry
**rel_hash
;
2741 Elf_Internal_Shdr
*input_rel_hdr
;
2742 Elf_Internal_Shdr
*output_rel_hdr
;
2744 /* Adjust the reloc addresses and symbol indices. */
2746 irela
= internal_relocs
;
2747 irelaend
= irela
+ o
->reloc_count
;
2748 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2749 + o
->output_section
->reloc_count
);
2750 for (; irela
< irelaend
; irela
++, rel_hash
++)
2753 Elf_Internal_Sym
*isym
;
2756 irela
->r_offset
+= o
->output_offset
;
2758 r_symndx
= ELF_R_SYM (irela
->r_info
);
2763 if (r_symndx
>= locsymcount
2764 || (elf_bad_symtab (input_bfd
)
2765 && finfo
->sections
[r_symndx
] == NULL
))
2769 /* This is a reloc against a global symbol. We
2770 have not yet output all the local symbols, so
2771 we do not know the symbol index of any global
2772 symbol. We set the rel_hash entry for this
2773 reloc to point to the global hash table entry
2774 for this symbol. The symbol index is then
2775 set at the end of elf_bfd_final_link. */
2776 indx
= r_symndx
- extsymoff
;
2777 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2779 /* Setting the index to -2 tells
2780 elf_link_output_extsym that this symbol is
2782 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2783 (*rel_hash
)->indx
= -2;
2788 /* This is a reloc against a local symbol. */
2791 isym
= finfo
->internal_syms
+ r_symndx
;
2792 sec
= finfo
->sections
[r_symndx
];
2793 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2795 /* I suppose the backend ought to fill in the
2796 section of any STT_SECTION symbol against a
2797 processor specific section. */
2798 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2800 else if (sec
== NULL
|| sec
->owner
== NULL
)
2802 bfd_set_error (bfd_error_bad_value
);
2807 r_symndx
= sec
->output_section
->target_index
;
2808 BFD_ASSERT (r_symndx
!= 0);
2813 if (finfo
->indices
[r_symndx
] == -1)
2819 if (finfo
->info
->strip
== strip_all
)
2821 /* You can't do ld -r -s. */
2822 bfd_set_error (bfd_error_invalid_operation
);
2826 /* This symbol was skipped earlier, but
2827 since it is needed by a reloc, we
2828 must output it now. */
2829 link
= symtab_hdr
->sh_link
;
2830 name
= bfd_elf_string_from_elf_section (input_bfd
,
2836 osec
= sec
->output_section
;
2838 _bfd_elf_section_from_bfd_section (output_bfd
,
2840 if (isym
->st_shndx
== (unsigned short) -1)
2843 isym
->st_value
+= sec
->output_offset
;
2844 if (! finfo
->info
->relocateable
)
2845 isym
->st_value
+= osec
->vma
;
2847 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2849 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2853 r_symndx
= finfo
->indices
[r_symndx
];
2856 irela
->r_info
= ELF_R_INFO (r_symndx
,
2857 ELF_R_TYPE (irela
->r_info
));
2860 /* Swap out the relocs. */
2861 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2862 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2863 BFD_ASSERT (output_rel_hdr
->sh_entsize
2864 == input_rel_hdr
->sh_entsize
);
2865 irela
= internal_relocs
;
2866 irelaend
= irela
+ o
->reloc_count
;
2867 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2869 Elf_External_Rel
*erel
;
2871 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2872 + o
->output_section
->reloc_count
);
2873 for (; irela
< irelaend
; irela
++, erel
++)
2875 Elf_Internal_Rel irel
;
2877 irel
.r_offset
= irela
->r_offset
;
2878 irel
.r_info
= irela
->r_info
;
2879 BFD_ASSERT (irela
->r_addend
== 0);
2880 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
2885 Elf_External_Rela
*erela
;
2887 BFD_ASSERT (input_rel_hdr
->sh_entsize
2888 == sizeof (Elf_External_Rela
));
2889 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
2890 + o
->output_section
->reloc_count
);
2891 for (; irela
< irelaend
; irela
++, erela
++)
2892 elf_swap_reloca_out (output_bfd
, irela
, erela
);
2895 o
->output_section
->reloc_count
+= o
->reloc_count
;
2899 /* Write out the modified section contents. */
2900 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2901 finfo
->contents
, o
->output_offset
,
2902 (o
->_cooked_size
!= 0
2911 /* Generate a reloc when linking an ELF file. This is a reloc
2912 requested by the linker, and does come from any input file. This
2913 is used to build constructor and destructor tables when linking
2917 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
2919 struct bfd_link_info
*info
;
2920 asection
*output_section
;
2921 struct bfd_link_order
*link_order
;
2923 reloc_howto_type
*howto
;
2926 struct elf_link_hash_entry
**rel_hash_ptr
;
2927 Elf_Internal_Shdr
*rel_hdr
;
2929 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2932 bfd_set_error (bfd_error_bad_value
);
2936 /* If this is an inplace reloc, we must write the addend into the
2938 if (howto
->partial_inplace
2939 && link_order
->u
.reloc
.p
->addend
!= 0)
2942 bfd_reloc_status_type rstat
;
2946 size
= bfd_get_reloc_size (howto
);
2947 buf
= (bfd_byte
*) bfd_zmalloc (size
);
2948 if (buf
== (bfd_byte
*) NULL
)
2950 bfd_set_error (bfd_error_no_memory
);
2953 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
2954 link_order
->u
.reloc
.p
->addend
, buf
);
2960 case bfd_reloc_outofrange
:
2962 case bfd_reloc_overflow
:
2963 if (! ((*info
->callbacks
->reloc_overflow
)
2965 (link_order
->type
== bfd_section_reloc_link_order
2966 ? bfd_section_name (output_bfd
,
2967 link_order
->u
.reloc
.p
->u
.section
)
2968 : link_order
->u
.reloc
.p
->u
.name
),
2969 howto
->name
, link_order
->u
.reloc
.p
->addend
,
2970 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
2977 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
2978 (file_ptr
) link_order
->offset
, size
);
2984 /* Figure out the symbol index. */
2985 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
2986 + output_section
->reloc_count
);
2987 if (link_order
->type
== bfd_section_reloc_link_order
)
2989 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
2990 BFD_ASSERT (indx
!= 0);
2991 *rel_hash_ptr
= NULL
;
2995 struct elf_link_hash_entry
*h
;
2997 h
= elf_link_hash_lookup (elf_hash_table (info
),
2998 link_order
->u
.reloc
.p
->u
.name
,
2999 false, false, true);
3002 /* Setting the index to -2 tells elf_link_output_extsym that
3003 this symbol is used by a reloc. */
3010 if (! ((*info
->callbacks
->unattached_reloc
)
3011 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
3012 (asection
*) NULL
, (bfd_vma
) 0)))
3018 /* The address of a reloc is relative to the section in a
3019 relocateable file, and is a virtual address in an executable
3021 offset
= link_order
->offset
;
3022 if (! info
->relocateable
)
3023 offset
+= output_section
->vma
;
3025 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
3027 if (rel_hdr
->sh_type
== SHT_REL
)
3029 Elf_Internal_Rel irel
;
3030 Elf_External_Rel
*erel
;
3032 irel
.r_offset
= offset
;
3033 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3034 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
3035 + output_section
->reloc_count
);
3036 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3040 Elf_Internal_Rela irela
;
3041 Elf_External_Rela
*erela
;
3043 irela
.r_offset
= offset
;
3044 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3045 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
3046 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3047 + output_section
->reloc_count
);
3048 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3051 ++output_section
->reloc_count
;