3 static boolean elf_link_add_object_symbols
4 PARAMS ((bfd
*, struct bfd_link_info
*));
5 static boolean elf_link_add_archive_symbols
6 PARAMS ((bfd
*, struct bfd_link_info
*));
7 static Elf_Internal_Rela
*elf_link_read_relocs
8 PARAMS ((bfd
*, asection
*, PTR
, Elf_Internal_Rela
*, boolean
));
9 static boolean elf_export_symbol
10 PARAMS ((struct elf_link_hash_entry
*, PTR
));
11 static boolean elf_adjust_dynamic_symbol
12 PARAMS ((struct elf_link_hash_entry
*, PTR
));
14 /* This struct is used to pass information to routines called via
15 elf_link_hash_traverse which must return failure. */
17 struct elf_info_failed
20 struct bfd_link_info
*info
;
23 /* Given an ELF BFD, add symbols to the global hash table as
27 elf_bfd_link_add_symbols (abfd
, info
)
29 struct bfd_link_info
*info
;
33 switch (bfd_get_format (abfd
))
36 return elf_link_add_object_symbols (abfd
, info
);
38 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
41 /* It's OK to have an empty archive. */
44 if (! bfd_check_format (first
, bfd_object
))
46 if (bfd_get_flavour (first
) != bfd_target_elf_flavour
)
48 /* On Linux, we may have an a.out archive which got
49 recognized as an ELF archive. Therefore, we treat all
50 archives as though they were actually of the flavour of
51 their first element. */
52 return (*first
->xvec
->_bfd_link_add_symbols
) (abfd
, info
);
54 return elf_link_add_archive_symbols (abfd
, info
);
56 bfd_set_error (bfd_error_wrong_format
);
61 /* Add symbols from an ELF archive file to the linker hash table. We
62 don't use _bfd_generic_link_add_archive_symbols because of a
63 problem which arises on UnixWare. The UnixWare libc.so is an
64 archive which includes an entry libc.so.1 which defines a bunch of
65 symbols. The libc.so archive also includes a number of other
66 object files, which also define symbols, some of which are the same
67 as those defined in libc.so.1. Correct linking requires that we
68 consider each object file in turn, and include it if it defines any
69 symbols we need. _bfd_generic_link_add_archive_symbols does not do
70 this; it looks through the list of undefined symbols, and includes
71 any object file which defines them. When this algorithm is used on
72 UnixWare, it winds up pulling in libc.so.1 early and defining a
73 bunch of symbols. This means that some of the other objects in the
74 archive are not included in the link, which is incorrect since they
75 precede libc.so.1 in the archive.
77 Fortunately, ELF archive handling is simpler than that done by
78 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
79 oddities. In ELF, if we find a symbol in the archive map, and the
80 symbol is currently undefined, we know that we must pull in that
83 Unfortunately, we do have to make multiple passes over the symbol
84 table until nothing further is resolved. */
87 elf_link_add_archive_symbols (abfd
, info
)
89 struct bfd_link_info
*info
;
92 boolean
*defined
= NULL
;
93 boolean
*included
= NULL
;
97 if (! bfd_has_map (abfd
))
99 /* An empty archive is a special case. */
100 if (bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
) == NULL
)
102 bfd_set_error (bfd_error_no_armap
);
106 /* Keep track of all symbols we know to be already defined, and all
107 files we know to be already included. This is to speed up the
108 second and subsequent passes. */
109 c
= bfd_ardata (abfd
)->symdef_count
;
112 defined
= (boolean
*) malloc (c
* sizeof (boolean
));
113 included
= (boolean
*) malloc (c
* sizeof (boolean
));
114 if (defined
== (boolean
*) NULL
|| included
== (boolean
*) NULL
)
116 bfd_set_error (bfd_error_no_memory
);
119 memset (defined
, 0, c
* sizeof (boolean
));
120 memset (included
, 0, c
* sizeof (boolean
));
122 symdefs
= bfd_ardata (abfd
)->symdefs
;
135 symdefend
= symdef
+ c
;
136 for (i
= 0; symdef
< symdefend
; symdef
++, i
++)
138 struct elf_link_hash_entry
*h
;
140 struct bfd_link_hash_entry
*undefs_tail
;
143 if (defined
[i
] || included
[i
])
145 if (symdef
->file_offset
== last
)
151 h
= elf_link_hash_lookup (elf_hash_table (info
), symdef
->name
,
152 false, false, false);
153 if (h
== (struct elf_link_hash_entry
*) NULL
)
155 if (h
->root
.type
!= bfd_link_hash_undefined
)
161 /* We need to include this archive member. */
163 element
= _bfd_get_elt_at_filepos (abfd
, symdef
->file_offset
);
164 if (element
== (bfd
*) NULL
)
167 if (! bfd_check_format (element
, bfd_object
))
170 /* Doublecheck that we have not included this object
171 already--it should be impossible, but there may be
172 something wrong with the archive. */
173 if (element
->archive_pass
!= 0)
175 bfd_set_error (bfd_error_bad_value
);
178 element
->archive_pass
= 1;
180 undefs_tail
= info
->hash
->undefs_tail
;
182 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
185 if (! elf_link_add_object_symbols (element
, info
))
188 /* If there are any new undefined symbols, we need to make
189 another pass through the archive in order to see whether
190 they can be defined. FIXME: This isn't perfect, because
191 common symbols wind up on undefs_tail and because an
192 undefined symbol which is defined later on in this pass
193 does not require another pass. This isn't a bug, but it
194 does make the code less efficient than it could be. */
195 if (undefs_tail
!= info
->hash
->undefs_tail
)
198 /* Look backward to mark all symbols from this object file
199 which we have already seen in this pass. */
203 included
[mark
] = true;
208 while (symdefs
[mark
].file_offset
== symdef
->file_offset
);
210 /* We mark subsequent symbols from this object file as we go
211 on through the loop. */
212 last
= symdef
->file_offset
;
223 if (defined
!= (boolean
*) NULL
)
225 if (included
!= (boolean
*) NULL
)
230 /* Add symbols from an ELF object file to the linker hash table. */
233 elf_link_add_object_symbols (abfd
, info
)
235 struct bfd_link_info
*info
;
237 boolean (*add_symbol_hook
) PARAMS ((bfd
*, struct bfd_link_info
*,
238 const Elf_Internal_Sym
*,
239 const char **, flagword
*,
240 asection
**, bfd_vma
*));
241 boolean (*check_relocs
) PARAMS ((bfd
*, struct bfd_link_info
*,
242 asection
*, const Elf_Internal_Rela
*));
244 Elf_Internal_Shdr
*hdr
;
248 Elf_External_Sym
*buf
= NULL
;
249 struct elf_link_hash_entry
**sym_hash
;
251 Elf_External_Dyn
*dynbuf
= NULL
;
252 struct elf_link_hash_entry
*weaks
;
253 Elf_External_Sym
*esym
;
254 Elf_External_Sym
*esymend
;
256 add_symbol_hook
= get_elf_backend_data (abfd
)->elf_add_symbol_hook
;
257 collect
= get_elf_backend_data (abfd
)->collect
;
259 /* A stripped shared library might only have a dynamic symbol table,
260 not a regular symbol table. In that case we can still go ahead
261 and link using the dynamic symbol table. */
262 if (elf_onesymtab (abfd
) == 0
263 && elf_dynsymtab (abfd
) != 0)
265 elf_onesymtab (abfd
) = elf_dynsymtab (abfd
);
266 elf_tdata (abfd
)->symtab_hdr
= elf_tdata (abfd
)->dynsymtab_hdr
;
269 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
270 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
272 /* The sh_info field of the symtab header tells us where the
273 external symbols start. We don't care about the local symbols at
275 if (elf_bad_symtab (abfd
))
277 extsymcount
= symcount
;
282 extsymcount
= symcount
- hdr
->sh_info
;
283 extsymoff
= hdr
->sh_info
;
286 buf
= (Elf_External_Sym
*) malloc (extsymcount
* sizeof (Elf_External_Sym
));
287 if (buf
== NULL
&& extsymcount
!= 0)
289 bfd_set_error (bfd_error_no_memory
);
293 /* We store a pointer to the hash table entry for each external
295 sym_hash
= ((struct elf_link_hash_entry
**)
297 extsymcount
* sizeof (struct elf_link_hash_entry
*)));
298 if (sym_hash
== NULL
)
300 bfd_set_error (bfd_error_no_memory
);
303 elf_sym_hashes (abfd
) = sym_hash
;
305 if (elf_elfheader (abfd
)->e_type
!= ET_DYN
)
309 /* If we are creating a shared library, create all the dynamic
310 sections immediately. We need to attach them to something,
311 so we attach them to this BFD, provided it is the right
312 format. FIXME: If there are no input BFD's of the same
313 format as the output, we can't make a shared library. */
315 && ! elf_hash_table (info
)->dynamic_sections_created
316 && abfd
->xvec
== info
->hash
->creator
)
318 if (! elf_link_create_dynamic_sections (abfd
, info
))
327 bfd_size_type oldsize
;
328 bfd_size_type strindex
;
332 /* You can't use -r against a dynamic object. Also, there's no
333 hope of using a dynamic object which does not exactly match
334 the format of the output file. */
335 if (info
->relocateable
336 || info
->hash
->creator
!= abfd
->xvec
)
338 bfd_set_error (bfd_error_invalid_operation
);
342 /* Find the name to use in a DT_NEEDED entry that refers to this
343 object. If the object has a DT_SONAME entry, we use it.
344 Otherwise, if the generic linker stuck something in
345 elf_dt_needed_name, we use that. Otherwise, we just use the
346 file name. If the generic linker put a null string into
347 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
348 even if there is a DT_SONAME entry. */
350 name
= bfd_get_filename (abfd
);
351 if (elf_dt_needed_name (abfd
) != NULL
)
353 name
= elf_dt_needed_name (abfd
);
357 s
= bfd_get_section_by_name (abfd
, ".dynamic");
360 Elf_External_Dyn
*extdyn
;
361 Elf_External_Dyn
*extdynend
;
365 dynbuf
= (Elf_External_Dyn
*) malloc (s
->_raw_size
);
368 bfd_set_error (bfd_error_no_memory
);
372 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
,
373 (file_ptr
) 0, s
->_raw_size
))
376 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
379 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
382 extdynend
= extdyn
+ s
->_raw_size
/ sizeof (Elf_External_Dyn
);
383 for (; extdyn
< extdynend
; extdyn
++)
385 Elf_Internal_Dyn dyn
;
387 elf_swap_dyn_in (abfd
, extdyn
, &dyn
);
388 if (add_needed
&& dyn
.d_tag
== DT_SONAME
)
390 name
= bfd_elf_string_from_elf_section (abfd
, link
,
395 if (dyn
.d_tag
== DT_NEEDED
)
397 struct bfd_elf_link_needed_list
*n
, **pn
;
401 sizeof (struct bfd_elf_link_needed_list
));
402 fnm
= bfd_elf_string_from_elf_section (abfd
, link
,
404 if (n
== NULL
|| fnm
== NULL
)
406 anm
= bfd_alloc (abfd
, strlen (fnm
) + 1);
413 for (pn
= &elf_hash_table (info
)->needed
;
425 /* We do not want to include any of the sections in a dynamic
426 object in the output file. We hack by simply clobbering the
427 list of sections in the BFD. This could be handled more
428 cleanly by, say, a new section flag; the existing
429 SEC_NEVER_LOAD flag is not the one we want, because that one
430 still implies that the section takes up space in the output
432 abfd
->sections
= NULL
;
434 /* If this is the first dynamic object found in the link, create
435 the special sections required for dynamic linking. */
436 if (! elf_hash_table (info
)->dynamic_sections_created
)
438 if (! elf_link_create_dynamic_sections (abfd
, info
))
444 /* Add a DT_NEEDED entry for this dynamic object. */
445 oldsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
446 strindex
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, name
,
448 if (strindex
== (bfd_size_type
) -1)
451 if (oldsize
== _bfd_stringtab_size (elf_hash_table (info
)->dynstr
))
454 Elf_External_Dyn
*dyncon
, *dynconend
;
456 /* The hash table size did not change, which means that
457 the dynamic object name was already entered. If we
458 have already included this dynamic object in the
459 link, just ignore it. There is no reason to include
460 a particular dynamic object more than once. */
461 sdyn
= bfd_get_section_by_name (elf_hash_table (info
)->dynobj
,
463 BFD_ASSERT (sdyn
!= NULL
);
465 dyncon
= (Elf_External_Dyn
*) sdyn
->contents
;
466 dynconend
= (Elf_External_Dyn
*) (sdyn
->contents
+
468 for (; dyncon
< dynconend
; dyncon
++)
470 Elf_Internal_Dyn dyn
;
472 elf_swap_dyn_in (elf_hash_table (info
)->dynobj
, dyncon
,
474 if (dyn
.d_tag
== DT_NEEDED
475 && dyn
.d_un
.d_val
== strindex
)
484 if (! elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
490 hdr
->sh_offset
+ extsymoff
* sizeof (Elf_External_Sym
),
492 || (bfd_read ((PTR
) buf
, sizeof (Elf_External_Sym
), extsymcount
, abfd
)
493 != extsymcount
* sizeof (Elf_External_Sym
)))
498 esymend
= buf
+ extsymcount
;
499 for (esym
= buf
; esym
< esymend
; esym
++, sym_hash
++)
501 Elf_Internal_Sym sym
;
507 struct elf_link_hash_entry
*h
= NULL
;
510 elf_swap_symbol_in (abfd
, esym
, &sym
);
512 flags
= BSF_NO_FLAGS
;
514 value
= sym
.st_value
;
517 bind
= ELF_ST_BIND (sym
.st_info
);
518 if (bind
== STB_LOCAL
)
520 /* This should be impossible, since ELF requires that all
521 global symbols follow all local symbols, and that sh_info
522 point to the first global symbol. Unfortunatealy, Irix 5
526 else if (bind
== STB_GLOBAL
)
528 if (sym
.st_shndx
!= SHN_UNDEF
529 && sym
.st_shndx
!= SHN_COMMON
)
534 else if (bind
== STB_WEAK
)
538 /* Leave it up to the processor backend. */
541 if (sym
.st_shndx
== SHN_UNDEF
)
542 sec
= bfd_und_section_ptr
;
543 else if (sym
.st_shndx
> 0 && sym
.st_shndx
< SHN_LORESERVE
)
545 sec
= section_from_elf_index (abfd
, sym
.st_shndx
);
549 sec
= bfd_abs_section_ptr
;
551 else if (sym
.st_shndx
== SHN_ABS
)
552 sec
= bfd_abs_section_ptr
;
553 else if (sym
.st_shndx
== SHN_COMMON
)
555 sec
= bfd_com_section_ptr
;
556 /* What ELF calls the size we call the value. What ELF
557 calls the value we call the alignment. */
562 /* Leave it up to the processor backend. */
565 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
, sym
.st_name
);
566 if (name
== (const char *) NULL
)
571 if (! (*add_symbol_hook
) (abfd
, info
, &sym
, &name
, &flags
, &sec
,
575 /* The hook function sets the name to NULL if this symbol
576 should be skipped for some reason. */
577 if (name
== (const char *) NULL
)
581 /* Sanity check that all possibilities were handled. */
582 if (sec
== (asection
*) NULL
)
584 bfd_set_error (bfd_error_bad_value
);
588 if (bfd_is_und_section (sec
)
589 || bfd_is_com_section (sec
))
594 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
596 /* We need to look up the symbol now in order to get some of
597 the dynamic object handling right. We pass the hash
598 table entry in to _bfd_generic_link_add_one_symbol so
599 that it does not have to look it up again. */
600 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
606 /* If we are looking at a dynamic object, and this is a
607 definition, we need to see if it has already been defined
608 by some other object. If it has, we want to use the
609 existing definition, and we do not want to report a
610 multiple symbol definition error; we do this by
611 clobbering sec to be bfd_und_section_ptr. */
612 if (dynamic
&& definition
)
614 if (h
->root
.type
== bfd_link_hash_defined
615 || h
->root
.type
== bfd_link_hash_defweak
)
616 sec
= bfd_und_section_ptr
;
619 /* Similarly, if we are not looking at a dynamic object, and
620 we have a definition, we want to override any definition
621 we may have from a dynamic object. Symbols from regular
622 files always take precedence over symbols from dynamic
623 objects, even if they are defined after the dynamic
624 object in the link. */
627 && (h
->root
.type
== bfd_link_hash_defined
628 || h
->root
.type
== bfd_link_hash_defweak
)
629 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
630 && (bfd_get_flavour (h
->root
.u
.def
.section
->owner
)
631 == bfd_target_elf_flavour
)
632 && (elf_elfheader (h
->root
.u
.def
.section
->owner
)->e_type
635 /* Change the hash table entry to undefined, and let
636 _bfd_generic_link_add_one_symbol do the right thing
637 with the new definition. */
638 h
->root
.type
= bfd_link_hash_undefined
;
639 h
->root
.u
.undef
.abfd
= h
->root
.u
.def
.section
->owner
;
643 if (! (_bfd_generic_link_add_one_symbol
644 (info
, abfd
, name
, flags
, sec
, value
, (const char *) NULL
,
645 false, collect
, (struct bfd_link_hash_entry
**) sym_hash
)))
650 && (flags
& BSF_WEAK
) != 0
651 && ELF_ST_TYPE (sym
.st_info
) != STT_FUNC
652 && info
->hash
->creator
->flavour
== bfd_target_elf_flavour
653 && (*sym_hash
)->weakdef
== NULL
)
655 /* Keep a list of all weak defined non function symbols from
656 a dynamic object, using the weakdef field. Later in this
657 function we will set the weakdef field to the correct
658 value. We only put non-function symbols from dynamic
659 objects on this list, because that happens to be the only
660 time we need to know the normal symbol corresponding to a
661 weak symbol, and the information is time consuming to
662 figure out. If the weakdef field is not already NULL,
663 then this symbol was already defined by some previous
664 dynamic object, and we will be using that previous
665 definition anyhow. */
667 (*sym_hash
)->weakdef
= weaks
;
671 /* Get the alignment of a common symbol. */
672 if (sym
.st_shndx
== SHN_COMMON
673 && (*sym_hash
)->root
.type
== bfd_link_hash_common
)
674 (*sym_hash
)->root
.u
.c
.p
->alignment_power
= bfd_log2 (sym
.st_value
);
676 if (info
->hash
->creator
->flavour
== bfd_target_elf_flavour
)
682 /* Remember the symbol size and type. */
683 if (sym
.st_size
!= 0)
685 /* FIXME: We should probably somehow give a warning if
686 the symbol size changes. */
687 h
->size
= sym
.st_size
;
689 if (ELF_ST_TYPE (sym
.st_info
) != STT_NOTYPE
)
691 /* FIXME: We should probably somehow give a warning if
692 the symbol type changes. */
693 h
->type
= ELF_ST_TYPE (sym
.st_info
);
696 /* Set a flag in the hash table entry indicating the type of
697 reference or definition we just found. Keep a count of
698 the number of dynamic symbols we find. A dynamic symbol
699 is one which is referenced or defined by both a regular
700 object and a shared object, or one which is referenced or
701 defined by more than one shared object. */
702 old_flags
= h
->elf_link_hash_flags
;
707 new_flag
= ELF_LINK_HASH_REF_REGULAR
;
709 new_flag
= ELF_LINK_HASH_DEF_REGULAR
;
711 || (old_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
712 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0)
718 new_flag
= ELF_LINK_HASH_REF_DYNAMIC
;
720 new_flag
= ELF_LINK_HASH_DEF_DYNAMIC
;
721 if ((old_flags
& new_flag
) != 0
722 || (old_flags
& (ELF_LINK_HASH_DEF_REGULAR
723 | ELF_LINK_HASH_REF_REGULAR
)) != 0)
727 h
->elf_link_hash_flags
|= new_flag
;
728 if (dynsym
&& h
->dynindx
== -1)
730 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
736 /* Now set the weakdefs field correctly for all the weak defined
737 symbols we found. The only way to do this is to search all the
738 symbols. Since we only need the information for non functions in
739 dynamic objects, that's the only time we actually put anything on
740 the list WEAKS. We need this information so that if a regular
741 object refers to a symbol defined weakly in a dynamic object, the
742 real symbol in the dynamic object is also put in the dynamic
743 symbols; we also must arrange for both symbols to point to the
744 same memory location. We could handle the general case of symbol
745 aliasing, but a general symbol alias can only be generated in
746 assembler code, handling it correctly would be very time
747 consuming, and other ELF linkers don't handle general aliasing
749 while (weaks
!= NULL
)
751 struct elf_link_hash_entry
*hlook
;
754 struct elf_link_hash_entry
**hpp
;
755 struct elf_link_hash_entry
**hppend
;
758 weaks
= hlook
->weakdef
;
759 hlook
->weakdef
= NULL
;
761 BFD_ASSERT (hlook
->root
.type
== bfd_link_hash_defined
762 || hlook
->root
.type
== bfd_link_hash_defweak
763 || hlook
->root
.type
== bfd_link_hash_common
764 || hlook
->root
.type
== bfd_link_hash_indirect
);
765 slook
= hlook
->root
.u
.def
.section
;
766 vlook
= hlook
->root
.u
.def
.value
;
768 hpp
= elf_sym_hashes (abfd
);
769 hppend
= hpp
+ extsymcount
;
770 for (; hpp
< hppend
; hpp
++)
772 struct elf_link_hash_entry
*h
;
775 if (h
!= NULL
&& h
!= hlook
776 && (h
->root
.type
== bfd_link_hash_defined
777 || h
->root
.type
== bfd_link_hash_defweak
)
778 && h
->root
.u
.def
.section
== slook
779 && h
->root
.u
.def
.value
== vlook
)
783 /* If the weak definition is in the list of dynamic
784 symbols, make sure the real definition is put there
786 if (hlook
->dynindx
!= -1
789 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
804 /* If this object is the same format as the output object, and it is
805 not a shared library, then let the backend look through the
808 This is required to build global offset table entries and to
809 arrange for dynamic relocs. It is not required for the
810 particular common case of linking non PIC code, even when linking
811 against shared libraries, but unfortunately there is no way of
812 knowing whether an object file has been compiled PIC or not.
813 Looking through the relocs is not particularly time consuming.
814 The problem is that we must either (1) keep the relocs in memory,
815 which causes the linker to require additional runtime memory or
816 (2) read the relocs twice from the input file, which wastes time.
817 This would be a good case for using mmap.
819 I have no idea how to handle linking PIC code into a file of a
820 different format. It probably can't be done. */
821 check_relocs
= get_elf_backend_data (abfd
)->check_relocs
;
823 && abfd
->xvec
== info
->hash
->creator
824 && check_relocs
!= NULL
)
828 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
830 Elf_Internal_Rela
*internal_relocs
;
833 if ((o
->flags
& SEC_RELOC
) == 0
834 || o
->reloc_count
== 0)
837 /* I believe we can ignore the relocs for any section which
838 does not form part of the final process image, such as a
839 debugging section. */
840 if ((o
->flags
& SEC_ALLOC
) == 0)
843 internal_relocs
= elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
844 (Elf_Internal_Rela
*) NULL
,
846 if (internal_relocs
== NULL
)
849 ok
= (*check_relocs
) (abfd
, info
, o
, internal_relocs
);
851 if (! info
->keep_memory
)
852 free (internal_relocs
);
869 /* Create some sections which will be filled in with dynamic linking
870 information. ABFD is an input file which requires dynamic sections
871 to be created. The dynamic sections take up virtual memory space
872 when the final executable is run, so we need to create them before
873 addresses are assigned to the output sections. We work out the
874 actual contents and size of these sections later. */
877 elf_link_create_dynamic_sections (abfd
, info
)
879 struct bfd_link_info
*info
;
882 register asection
*s
;
883 struct elf_link_hash_entry
*h
;
884 struct elf_backend_data
*bed
;
886 if (elf_hash_table (info
)->dynamic_sections_created
)
889 /* Make sure that all dynamic sections use the same input BFD. */
890 if (elf_hash_table (info
)->dynobj
== NULL
)
891 elf_hash_table (info
)->dynobj
= abfd
;
893 abfd
= elf_hash_table (info
)->dynobj
;
895 /* Note that we set the SEC_IN_MEMORY flag for all of these
897 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
899 /* A dynamically linked executable has a .interp section, but a
900 shared library does not. */
903 s
= bfd_make_section (abfd
, ".interp");
905 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
909 s
= bfd_make_section (abfd
, ".dynsym");
911 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
912 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
915 s
= bfd_make_section (abfd
, ".dynstr");
917 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
))
920 /* Create a strtab to hold the dynamic symbol names. */
921 if (elf_hash_table (info
)->dynstr
== NULL
)
923 elf_hash_table (info
)->dynstr
= elf_stringtab_init ();
924 if (elf_hash_table (info
)->dynstr
== NULL
)
928 s
= bfd_make_section (abfd
, ".dynamic");
930 || ! bfd_set_section_flags (abfd
, s
, flags
)
931 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
934 /* The special symbol _DYNAMIC is always set to the start of the
935 .dynamic section. This call occurs before we have processed the
936 symbols for any dynamic object, so we don't have to worry about
937 overriding a dynamic definition. We could set _DYNAMIC in a
938 linker script, but we only want to define it if we are, in fact,
939 creating a .dynamic section. We don't want to define it if there
940 is no .dynamic section, since on some ELF platforms the start up
941 code examines it to decide how to initialize the process. */
943 if (! (_bfd_generic_link_add_one_symbol
944 (info
, abfd
, "_DYNAMIC", BSF_GLOBAL
, s
, (bfd_vma
) 0,
945 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
946 (struct bfd_link_hash_entry
**) &h
)))
948 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
949 h
->type
= STT_OBJECT
;
952 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
955 s
= bfd_make_section (abfd
, ".hash");
957 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
958 || ! bfd_set_section_alignment (abfd
, s
, LOG_FILE_ALIGN
))
961 /* Let the backend create the rest of the sections. This lets the
962 backend set the right flags. The backend will normally create
963 the .got and .plt sections. */
964 bed
= get_elf_backend_data (abfd
);
965 if (! (*bed
->elf_backend_create_dynamic_sections
) (abfd
, info
))
968 elf_hash_table (info
)->dynamic_sections_created
= true;
973 /* Add an entry to the .dynamic table. */
976 elf_add_dynamic_entry (info
, tag
, val
)
977 struct bfd_link_info
*info
;
981 Elf_Internal_Dyn dyn
;
985 bfd_byte
*newcontents
;
987 dynobj
= elf_hash_table (info
)->dynobj
;
989 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
990 BFD_ASSERT (s
!= NULL
);
992 newsize
= s
->_raw_size
+ sizeof (Elf_External_Dyn
);
993 if (s
->contents
== NULL
)
994 newcontents
= (bfd_byte
*) malloc (newsize
);
996 newcontents
= (bfd_byte
*) realloc (s
->contents
, newsize
);
997 if (newcontents
== NULL
)
999 bfd_set_error (bfd_error_no_memory
);
1004 dyn
.d_un
.d_val
= val
;
1005 elf_swap_dyn_out (dynobj
, &dyn
,
1006 (Elf_External_Dyn
*) (newcontents
+ s
->_raw_size
));
1008 s
->_raw_size
= newsize
;
1009 s
->contents
= newcontents
;
1014 /* Read and swap the relocs for a section. They may have been cached.
1015 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1016 they are used as buffers to read into. They are known to be large
1017 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1018 value is allocated using either malloc or bfd_alloc, according to
1019 the KEEP_MEMORY argument. */
1021 static Elf_Internal_Rela
*
1022 elf_link_read_relocs (abfd
, o
, external_relocs
, internal_relocs
, keep_memory
)
1025 PTR external_relocs
;
1026 Elf_Internal_Rela
*internal_relocs
;
1027 boolean keep_memory
;
1029 Elf_Internal_Shdr
*rel_hdr
;
1031 Elf_Internal_Rela
*alloc2
= NULL
;
1033 if (elf_section_data (o
)->relocs
!= NULL
)
1034 return elf_section_data (o
)->relocs
;
1036 if (o
->reloc_count
== 0)
1039 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1041 if (internal_relocs
== NULL
)
1045 size
= o
->reloc_count
* sizeof (Elf_Internal_Rela
);
1047 internal_relocs
= (Elf_Internal_Rela
*) bfd_alloc (abfd
, size
);
1049 internal_relocs
= alloc2
= (Elf_Internal_Rela
*) malloc (size
);
1050 if (internal_relocs
== NULL
)
1052 bfd_set_error (bfd_error_no_memory
);
1057 if (external_relocs
== NULL
)
1059 alloc1
= (PTR
) malloc (rel_hdr
->sh_size
);
1062 bfd_set_error (bfd_error_no_memory
);
1065 external_relocs
= alloc1
;
1068 if ((bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1069 || (bfd_read (external_relocs
, 1, rel_hdr
->sh_size
, abfd
)
1070 != rel_hdr
->sh_size
))
1073 /* Swap in the relocs. For convenience, we always produce an
1074 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1076 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1078 Elf_External_Rel
*erel
;
1079 Elf_External_Rel
*erelend
;
1080 Elf_Internal_Rela
*irela
;
1082 erel
= (Elf_External_Rel
*) external_relocs
;
1083 erelend
= erel
+ o
->reloc_count
;
1084 irela
= internal_relocs
;
1085 for (; erel
< erelend
; erel
++, irela
++)
1087 Elf_Internal_Rel irel
;
1089 elf_swap_reloc_in (abfd
, erel
, &irel
);
1090 irela
->r_offset
= irel
.r_offset
;
1091 irela
->r_info
= irel
.r_info
;
1092 irela
->r_addend
= 0;
1097 Elf_External_Rela
*erela
;
1098 Elf_External_Rela
*erelaend
;
1099 Elf_Internal_Rela
*irela
;
1101 BFD_ASSERT (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rela
));
1103 erela
= (Elf_External_Rela
*) external_relocs
;
1104 erelaend
= erela
+ o
->reloc_count
;
1105 irela
= internal_relocs
;
1106 for (; erela
< erelaend
; erela
++, irela
++)
1107 elf_swap_reloca_in (abfd
, erela
, irela
);
1110 /* Cache the results for next time, if we can. */
1112 elf_section_data (o
)->relocs
= internal_relocs
;
1117 /* Don't free alloc2, since if it was allocated we are passing it
1118 back (under the name of internal_relocs). */
1120 return internal_relocs
;
1130 /* Record an assignment to a symbol made by a linker script. We need
1131 this in case some dynamic object refers to this symbol. */
1135 NAME(bfd_elf
,record_link_assignment
) (output_bfd
, info
, name
, provide
)
1137 struct bfd_link_info
*info
;
1141 struct elf_link_hash_entry
*h
;
1143 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1146 h
= elf_link_hash_lookup (elf_hash_table (info
), name
, true, true, false);
1150 /* If this symbol is being provided by the linker script, and it is
1151 currently defined by a dynamic object, but not by a regular
1152 object, then mark it as undefined so that the generic linker will
1153 force the correct value. */
1155 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1156 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1157 h
->root
.type
= bfd_link_hash_undefined
;
1159 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1160 h
->type
= STT_OBJECT
;
1162 if (((h
->elf_link_hash_flags
& (ELF_LINK_HASH_DEF_DYNAMIC
1163 | ELF_LINK_HASH_REF_DYNAMIC
)) != 0
1165 && h
->dynindx
== -1)
1167 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1170 /* If this is a weak defined symbol, and we know a corresponding
1171 real symbol from the same dynamic object, make sure the real
1172 symbol is also made into a dynamic symbol. */
1173 if (h
->weakdef
!= NULL
1174 && h
->weakdef
->dynindx
== -1)
1176 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
->weakdef
))
1184 /* Array used to determine the number of hash table buckets to use
1185 based on the number of symbols there are. If there are fewer than
1186 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1187 fewer than 37 we use 17 buckets, and so forth. We never use more
1188 than 521 buckets. */
1190 static const size_t elf_buckets
[] =
1192 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1195 /* Set up the sizes and contents of the ELF dynamic sections. This is
1196 called by the ELF linker emulation before_allocation routine. We
1197 must set the sizes of the sections before the linker sets the
1198 addresses of the various sections. */
1201 NAME(bfd_elf
,size_dynamic_sections
) (output_bfd
, soname
, rpath
,
1202 export_dynamic
, info
, sinterpptr
)
1206 boolean export_dynamic
;
1207 struct bfd_link_info
*info
;
1208 asection
**sinterpptr
;
1211 struct elf_backend_data
*bed
;
1215 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1218 dynobj
= elf_hash_table (info
)->dynobj
;
1220 /* If there were no dynamic objects in the link, there is nothing to
1225 /* If we are supposed to export all symbols into the dynamic symbol
1226 table (this is not the normal case), then do so. */
1229 struct elf_info_failed eif
;
1233 elf_link_hash_traverse (elf_hash_table (info
), elf_export_symbol
,
1239 if (elf_hash_table (info
)->dynamic_sections_created
)
1241 struct elf_info_failed eif
;
1242 bfd_size_type strsize
;
1244 *sinterpptr
= bfd_get_section_by_name (dynobj
, ".interp");
1245 BFD_ASSERT (*sinterpptr
!= NULL
|| info
->shared
);
1251 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, soname
,
1253 if (indx
== (bfd_size_type
) -1
1254 || ! elf_add_dynamic_entry (info
, DT_SONAME
, indx
))
1262 indx
= _bfd_stringtab_add (elf_hash_table (info
)->dynstr
, rpath
,
1264 if (indx
== (bfd_size_type
) -1
1265 || ! elf_add_dynamic_entry (info
, DT_RPATH
, indx
))
1269 /* Find all symbols which were defined in a dynamic object and make
1270 the backend pick a reasonable value for them. */
1273 elf_link_hash_traverse (elf_hash_table (info
),
1274 elf_adjust_dynamic_symbol
,
1279 /* Add some entries to the .dynamic section. We fill in some of the
1280 values later, in elf_bfd_final_link, but we must add the entries
1281 now so that we know the final size of the .dynamic section. */
1282 if (elf_link_hash_lookup (elf_hash_table (info
), "_init", false,
1283 false, false) != NULL
)
1285 if (! elf_add_dynamic_entry (info
, DT_INIT
, 0))
1288 if (elf_link_hash_lookup (elf_hash_table (info
), "_fini", false,
1289 false, false) != NULL
)
1291 if (! elf_add_dynamic_entry (info
, DT_FINI
, 0))
1294 strsize
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1295 if (! elf_add_dynamic_entry (info
, DT_HASH
, 0)
1296 || ! elf_add_dynamic_entry (info
, DT_STRTAB
, 0)
1297 || ! elf_add_dynamic_entry (info
, DT_SYMTAB
, 0)
1298 || ! elf_add_dynamic_entry (info
, DT_STRSZ
, strsize
)
1299 || ! elf_add_dynamic_entry (info
, DT_SYMENT
,
1300 sizeof (Elf_External_Sym
)))
1304 /* The backend must work out the sizes of all the other dynamic
1306 bed
= get_elf_backend_data (output_bfd
);
1307 if (! (*bed
->elf_backend_size_dynamic_sections
) (output_bfd
, info
))
1310 if (elf_hash_table (info
)->dynamic_sections_created
)
1315 size_t bucketcount
= 0;
1316 Elf_Internal_Sym isym
;
1318 /* Set the size of the .dynsym and .hash sections. We counted
1319 the number of dynamic symbols in elf_link_add_object_symbols.
1320 We will build the contents of .dynsym and .hash when we build
1321 the final symbol table, because until then we do not know the
1322 correct value to give the symbols. We built the .dynstr
1323 section as we went along in elf_link_add_object_symbols. */
1324 dynsymcount
= elf_hash_table (info
)->dynsymcount
;
1325 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1326 BFD_ASSERT (s
!= NULL
);
1327 s
->_raw_size
= dynsymcount
* sizeof (Elf_External_Sym
);
1328 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1329 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1331 bfd_set_error (bfd_error_no_memory
);
1335 /* The first entry in .dynsym is a dummy symbol. */
1342 elf_swap_symbol_out (output_bfd
, &isym
,
1343 (char *) (Elf_External_Sym
*) s
->contents
);
1345 for (i
= 0; elf_buckets
[i
] != 0; i
++)
1347 bucketcount
= elf_buckets
[i
];
1348 if (dynsymcount
< elf_buckets
[i
+ 1])
1352 s
= bfd_get_section_by_name (dynobj
, ".hash");
1353 BFD_ASSERT (s
!= NULL
);
1354 s
->_raw_size
= (2 + bucketcount
+ dynsymcount
) * (ARCH_SIZE
/ 8);
1355 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1356 if (s
->contents
== NULL
)
1358 bfd_set_error (bfd_error_no_memory
);
1361 memset (s
->contents
, 0, s
->_raw_size
);
1363 put_word (output_bfd
, bucketcount
, s
->contents
);
1364 put_word (output_bfd
, dynsymcount
, s
->contents
+ (ARCH_SIZE
/ 8));
1366 elf_hash_table (info
)->bucketcount
= bucketcount
;
1368 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1369 BFD_ASSERT (s
!= NULL
);
1370 s
->_raw_size
= _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
1372 if (! elf_add_dynamic_entry (info
, DT_NULL
, 0))
1379 /* This routine is used to export all defined symbols into the dynamic
1380 symbol table. It is called via elf_link_hash_traverse. */
1383 elf_export_symbol (h
, data
)
1384 struct elf_link_hash_entry
*h
;
1387 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1389 if (h
->dynindx
== -1
1390 && (h
->elf_link_hash_flags
1391 & (ELF_LINK_HASH_DEF_REGULAR
| ELF_LINK_HASH_REF_REGULAR
)) != 0)
1393 if (! _bfd_elf_link_record_dynamic_symbol (eif
->info
, h
))
1403 /* Make the backend pick a good value for a dynamic symbol. This is
1404 called via elf_link_hash_traverse, and also calls itself
1408 elf_adjust_dynamic_symbol (h
, data
)
1409 struct elf_link_hash_entry
*h
;
1412 struct elf_info_failed
*eif
= (struct elf_info_failed
*) data
;
1414 struct elf_backend_data
*bed
;
1416 /* If this symbol does not require a PLT entry, and it is not
1417 defined by a dynamic object, or is not referenced by a regular
1418 object, ignore it. FIXME: Do we need to worry about symbols
1419 which are defined by one dynamic object and referenced by another
1421 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0
1422 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1423 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1424 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0))
1427 /* If we've already adjusted this symbol, don't do it again. This
1428 can happen via a recursive call. */
1429 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DYNAMIC_ADJUSTED
) != 0)
1432 /* Don't look at this symbol again. Note that we must set this
1433 after checking the above conditions, because we may look at a
1434 symbol once, decide not to do anything, and then get called
1435 recursively later after REF_REGULAR is set below. */
1436 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DYNAMIC_ADJUSTED
;
1438 /* If this is a weak definition, and we know a real definition, and
1439 the real symbol is not itself defined by a regular object file,
1440 then get a good value for the real definition. We handle the
1441 real symbol first, for the convenience of the backend routine.
1443 Note that there is a confusing case here. If the real definition
1444 is defined by a regular object file, we don't get the real symbol
1445 from the dynamic object, but we do get the weak symbol. If the
1446 processor backend uses a COPY reloc, then if some routine in the
1447 dynamic object changes the real symbol, we will not see that
1448 change in the corresponding weak symbol. This is the way other
1449 ELF linkers work as well, and seems to be a result of the shared
1452 I will clarify this issue. Most SVR4 shared libraries define the
1453 variable _timezone and define timezone as a weak synonym. The
1454 tzset call changes _timezone. If you write
1455 extern int timezone;
1457 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1458 you might expect that, since timezone is a synonym for _timezone,
1459 the same number will print both times. However, if the processor
1460 backend uses a COPY reloc, then actually timezone will be copied
1461 into your process image, and, since you define _timezone
1462 yourself, _timezone will not. Thus timezone and _timezone will
1463 wind up at different memory locations. The tzset call will set
1464 _timezone, leaving timezone unchanged. */
1466 if (h
->weakdef
!= NULL
)
1468 struct elf_link_hash_entry
*weakdef
;
1470 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1471 || h
->root
.type
== bfd_link_hash_defweak
);
1472 weakdef
= h
->weakdef
;
1473 BFD_ASSERT (weakdef
->root
.type
== bfd_link_hash_defined
1474 || weakdef
->root
.type
== bfd_link_hash_defweak
);
1475 BFD_ASSERT (weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
);
1476 if ((weakdef
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0)
1478 /* This symbol is defined by a regular object file, so we
1479 will not do anything special. Clear weakdef for the
1480 convenience of the processor backend. */
1485 /* There is an implicit reference by a regular object file
1486 via the weak symbol. */
1487 weakdef
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1488 if (! elf_adjust_dynamic_symbol (weakdef
, (PTR
) eif
))
1493 dynobj
= elf_hash_table (eif
->info
)->dynobj
;
1494 bed
= get_elf_backend_data (dynobj
);
1495 if (! (*bed
->elf_backend_adjust_dynamic_symbol
) (eif
->info
, h
))
1504 /* Final phase of ELF linker. */
1506 /* A structure we use to avoid passing large numbers of arguments. */
1508 struct elf_final_link_info
1510 /* General link information. */
1511 struct bfd_link_info
*info
;
1514 /* Symbol string table. */
1515 struct bfd_strtab_hash
*symstrtab
;
1516 /* .dynsym section. */
1517 asection
*dynsym_sec
;
1518 /* .hash section. */
1520 /* Buffer large enough to hold contents of any section. */
1522 /* Buffer large enough to hold external relocs of any section. */
1523 PTR external_relocs
;
1524 /* Buffer large enough to hold internal relocs of any section. */
1525 Elf_Internal_Rela
*internal_relocs
;
1526 /* Buffer large enough to hold external local symbols of any input
1528 Elf_External_Sym
*external_syms
;
1529 /* Buffer large enough to hold internal local symbols of any input
1531 Elf_Internal_Sym
*internal_syms
;
1532 /* Array large enough to hold a symbol index for each local symbol
1533 of any input BFD. */
1535 /* Array large enough to hold a section pointer for each local
1536 symbol of any input BFD. */
1537 asection
**sections
;
1538 /* Buffer to hold swapped out symbols. */
1539 Elf_External_Sym
*symbuf
;
1540 /* Number of swapped out symbols in buffer. */
1541 size_t symbuf_count
;
1542 /* Number of symbols which fit in symbuf. */
1546 static boolean elf_link_output_sym
1547 PARAMS ((struct elf_final_link_info
*, const char *,
1548 Elf_Internal_Sym
*, asection
*));
1549 static boolean elf_link_flush_output_syms
1550 PARAMS ((struct elf_final_link_info
*));
1551 static boolean elf_link_output_extsym
1552 PARAMS ((struct elf_link_hash_entry
*, PTR
));
1553 static boolean elf_link_input_bfd
1554 PARAMS ((struct elf_final_link_info
*, bfd
*));
1555 static boolean elf_reloc_link_order
1556 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
1557 struct bfd_link_order
*));
1559 /* This struct is used to pass information to routines called via
1560 elf_link_hash_traverse which must return failure. */
1562 struct elf_finfo_failed
1565 struct elf_final_link_info
*finfo
;
1568 /* Do the final step of an ELF link. */
1571 elf_bfd_final_link (abfd
, info
)
1573 struct bfd_link_info
*info
;
1577 struct elf_final_link_info finfo
;
1578 register asection
*o
;
1579 register struct bfd_link_order
*p
;
1581 size_t max_contents_size
;
1582 size_t max_external_reloc_size
;
1583 size_t max_internal_reloc_count
;
1584 size_t max_sym_count
;
1586 Elf_Internal_Sym elfsym
;
1588 Elf_Internal_Shdr
*symtab_hdr
;
1589 Elf_Internal_Shdr
*symstrtab_hdr
;
1590 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1591 struct elf_finfo_failed eif
;
1594 abfd
->flags
|= DYNAMIC
;
1596 dynamic
= elf_hash_table (info
)->dynamic_sections_created
;
1597 dynobj
= elf_hash_table (info
)->dynobj
;
1600 finfo
.output_bfd
= abfd
;
1601 finfo
.symstrtab
= elf_stringtab_init ();
1602 if (finfo
.symstrtab
== NULL
)
1606 finfo
.dynsym_sec
= NULL
;
1607 finfo
.hash_sec
= NULL
;
1611 finfo
.dynsym_sec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1612 finfo
.hash_sec
= bfd_get_section_by_name (dynobj
, ".hash");
1613 BFD_ASSERT (finfo
.dynsym_sec
!= NULL
&& finfo
.hash_sec
!= NULL
);
1615 finfo
.contents
= NULL
;
1616 finfo
.external_relocs
= NULL
;
1617 finfo
.internal_relocs
= NULL
;
1618 finfo
.external_syms
= NULL
;
1619 finfo
.internal_syms
= NULL
;
1620 finfo
.indices
= NULL
;
1621 finfo
.sections
= NULL
;
1622 finfo
.symbuf
= NULL
;
1623 finfo
.symbuf_count
= 0;
1625 /* Count up the number of relocations we will output for each output
1626 section, so that we know the sizes of the reloc sections. We
1627 also figure out some maximum sizes. */
1628 max_contents_size
= 0;
1629 max_external_reloc_size
= 0;
1630 max_internal_reloc_count
= 0;
1632 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
1636 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1638 if (p
->type
== bfd_section_reloc_link_order
1639 || p
->type
== bfd_symbol_reloc_link_order
)
1641 else if (p
->type
== bfd_indirect_link_order
)
1645 sec
= p
->u
.indirect
.section
;
1647 if (info
->relocateable
)
1648 o
->reloc_count
+= sec
->reloc_count
;
1650 if (sec
->_raw_size
> max_contents_size
)
1651 max_contents_size
= sec
->_raw_size
;
1652 if (sec
->_cooked_size
> max_contents_size
)
1653 max_contents_size
= sec
->_cooked_size
;
1655 /* We are interested in just local symbols, not all
1657 if (bfd_get_flavour (sec
->owner
) == bfd_target_elf_flavour
)
1661 if (elf_bad_symtab (sec
->owner
))
1662 sym_count
= (elf_tdata (sec
->owner
)->symtab_hdr
.sh_size
1663 / sizeof (Elf_External_Sym
));
1665 sym_count
= elf_tdata (sec
->owner
)->symtab_hdr
.sh_info
;
1667 if (sym_count
> max_sym_count
)
1668 max_sym_count
= sym_count
;
1670 if ((sec
->flags
& SEC_RELOC
) != 0)
1674 ext_size
= elf_section_data (sec
)->rel_hdr
.sh_size
;
1675 if (ext_size
> max_external_reloc_size
)
1676 max_external_reloc_size
= ext_size
;
1677 if (sec
->reloc_count
> max_internal_reloc_count
)
1678 max_internal_reloc_count
= sec
->reloc_count
;
1684 if (o
->reloc_count
> 0)
1685 o
->flags
|= SEC_RELOC
;
1688 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1689 set it (this is probably a bug) and if it is set
1690 assign_section_numbers will create a reloc section. */
1691 o
->flags
&=~ SEC_RELOC
;
1694 /* If the SEC_ALLOC flag is not set, force the section VMA to
1695 zero. This is done in elf_fake_sections as well, but forcing
1696 the VMA to 0 here will ensure that relocs against these
1697 sections are handled correctly. */
1698 if ((o
->flags
& SEC_ALLOC
) == 0)
1702 /* Figure out the file positions for everything but the symbol table
1703 and the relocs. We set symcount to force assign_section_numbers
1704 to create a symbol table. */
1705 abfd
->symcount
= info
->strip
== strip_all
? 0 : 1;
1706 BFD_ASSERT (! abfd
->output_has_begun
);
1707 if (! _bfd_elf_compute_section_file_positions (abfd
, info
))
1710 /* That created the reloc sections. Set their sizes, and assign
1711 them file positions, and allocate some buffers. */
1712 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1714 if ((o
->flags
& SEC_RELOC
) != 0)
1716 Elf_Internal_Shdr
*rel_hdr
;
1717 register struct elf_link_hash_entry
**p
, **pend
;
1719 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1721 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
* o
->reloc_count
;
1723 /* The contents field must last into write_object_contents,
1724 so we allocate it with bfd_alloc rather than malloc. */
1725 rel_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rel_hdr
->sh_size
);
1726 if (rel_hdr
->contents
== NULL
&& rel_hdr
->sh_size
!= 0)
1728 bfd_set_error (bfd_error_no_memory
);
1732 p
= ((struct elf_link_hash_entry
**)
1733 malloc (o
->reloc_count
1734 * sizeof (struct elf_link_hash_entry
*)));
1735 if (p
== NULL
&& o
->reloc_count
!= 0)
1737 bfd_set_error (bfd_error_no_memory
);
1740 elf_section_data (o
)->rel_hashes
= p
;
1741 pend
= p
+ o
->reloc_count
;
1742 for (; p
< pend
; p
++)
1745 /* Use the reloc_count field as an index when outputting the
1751 _bfd_elf_assign_file_positions_for_relocs (abfd
);
1753 /* We have now assigned file positions for all the sections except
1754 .symtab and .strtab. We start the .symtab section at the current
1755 file position, and write directly to it. We build the .strtab
1756 section in memory. When we add .dynsym support, we will build
1757 that in memory as well (.dynsym is smaller than .symtab). */
1759 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1760 /* sh_name is set in prep_headers. */
1761 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1762 symtab_hdr
->sh_flags
= 0;
1763 symtab_hdr
->sh_addr
= 0;
1764 symtab_hdr
->sh_size
= 0;
1765 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1766 /* sh_link is set in assign_section_numbers. */
1767 /* sh_info is set below. */
1768 /* sh_offset is set just below. */
1769 symtab_hdr
->sh_addralign
= 4; /* FIXME: system dependent? */
1771 off
= elf_tdata (abfd
)->next_file_pos
;
1772 off
= _bfd_elf_assign_file_position_for_section (symtab_hdr
, off
, true);
1774 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1775 incorrect. We do not yet know the size of the .symtab section.
1776 We correct next_file_pos below, after we do know the size. */
1778 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1779 continuously seeking to the right position in the file. */
1780 if (! info
->keep_memory
|| max_sym_count
< 20)
1781 finfo
.symbuf_size
= 20;
1783 finfo
.symbuf_size
= max_sym_count
;
1784 finfo
.symbuf
= ((Elf_External_Sym
*)
1785 malloc (finfo
.symbuf_size
* sizeof (Elf_External_Sym
)));
1786 if (finfo
.symbuf
== NULL
)
1788 bfd_set_error (bfd_error_no_memory
);
1792 /* Start writing out the symbol table. The first symbol is always a
1794 elfsym
.st_value
= 0;
1797 elfsym
.st_other
= 0;
1798 elfsym
.st_shndx
= SHN_UNDEF
;
1799 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1800 &elfsym
, bfd_und_section_ptr
))
1804 /* Some standard ELF linkers do this, but we don't because it causes
1805 bootstrap comparison failures. */
1806 /* Output a file symbol for the output file as the second symbol.
1807 We output this even if we are discarding local symbols, although
1808 I'm not sure if this is correct. */
1809 elfsym
.st_value
= 0;
1811 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
1812 elfsym
.st_other
= 0;
1813 elfsym
.st_shndx
= SHN_ABS
;
1814 if (! elf_link_output_sym (&finfo
, bfd_get_filename (abfd
),
1815 &elfsym
, bfd_abs_section_ptr
))
1819 /* Output a symbol for each section. We output these even if we are
1820 discarding local symbols, since they are used for relocs. These
1821 symbols have no names. We store the index of each one in the
1822 index field of the section, so that we can find it again when
1823 outputting relocs. */
1824 elfsym
.st_value
= 0;
1826 elfsym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1827 elfsym
.st_other
= 0;
1828 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
1830 o
= section_from_elf_index (abfd
, i
);
1832 o
->target_index
= abfd
->symcount
;
1833 elfsym
.st_shndx
= i
;
1834 if (! elf_link_output_sym (&finfo
, (const char *) NULL
,
1839 /* Allocate some memory to hold information read in from the input
1841 finfo
.contents
= (bfd_byte
*) malloc (max_contents_size
);
1842 finfo
.external_relocs
= (PTR
) malloc (max_external_reloc_size
);
1843 finfo
.internal_relocs
= ((Elf_Internal_Rela
*)
1844 malloc (max_internal_reloc_count
1845 * sizeof (Elf_Internal_Rela
)));
1846 finfo
.external_syms
= ((Elf_External_Sym
*)
1847 malloc (max_sym_count
* sizeof (Elf_External_Sym
)));
1848 finfo
.internal_syms
= ((Elf_Internal_Sym
*)
1849 malloc (max_sym_count
* sizeof (Elf_Internal_Sym
)));
1850 finfo
.indices
= (long *) malloc (max_sym_count
* sizeof (long));
1851 finfo
.sections
= (asection
**) malloc (max_sym_count
* sizeof (asection
*));
1852 if ((finfo
.contents
== NULL
&& max_contents_size
!= 0)
1853 || (finfo
.external_relocs
== NULL
&& max_external_reloc_size
!= 0)
1854 || (finfo
.internal_relocs
== NULL
&& max_internal_reloc_count
!= 0)
1855 || (finfo
.external_syms
== NULL
&& max_sym_count
!= 0)
1856 || (finfo
.internal_syms
== NULL
&& max_sym_count
!= 0)
1857 || (finfo
.indices
== NULL
&& max_sym_count
!= 0)
1858 || (finfo
.sections
== NULL
&& max_sym_count
!= 0))
1860 bfd_set_error (bfd_error_no_memory
);
1864 /* Since ELF permits relocations to be against local symbols, we
1865 must have the local symbols available when we do the relocations.
1866 Since we would rather only read the local symbols once, and we
1867 would rather not keep them in memory, we handle all the
1868 relocations for a single input file at the same time.
1870 Unfortunately, there is no way to know the total number of local
1871 symbols until we have seen all of them, and the local symbol
1872 indices precede the global symbol indices. This means that when
1873 we are generating relocateable output, and we see a reloc against
1874 a global symbol, we can not know the symbol index until we have
1875 finished examining all the local symbols to see which ones we are
1876 going to output. To deal with this, we keep the relocations in
1877 memory, and don't output them until the end of the link. This is
1878 an unfortunate waste of memory, but I don't see a good way around
1879 it. Fortunately, it only happens when performing a relocateable
1880 link, which is not the common case. FIXME: If keep_memory is set
1881 we could write the relocs out and then read them again; I don't
1882 know how bad the memory loss will be. */
1884 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->next
)
1885 sub
->output_has_begun
= false;
1886 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1888 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
1890 if (p
->type
== bfd_indirect_link_order
1891 && (bfd_get_flavour (p
->u
.indirect
.section
->owner
)
1892 == bfd_target_elf_flavour
))
1894 sub
= p
->u
.indirect
.section
->owner
;
1895 if (! sub
->output_has_begun
)
1897 if (! elf_link_input_bfd (&finfo
, sub
))
1899 sub
->output_has_begun
= true;
1902 else if (p
->type
== bfd_section_reloc_link_order
1903 || p
->type
== bfd_symbol_reloc_link_order
)
1905 if (! elf_reloc_link_order (abfd
, info
, o
, p
))
1910 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
1916 /* That wrote out all the local symbols. Finish up the symbol table
1917 with the global symbols. */
1919 /* The sh_info field records the index of the first non local
1921 symtab_hdr
->sh_info
= abfd
->symcount
;
1923 elf_section_data (finfo
.dynsym_sec
->output_section
)->this_hdr
.sh_info
= 1;
1925 /* We get the global symbols from the hash table. */
1928 elf_link_hash_traverse (elf_hash_table (info
), elf_link_output_extsym
,
1933 /* Flush all symbols to the file. */
1934 if (! elf_link_flush_output_syms (&finfo
))
1937 /* Now we know the size of the symtab section. */
1938 off
+= symtab_hdr
->sh_size
;
1940 /* Finish up and write out the symbol string table (.strtab)
1942 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1943 /* sh_name was set in prep_headers. */
1944 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
1945 symstrtab_hdr
->sh_flags
= 0;
1946 symstrtab_hdr
->sh_addr
= 0;
1947 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (finfo
.symstrtab
);
1948 symstrtab_hdr
->sh_entsize
= 0;
1949 symstrtab_hdr
->sh_link
= 0;
1950 symstrtab_hdr
->sh_info
= 0;
1951 /* sh_offset is set just below. */
1952 symstrtab_hdr
->sh_addralign
= 1;
1954 off
= _bfd_elf_assign_file_position_for_section (symstrtab_hdr
, off
, true);
1955 elf_tdata (abfd
)->next_file_pos
= off
;
1957 if (bfd_seek (abfd
, symstrtab_hdr
->sh_offset
, SEEK_SET
) != 0
1958 || ! _bfd_stringtab_emit (abfd
, finfo
.symstrtab
))
1961 /* Adjust the relocs to have the correct symbol indices. */
1962 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1964 struct elf_link_hash_entry
**rel_hash
;
1965 Elf_Internal_Shdr
*rel_hdr
;
1967 if ((o
->flags
& SEC_RELOC
) == 0)
1970 rel_hash
= elf_section_data (o
)->rel_hashes
;
1971 rel_hdr
= &elf_section_data (o
)->rel_hdr
;
1972 for (i
= 0; i
< o
->reloc_count
; i
++, rel_hash
++)
1974 if (*rel_hash
== NULL
)
1977 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
1979 if (rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
1981 Elf_External_Rel
*erel
;
1982 Elf_Internal_Rel irel
;
1984 erel
= (Elf_External_Rel
*) rel_hdr
->contents
+ i
;
1985 elf_swap_reloc_in (abfd
, erel
, &irel
);
1986 irel
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
1987 ELF_R_TYPE (irel
.r_info
));
1988 elf_swap_reloc_out (abfd
, &irel
, erel
);
1992 Elf_External_Rela
*erela
;
1993 Elf_Internal_Rela irela
;
1995 BFD_ASSERT (rel_hdr
->sh_entsize
1996 == sizeof (Elf_External_Rela
));
1998 erela
= (Elf_External_Rela
*) rel_hdr
->contents
+ i
;
1999 elf_swap_reloca_in (abfd
, erela
, &irela
);
2000 irela
.r_info
= ELF_R_INFO ((*rel_hash
)->indx
,
2001 ELF_R_TYPE (irela
.r_info
));
2002 elf_swap_reloca_out (abfd
, &irela
, erela
);
2006 /* Set the reloc_count field to 0 to prevent write_relocs from
2007 trying to swap the relocs out itself. */
2011 /* If we are linking against a dynamic object, or generating a
2012 shared library, finish up the dynamic linking information. */
2015 Elf_External_Dyn
*dyncon
, *dynconend
;
2017 /* Fix up .dynamic entries. */
2018 o
= bfd_get_section_by_name (dynobj
, ".dynamic");
2019 BFD_ASSERT (o
!= NULL
);
2021 dyncon
= (Elf_External_Dyn
*) o
->contents
;
2022 dynconend
= (Elf_External_Dyn
*) (o
->contents
+ o
->_raw_size
);
2023 for (; dyncon
< dynconend
; dyncon
++)
2025 Elf_Internal_Dyn dyn
;
2029 elf_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2036 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2037 magic _init and _fini symbols. This is pretty ugly,
2038 but we are compatible. */
2046 struct elf_link_hash_entry
*h
;
2048 h
= elf_link_hash_lookup (elf_hash_table (info
), name
,
2049 false, false, true);
2050 BFD_ASSERT (h
!= NULL
);
2051 if (h
->root
.type
== bfd_link_hash_defined
2052 || h
->root
.type
== bfd_link_hash_defweak
)
2054 dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2055 o
= h
->root
.u
.def
.section
;
2056 if (o
->output_section
!= NULL
)
2057 dyn
.d_un
.d_val
+= (o
->output_section
->vma
2058 + o
->output_offset
);
2060 /* The symbol is imported from another shared
2061 library and does not apply to this one. */
2064 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2077 o
= bfd_get_section_by_name (abfd
, name
);
2078 BFD_ASSERT (o
!= NULL
);
2079 dyn
.d_un
.d_ptr
= o
->vma
;
2080 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2087 if (dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
2092 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2094 Elf_Internal_Shdr
*hdr
;
2096 hdr
= elf_elfsections (abfd
)[i
];
2097 if (hdr
->sh_type
== type
2098 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2100 if (dyn
.d_tag
== DT_RELSZ
|| dyn
.d_tag
== DT_RELASZ
)
2101 dyn
.d_un
.d_val
+= hdr
->sh_size
;
2104 if (dyn
.d_un
.d_val
== 0
2105 || hdr
->sh_addr
< dyn
.d_un
.d_val
)
2106 dyn
.d_un
.d_val
= hdr
->sh_addr
;
2110 elf_swap_dyn_out (dynobj
, &dyn
, dyncon
);
2116 /* If we have created any dynamic sections, then output them. */
2119 if (! (*bed
->elf_backend_finish_dynamic_sections
) (abfd
, info
))
2122 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2124 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2125 || o
->_raw_size
== 0)
2127 if ((o
->flags
& SEC_IN_MEMORY
) == 0)
2129 /* At this point, we are only interested in sections
2130 created by elf_link_create_dynamic_sections. FIXME:
2131 This test is fragile. */
2134 if ((elf_section_data (o
->output_section
)->this_hdr
.sh_type
2136 || strcmp (bfd_get_section_name (abfd
, o
), ".dynstr") != 0)
2138 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2139 o
->contents
, o
->output_offset
,
2147 /* The contents of the .dynstr section are actually in a
2149 off
= elf_section_data (o
->output_section
)->this_hdr
.sh_offset
;
2150 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
2151 || ! _bfd_stringtab_emit (abfd
,
2152 elf_hash_table (info
)->dynstr
))
2158 if (finfo
.symstrtab
!= NULL
)
2159 _bfd_stringtab_free (finfo
.symstrtab
);
2160 if (finfo
.contents
!= NULL
)
2161 free (finfo
.contents
);
2162 if (finfo
.external_relocs
!= NULL
)
2163 free (finfo
.external_relocs
);
2164 if (finfo
.internal_relocs
!= NULL
)
2165 free (finfo
.internal_relocs
);
2166 if (finfo
.external_syms
!= NULL
)
2167 free (finfo
.external_syms
);
2168 if (finfo
.internal_syms
!= NULL
)
2169 free (finfo
.internal_syms
);
2170 if (finfo
.indices
!= NULL
)
2171 free (finfo
.indices
);
2172 if (finfo
.sections
!= NULL
)
2173 free (finfo
.sections
);
2174 if (finfo
.symbuf
!= NULL
)
2175 free (finfo
.symbuf
);
2176 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2178 if ((o
->flags
& SEC_RELOC
) != 0
2179 && elf_section_data (o
)->rel_hashes
!= NULL
)
2180 free (elf_section_data (o
)->rel_hashes
);
2183 elf_tdata (abfd
)->linker
= true;
2188 if (finfo
.symstrtab
!= NULL
)
2189 _bfd_stringtab_free (finfo
.symstrtab
);
2190 if (finfo
.contents
!= NULL
)
2191 free (finfo
.contents
);
2192 if (finfo
.external_relocs
!= NULL
)
2193 free (finfo
.external_relocs
);
2194 if (finfo
.internal_relocs
!= NULL
)
2195 free (finfo
.internal_relocs
);
2196 if (finfo
.external_syms
!= NULL
)
2197 free (finfo
.external_syms
);
2198 if (finfo
.internal_syms
!= NULL
)
2199 free (finfo
.internal_syms
);
2200 if (finfo
.indices
!= NULL
)
2201 free (finfo
.indices
);
2202 if (finfo
.sections
!= NULL
)
2203 free (finfo
.sections
);
2204 if (finfo
.symbuf
!= NULL
)
2205 free (finfo
.symbuf
);
2206 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2208 if ((o
->flags
& SEC_RELOC
) != 0
2209 && elf_section_data (o
)->rel_hashes
!= NULL
)
2210 free (elf_section_data (o
)->rel_hashes
);
2216 /* Add a symbol to the output symbol table. */
2219 elf_link_output_sym (finfo
, name
, elfsym
, input_sec
)
2220 struct elf_final_link_info
*finfo
;
2222 Elf_Internal_Sym
*elfsym
;
2223 asection
*input_sec
;
2225 boolean (*output_symbol_hook
) PARAMS ((bfd
*,
2226 struct bfd_link_info
*info
,
2231 output_symbol_hook
= get_elf_backend_data (finfo
->output_bfd
)->
2232 elf_backend_link_output_symbol_hook
;
2233 if (output_symbol_hook
!= NULL
)
2235 if (! ((*output_symbol_hook
)
2236 (finfo
->output_bfd
, finfo
->info
, name
, elfsym
, input_sec
)))
2240 if (name
== (const char *) NULL
|| *name
== '\0')
2241 elfsym
->st_name
= 0;
2244 elfsym
->st_name
= (unsigned long) _bfd_stringtab_add (finfo
->symstrtab
,
2247 if (elfsym
->st_name
== (unsigned long) -1)
2251 if (finfo
->symbuf_count
>= finfo
->symbuf_size
)
2253 if (! elf_link_flush_output_syms (finfo
))
2257 elf_swap_symbol_out (finfo
->output_bfd
, elfsym
,
2258 (char *) (finfo
->symbuf
+ finfo
->symbuf_count
));
2259 ++finfo
->symbuf_count
;
2261 ++finfo
->output_bfd
->symcount
;
2266 /* Flush the output symbols to the file. */
2269 elf_link_flush_output_syms (finfo
)
2270 struct elf_final_link_info
*finfo
;
2272 Elf_Internal_Shdr
*symtab
;
2274 symtab
= &elf_tdata (finfo
->output_bfd
)->symtab_hdr
;
2276 if (bfd_seek (finfo
->output_bfd
, symtab
->sh_offset
+ symtab
->sh_size
,
2278 || (bfd_write ((PTR
) finfo
->symbuf
, finfo
->symbuf_count
,
2279 sizeof (Elf_External_Sym
), finfo
->output_bfd
)
2280 != finfo
->symbuf_count
* sizeof (Elf_External_Sym
)))
2283 symtab
->sh_size
+= finfo
->symbuf_count
* sizeof (Elf_External_Sym
);
2285 finfo
->symbuf_count
= 0;
2290 /* Add an external symbol to the symbol table. This is called from
2291 the hash table traversal routine. */
2294 elf_link_output_extsym (h
, data
)
2295 struct elf_link_hash_entry
*h
;
2298 struct elf_finfo_failed
*eif
= (struct elf_finfo_failed
*) data
;
2299 struct elf_final_link_info
*finfo
= eif
->finfo
;
2301 Elf_Internal_Sym sym
;
2302 asection
*input_sec
;
2304 /* If we are not creating a shared library, and this symbol is
2305 referenced by a shared library but is not defined anywhere, then
2306 warn that it is undefined. If we do not do this, the runtime
2307 linker will complain that the symbol is undefined when the
2308 program is run. We don't have to worry about symbols that are
2309 referenced by regular files, because we will already have issued
2310 warnings for them. */
2311 if (! finfo
->info
->relocateable
2312 && ! finfo
->info
->shared
2313 && h
->root
.type
== bfd_link_hash_undefined
2314 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0
2315 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2317 if (! ((*finfo
->info
->callbacks
->undefined_symbol
)
2318 (finfo
->info
, h
->root
.root
.string
, h
->root
.u
.undef
.abfd
,
2319 (asection
*) NULL
, 0)))
2326 /* We don't want to output symbols that have never been mentioned by
2327 a regular file, or that we have been told to strip. However, if
2328 h->indx is set to -2, the symbol is used by a reloc and we must
2332 else if (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2333 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2334 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2335 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2337 else if (finfo
->info
->strip
== strip_all
2338 || (finfo
->info
->strip
== strip_some
2339 && bfd_hash_lookup (finfo
->info
->keep_hash
,
2340 h
->root
.root
.string
,
2341 false, false) == NULL
))
2346 /* If we're stripping it, and it's not a dynamic symbol, there's
2347 nothing else to do. */
2348 if (strip
&& h
->dynindx
== -1)
2352 sym
.st_size
= h
->size
;
2354 if (h
->root
.type
== bfd_link_hash_undefweak
2355 || h
->root
.type
== bfd_link_hash_defweak
)
2356 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, h
->type
);
2358 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, h
->type
);
2360 switch (h
->root
.type
)
2363 case bfd_link_hash_new
:
2367 case bfd_link_hash_undefined
:
2368 input_sec
= bfd_und_section_ptr
;
2369 sym
.st_shndx
= SHN_UNDEF
;
2372 case bfd_link_hash_undefweak
:
2373 input_sec
= bfd_und_section_ptr
;
2374 sym
.st_shndx
= SHN_UNDEF
;
2377 case bfd_link_hash_defined
:
2378 case bfd_link_hash_defweak
:
2380 input_sec
= h
->root
.u
.def
.section
;
2381 if (input_sec
->output_section
!= NULL
)
2384 _bfd_elf_section_from_bfd_section (finfo
->output_bfd
,
2385 input_sec
->output_section
);
2386 if (sym
.st_shndx
== (unsigned short) -1)
2392 /* ELF symbols in relocateable files are section relative,
2393 but in nonrelocateable files they are virtual
2395 sym
.st_value
= h
->root
.u
.def
.value
+ input_sec
->output_offset
;
2396 if (! finfo
->info
->relocateable
)
2397 sym
.st_value
+= input_sec
->output_section
->vma
;
2401 BFD_ASSERT ((bfd_get_flavour (input_sec
->owner
)
2402 == bfd_target_elf_flavour
)
2403 && elf_elfheader (input_sec
->owner
)->e_type
== ET_DYN
);
2404 sym
.st_shndx
= SHN_UNDEF
;
2405 input_sec
= bfd_und_section_ptr
;
2410 case bfd_link_hash_common
:
2411 input_sec
= bfd_com_section_ptr
;
2412 sym
.st_shndx
= SHN_COMMON
;
2413 sym
.st_value
= 1 << h
->root
.u
.c
.p
->alignment_power
;
2416 case bfd_link_hash_indirect
:
2417 case bfd_link_hash_warning
:
2418 /* I have no idea how these should be handled. */
2422 /* If this symbol should be put in the .dynsym section, then put it
2423 there now. We have already know the symbol index. We also fill
2424 in the entry in the .hash section. */
2425 if (h
->dynindx
!= -1
2426 && elf_hash_table (finfo
->info
)->dynamic_sections_created
)
2428 struct elf_backend_data
*bed
;
2431 bfd_byte
*bucketpos
;
2434 sym
.st_name
= h
->dynstr_index
;
2436 /* Give the processor backend a chance to tweak the symbol
2437 value, and also to finish up anything that needs to be done
2439 bed
= get_elf_backend_data (finfo
->output_bfd
);
2440 if (! ((*bed
->elf_backend_finish_dynamic_symbol
)
2441 (finfo
->output_bfd
, finfo
->info
, h
, &sym
)))
2447 elf_swap_symbol_out (finfo
->output_bfd
, &sym
,
2448 (char *) ((Elf_External_Sym
*) finfo
->dynsym_sec
->contents
2451 bucketcount
= elf_hash_table (finfo
->info
)->bucketcount
;
2452 bucket
= (bfd_elf_hash ((const unsigned char *) h
->root
.root
.string
)
2454 bucketpos
= ((bfd_byte
*) finfo
->hash_sec
->contents
2455 + (bucket
+ 2) * (ARCH_SIZE
/ 8));
2456 chain
= get_word (finfo
->output_bfd
, bucketpos
);
2457 put_word (finfo
->output_bfd
, h
->dynindx
, bucketpos
);
2458 put_word (finfo
->output_bfd
, chain
,
2459 ((bfd_byte
*) finfo
->hash_sec
->contents
2460 + (bucketcount
+ 2 + h
->dynindx
) * (ARCH_SIZE
/ 8)));
2463 /* If we're stripping it, then it was just a dynamic symbol, and
2464 there's nothing else to do. */
2468 h
->indx
= finfo
->output_bfd
->symcount
;
2470 if (! elf_link_output_sym (finfo
, h
->root
.root
.string
, &sym
, input_sec
))
2479 /* Link an input file into the linker output file. This function
2480 handles all the sections and relocations of the input file at once.
2481 This is so that we only have to read the local symbols once, and
2482 don't have to keep them in memory. */
2485 elf_link_input_bfd (finfo
, input_bfd
)
2486 struct elf_final_link_info
*finfo
;
2489 boolean (*relocate_section
) PARAMS ((bfd
*, struct bfd_link_info
*,
2490 bfd
*, asection
*, bfd_byte
*,
2491 Elf_Internal_Rela
*,
2492 Elf_Internal_Sym
*, asection
**));
2494 Elf_Internal_Shdr
*symtab_hdr
;
2497 Elf_External_Sym
*esym
;
2498 Elf_External_Sym
*esymend
;
2499 Elf_Internal_Sym
*isym
;
2501 asection
**ppsection
;
2504 output_bfd
= finfo
->output_bfd
;
2506 get_elf_backend_data (output_bfd
)->elf_backend_relocate_section
;
2508 /* If this is a dynamic object, we don't want to do anything here:
2509 we don't want the local symbols, and we don't want the section
2511 if (elf_elfheader (input_bfd
)->e_type
== ET_DYN
)
2514 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2515 if (elf_bad_symtab (input_bfd
))
2517 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2522 locsymcount
= symtab_hdr
->sh_info
;
2523 extsymoff
= symtab_hdr
->sh_info
;
2526 /* Read the local symbols. */
2528 && (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2529 || (bfd_read (finfo
->external_syms
, sizeof (Elf_External_Sym
),
2530 locsymcount
, input_bfd
)
2531 != locsymcount
* sizeof (Elf_External_Sym
))))
2534 /* Swap in the local symbols and write out the ones which we know
2535 are going into the output file. */
2536 esym
= finfo
->external_syms
;
2537 esymend
= esym
+ locsymcount
;
2538 isym
= finfo
->internal_syms
;
2539 pindex
= finfo
->indices
;
2540 ppsection
= finfo
->sections
;
2541 for (; esym
< esymend
; esym
++, isym
++, pindex
++, ppsection
++)
2545 Elf_Internal_Sym osym
;
2547 elf_swap_symbol_in (input_bfd
, esym
, isym
);
2550 if (elf_bad_symtab (input_bfd
))
2552 if (ELF_ST_BIND (isym
->st_info
) != STB_LOCAL
)
2559 if (isym
->st_shndx
== SHN_UNDEF
)
2560 isec
= bfd_und_section_ptr
;
2561 else if (isym
->st_shndx
> 0 && isym
->st_shndx
< SHN_LORESERVE
)
2562 isec
= section_from_elf_index (input_bfd
, isym
->st_shndx
);
2563 else if (isym
->st_shndx
== SHN_ABS
)
2564 isec
= bfd_abs_section_ptr
;
2565 else if (isym
->st_shndx
== SHN_COMMON
)
2566 isec
= bfd_com_section_ptr
;
2575 /* Don't output the first, undefined, symbol. */
2576 if (esym
== finfo
->external_syms
)
2579 /* If we are stripping all symbols, we don't want to output this
2581 if (finfo
->info
->strip
== strip_all
)
2584 /* We never output section symbols. Instead, we use the section
2585 symbol of the corresponding section in the output file. */
2586 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2589 /* If we are discarding all local symbols, we don't want to
2590 output this one. If we are generating a relocateable output
2591 file, then some of the local symbols may be required by
2592 relocs; we output them below as we discover that they are
2594 if (finfo
->info
->discard
== discard_all
)
2597 /* Get the name of the symbol. */
2598 name
= bfd_elf_string_from_elf_section (input_bfd
, symtab_hdr
->sh_link
,
2603 /* See if we are discarding symbols with this name. */
2604 if ((finfo
->info
->strip
== strip_some
2605 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false, false)
2607 || (finfo
->info
->discard
== discard_l
2608 && strncmp (name
, finfo
->info
->lprefix
,
2609 finfo
->info
->lprefix_len
) == 0))
2612 /* If we get here, we are going to output this symbol. */
2616 /* Adjust the section index for the output file. */
2617 osym
.st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
2618 isec
->output_section
);
2619 if (osym
.st_shndx
== (unsigned short) -1)
2622 *pindex
= output_bfd
->symcount
;
2624 /* ELF symbols in relocateable files are section relative, but
2625 in executable files they are virtual addresses. Note that
2626 this code assumes that all ELF sections have an associated
2627 BFD section with a reasonable value for output_offset; below
2628 we assume that they also have a reasonable value for
2629 output_section. Any special sections must be set up to meet
2630 these requirements. */
2631 osym
.st_value
+= isec
->output_offset
;
2632 if (! finfo
->info
->relocateable
)
2633 osym
.st_value
+= isec
->output_section
->vma
;
2635 if (! elf_link_output_sym (finfo
, name
, &osym
, isec
))
2639 /* Relocate the contents of each section. */
2640 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2642 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0)
2645 if ((o
->flags
& SEC_IN_MEMORY
) != 0
2646 && input_bfd
== elf_hash_table (finfo
->info
)->dynobj
)
2648 /* Section was created by elf_link_create_dynamic_sections.
2649 FIXME: This test is fragile. */
2653 /* Read the contents of the section. */
2654 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2655 (file_ptr
) 0, o
->_raw_size
))
2658 if ((o
->flags
& SEC_RELOC
) != 0)
2660 Elf_Internal_Rela
*internal_relocs
;
2662 /* Get the swapped relocs. */
2663 internal_relocs
= elf_link_read_relocs (input_bfd
, o
,
2664 finfo
->external_relocs
,
2665 finfo
->internal_relocs
,
2667 if (internal_relocs
== NULL
2668 && o
->reloc_count
> 0)
2671 /* Relocate the section by invoking a back end routine.
2673 The back end routine is responsible for adjusting the
2674 section contents as necessary, and (if using Rela relocs
2675 and generating a relocateable output file) adjusting the
2676 reloc addend as necessary.
2678 The back end routine does not have to worry about setting
2679 the reloc address or the reloc symbol index.
2681 The back end routine is given a pointer to the swapped in
2682 internal symbols, and can access the hash table entries
2683 for the external symbols via elf_sym_hashes (input_bfd).
2685 When generating relocateable output, the back end routine
2686 must handle STB_LOCAL/STT_SECTION symbols specially. The
2687 output symbol is going to be a section symbol
2688 corresponding to the output section, which will require
2689 the addend to be adjusted. */
2691 if (! (*relocate_section
) (output_bfd
, finfo
->info
,
2695 finfo
->internal_syms
,
2699 if (finfo
->info
->relocateable
)
2701 Elf_Internal_Rela
*irela
;
2702 Elf_Internal_Rela
*irelaend
;
2703 struct elf_link_hash_entry
**rel_hash
;
2704 Elf_Internal_Shdr
*input_rel_hdr
;
2705 Elf_Internal_Shdr
*output_rel_hdr
;
2707 /* Adjust the reloc addresses and symbol indices. */
2709 irela
= internal_relocs
;
2710 irelaend
= irela
+ o
->reloc_count
;
2711 rel_hash
= (elf_section_data (o
->output_section
)->rel_hashes
2712 + o
->output_section
->reloc_count
);
2713 for (; irela
< irelaend
; irela
++, rel_hash
++)
2716 Elf_Internal_Sym
*isym
;
2719 irela
->r_offset
+= o
->output_offset
;
2721 r_symndx
= ELF_R_SYM (irela
->r_info
);
2726 if (r_symndx
>= locsymcount
2727 || (elf_bad_symtab (input_bfd
)
2728 && finfo
->sections
[r_symndx
] == NULL
))
2732 /* This is a reloc against a global symbol. We
2733 have not yet output all the local symbols, so
2734 we do not know the symbol index of any global
2735 symbol. We set the rel_hash entry for this
2736 reloc to point to the global hash table entry
2737 for this symbol. The symbol index is then
2738 set at the end of elf_bfd_final_link. */
2739 indx
= r_symndx
- extsymoff
;
2740 *rel_hash
= elf_sym_hashes (input_bfd
)[indx
];
2742 /* Setting the index to -2 tells
2743 elf_link_output_extsym that this symbol is
2745 BFD_ASSERT ((*rel_hash
)->indx
< 0);
2746 (*rel_hash
)->indx
= -2;
2751 /* This is a reloc against a local symbol. */
2754 isym
= finfo
->internal_syms
+ r_symndx
;
2755 sec
= finfo
->sections
[r_symndx
];
2756 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
2758 /* I suppose the backend ought to fill in the
2759 section of any STT_SECTION symbol against a
2760 processor specific section. */
2761 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2763 else if (sec
== NULL
|| sec
->owner
== NULL
)
2765 bfd_set_error (bfd_error_bad_value
);
2770 r_symndx
= sec
->output_section
->target_index
;
2771 BFD_ASSERT (r_symndx
!= 0);
2776 if (finfo
->indices
[r_symndx
] == -1)
2782 if (finfo
->info
->strip
== strip_all
)
2784 /* You can't do ld -r -s. */
2785 bfd_set_error (bfd_error_invalid_operation
);
2789 /* This symbol was skipped earlier, but
2790 since it is needed by a reloc, we
2791 must output it now. */
2792 link
= symtab_hdr
->sh_link
;
2793 name
= bfd_elf_string_from_elf_section (input_bfd
,
2799 osec
= sec
->output_section
;
2801 _bfd_elf_section_from_bfd_section (output_bfd
,
2803 if (isym
->st_shndx
== (unsigned short) -1)
2806 isym
->st_value
+= sec
->output_offset
;
2807 if (! finfo
->info
->relocateable
)
2808 isym
->st_value
+= osec
->vma
;
2810 finfo
->indices
[r_symndx
] = output_bfd
->symcount
;
2812 if (! elf_link_output_sym (finfo
, name
, isym
, sec
))
2816 r_symndx
= finfo
->indices
[r_symndx
];
2819 irela
->r_info
= ELF_R_INFO (r_symndx
,
2820 ELF_R_TYPE (irela
->r_info
));
2823 /* Swap out the relocs. */
2824 input_rel_hdr
= &elf_section_data (o
)->rel_hdr
;
2825 output_rel_hdr
= &elf_section_data (o
->output_section
)->rel_hdr
;
2826 BFD_ASSERT (output_rel_hdr
->sh_entsize
2827 == input_rel_hdr
->sh_entsize
);
2828 irela
= internal_relocs
;
2829 irelaend
= irela
+ o
->reloc_count
;
2830 if (input_rel_hdr
->sh_entsize
== sizeof (Elf_External_Rel
))
2832 Elf_External_Rel
*erel
;
2834 erel
= ((Elf_External_Rel
*) output_rel_hdr
->contents
2835 + o
->output_section
->reloc_count
);
2836 for (; irela
< irelaend
; irela
++, erel
++)
2838 Elf_Internal_Rel irel
;
2840 irel
.r_offset
= irela
->r_offset
;
2841 irel
.r_info
= irela
->r_info
;
2842 BFD_ASSERT (irela
->r_addend
== 0);
2843 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
2848 Elf_External_Rela
*erela
;
2850 BFD_ASSERT (input_rel_hdr
->sh_entsize
2851 == sizeof (Elf_External_Rela
));
2852 erela
= ((Elf_External_Rela
*) output_rel_hdr
->contents
2853 + o
->output_section
->reloc_count
);
2854 for (; irela
< irelaend
; irela
++, erela
++)
2855 elf_swap_reloca_out (output_bfd
, irela
, erela
);
2858 o
->output_section
->reloc_count
+= o
->reloc_count
;
2862 /* Write out the modified section contents. */
2863 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2864 finfo
->contents
, o
->output_offset
,
2865 (o
->_cooked_size
!= 0
2874 /* Generate a reloc when linking an ELF file. This is a reloc
2875 requested by the linker, and does come from any input file. This
2876 is used to build constructor and destructor tables when linking
2880 elf_reloc_link_order (output_bfd
, info
, output_section
, link_order
)
2882 struct bfd_link_info
*info
;
2883 asection
*output_section
;
2884 struct bfd_link_order
*link_order
;
2886 reloc_howto_type
*howto
;
2889 struct elf_link_hash_entry
**rel_hash_ptr
;
2890 Elf_Internal_Shdr
*rel_hdr
;
2892 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2895 bfd_set_error (bfd_error_bad_value
);
2899 /* If this is an inplace reloc, we must write the addend into the
2901 if (howto
->partial_inplace
2902 && link_order
->u
.reloc
.p
->addend
!= 0)
2905 bfd_reloc_status_type rstat
;
2909 size
= bfd_get_reloc_size (howto
);
2910 buf
= (bfd_byte
*) bfd_zmalloc (size
);
2911 if (buf
== (bfd_byte
*) NULL
)
2913 bfd_set_error (bfd_error_no_memory
);
2916 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
2917 link_order
->u
.reloc
.p
->addend
, buf
);
2923 case bfd_reloc_outofrange
:
2925 case bfd_reloc_overflow
:
2926 if (! ((*info
->callbacks
->reloc_overflow
)
2928 (link_order
->type
== bfd_section_reloc_link_order
2929 ? bfd_section_name (output_bfd
,
2930 link_order
->u
.reloc
.p
->u
.section
)
2931 : link_order
->u
.reloc
.p
->u
.name
),
2932 howto
->name
, link_order
->u
.reloc
.p
->addend
,
2933 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
2940 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
2941 (file_ptr
) link_order
->offset
, size
);
2947 /* Figure out the symbol index. */
2948 rel_hash_ptr
= (elf_section_data (output_section
)->rel_hashes
2949 + output_section
->reloc_count
);
2950 if (link_order
->type
== bfd_section_reloc_link_order
)
2952 indx
= link_order
->u
.reloc
.p
->u
.section
->target_index
;
2953 BFD_ASSERT (indx
!= 0);
2954 *rel_hash_ptr
= NULL
;
2958 struct elf_link_hash_entry
*h
;
2960 h
= elf_link_hash_lookup (elf_hash_table (info
),
2961 link_order
->u
.reloc
.p
->u
.name
,
2962 false, false, true);
2965 /* Setting the index to -2 tells elf_link_output_extsym that
2966 this symbol is used by a reloc. */
2973 if (! ((*info
->callbacks
->unattached_reloc
)
2974 (info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
2975 (asection
*) NULL
, (bfd_vma
) 0)))
2981 /* The address of a reloc is relative to the section in a
2982 relocateable file, and is a virtual address in an executable
2984 offset
= link_order
->offset
;
2985 if (! info
->relocateable
)
2986 offset
+= output_section
->vma
;
2988 rel_hdr
= &elf_section_data (output_section
)->rel_hdr
;
2990 if (rel_hdr
->sh_type
== SHT_REL
)
2992 Elf_Internal_Rel irel
;
2993 Elf_External_Rel
*erel
;
2995 irel
.r_offset
= offset
;
2996 irel
.r_info
= ELF_R_INFO (indx
, howto
->type
);
2997 erel
= ((Elf_External_Rel
*) rel_hdr
->contents
2998 + output_section
->reloc_count
);
2999 elf_swap_reloc_out (output_bfd
, &irel
, erel
);
3003 Elf_Internal_Rela irela
;
3004 Elf_External_Rela
*erela
;
3006 irela
.r_offset
= offset
;
3007 irela
.r_info
= ELF_R_INFO (indx
, howto
->type
);
3008 irela
.r_addend
= link_order
->u
.reloc
.p
->addend
;
3009 erela
= ((Elf_External_Rela
*) rel_hdr
->contents
3010 + output_section
->reloc_count
);
3011 elf_swap_reloca_out (output_bfd
, &irela
, erela
);
3014 ++output_section
->reloc_count
;