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., 675 Mass Ave, Cambridge, MA 02139, USA. */
19 /* ELF linker code. */
21 static boolean elf_link_add_object_symbols
22 PARAMS ((bfd *, struct bfd_link_info *));
23 static boolean elf_link_add_archive_symbols
24 PARAMS ((bfd *, struct bfd_link_info *));
25 static Elf_Internal_Rela *elf_link_read_relocs
26 PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean));
27 static boolean elf_export_symbol
28 PARAMS ((struct elf_link_hash_entry *, PTR));
29 static boolean elf_adjust_dynamic_symbol
30 PARAMS ((struct elf_link_hash_entry *, PTR));
32 /* This struct is used to pass information to routines called via
33 elf_link_hash_traverse which must return failure. */
35 struct elf_info_failed
38 struct bfd_link_info *info;
41 /* Given an ELF BFD, add symbols to the global hash table as
45 elf_bfd_link_add_symbols (abfd, info)
47 struct bfd_link_info *info;
51 switch (bfd_get_format (abfd))
54 return elf_link_add_object_symbols (abfd, info);
56 first = bfd_openr_next_archived_file (abfd, (bfd *) NULL);
59 /* It's OK to have an empty archive. */
62 if (! bfd_check_format (first, bfd_object))
64 if (bfd_get_flavour (first) != bfd_target_elf_flavour)
66 /* On Linux, we may have an a.out archive which got
67 recognized as an ELF archive. Therefore, we treat all
68 archives as though they were actually of the flavour of
69 their first element. */
70 return (*first->xvec->_bfd_link_add_symbols) (abfd, info);
72 return elf_link_add_archive_symbols (abfd, info);
74 bfd_set_error (bfd_error_wrong_format);
79 /* Add symbols from an ELF archive file to the linker hash table. We
80 don't use _bfd_generic_link_add_archive_symbols because of a
81 problem which arises on UnixWare. The UnixWare libc.so is an
82 archive which includes an entry libc.so.1 which defines a bunch of
83 symbols. The libc.so archive also includes a number of other
84 object files, which also define symbols, some of which are the same
85 as those defined in libc.so.1. Correct linking requires that we
86 consider each object file in turn, and include it if it defines any
87 symbols we need. _bfd_generic_link_add_archive_symbols does not do
88 this; it looks through the list of undefined symbols, and includes
89 any object file which defines them. When this algorithm is used on
90 UnixWare, it winds up pulling in libc.so.1 early and defining a
91 bunch of symbols. This means that some of the other objects in the
92 archive are not included in the link, which is incorrect since they
93 precede libc.so.1 in the archive.
95 Fortunately, ELF archive handling is simpler than that done by
96 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
97 oddities. In ELF, if we find a symbol in the archive map, and the
98 symbol is currently undefined, we know that we must pull in that
101 Unfortunately, we do have to make multiple passes over the symbol
102 table until nothing further is resolved. */
105 elf_link_add_archive_symbols (abfd, info)
107 struct bfd_link_info *info;
110 boolean *defined = NULL;
111 boolean *included = NULL;
115 if (! bfd_has_map (abfd))
117 /* An empty archive is a special case. */
118 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
120 bfd_set_error (bfd_error_no_armap);
124 /* Keep track of all symbols we know to be already defined, and all
125 files we know to be already included. This is to speed up the
126 second and subsequent passes. */
127 c = bfd_ardata (abfd)->symdef_count;
130 defined = (boolean *) malloc (c * sizeof (boolean));
131 included = (boolean *) malloc (c * sizeof (boolean));
132 if (defined == (boolean *) NULL || included == (boolean *) NULL)
134 bfd_set_error (bfd_error_no_memory);
137 memset (defined, 0, c * sizeof (boolean));
138 memset (included, 0, c * sizeof (boolean));
140 symdefs = bfd_ardata (abfd)->symdefs;
153 symdefend = symdef + c;
154 for (i = 0; symdef < symdefend; symdef++, i++)
156 struct elf_link_hash_entry *h;
158 struct bfd_link_hash_entry *undefs_tail;
161 if (defined[i] || included[i])
163 if (symdef->file_offset == last)
169 h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
170 false, false, false);
171 if (h == (struct elf_link_hash_entry *) NULL)
173 if (h->root.type != bfd_link_hash_undefined)
179 /* We need to include this archive member. */
181 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
182 if (element == (bfd *) NULL)
185 if (! bfd_check_format (element, bfd_object))
188 /* Doublecheck that we have not included this object
189 already--it should be impossible, but there may be
190 something wrong with the archive. */
191 if (element->archive_pass != 0)
193 bfd_set_error (bfd_error_bad_value);
196 element->archive_pass = 1;
198 undefs_tail = info->hash->undefs_tail;
200 if (! (*info->callbacks->add_archive_element) (info, element,
203 if (! elf_link_add_object_symbols (element, info))
206 /* If there are any new undefined symbols, we need to make
207 another pass through the archive in order to see whether
208 they can be defined. FIXME: This isn't perfect, because
209 common symbols wind up on undefs_tail and because an
210 undefined symbol which is defined later on in this pass
211 does not require another pass. This isn't a bug, but it
212 does make the code less efficient than it could be. */
213 if (undefs_tail != info->hash->undefs_tail)
216 /* Look backward to mark all symbols from this object file
217 which we have already seen in this pass. */
221 included[mark] = true;
226 while (symdefs[mark].file_offset == symdef->file_offset);
228 /* We mark subsequent symbols from this object file as we go
229 on through the loop. */
230 last = symdef->file_offset;
241 if (defined != (boolean *) NULL)
243 if (included != (boolean *) NULL)
248 /* Add symbols from an ELF object file to the linker hash table. */
251 elf_link_add_object_symbols (abfd, info)
253 struct bfd_link_info *info;
255 boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
256 const Elf_Internal_Sym *,
257 const char **, flagword *,
258 asection **, bfd_vma *));
259 boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
260 asection *, const Elf_Internal_Rela *));
262 Elf_Internal_Shdr *hdr;
266 Elf_External_Sym *buf = NULL;
267 struct elf_link_hash_entry **sym_hash;
269 Elf_External_Dyn *dynbuf = NULL;
270 struct elf_link_hash_entry *weaks;
271 Elf_External_Sym *esym;
272 Elf_External_Sym *esymend;
274 add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
275 collect = get_elf_backend_data (abfd)->collect;
277 /* A stripped shared library might only have a dynamic symbol table,
278 not a regular symbol table. In that case we can still go ahead
279 and link using the dynamic symbol table. */
280 if (elf_onesymtab (abfd) == 0
281 && elf_dynsymtab (abfd) != 0)
283 elf_onesymtab (abfd) = elf_dynsymtab (abfd);
284 elf_tdata (abfd)->symtab_hdr = elf_tdata (abfd)->dynsymtab_hdr;
287 hdr = &elf_tdata (abfd)->symtab_hdr;
288 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
290 /* The sh_info field of the symtab header tells us where the
291 external symbols start. We don't care about the local symbols at
293 if (elf_bad_symtab (abfd))
295 extsymcount = symcount;
300 extsymcount = symcount - hdr->sh_info;
301 extsymoff = hdr->sh_info;
304 buf = (Elf_External_Sym *) malloc (extsymcount * sizeof (Elf_External_Sym));
305 if (buf == NULL && extsymcount != 0)
307 bfd_set_error (bfd_error_no_memory);
311 /* We store a pointer to the hash table entry for each external
313 sym_hash = ((struct elf_link_hash_entry **)
315 extsymcount * sizeof (struct elf_link_hash_entry *)));
316 if (sym_hash == NULL)
318 bfd_set_error (bfd_error_no_memory);
321 elf_sym_hashes (abfd) = sym_hash;
323 if (elf_elfheader (abfd)->e_type != ET_DYN)
327 /* If we are creating a shared library, create all the dynamic
328 sections immediately. We need to attach them to something,
329 so we attach them to this BFD, provided it is the right
330 format. FIXME: If there are no input BFD's of the same
331 format as the output, we can't make a shared library. */
333 && ! elf_hash_table (info)->dynamic_sections_created
334 && abfd->xvec == info->hash->creator)
336 if (! elf_link_create_dynamic_sections (abfd, info))
345 bfd_size_type oldsize;
346 bfd_size_type strindex;
350 /* You can't use -r against a dynamic object. Also, there's no
351 hope of using a dynamic object which does not exactly match
352 the format of the output file. */
353 if (info->relocateable
354 || info->hash->creator != abfd->xvec)
356 bfd_set_error (bfd_error_invalid_operation);
360 /* Find the name to use in a DT_NEEDED entry that refers to this
361 object. If the object has a DT_SONAME entry, we use it.
362 Otherwise, if the generic linker stuck something in
363 elf_dt_needed_name, we use that. Otherwise, we just use the
364 file name. If the generic linker put a null string into
365 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
366 even if there is a DT_SONAME entry. */
368 name = bfd_get_filename (abfd);
369 if (elf_dt_needed_name (abfd) != NULL)
371 name = elf_dt_needed_name (abfd);
375 s = bfd_get_section_by_name (abfd, ".dynamic");
378 Elf_External_Dyn *extdyn;
379 Elf_External_Dyn *extdynend;
383 dynbuf = (Elf_External_Dyn *) malloc (s->_raw_size);
386 bfd_set_error (bfd_error_no_memory);
390 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
391 (file_ptr) 0, s->_raw_size))
394 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
397 link = elf_elfsections (abfd)[elfsec]->sh_link;
400 extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
401 for (; extdyn < extdynend; extdyn++)
403 Elf_Internal_Dyn dyn;
405 elf_swap_dyn_in (abfd, extdyn, &dyn);
406 if (add_needed && dyn.d_tag == DT_SONAME)
408 name = bfd_elf_string_from_elf_section (abfd, link,
413 if (dyn.d_tag == DT_NEEDED)
415 struct bfd_elf_link_needed_list *n, **pn;
419 sizeof (struct bfd_elf_link_needed_list));
420 fnm = bfd_elf_string_from_elf_section (abfd, link,
422 if (n == NULL || fnm == NULL)
424 anm = bfd_alloc (abfd, strlen (fnm) + 1);
431 for (pn = &elf_hash_table (info)->needed;
443 /* We do not want to include any of the sections in a dynamic
444 object in the output file. We hack by simply clobbering the
445 list of sections in the BFD. This could be handled more
446 cleanly by, say, a new section flag; the existing
447 SEC_NEVER_LOAD flag is not the one we want, because that one
448 still implies that the section takes up space in the output
450 abfd->sections = NULL;
452 /* If this is the first dynamic object found in the link, create
453 the special sections required for dynamic linking. */
454 if (! elf_hash_table (info)->dynamic_sections_created)
456 if (! elf_link_create_dynamic_sections (abfd, info))
462 /* Add a DT_NEEDED entry for this dynamic object. */
463 oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
464 strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
466 if (strindex == (bfd_size_type) -1)
469 if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
472 Elf_External_Dyn *dyncon, *dynconend;
474 /* The hash table size did not change, which means that
475 the dynamic object name was already entered. If we
476 have already included this dynamic object in the
477 link, just ignore it. There is no reason to include
478 a particular dynamic object more than once. */
479 sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
481 BFD_ASSERT (sdyn != NULL);
483 dyncon = (Elf_External_Dyn *) sdyn->contents;
484 dynconend = (Elf_External_Dyn *) (sdyn->contents +
486 for (; dyncon < dynconend; dyncon++)
488 Elf_Internal_Dyn dyn;
490 elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
492 if (dyn.d_tag == DT_NEEDED
493 && dyn.d_un.d_val == strindex)
502 if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
508 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
510 || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
511 != extsymcount * sizeof (Elf_External_Sym)))
516 esymend = buf + extsymcount;
517 for (esym = buf; esym < esymend; esym++, sym_hash++)
519 Elf_Internal_Sym sym;
525 struct elf_link_hash_entry *h = NULL;
528 elf_swap_symbol_in (abfd, esym, &sym);
530 flags = BSF_NO_FLAGS;
532 value = sym.st_value;
535 bind = ELF_ST_BIND (sym.st_info);
536 if (bind == STB_LOCAL)
538 /* This should be impossible, since ELF requires that all
539 global symbols follow all local symbols, and that sh_info
540 point to the first global symbol. Unfortunatealy, Irix 5
544 else if (bind == STB_GLOBAL)
546 if (sym.st_shndx != SHN_UNDEF
547 && sym.st_shndx != SHN_COMMON)
552 else if (bind == STB_WEAK)
556 /* Leave it up to the processor backend. */
559 if (sym.st_shndx == SHN_UNDEF)
560 sec = bfd_und_section_ptr;
561 else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
563 sec = section_from_elf_index (abfd, sym.st_shndx);
567 sec = bfd_abs_section_ptr;
569 else if (sym.st_shndx == SHN_ABS)
570 sec = bfd_abs_section_ptr;
571 else if (sym.st_shndx == SHN_COMMON)
573 sec = bfd_com_section_ptr;
574 /* What ELF calls the size we call the value. What ELF
575 calls the value we call the alignment. */
580 /* Leave it up to the processor backend. */
583 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
584 if (name == (const char *) NULL)
589 if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
593 /* The hook function sets the name to NULL if this symbol
594 should be skipped for some reason. */
595 if (name == (const char *) NULL)
599 /* Sanity check that all possibilities were handled. */
600 if (sec == (asection *) NULL)
602 bfd_set_error (bfd_error_bad_value);
606 if (bfd_is_und_section (sec)
607 || bfd_is_com_section (sec))
612 if (info->hash->creator->flavour == bfd_target_elf_flavour)
614 /* We need to look up the symbol now in order to get some of
615 the dynamic object handling right. We pass the hash
616 table entry in to _bfd_generic_link_add_one_symbol so
617 that it does not have to look it up again. */
618 h = elf_link_hash_lookup (elf_hash_table (info), name,
624 /* If we are looking at a dynamic object, and this is a
625 definition, we need to see if it has already been defined
626 by some other object. If it has, we want to use the
627 existing definition, and we do not want to report a
628 multiple symbol definition error; we do this by
629 clobbering sec to be bfd_und_section_ptr. */
630 if (dynamic && definition)
632 if (h->root.type == bfd_link_hash_defined
633 || h->root.type == bfd_link_hash_defweak)
634 sec = bfd_und_section_ptr;
637 /* Similarly, if we are not looking at a dynamic object, and
638 we have a definition, we want to override any definition
639 we may have from a dynamic object. Symbols from regular
640 files always take precedence over symbols from dynamic
641 objects, even if they are defined after the dynamic
642 object in the link. */
645 && (h->root.type == bfd_link_hash_defined
646 || h->root.type == bfd_link_hash_defweak)
647 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
648 && (bfd_get_flavour (h->root.u.def.section->owner)
649 == bfd_target_elf_flavour)
650 && (elf_elfheader (h->root.u.def.section->owner)->e_type
653 /* Change the hash table entry to undefined, and let
654 _bfd_generic_link_add_one_symbol do the right thing
655 with the new definition. */
656 h->root.type = bfd_link_hash_undefined;
657 h->root.u.undef.abfd = h->root.u.def.section->owner;
661 if (! (_bfd_generic_link_add_one_symbol
662 (info, abfd, name, flags, sec, value, (const char *) NULL,
663 false, collect, (struct bfd_link_hash_entry **) sym_hash)))
668 && (flags & BSF_WEAK) != 0
669 && ELF_ST_TYPE (sym.st_info) != STT_FUNC
670 && info->hash->creator->flavour == bfd_target_elf_flavour
671 && (*sym_hash)->weakdef == NULL)
673 /* Keep a list of all weak defined non function symbols from
674 a dynamic object, using the weakdef field. Later in this
675 function we will set the weakdef field to the correct
676 value. We only put non-function symbols from dynamic
677 objects on this list, because that happens to be the only
678 time we need to know the normal symbol corresponding to a
679 weak symbol, and the information is time consuming to
680 figure out. If the weakdef field is not already NULL,
681 then this symbol was already defined by some previous
682 dynamic object, and we will be using that previous
683 definition anyhow. */
685 (*sym_hash)->weakdef = weaks;
689 /* Get the alignment of a common symbol. */
690 if (sym.st_shndx == SHN_COMMON
691 && (*sym_hash)->root.type == bfd_link_hash_common)
692 (*sym_hash)->root.u.c.p->alignment_power = bfd_log2 (sym.st_value);
694 if (info->hash->creator->flavour == bfd_target_elf_flavour)
700 /* Remember the symbol size and type. */
701 if (sym.st_size != 0)
703 /* FIXME: We should probably somehow give a warning if
704 the symbol size changes. */
705 h->size = sym.st_size;
707 if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE)
709 /* FIXME: We should probably somehow give a warning if
710 the symbol type changes. */
711 h->type = ELF_ST_TYPE (sym.st_info);
714 /* Set a flag in the hash table entry indicating the type of
715 reference or definition we just found. Keep a count of
716 the number of dynamic symbols we find. A dynamic symbol
717 is one which is referenced or defined by both a regular
718 object and a shared object, or one which is referenced or
719 defined by more than one shared object. */
720 old_flags = h->elf_link_hash_flags;
725 new_flag = ELF_LINK_HASH_REF_REGULAR;
727 new_flag = ELF_LINK_HASH_DEF_REGULAR;
729 || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
730 | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
736 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
738 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
739 if ((old_flags & new_flag) != 0
740 || (old_flags & (ELF_LINK_HASH_DEF_REGULAR
741 | ELF_LINK_HASH_REF_REGULAR)) != 0)
745 h->elf_link_hash_flags |= new_flag;
746 if (dynsym && h->dynindx == -1)
748 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
754 /* Now set the weakdefs field correctly for all the weak defined
755 symbols we found. The only way to do this is to search all the
756 symbols. Since we only need the information for non functions in
757 dynamic objects, that's the only time we actually put anything on
758 the list WEAKS. We need this information so that if a regular
759 object refers to a symbol defined weakly in a dynamic object, the
760 real symbol in the dynamic object is also put in the dynamic
761 symbols; we also must arrange for both symbols to point to the
762 same memory location. We could handle the general case of symbol
763 aliasing, but a general symbol alias can only be generated in
764 assembler code, handling it correctly would be very time
765 consuming, and other ELF linkers don't handle general aliasing
767 while (weaks != NULL)
769 struct elf_link_hash_entry *hlook;
772 struct elf_link_hash_entry **hpp;
773 struct elf_link_hash_entry **hppend;
776 weaks = hlook->weakdef;
777 hlook->weakdef = NULL;
779 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
780 || hlook->root.type == bfd_link_hash_defweak
781 || hlook->root.type == bfd_link_hash_common
782 || hlook->root.type == bfd_link_hash_indirect);
783 slook = hlook->root.u.def.section;
784 vlook = hlook->root.u.def.value;
786 hpp = elf_sym_hashes (abfd);
787 hppend = hpp + extsymcount;
788 for (; hpp < hppend; hpp++)
790 struct elf_link_hash_entry *h;
793 if (h != NULL && h != hlook
794 && (h->root.type == bfd_link_hash_defined
795 || h->root.type == bfd_link_hash_defweak)
796 && h->root.u.def.section == slook
797 && h->root.u.def.value == vlook)
801 /* If the weak definition is in the list of dynamic
802 symbols, make sure the real definition is put there
804 if (hlook->dynindx != -1
807 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
822 /* If this object is the same format as the output object, and it is
823 not a shared library, then let the backend look through the
826 This is required to build global offset table entries and to
827 arrange for dynamic relocs. It is not required for the
828 particular common case of linking non PIC code, even when linking
829 against shared libraries, but unfortunately there is no way of
830 knowing whether an object file has been compiled PIC or not.
831 Looking through the relocs is not particularly time consuming.
832 The problem is that we must either (1) keep the relocs in memory,
833 which causes the linker to require additional runtime memory or
834 (2) read the relocs twice from the input file, which wastes time.
835 This would be a good case for using mmap.
837 I have no idea how to handle linking PIC code into a file of a
838 different format. It probably can't be done. */
839 check_relocs = get_elf_backend_data (abfd)->check_relocs;
841 && abfd->xvec == info->hash->creator
842 && check_relocs != NULL)
846 for (o = abfd->sections; o != NULL; o = o->next)
848 Elf_Internal_Rela *internal_relocs;
851 if ((o->flags & SEC_RELOC) == 0
852 || o->reloc_count == 0)
855 /* I believe we can ignore the relocs for any section which
856 does not form part of the final process image, such as a
857 debugging section. */
858 if ((o->flags & SEC_ALLOC) == 0)
861 internal_relocs = elf_link_read_relocs (abfd, o, (PTR) NULL,
862 (Elf_Internal_Rela *) NULL,
864 if (internal_relocs == NULL)
867 ok = (*check_relocs) (abfd, info, o, internal_relocs);
869 if (! info->keep_memory)
870 free (internal_relocs);
887 /* Create some sections which will be filled in with dynamic linking
888 information. ABFD is an input file which requires dynamic sections
889 to be created. The dynamic sections take up virtual memory space
890 when the final executable is run, so we need to create them before
891 addresses are assigned to the output sections. We work out the
892 actual contents and size of these sections later. */
895 elf_link_create_dynamic_sections (abfd, info)
897 struct bfd_link_info *info;
900 register asection *s;
901 struct elf_link_hash_entry *h;
902 struct elf_backend_data *bed;
904 if (elf_hash_table (info)->dynamic_sections_created)
907 /* Make sure that all dynamic sections use the same input BFD. */
908 if (elf_hash_table (info)->dynobj == NULL)
909 elf_hash_table (info)->dynobj = abfd;
911 abfd = elf_hash_table (info)->dynobj;
913 /* Note that we set the SEC_IN_MEMORY flag for all of these
915 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
917 /* A dynamically linked executable has a .interp section, but a
918 shared library does not. */
921 s = bfd_make_section (abfd, ".interp");
923 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
927 s = bfd_make_section (abfd, ".dynsym");
929 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
930 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
933 s = bfd_make_section (abfd, ".dynstr");
935 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
938 /* Create a strtab to hold the dynamic symbol names. */
939 if (elf_hash_table (info)->dynstr == NULL)
941 elf_hash_table (info)->dynstr = elf_stringtab_init ();
942 if (elf_hash_table (info)->dynstr == NULL)
946 s = bfd_make_section (abfd, ".dynamic");
948 || ! bfd_set_section_flags (abfd, s, flags)
949 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
952 /* The special symbol _DYNAMIC is always set to the start of the
953 .dynamic section. This call occurs before we have processed the
954 symbols for any dynamic object, so we don't have to worry about
955 overriding a dynamic definition. We could set _DYNAMIC in a
956 linker script, but we only want to define it if we are, in fact,
957 creating a .dynamic section. We don't want to define it if there
958 is no .dynamic section, since on some ELF platforms the start up
959 code examines it to decide how to initialize the process. */
961 if (! (_bfd_generic_link_add_one_symbol
962 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
963 (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
964 (struct bfd_link_hash_entry **) &h)))
966 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
967 h->type = STT_OBJECT;
970 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
973 s = bfd_make_section (abfd, ".hash");
975 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
976 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
979 /* Let the backend create the rest of the sections. This lets the
980 backend set the right flags. The backend will normally create
981 the .got and .plt sections. */
982 bed = get_elf_backend_data (abfd);
983 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
986 elf_hash_table (info)->dynamic_sections_created = true;
991 /* Add an entry to the .dynamic table. */
994 elf_add_dynamic_entry (info, tag, val)
995 struct bfd_link_info *info;
999 Elf_Internal_Dyn dyn;
1003 bfd_byte *newcontents;
1005 dynobj = elf_hash_table (info)->dynobj;
1007 s = bfd_get_section_by_name (dynobj, ".dynamic");
1008 BFD_ASSERT (s != NULL);
1010 newsize = s->_raw_size + sizeof (Elf_External_Dyn);
1011 if (s->contents == NULL)
1012 newcontents = (bfd_byte *) malloc (newsize);
1014 newcontents = (bfd_byte *) realloc (s->contents, newsize);
1015 if (newcontents == NULL)
1017 bfd_set_error (bfd_error_no_memory);
1022 dyn.d_un.d_val = val;
1023 elf_swap_dyn_out (dynobj, &dyn,
1024 (Elf_External_Dyn *) (newcontents + s->_raw_size));
1026 s->_raw_size = newsize;
1027 s->contents = newcontents;
1032 /* Read and swap the relocs for a section. They may have been cached.
1033 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1034 they are used as buffers to read into. They are known to be large
1035 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1036 value is allocated using either malloc or bfd_alloc, according to
1037 the KEEP_MEMORY argument. */
1039 static Elf_Internal_Rela *
1040 elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
1043 PTR external_relocs;
1044 Elf_Internal_Rela *internal_relocs;
1045 boolean keep_memory;
1047 Elf_Internal_Shdr *rel_hdr;
1049 Elf_Internal_Rela *alloc2 = NULL;
1051 if (elf_section_data (o)->relocs != NULL)
1052 return elf_section_data (o)->relocs;
1054 if (o->reloc_count == 0)
1057 rel_hdr = &elf_section_data (o)->rel_hdr;
1059 if (internal_relocs == NULL)
1063 size = o->reloc_count * sizeof (Elf_Internal_Rela);
1065 internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
1067 internal_relocs = alloc2 = (Elf_Internal_Rela *) malloc (size);
1068 if (internal_relocs == NULL)
1070 bfd_set_error (bfd_error_no_memory);
1075 if (external_relocs == NULL)
1077 alloc1 = (PTR) malloc (rel_hdr->sh_size);
1080 bfd_set_error (bfd_error_no_memory);
1083 external_relocs = alloc1;
1086 if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
1087 || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
1088 != rel_hdr->sh_size))
1091 /* Swap in the relocs. For convenience, we always produce an
1092 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1094 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
1096 Elf_External_Rel *erel;
1097 Elf_External_Rel *erelend;
1098 Elf_Internal_Rela *irela;
1100 erel = (Elf_External_Rel *) external_relocs;
1101 erelend = erel + o->reloc_count;
1102 irela = internal_relocs;
1103 for (; erel < erelend; erel++, irela++)
1105 Elf_Internal_Rel irel;
1107 elf_swap_reloc_in (abfd, erel, &irel);
1108 irela->r_offset = irel.r_offset;
1109 irela->r_info = irel.r_info;
1110 irela->r_addend = 0;
1115 Elf_External_Rela *erela;
1116 Elf_External_Rela *erelaend;
1117 Elf_Internal_Rela *irela;
1119 BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
1121 erela = (Elf_External_Rela *) external_relocs;
1122 erelaend = erela + o->reloc_count;
1123 irela = internal_relocs;
1124 for (; erela < erelaend; erela++, irela++)
1125 elf_swap_reloca_in (abfd, erela, irela);
1128 /* Cache the results for next time, if we can. */
1130 elf_section_data (o)->relocs = internal_relocs;
1135 /* Don't free alloc2, since if it was allocated we are passing it
1136 back (under the name of internal_relocs). */
1138 return internal_relocs;
1148 /* Record an assignment to a symbol made by a linker script. We need
1149 this in case some dynamic object refers to this symbol. */
1153 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
1155 struct bfd_link_info *info;
1159 struct elf_link_hash_entry *h;
1161 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1164 h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
1168 /* If this symbol is being provided by the linker script, and it is
1169 currently defined by a dynamic object, but not by a regular
1170 object, then mark it as undefined so that the generic linker will
1171 force the correct value. */
1173 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1174 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1175 h->root.type = bfd_link_hash_undefined;
1177 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1178 h->type = STT_OBJECT;
1180 if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1181 | ELF_LINK_HASH_REF_DYNAMIC)) != 0
1183 && h->dynindx == -1)
1185 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1188 /* If this is a weak defined symbol, and we know a corresponding
1189 real symbol from the same dynamic object, make sure the real
1190 symbol is also made into a dynamic symbol. */
1191 if (h->weakdef != NULL
1192 && h->weakdef->dynindx == -1)
1194 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
1202 /* Array used to determine the number of hash table buckets to use
1203 based on the number of symbols there are. If there are fewer than
1204 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1205 fewer than 37 we use 17 buckets, and so forth. We never use more
1206 than 521 buckets. */
1208 static const size_t elf_buckets[] =
1210 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1213 /* Set up the sizes and contents of the ELF dynamic sections. This is
1214 called by the ELF linker emulation before_allocation routine. We
1215 must set the sizes of the sections before the linker sets the
1216 addresses of the various sections. */
1219 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
1220 export_dynamic, info, sinterpptr)
1224 boolean export_dynamic;
1225 struct bfd_link_info *info;
1226 asection **sinterpptr;
1229 struct elf_backend_data *bed;
1233 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1236 dynobj = elf_hash_table (info)->dynobj;
1238 /* If there were no dynamic objects in the link, there is nothing to
1243 /* If we are supposed to export all symbols into the dynamic symbol
1244 table (this is not the normal case), then do so. */
1247 struct elf_info_failed eif;
1251 elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
1257 if (elf_hash_table (info)->dynamic_sections_created)
1259 struct elf_info_failed eif;
1260 bfd_size_type strsize;
1262 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
1263 BFD_ASSERT (*sinterpptr != NULL || info->shared);
1269 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, soname,
1271 if (indx == (bfd_size_type) -1
1272 || ! elf_add_dynamic_entry (info, DT_SONAME, indx))
1280 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
1282 if (indx == (bfd_size_type) -1
1283 || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
1287 /* Find all symbols which were defined in a dynamic object and make
1288 the backend pick a reasonable value for them. */
1291 elf_link_hash_traverse (elf_hash_table (info),
1292 elf_adjust_dynamic_symbol,
1297 /* Add some entries to the .dynamic section. We fill in some of the
1298 values later, in elf_bfd_final_link, but we must add the entries
1299 now so that we know the final size of the .dynamic section. */
1300 if (elf_link_hash_lookup (elf_hash_table (info), "_init", false,
1301 false, false) != NULL)
1303 if (! elf_add_dynamic_entry (info, DT_INIT, 0))
1306 if (elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
1307 false, false) != NULL)
1309 if (! elf_add_dynamic_entry (info, DT_FINI, 0))
1312 strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1313 if (! elf_add_dynamic_entry (info, DT_HASH, 0)
1314 || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
1315 || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
1316 || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
1317 || ! elf_add_dynamic_entry (info, DT_SYMENT,
1318 sizeof (Elf_External_Sym)))
1322 /* The backend must work out the sizes of all the other dynamic
1324 bed = get_elf_backend_data (output_bfd);
1325 if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
1328 if (elf_hash_table (info)->dynamic_sections_created)
1333 size_t bucketcount = 0;
1334 Elf_Internal_Sym isym;
1336 /* Set the size of the .dynsym and .hash sections. We counted
1337 the number of dynamic symbols in elf_link_add_object_symbols.
1338 We will build the contents of .dynsym and .hash when we build
1339 the final symbol table, because until then we do not know the
1340 correct value to give the symbols. We built the .dynstr
1341 section as we went along in elf_link_add_object_symbols. */
1342 dynsymcount = elf_hash_table (info)->dynsymcount;
1343 s = bfd_get_section_by_name (dynobj, ".dynsym");
1344 BFD_ASSERT (s != NULL);
1345 s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
1346 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1347 if (s->contents == NULL && s->_raw_size != 0)
1349 bfd_set_error (bfd_error_no_memory);
1353 /* The first entry in .dynsym is a dummy symbol. */
1360 elf_swap_symbol_out (output_bfd, &isym,
1361 (char *) (Elf_External_Sym *) s->contents);
1363 for (i = 0; elf_buckets[i] != 0; i++)
1365 bucketcount = elf_buckets[i];
1366 if (dynsymcount < elf_buckets[i + 1])
1370 s = bfd_get_section_by_name (dynobj, ".hash");
1371 BFD_ASSERT (s != NULL);
1372 s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
1373 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1374 if (s->contents == NULL)
1376 bfd_set_error (bfd_error_no_memory);
1379 memset (s->contents, 0, s->_raw_size);
1381 put_word (output_bfd, bucketcount, s->contents);
1382 put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
1384 elf_hash_table (info)->bucketcount = bucketcount;
1386 s = bfd_get_section_by_name (dynobj, ".dynstr");
1387 BFD_ASSERT (s != NULL);
1388 s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1390 if (! elf_add_dynamic_entry (info, DT_NULL, 0))
1397 /* This routine is used to export all defined symbols into the dynamic
1398 symbol table. It is called via elf_link_hash_traverse. */
1401 elf_export_symbol (h, data)
1402 struct elf_link_hash_entry *h;
1405 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1407 if (h->dynindx == -1
1408 && (h->elf_link_hash_flags
1409 & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
1411 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1421 /* Make the backend pick a good value for a dynamic symbol. This is
1422 called via elf_link_hash_traverse, and also calls itself
1426 elf_adjust_dynamic_symbol (h, data)
1427 struct elf_link_hash_entry *h;
1430 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1432 struct elf_backend_data *bed;
1434 /* If this symbol does not require a PLT entry, and it is not
1435 defined by a dynamic object, or is not referenced by a regular
1436 object, ignore it. FIXME: Do we need to worry about symbols
1437 which are defined by one dynamic object and referenced by another
1439 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
1440 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1441 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1442 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0))
1445 /* If we've already adjusted this symbol, don't do it again. This
1446 can happen via a recursive call. */
1447 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
1450 /* Don't look at this symbol again. Note that we must set this
1451 after checking the above conditions, because we may look at a
1452 symbol once, decide not to do anything, and then get called
1453 recursively later after REF_REGULAR is set below. */
1454 h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
1456 /* If this is a weak definition, and we know a real definition, and
1457 the real symbol is not itself defined by a regular object file,
1458 then get a good value for the real definition. We handle the
1459 real symbol first, for the convenience of the backend routine.
1461 Note that there is a confusing case here. If the real definition
1462 is defined by a regular object file, we don't get the real symbol
1463 from the dynamic object, but we do get the weak symbol. If the
1464 processor backend uses a COPY reloc, then if some routine in the
1465 dynamic object changes the real symbol, we will not see that
1466 change in the corresponding weak symbol. This is the way other
1467 ELF linkers work as well, and seems to be a result of the shared
1470 I will clarify this issue. Most SVR4 shared libraries define the
1471 variable _timezone and define timezone as a weak synonym. The
1472 tzset call changes _timezone. If you write
1473 extern int timezone;
1475 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1476 you might expect that, since timezone is a synonym for _timezone,
1477 the same number will print both times. However, if the processor
1478 backend uses a COPY reloc, then actually timezone will be copied
1479 into your process image, and, since you define _timezone
1480 yourself, _timezone will not. Thus timezone and _timezone will
1481 wind up at different memory locations. The tzset call will set
1482 _timezone, leaving timezone unchanged. */
1484 if (h->weakdef != NULL)
1486 struct elf_link_hash_entry *weakdef;
1488 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1489 || h->root.type == bfd_link_hash_defweak);
1490 weakdef = h->weakdef;
1491 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
1492 || weakdef->root.type == bfd_link_hash_defweak);
1493 BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
1494 if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1496 /* This symbol is defined by a regular object file, so we
1497 will not do anything special. Clear weakdef for the
1498 convenience of the processor backend. */
1503 /* There is an implicit reference by a regular object file
1504 via the weak symbol. */
1505 weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1506 if (! elf_adjust_dynamic_symbol (weakdef, (PTR) eif))
1511 dynobj = elf_hash_table (eif->info)->dynobj;
1512 bed = get_elf_backend_data (dynobj);
1513 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
1522 /* Final phase of ELF linker. */
1524 /* A structure we use to avoid passing large numbers of arguments. */
1526 struct elf_final_link_info
1528 /* General link information. */
1529 struct bfd_link_info *info;
1532 /* Symbol string table. */
1533 struct bfd_strtab_hash *symstrtab;
1534 /* .dynsym section. */
1535 asection *dynsym_sec;
1536 /* .hash section. */
1538 /* Buffer large enough to hold contents of any section. */
1540 /* Buffer large enough to hold external relocs of any section. */
1541 PTR external_relocs;
1542 /* Buffer large enough to hold internal relocs of any section. */
1543 Elf_Internal_Rela *internal_relocs;
1544 /* Buffer large enough to hold external local symbols of any input
1546 Elf_External_Sym *external_syms;
1547 /* Buffer large enough to hold internal local symbols of any input
1549 Elf_Internal_Sym *internal_syms;
1550 /* Array large enough to hold a symbol index for each local symbol
1551 of any input BFD. */
1553 /* Array large enough to hold a section pointer for each local
1554 symbol of any input BFD. */
1555 asection **sections;
1556 /* Buffer to hold swapped out symbols. */
1557 Elf_External_Sym *symbuf;
1558 /* Number of swapped out symbols in buffer. */
1559 size_t symbuf_count;
1560 /* Number of symbols which fit in symbuf. */
1564 static boolean elf_link_output_sym
1565 PARAMS ((struct elf_final_link_info *, const char *,
1566 Elf_Internal_Sym *, asection *));
1567 static boolean elf_link_flush_output_syms
1568 PARAMS ((struct elf_final_link_info *));
1569 static boolean elf_link_output_extsym
1570 PARAMS ((struct elf_link_hash_entry *, PTR));
1571 static boolean elf_link_input_bfd
1572 PARAMS ((struct elf_final_link_info *, bfd *));
1573 static boolean elf_reloc_link_order
1574 PARAMS ((bfd *, struct bfd_link_info *, asection *,
1575 struct bfd_link_order *));
1577 /* This struct is used to pass information to routines called via
1578 elf_link_hash_traverse which must return failure. */
1580 struct elf_finfo_failed
1583 struct elf_final_link_info *finfo;
1586 /* Do the final step of an ELF link. */
1589 elf_bfd_final_link (abfd, info)
1591 struct bfd_link_info *info;
1595 struct elf_final_link_info finfo;
1596 register asection *o;
1597 register struct bfd_link_order *p;
1599 size_t max_contents_size;
1600 size_t max_external_reloc_size;
1601 size_t max_internal_reloc_count;
1602 size_t max_sym_count;
1604 Elf_Internal_Sym elfsym;
1606 Elf_Internal_Shdr *symtab_hdr;
1607 Elf_Internal_Shdr *symstrtab_hdr;
1608 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1609 struct elf_finfo_failed eif;
1612 abfd->flags |= DYNAMIC;
1614 dynamic = elf_hash_table (info)->dynamic_sections_created;
1615 dynobj = elf_hash_table (info)->dynobj;
1618 finfo.output_bfd = abfd;
1619 finfo.symstrtab = elf_stringtab_init ();
1620 if (finfo.symstrtab == NULL)
1624 finfo.dynsym_sec = NULL;
1625 finfo.hash_sec = NULL;
1629 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
1630 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
1631 BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
1633 finfo.contents = NULL;
1634 finfo.external_relocs = NULL;
1635 finfo.internal_relocs = NULL;
1636 finfo.external_syms = NULL;
1637 finfo.internal_syms = NULL;
1638 finfo.indices = NULL;
1639 finfo.sections = NULL;
1640 finfo.symbuf = NULL;
1641 finfo.symbuf_count = 0;
1643 /* Count up the number of relocations we will output for each output
1644 section, so that we know the sizes of the reloc sections. We
1645 also figure out some maximum sizes. */
1646 max_contents_size = 0;
1647 max_external_reloc_size = 0;
1648 max_internal_reloc_count = 0;
1650 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
1654 for (p = o->link_order_head; p != NULL; p = p->next)
1656 if (p->type == bfd_section_reloc_link_order
1657 || p->type == bfd_symbol_reloc_link_order)
1659 else if (p->type == bfd_indirect_link_order)
1663 sec = p->u.indirect.section;
1665 if (info->relocateable)
1666 o->reloc_count += sec->reloc_count;
1668 if (sec->_raw_size > max_contents_size)
1669 max_contents_size = sec->_raw_size;
1670 if (sec->_cooked_size > max_contents_size)
1671 max_contents_size = sec->_cooked_size;
1673 /* We are interested in just local symbols, not all
1675 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour)
1679 if (elf_bad_symtab (sec->owner))
1680 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
1681 / sizeof (Elf_External_Sym));
1683 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
1685 if (sym_count > max_sym_count)
1686 max_sym_count = sym_count;
1688 if ((sec->flags & SEC_RELOC) != 0)
1692 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
1693 if (ext_size > max_external_reloc_size)
1694 max_external_reloc_size = ext_size;
1695 if (sec->reloc_count > max_internal_reloc_count)
1696 max_internal_reloc_count = sec->reloc_count;
1702 if (o->reloc_count > 0)
1703 o->flags |= SEC_RELOC;
1706 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1707 set it (this is probably a bug) and if it is set
1708 assign_section_numbers will create a reloc section. */
1709 o->flags &=~ SEC_RELOC;
1712 /* If the SEC_ALLOC flag is not set, force the section VMA to
1713 zero. This is done in elf_fake_sections as well, but forcing
1714 the VMA to 0 here will ensure that relocs against these
1715 sections are handled correctly. */
1716 if ((o->flags & SEC_ALLOC) == 0)
1720 /* Figure out the file positions for everything but the symbol table
1721 and the relocs. We set symcount to force assign_section_numbers
1722 to create a symbol table. */
1723 abfd->symcount = info->strip == strip_all ? 0 : 1;
1724 BFD_ASSERT (! abfd->output_has_begun);
1725 if (! _bfd_elf_compute_section_file_positions (abfd, info))
1728 /* That created the reloc sections. Set their sizes, and assign
1729 them file positions, and allocate some buffers. */
1730 for (o = abfd->sections; o != NULL; o = o->next)
1732 if ((o->flags & SEC_RELOC) != 0)
1734 Elf_Internal_Shdr *rel_hdr;
1735 register struct elf_link_hash_entry **p, **pend;
1737 rel_hdr = &elf_section_data (o)->rel_hdr;
1739 rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
1741 /* The contents field must last into write_object_contents,
1742 so we allocate it with bfd_alloc rather than malloc. */
1743 rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
1744 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
1746 bfd_set_error (bfd_error_no_memory);
1750 p = ((struct elf_link_hash_entry **)
1751 malloc (o->reloc_count
1752 * sizeof (struct elf_link_hash_entry *)));
1753 if (p == NULL && o->reloc_count != 0)
1755 bfd_set_error (bfd_error_no_memory);
1758 elf_section_data (o)->rel_hashes = p;
1759 pend = p + o->reloc_count;
1760 for (; p < pend; p++)
1763 /* Use the reloc_count field as an index when outputting the
1769 _bfd_elf_assign_file_positions_for_relocs (abfd);
1771 /* We have now assigned file positions for all the sections except
1772 .symtab and .strtab. We start the .symtab section at the current
1773 file position, and write directly to it. We build the .strtab
1774 section in memory. When we add .dynsym support, we will build
1775 that in memory as well (.dynsym is smaller than .symtab). */
1777 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1778 /* sh_name is set in prep_headers. */
1779 symtab_hdr->sh_type = SHT_SYMTAB;
1780 symtab_hdr->sh_flags = 0;
1781 symtab_hdr->sh_addr = 0;
1782 symtab_hdr->sh_size = 0;
1783 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
1784 /* sh_link is set in assign_section_numbers. */
1785 /* sh_info is set below. */
1786 /* sh_offset is set just below. */
1787 symtab_hdr->sh_addralign = 4; /* FIXME: system dependent? */
1789 off = elf_tdata (abfd)->next_file_pos;
1790 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
1792 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1793 incorrect. We do not yet know the size of the .symtab section.
1794 We correct next_file_pos below, after we do know the size. */
1796 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1797 continuously seeking to the right position in the file. */
1798 if (! info->keep_memory || max_sym_count < 20)
1799 finfo.symbuf_size = 20;
1801 finfo.symbuf_size = max_sym_count;
1802 finfo.symbuf = ((Elf_External_Sym *)
1803 malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
1804 if (finfo.symbuf == NULL)
1806 bfd_set_error (bfd_error_no_memory);
1810 /* Start writing out the symbol table. The first symbol is always a
1812 elfsym.st_value = 0;
1815 elfsym.st_other = 0;
1816 elfsym.st_shndx = SHN_UNDEF;
1817 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1818 &elfsym, bfd_und_section_ptr))
1822 /* Some standard ELF linkers do this, but we don't because it causes
1823 bootstrap comparison failures. */
1824 /* Output a file symbol for the output file as the second symbol.
1825 We output this even if we are discarding local symbols, although
1826 I'm not sure if this is correct. */
1827 elfsym.st_value = 0;
1829 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
1830 elfsym.st_other = 0;
1831 elfsym.st_shndx = SHN_ABS;
1832 if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
1833 &elfsym, bfd_abs_section_ptr))
1837 /* Output a symbol for each section. We output these even if we are
1838 discarding local symbols, since they are used for relocs. These
1839 symbols have no names. We store the index of each one in the
1840 index field of the section, so that we can find it again when
1841 outputting relocs. */
1842 elfsym.st_value = 0;
1844 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1845 elfsym.st_other = 0;
1846 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
1848 o = section_from_elf_index (abfd, i);
1850 o->target_index = abfd->symcount;
1851 elfsym.st_shndx = i;
1852 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1857 /* Allocate some memory to hold information read in from the input
1859 finfo.contents = (bfd_byte *) malloc (max_contents_size);
1860 finfo.external_relocs = (PTR) malloc (max_external_reloc_size);
1861 finfo.internal_relocs = ((Elf_Internal_Rela *)
1862 malloc (max_internal_reloc_count
1863 * sizeof (Elf_Internal_Rela)));
1864 finfo.external_syms = ((Elf_External_Sym *)
1865 malloc (max_sym_count * sizeof (Elf_External_Sym)));
1866 finfo.internal_syms = ((Elf_Internal_Sym *)
1867 malloc (max_sym_count * sizeof (Elf_Internal_Sym)));
1868 finfo.indices = (long *) malloc (max_sym_count * sizeof (long));
1869 finfo.sections = (asection **) malloc (max_sym_count * sizeof (asection *));
1870 if ((finfo.contents == NULL && max_contents_size != 0)
1871 || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
1872 || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
1873 || (finfo.external_syms == NULL && max_sym_count != 0)
1874 || (finfo.internal_syms == NULL && max_sym_count != 0)
1875 || (finfo.indices == NULL && max_sym_count != 0)
1876 || (finfo.sections == NULL && max_sym_count != 0))
1878 bfd_set_error (bfd_error_no_memory);
1882 /* Since ELF permits relocations to be against local symbols, we
1883 must have the local symbols available when we do the relocations.
1884 Since we would rather only read the local symbols once, and we
1885 would rather not keep them in memory, we handle all the
1886 relocations for a single input file at the same time.
1888 Unfortunately, there is no way to know the total number of local
1889 symbols until we have seen all of them, and the local symbol
1890 indices precede the global symbol indices. This means that when
1891 we are generating relocateable output, and we see a reloc against
1892 a global symbol, we can not know the symbol index until we have
1893 finished examining all the local symbols to see which ones we are
1894 going to output. To deal with this, we keep the relocations in
1895 memory, and don't output them until the end of the link. This is
1896 an unfortunate waste of memory, but I don't see a good way around
1897 it. Fortunately, it only happens when performing a relocateable
1898 link, which is not the common case. FIXME: If keep_memory is set
1899 we could write the relocs out and then read them again; I don't
1900 know how bad the memory loss will be. */
1902 for (sub = info->input_bfds; sub != NULL; sub = sub->next)
1903 sub->output_has_begun = false;
1904 for (o = abfd->sections; o != NULL; o = o->next)
1906 for (p = o->link_order_head; p != NULL; p = p->next)
1908 if (p->type == bfd_indirect_link_order
1909 && (bfd_get_flavour (p->u.indirect.section->owner)
1910 == bfd_target_elf_flavour))
1912 sub = p->u.indirect.section->owner;
1913 if (! sub->output_has_begun)
1915 if (! elf_link_input_bfd (&finfo, sub))
1917 sub->output_has_begun = true;
1920 else if (p->type == bfd_section_reloc_link_order
1921 || p->type == bfd_symbol_reloc_link_order)
1923 if (! elf_reloc_link_order (abfd, info, o, p))
1928 if (! _bfd_default_link_order (abfd, info, o, p))
1934 /* That wrote out all the local symbols. Finish up the symbol table
1935 with the global symbols. */
1937 /* The sh_info field records the index of the first non local
1939 symtab_hdr->sh_info = abfd->symcount;
1941 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
1943 /* We get the global symbols from the hash table. */
1946 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
1951 /* Flush all symbols to the file. */
1952 if (! elf_link_flush_output_syms (&finfo))
1955 /* Now we know the size of the symtab section. */
1956 off += symtab_hdr->sh_size;
1958 /* Finish up and write out the symbol string table (.strtab)
1960 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
1961 /* sh_name was set in prep_headers. */
1962 symstrtab_hdr->sh_type = SHT_STRTAB;
1963 symstrtab_hdr->sh_flags = 0;
1964 symstrtab_hdr->sh_addr = 0;
1965 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
1966 symstrtab_hdr->sh_entsize = 0;
1967 symstrtab_hdr->sh_link = 0;
1968 symstrtab_hdr->sh_info = 0;
1969 /* sh_offset is set just below. */
1970 symstrtab_hdr->sh_addralign = 1;
1972 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
1973 elf_tdata (abfd)->next_file_pos = off;
1975 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
1976 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
1979 /* Adjust the relocs to have the correct symbol indices. */
1980 for (o = abfd->sections; o != NULL; o = o->next)
1982 struct elf_link_hash_entry **rel_hash;
1983 Elf_Internal_Shdr *rel_hdr;
1985 if ((o->flags & SEC_RELOC) == 0)
1988 rel_hash = elf_section_data (o)->rel_hashes;
1989 rel_hdr = &elf_section_data (o)->rel_hdr;
1990 for (i = 0; i < o->reloc_count; i++, rel_hash++)
1992 if (*rel_hash == NULL)
1995 BFD_ASSERT ((*rel_hash)->indx >= 0);
1997 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
1999 Elf_External_Rel *erel;
2000 Elf_Internal_Rel irel;
2002 erel = (Elf_External_Rel *) rel_hdr->contents + i;
2003 elf_swap_reloc_in (abfd, erel, &irel);
2004 irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
2005 ELF_R_TYPE (irel.r_info));
2006 elf_swap_reloc_out (abfd, &irel, erel);
2010 Elf_External_Rela *erela;
2011 Elf_Internal_Rela irela;
2013 BFD_ASSERT (rel_hdr->sh_entsize
2014 == sizeof (Elf_External_Rela));
2016 erela = (Elf_External_Rela *) rel_hdr->contents + i;
2017 elf_swap_reloca_in (abfd, erela, &irela);
2018 irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
2019 ELF_R_TYPE (irela.r_info));
2020 elf_swap_reloca_out (abfd, &irela, erela);
2024 /* Set the reloc_count field to 0 to prevent write_relocs from
2025 trying to swap the relocs out itself. */
2029 /* If we are linking against a dynamic object, or generating a
2030 shared library, finish up the dynamic linking information. */
2033 Elf_External_Dyn *dyncon, *dynconend;
2035 /* Fix up .dynamic entries. */
2036 o = bfd_get_section_by_name (dynobj, ".dynamic");
2037 BFD_ASSERT (o != NULL);
2039 dyncon = (Elf_External_Dyn *) o->contents;
2040 dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
2041 for (; dyncon < dynconend; dyncon++)
2043 Elf_Internal_Dyn dyn;
2047 elf_swap_dyn_in (dynobj, dyncon, &dyn);
2054 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2055 magic _init and _fini symbols. This is pretty ugly,
2056 but we are compatible. */
2064 struct elf_link_hash_entry *h;
2066 h = elf_link_hash_lookup (elf_hash_table (info), name,
2067 false, false, true);
2068 BFD_ASSERT (h != NULL);
2069 if (h->root.type == bfd_link_hash_defined
2070 || h->root.type == bfd_link_hash_defweak)
2072 dyn.d_un.d_val = h->root.u.def.value;
2073 o = h->root.u.def.section;
2074 if (o->output_section != NULL)
2075 dyn.d_un.d_val += (o->output_section->vma
2076 + o->output_offset);
2078 /* The symbol is imported from another shared
2079 library and does not apply to this one. */
2082 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2095 o = bfd_get_section_by_name (abfd, name);
2096 BFD_ASSERT (o != NULL);
2097 dyn.d_un.d_ptr = o->vma;
2098 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2105 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
2110 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
2112 Elf_Internal_Shdr *hdr;
2114 hdr = elf_elfsections (abfd)[i];
2115 if (hdr->sh_type == type
2116 && (hdr->sh_flags & SHF_ALLOC) != 0)
2118 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
2119 dyn.d_un.d_val += hdr->sh_size;
2122 if (dyn.d_un.d_val == 0
2123 || hdr->sh_addr < dyn.d_un.d_val)
2124 dyn.d_un.d_val = hdr->sh_addr;
2128 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2134 /* If we have created any dynamic sections, then output them. */
2137 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
2140 for (o = dynobj->sections; o != NULL; o = o->next)
2142 if ((o->flags & SEC_HAS_CONTENTS) == 0
2143 || o->_raw_size == 0)
2145 if ((o->flags & SEC_IN_MEMORY) == 0)
2147 /* At this point, we are only interested in sections
2148 created by elf_link_create_dynamic_sections. FIXME:
2149 This test is fragile. */
2152 if ((elf_section_data (o->output_section)->this_hdr.sh_type
2154 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
2156 if (! bfd_set_section_contents (abfd, o->output_section,
2157 o->contents, o->output_offset,
2165 /* The contents of the .dynstr section are actually in a
2167 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
2168 if (bfd_seek (abfd, off, SEEK_SET) != 0
2169 || ! _bfd_stringtab_emit (abfd,
2170 elf_hash_table (info)->dynstr))
2176 if (finfo.symstrtab != NULL)
2177 _bfd_stringtab_free (finfo.symstrtab);
2178 if (finfo.contents != NULL)
2179 free (finfo.contents);
2180 if (finfo.external_relocs != NULL)
2181 free (finfo.external_relocs);
2182 if (finfo.internal_relocs != NULL)
2183 free (finfo.internal_relocs);
2184 if (finfo.external_syms != NULL)
2185 free (finfo.external_syms);
2186 if (finfo.internal_syms != NULL)
2187 free (finfo.internal_syms);
2188 if (finfo.indices != NULL)
2189 free (finfo.indices);
2190 if (finfo.sections != NULL)
2191 free (finfo.sections);
2192 if (finfo.symbuf != NULL)
2193 free (finfo.symbuf);
2194 for (o = abfd->sections; o != NULL; o = o->next)
2196 if ((o->flags & SEC_RELOC) != 0
2197 && elf_section_data (o)->rel_hashes != NULL)
2198 free (elf_section_data (o)->rel_hashes);
2201 elf_tdata (abfd)->linker = true;
2206 if (finfo.symstrtab != NULL)
2207 _bfd_stringtab_free (finfo.symstrtab);
2208 if (finfo.contents != NULL)
2209 free (finfo.contents);
2210 if (finfo.external_relocs != NULL)
2211 free (finfo.external_relocs);
2212 if (finfo.internal_relocs != NULL)
2213 free (finfo.internal_relocs);
2214 if (finfo.external_syms != NULL)
2215 free (finfo.external_syms);
2216 if (finfo.internal_syms != NULL)
2217 free (finfo.internal_syms);
2218 if (finfo.indices != NULL)
2219 free (finfo.indices);
2220 if (finfo.sections != NULL)
2221 free (finfo.sections);
2222 if (finfo.symbuf != NULL)
2223 free (finfo.symbuf);
2224 for (o = abfd->sections; o != NULL; o = o->next)
2226 if ((o->flags & SEC_RELOC) != 0
2227 && elf_section_data (o)->rel_hashes != NULL)
2228 free (elf_section_data (o)->rel_hashes);
2234 /* Add a symbol to the output symbol table. */
2237 elf_link_output_sym (finfo, name, elfsym, input_sec)
2238 struct elf_final_link_info *finfo;
2240 Elf_Internal_Sym *elfsym;
2241 asection *input_sec;
2243 boolean (*output_symbol_hook) PARAMS ((bfd *,
2244 struct bfd_link_info *info,
2249 output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
2250 elf_backend_link_output_symbol_hook;
2251 if (output_symbol_hook != NULL)
2253 if (! ((*output_symbol_hook)
2254 (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
2258 if (name == (const char *) NULL || *name == '\0')
2259 elfsym->st_name = 0;
2262 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
2265 if (elfsym->st_name == (unsigned long) -1)
2269 if (finfo->symbuf_count >= finfo->symbuf_size)
2271 if (! elf_link_flush_output_syms (finfo))
2275 elf_swap_symbol_out (finfo->output_bfd, elfsym,
2276 (char *) (finfo->symbuf + finfo->symbuf_count));
2277 ++finfo->symbuf_count;
2279 ++finfo->output_bfd->symcount;
2284 /* Flush the output symbols to the file. */
2287 elf_link_flush_output_syms (finfo)
2288 struct elf_final_link_info *finfo;
2290 Elf_Internal_Shdr *symtab;
2292 symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
2294 if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
2296 || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
2297 sizeof (Elf_External_Sym), finfo->output_bfd)
2298 != finfo->symbuf_count * sizeof (Elf_External_Sym)))
2301 symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
2303 finfo->symbuf_count = 0;
2308 /* Add an external symbol to the symbol table. This is called from
2309 the hash table traversal routine. */
2312 elf_link_output_extsym (h, data)
2313 struct elf_link_hash_entry *h;
2316 struct elf_finfo_failed *eif = (struct elf_finfo_failed *) data;
2317 struct elf_final_link_info *finfo = eif->finfo;
2319 Elf_Internal_Sym sym;
2320 asection *input_sec;
2322 /* If we are not creating a shared library, and this symbol is
2323 referenced by a shared library but is not defined anywhere, then
2324 warn that it is undefined. If we do not do this, the runtime
2325 linker will complain that the symbol is undefined when the
2326 program is run. We don't have to worry about symbols that are
2327 referenced by regular files, because we will already have issued
2328 warnings for them. */
2329 if (! finfo->info->relocateable
2330 && ! finfo->info->shared
2331 && h->root.type == bfd_link_hash_undefined
2332 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
2333 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2335 if (! ((*finfo->info->callbacks->undefined_symbol)
2336 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
2337 (asection *) NULL, 0)))
2344 /* We don't want to output symbols that have never been mentioned by
2345 a regular file, or that we have been told to strip. However, if
2346 h->indx is set to -2, the symbol is used by a reloc and we must
2350 else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2351 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2352 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2353 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2355 else if (finfo->info->strip == strip_all
2356 || (finfo->info->strip == strip_some
2357 && bfd_hash_lookup (finfo->info->keep_hash,
2358 h->root.root.string,
2359 false, false) == NULL))
2364 /* If we're stripping it, and it's not a dynamic symbol, there's
2365 nothing else to do. */
2366 if (strip && h->dynindx == -1)
2370 sym.st_size = h->size;
2372 if (h->root.type == bfd_link_hash_undefweak
2373 || h->root.type == bfd_link_hash_defweak)
2374 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
2376 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
2378 switch (h->root.type)
2381 case bfd_link_hash_new:
2385 case bfd_link_hash_undefined:
2386 input_sec = bfd_und_section_ptr;
2387 sym.st_shndx = SHN_UNDEF;
2390 case bfd_link_hash_undefweak:
2391 input_sec = bfd_und_section_ptr;
2392 sym.st_shndx = SHN_UNDEF;
2395 case bfd_link_hash_defined:
2396 case bfd_link_hash_defweak:
2398 input_sec = h->root.u.def.section;
2399 if (input_sec->output_section != NULL)
2402 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
2403 input_sec->output_section);
2404 if (sym.st_shndx == (unsigned short) -1)
2410 /* ELF symbols in relocateable files are section relative,
2411 but in nonrelocateable files they are virtual
2413 sym.st_value = h->root.u.def.value + input_sec->output_offset;
2414 if (! finfo->info->relocateable)
2415 sym.st_value += input_sec->output_section->vma;
2419 BFD_ASSERT ((bfd_get_flavour (input_sec->owner)
2420 == bfd_target_elf_flavour)
2421 && elf_elfheader (input_sec->owner)->e_type == ET_DYN);
2422 sym.st_shndx = SHN_UNDEF;
2423 input_sec = bfd_und_section_ptr;
2428 case bfd_link_hash_common:
2429 input_sec = bfd_com_section_ptr;
2430 sym.st_shndx = SHN_COMMON;
2431 sym.st_value = 1 << h->root.u.c.p->alignment_power;
2434 case bfd_link_hash_indirect:
2435 case bfd_link_hash_warning:
2436 /* I have no idea how these should be handled. */
2440 /* If this symbol should be put in the .dynsym section, then put it
2441 there now. We have already know the symbol index. We also fill
2442 in the entry in the .hash section. */
2443 if (h->dynindx != -1
2444 && elf_hash_table (finfo->info)->dynamic_sections_created)
2446 struct elf_backend_data *bed;
2449 bfd_byte *bucketpos;
2452 sym.st_name = h->dynstr_index;
2454 /* Give the processor backend a chance to tweak the symbol
2455 value, and also to finish up anything that needs to be done
2457 bed = get_elf_backend_data (finfo->output_bfd);
2458 if (! ((*bed->elf_backend_finish_dynamic_symbol)
2459 (finfo->output_bfd, finfo->info, h, &sym)))
2465 elf_swap_symbol_out (finfo->output_bfd, &sym,
2466 (char *) ((Elf_External_Sym *) finfo->dynsym_sec->contents
2469 bucketcount = elf_hash_table (finfo->info)->bucketcount;
2470 bucket = (bfd_elf_hash ((const unsigned char *) h->root.root.string)
2472 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
2473 + (bucket + 2) * (ARCH_SIZE / 8));
2474 chain = get_word (finfo->output_bfd, bucketpos);
2475 put_word (finfo->output_bfd, h->dynindx, bucketpos);
2476 put_word (finfo->output_bfd, chain,
2477 ((bfd_byte *) finfo->hash_sec->contents
2478 + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
2481 /* If we're stripping it, then it was just a dynamic symbol, and
2482 there's nothing else to do. */
2486 h->indx = finfo->output_bfd->symcount;
2488 if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
2497 /* Link an input file into the linker output file. This function
2498 handles all the sections and relocations of the input file at once.
2499 This is so that we only have to read the local symbols once, and
2500 don't have to keep them in memory. */
2503 elf_link_input_bfd (finfo, input_bfd)
2504 struct elf_final_link_info *finfo;
2507 boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
2508 bfd *, asection *, bfd_byte *,
2509 Elf_Internal_Rela *,
2510 Elf_Internal_Sym *, asection **));
2512 Elf_Internal_Shdr *symtab_hdr;
2515 Elf_External_Sym *esym;
2516 Elf_External_Sym *esymend;
2517 Elf_Internal_Sym *isym;
2519 asection **ppsection;
2522 output_bfd = finfo->output_bfd;
2524 get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
2526 /* If this is a dynamic object, we don't want to do anything here:
2527 we don't want the local symbols, and we don't want the section
2529 if (elf_elfheader (input_bfd)->e_type == ET_DYN)
2532 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2533 if (elf_bad_symtab (input_bfd))
2535 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
2540 locsymcount = symtab_hdr->sh_info;
2541 extsymoff = symtab_hdr->sh_info;
2544 /* Read the local symbols. */
2546 && (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2547 || (bfd_read (finfo->external_syms, sizeof (Elf_External_Sym),
2548 locsymcount, input_bfd)
2549 != locsymcount * sizeof (Elf_External_Sym))))
2552 /* Swap in the local symbols and write out the ones which we know
2553 are going into the output file. */
2554 esym = finfo->external_syms;
2555 esymend = esym + locsymcount;
2556 isym = finfo->internal_syms;
2557 pindex = finfo->indices;
2558 ppsection = finfo->sections;
2559 for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
2563 Elf_Internal_Sym osym;
2565 elf_swap_symbol_in (input_bfd, esym, isym);
2568 if (elf_bad_symtab (input_bfd))
2570 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
2577 if (isym->st_shndx == SHN_UNDEF)
2578 isec = bfd_und_section_ptr;
2579 else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
2580 isec = section_from_elf_index (input_bfd, isym->st_shndx);
2581 else if (isym->st_shndx == SHN_ABS)
2582 isec = bfd_abs_section_ptr;
2583 else if (isym->st_shndx == SHN_COMMON)
2584 isec = bfd_com_section_ptr;
2593 /* Don't output the first, undefined, symbol. */
2594 if (esym == finfo->external_syms)
2597 /* If we are stripping all symbols, we don't want to output this
2599 if (finfo->info->strip == strip_all)
2602 /* We never output section symbols. Instead, we use the section
2603 symbol of the corresponding section in the output file. */
2604 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2607 /* If we are discarding all local symbols, we don't want to
2608 output this one. If we are generating a relocateable output
2609 file, then some of the local symbols may be required by
2610 relocs; we output them below as we discover that they are
2612 if (finfo->info->discard == discard_all)
2615 /* Get the name of the symbol. */
2616 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
2621 /* See if we are discarding symbols with this name. */
2622 if ((finfo->info->strip == strip_some
2623 && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
2625 || (finfo->info->discard == discard_l
2626 && strncmp (name, finfo->info->lprefix,
2627 finfo->info->lprefix_len) == 0))
2630 /* If we get here, we are going to output this symbol. */
2634 /* Adjust the section index for the output file. */
2635 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
2636 isec->output_section);
2637 if (osym.st_shndx == (unsigned short) -1)
2640 *pindex = output_bfd->symcount;
2642 /* ELF symbols in relocateable files are section relative, but
2643 in executable files they are virtual addresses. Note that
2644 this code assumes that all ELF sections have an associated
2645 BFD section with a reasonable value for output_offset; below
2646 we assume that they also have a reasonable value for
2647 output_section. Any special sections must be set up to meet
2648 these requirements. */
2649 osym.st_value += isec->output_offset;
2650 if (! finfo->info->relocateable)
2651 osym.st_value += isec->output_section->vma;
2653 if (! elf_link_output_sym (finfo, name, &osym, isec))
2657 /* Relocate the contents of each section. */
2658 for (o = input_bfd->sections; o != NULL; o = o->next)
2660 if ((o->flags & SEC_HAS_CONTENTS) == 0)
2663 if ((o->flags & SEC_IN_MEMORY) != 0
2664 && input_bfd == elf_hash_table (finfo->info)->dynobj)
2666 /* Section was created by elf_link_create_dynamic_sections.
2667 FIXME: This test is fragile. */
2671 /* Read the contents of the section. */
2672 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2673 (file_ptr) 0, o->_raw_size))
2676 if ((o->flags & SEC_RELOC) != 0)
2678 Elf_Internal_Rela *internal_relocs;
2680 /* Get the swapped relocs. */
2681 internal_relocs = elf_link_read_relocs (input_bfd, o,
2682 finfo->external_relocs,
2683 finfo->internal_relocs,
2685 if (internal_relocs == NULL
2686 && o->reloc_count > 0)
2689 /* Relocate the section by invoking a back end routine.
2691 The back end routine is responsible for adjusting the
2692 section contents as necessary, and (if using Rela relocs
2693 and generating a relocateable output file) adjusting the
2694 reloc addend as necessary.
2696 The back end routine does not have to worry about setting
2697 the reloc address or the reloc symbol index.
2699 The back end routine is given a pointer to the swapped in
2700 internal symbols, and can access the hash table entries
2701 for the external symbols via elf_sym_hashes (input_bfd).
2703 When generating relocateable output, the back end routine
2704 must handle STB_LOCAL/STT_SECTION symbols specially. The
2705 output symbol is going to be a section symbol
2706 corresponding to the output section, which will require
2707 the addend to be adjusted. */
2709 if (! (*relocate_section) (output_bfd, finfo->info,
2713 finfo->internal_syms,
2717 if (finfo->info->relocateable)
2719 Elf_Internal_Rela *irela;
2720 Elf_Internal_Rela *irelaend;
2721 struct elf_link_hash_entry **rel_hash;
2722 Elf_Internal_Shdr *input_rel_hdr;
2723 Elf_Internal_Shdr *output_rel_hdr;
2725 /* Adjust the reloc addresses and symbol indices. */
2727 irela = internal_relocs;
2728 irelaend = irela + o->reloc_count;
2729 rel_hash = (elf_section_data (o->output_section)->rel_hashes
2730 + o->output_section->reloc_count);
2731 for (; irela < irelaend; irela++, rel_hash++)
2734 Elf_Internal_Sym *isym;
2737 irela->r_offset += o->output_offset;
2739 r_symndx = ELF_R_SYM (irela->r_info);
2744 if (r_symndx >= locsymcount
2745 || (elf_bad_symtab (input_bfd)
2746 && finfo->sections[r_symndx] == NULL))
2750 /* This is a reloc against a global symbol. We
2751 have not yet output all the local symbols, so
2752 we do not know the symbol index of any global
2753 symbol. We set the rel_hash entry for this
2754 reloc to point to the global hash table entry
2755 for this symbol. The symbol index is then
2756 set at the end of elf_bfd_final_link. */
2757 indx = r_symndx - extsymoff;
2758 *rel_hash = elf_sym_hashes (input_bfd)[indx];
2760 /* Setting the index to -2 tells
2761 elf_link_output_extsym that this symbol is
2763 BFD_ASSERT ((*rel_hash)->indx < 0);
2764 (*rel_hash)->indx = -2;
2769 /* This is a reloc against a local symbol. */
2772 isym = finfo->internal_syms + r_symndx;
2773 sec = finfo->sections[r_symndx];
2774 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2776 /* I suppose the backend ought to fill in the
2777 section of any STT_SECTION symbol against a
2778 processor specific section. */
2779 if (sec != NULL && bfd_is_abs_section (sec))
2781 else if (sec == NULL || sec->owner == NULL)
2783 bfd_set_error (bfd_error_bad_value);
2788 r_symndx = sec->output_section->target_index;
2789 BFD_ASSERT (r_symndx != 0);
2794 if (finfo->indices[r_symndx] == -1)
2800 if (finfo->info->strip == strip_all)
2802 /* You can't do ld -r -s. */
2803 bfd_set_error (bfd_error_invalid_operation);
2807 /* This symbol was skipped earlier, but
2808 since it is needed by a reloc, we
2809 must output it now. */
2810 link = symtab_hdr->sh_link;
2811 name = bfd_elf_string_from_elf_section (input_bfd,
2817 osec = sec->output_section;
2819 _bfd_elf_section_from_bfd_section (output_bfd,
2821 if (isym->st_shndx == (unsigned short) -1)
2824 isym->st_value += sec->output_offset;
2825 if (! finfo->info->relocateable)
2826 isym->st_value += osec->vma;
2828 finfo->indices[r_symndx] = output_bfd->symcount;
2830 if (! elf_link_output_sym (finfo, name, isym, sec))
2834 r_symndx = finfo->indices[r_symndx];
2837 irela->r_info = ELF_R_INFO (r_symndx,
2838 ELF_R_TYPE (irela->r_info));
2841 /* Swap out the relocs. */
2842 input_rel_hdr = &elf_section_data (o)->rel_hdr;
2843 output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
2844 BFD_ASSERT (output_rel_hdr->sh_entsize
2845 == input_rel_hdr->sh_entsize);
2846 irela = internal_relocs;
2847 irelaend = irela + o->reloc_count;
2848 if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2850 Elf_External_Rel *erel;
2852 erel = ((Elf_External_Rel *) output_rel_hdr->contents
2853 + o->output_section->reloc_count);
2854 for (; irela < irelaend; irela++, erel++)
2856 Elf_Internal_Rel irel;
2858 irel.r_offset = irela->r_offset;
2859 irel.r_info = irela->r_info;
2860 BFD_ASSERT (irela->r_addend == 0);
2861 elf_swap_reloc_out (output_bfd, &irel, erel);
2866 Elf_External_Rela *erela;
2868 BFD_ASSERT (input_rel_hdr->sh_entsize
2869 == sizeof (Elf_External_Rela));
2870 erela = ((Elf_External_Rela *) output_rel_hdr->contents
2871 + o->output_section->reloc_count);
2872 for (; irela < irelaend; irela++, erela++)
2873 elf_swap_reloca_out (output_bfd, irela, erela);
2876 o->output_section->reloc_count += o->reloc_count;
2880 /* Write out the modified section contents. */
2881 if (! bfd_set_section_contents (output_bfd, o->output_section,
2882 finfo->contents, o->output_offset,
2883 (o->_cooked_size != 0
2892 /* Generate a reloc when linking an ELF file. This is a reloc
2893 requested by the linker, and does come from any input file. This
2894 is used to build constructor and destructor tables when linking
2898 elf_reloc_link_order (output_bfd, info, output_section, link_order)
2900 struct bfd_link_info *info;
2901 asection *output_section;
2902 struct bfd_link_order *link_order;
2904 reloc_howto_type *howto;
2907 struct elf_link_hash_entry **rel_hash_ptr;
2908 Elf_Internal_Shdr *rel_hdr;
2910 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2913 bfd_set_error (bfd_error_bad_value);
2917 /* If this is an inplace reloc, we must write the addend into the
2919 if (howto->partial_inplace
2920 && link_order->u.reloc.p->addend != 0)
2923 bfd_reloc_status_type rstat;
2927 size = bfd_get_reloc_size (howto);
2928 buf = (bfd_byte *) bfd_zmalloc (size);
2929 if (buf == (bfd_byte *) NULL)
2931 bfd_set_error (bfd_error_no_memory);
2934 rstat = _bfd_relocate_contents (howto, output_bfd,
2935 link_order->u.reloc.p->addend, buf);
2941 case bfd_reloc_outofrange:
2943 case bfd_reloc_overflow:
2944 if (! ((*info->callbacks->reloc_overflow)
2946 (link_order->type == bfd_section_reloc_link_order
2947 ? bfd_section_name (output_bfd,
2948 link_order->u.reloc.p->u.section)
2949 : link_order->u.reloc.p->u.name),
2950 howto->name, link_order->u.reloc.p->addend,
2951 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2958 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
2959 (file_ptr) link_order->offset, size);
2965 /* Figure out the symbol index. */
2966 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
2967 + output_section->reloc_count);
2968 if (link_order->type == bfd_section_reloc_link_order)
2970 indx = link_order->u.reloc.p->u.section->target_index;
2971 BFD_ASSERT (indx != 0);
2972 *rel_hash_ptr = NULL;
2976 struct elf_link_hash_entry *h;
2978 h = elf_link_hash_lookup (elf_hash_table (info),
2979 link_order->u.reloc.p->u.name,
2980 false, false, true);
2983 /* Setting the index to -2 tells elf_link_output_extsym that
2984 this symbol is used by a reloc. */
2991 if (! ((*info->callbacks->unattached_reloc)
2992 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2993 (asection *) NULL, (bfd_vma) 0)))
2999 /* The address of a reloc is relative to the section in a
3000 relocateable file, and is a virtual address in an executable
3002 offset = link_order->offset;
3003 if (! info->relocateable)
3004 offset += output_section->vma;
3006 rel_hdr = &elf_section_data (output_section)->rel_hdr;
3008 if (rel_hdr->sh_type == SHT_REL)
3010 Elf_Internal_Rel irel;
3011 Elf_External_Rel *erel;
3013 irel.r_offset = offset;
3014 irel.r_info = ELF_R_INFO (indx, howto->type);
3015 erel = ((Elf_External_Rel *) rel_hdr->contents
3016 + output_section->reloc_count);
3017 elf_swap_reloc_out (output_bfd, &irel, erel);
3021 Elf_Internal_Rela irela;
3022 Elf_External_Rela *erela;
3024 irela.r_offset = offset;
3025 irela.r_info = ELF_R_INFO (indx, howto->type);
3026 irela.r_addend = link_order->u.reloc.p->addend;
3027 erela = ((Elf_External_Rela *) rel_hdr->contents
3028 + output_section->reloc_count);
3029 elf_swap_reloca_out (output_bfd, &irela, erela);
3032 ++output_section->reloc_count;