2 Copyright 1995 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* ELF linker code. */
22 static boolean elf_link_add_object_symbols
23 PARAMS ((bfd *, struct bfd_link_info *));
24 static boolean elf_link_add_archive_symbols
25 PARAMS ((bfd *, struct bfd_link_info *));
26 static Elf_Internal_Rela *elf_link_read_relocs
27 PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean));
28 static boolean elf_export_symbol
29 PARAMS ((struct elf_link_hash_entry *, PTR));
30 static boolean elf_adjust_dynamic_symbol
31 PARAMS ((struct elf_link_hash_entry *, PTR));
33 /* This struct is used to pass information to routines called via
34 elf_link_hash_traverse which must return failure. */
36 struct elf_info_failed
39 struct bfd_link_info *info;
42 /* Given an ELF BFD, add symbols to the global hash table as
46 elf_bfd_link_add_symbols (abfd, info)
48 struct bfd_link_info *info;
50 switch (bfd_get_format (abfd))
53 return elf_link_add_object_symbols (abfd, info);
55 return elf_link_add_archive_symbols (abfd, info);
57 bfd_set_error (bfd_error_wrong_format);
62 /* Add symbols from an ELF archive file to the linker hash table. We
63 don't use _bfd_generic_link_add_archive_symbols because of a
64 problem which arises on UnixWare. The UnixWare libc.so is an
65 archive which includes an entry libc.so.1 which defines a bunch of
66 symbols. The libc.so archive also includes a number of other
67 object files, which also define symbols, some of which are the same
68 as those defined in libc.so.1. Correct linking requires that we
69 consider each object file in turn, and include it if it defines any
70 symbols we need. _bfd_generic_link_add_archive_symbols does not do
71 this; it looks through the list of undefined symbols, and includes
72 any object file which defines them. When this algorithm is used on
73 UnixWare, it winds up pulling in libc.so.1 early and defining a
74 bunch of symbols. This means that some of the other objects in the
75 archive are not included in the link, which is incorrect since they
76 precede libc.so.1 in the archive.
78 Fortunately, ELF archive handling is simpler than that done by
79 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
80 oddities. In ELF, if we find a symbol in the archive map, and the
81 symbol is currently undefined, we know that we must pull in that
84 Unfortunately, we do have to make multiple passes over the symbol
85 table until nothing further is resolved. */
88 elf_link_add_archive_symbols (abfd, info)
90 struct bfd_link_info *info;
93 boolean *defined = NULL;
94 boolean *included = NULL;
98 if (! bfd_has_map (abfd))
100 /* An empty archive is a special case. */
101 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
103 bfd_set_error (bfd_error_no_armap);
107 /* Keep track of all symbols we know to be already defined, and all
108 files we know to be already included. This is to speed up the
109 second and subsequent passes. */
110 c = bfd_ardata (abfd)->symdef_count;
113 defined = (boolean *) malloc (c * sizeof (boolean));
114 included = (boolean *) malloc (c * sizeof (boolean));
115 if (defined == (boolean *) NULL || included == (boolean *) NULL)
117 bfd_set_error (bfd_error_no_memory);
120 memset (defined, 0, c * sizeof (boolean));
121 memset (included, 0, c * sizeof (boolean));
123 symdefs = bfd_ardata (abfd)->symdefs;
136 symdefend = symdef + c;
137 for (i = 0; symdef < symdefend; symdef++, i++)
139 struct elf_link_hash_entry *h;
141 struct bfd_link_hash_entry *undefs_tail;
144 if (defined[i] || included[i])
146 if (symdef->file_offset == last)
152 h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
153 false, false, false);
154 if (h == (struct elf_link_hash_entry *) NULL)
156 if (h->root.type != bfd_link_hash_undefined)
158 if (h->root.type != bfd_link_hash_undefweak)
163 /* We need to include this archive member. */
165 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
166 if (element == (bfd *) NULL)
169 if (! bfd_check_format (element, bfd_object))
172 /* Doublecheck that we have not included this object
173 already--it should be impossible, but there may be
174 something wrong with the archive. */
175 if (element->archive_pass != 0)
177 bfd_set_error (bfd_error_bad_value);
180 element->archive_pass = 1;
182 undefs_tail = info->hash->undefs_tail;
184 if (! (*info->callbacks->add_archive_element) (info, element,
187 if (! elf_link_add_object_symbols (element, info))
190 /* If there are any new undefined symbols, we need to make
191 another pass through the archive in order to see whether
192 they can be defined. FIXME: This isn't perfect, because
193 common symbols wind up on undefs_tail and because an
194 undefined symbol which is defined later on in this pass
195 does not require another pass. This isn't a bug, but it
196 does make the code less efficient than it could be. */
197 if (undefs_tail != info->hash->undefs_tail)
200 /* Look backward to mark all symbols from this object file
201 which we have already seen in this pass. */
205 included[mark] = true;
210 while (symdefs[mark].file_offset == symdef->file_offset);
212 /* We mark subsequent symbols from this object file as we go
213 on through the loop. */
214 last = symdef->file_offset;
225 if (defined != (boolean *) NULL)
227 if (included != (boolean *) NULL)
232 /* Add symbols from an ELF object file to the linker hash table. */
235 elf_link_add_object_symbols (abfd, info)
237 struct bfd_link_info *info;
239 boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
240 const Elf_Internal_Sym *,
241 const char **, flagword *,
242 asection **, bfd_vma *));
243 boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
244 asection *, const Elf_Internal_Rela *));
246 Elf_Internal_Shdr *hdr;
250 Elf_External_Sym *buf = NULL;
251 struct elf_link_hash_entry **sym_hash;
253 Elf_External_Dyn *dynbuf = NULL;
254 struct elf_link_hash_entry *weaks;
255 Elf_External_Sym *esym;
256 Elf_External_Sym *esymend;
258 add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
259 collect = get_elf_backend_data (abfd)->collect;
261 /* As a GNU extension, any input sections which are named
262 .gnu.warning.SYMBOL are treated as warning symbols for the given
263 symbol. This differs from .gnu.warning sections, which generate
264 warnings when they are included in an output file. */
269 for (s = abfd->sections; s != NULL; s = s->next)
273 name = bfd_get_section_name (abfd, s);
274 if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
279 sz = bfd_section_size (abfd, s);
280 msg = (char *) bfd_alloc (abfd, sz);
283 bfd_set_error (bfd_error_no_memory);
287 if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
290 if (! (_bfd_generic_link_add_one_symbol
292 name + sizeof ".gnu.warning." - 1,
293 BSF_WARNING, s, (bfd_vma) 0, msg, false, collect,
294 (struct bfd_link_hash_entry **) NULL)))
297 if (! info->relocateable)
299 /* Clobber the section size so that the warning does
300 not get copied into the output file. */
307 /* A stripped shared library might only have a dynamic symbol table,
308 not a regular symbol table. In that case we can still go ahead
309 and link using the dynamic symbol table. */
310 if (elf_onesymtab (abfd) == 0
311 && elf_dynsymtab (abfd) != 0)
313 elf_onesymtab (abfd) = elf_dynsymtab (abfd);
314 elf_tdata (abfd)->symtab_hdr = elf_tdata (abfd)->dynsymtab_hdr;
317 hdr = &elf_tdata (abfd)->symtab_hdr;
318 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
320 /* The sh_info field of the symtab header tells us where the
321 external symbols start. We don't care about the local symbols at
323 if (elf_bad_symtab (abfd))
325 extsymcount = symcount;
330 extsymcount = symcount - hdr->sh_info;
331 extsymoff = hdr->sh_info;
334 buf = (Elf_External_Sym *) malloc (extsymcount * sizeof (Elf_External_Sym));
335 if (buf == NULL && extsymcount != 0)
337 bfd_set_error (bfd_error_no_memory);
341 /* We store a pointer to the hash table entry for each external
343 sym_hash = ((struct elf_link_hash_entry **)
345 extsymcount * sizeof (struct elf_link_hash_entry *)));
346 if (sym_hash == NULL)
348 bfd_set_error (bfd_error_no_memory);
351 elf_sym_hashes (abfd) = sym_hash;
353 if (elf_elfheader (abfd)->e_type != ET_DYN)
357 /* If we are creating a shared library, create all the dynamic
358 sections immediately. We need to attach them to something,
359 so we attach them to this BFD, provided it is the right
360 format. FIXME: If there are no input BFD's of the same
361 format as the output, we can't make a shared library. */
363 && ! elf_hash_table (info)->dynamic_sections_created
364 && abfd->xvec == info->hash->creator)
366 if (! elf_link_create_dynamic_sections (abfd, info))
375 bfd_size_type oldsize;
376 bfd_size_type strindex;
380 /* You can't use -r against a dynamic object. Also, there's no
381 hope of using a dynamic object which does not exactly match
382 the format of the output file. */
383 if (info->relocateable
384 || info->hash->creator != abfd->xvec)
386 bfd_set_error (bfd_error_invalid_operation);
390 /* Find the name to use in a DT_NEEDED entry that refers to this
391 object. If the object has a DT_SONAME entry, we use it.
392 Otherwise, if the generic linker stuck something in
393 elf_dt_needed_name, we use that. Otherwise, we just use the
394 file name. If the generic linker put a null string into
395 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
396 even if there is a DT_SONAME entry. */
398 name = bfd_get_filename (abfd);
399 if (elf_dt_needed_name (abfd) != NULL)
401 name = elf_dt_needed_name (abfd);
405 s = bfd_get_section_by_name (abfd, ".dynamic");
408 Elf_External_Dyn *extdyn;
409 Elf_External_Dyn *extdynend;
413 dynbuf = (Elf_External_Dyn *) malloc ((size_t) s->_raw_size);
416 bfd_set_error (bfd_error_no_memory);
420 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
421 (file_ptr) 0, s->_raw_size))
424 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
427 link = elf_elfsections (abfd)[elfsec]->sh_link;
430 extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
431 for (; extdyn < extdynend; extdyn++)
433 Elf_Internal_Dyn dyn;
435 elf_swap_dyn_in (abfd, extdyn, &dyn);
436 if (add_needed && dyn.d_tag == DT_SONAME)
438 name = bfd_elf_string_from_elf_section (abfd, link,
443 if (dyn.d_tag == DT_NEEDED)
445 struct bfd_elf_link_needed_list *n, **pn;
448 n = (struct bfd_elf_link_needed_list *)
450 sizeof (struct bfd_elf_link_needed_list));
451 fnm = bfd_elf_string_from_elf_section (abfd, link,
453 if (n == NULL || fnm == NULL)
455 anm = bfd_alloc (abfd, strlen (fnm) + 1);
462 for (pn = &elf_hash_table (info)->needed;
474 /* We do not want to include any of the sections in a dynamic
475 object in the output file. We hack by simply clobbering the
476 list of sections in the BFD. This could be handled more
477 cleanly by, say, a new section flag; the existing
478 SEC_NEVER_LOAD flag is not the one we want, because that one
479 still implies that the section takes up space in the output
481 abfd->sections = NULL;
483 /* If this is the first dynamic object found in the link, create
484 the special sections required for dynamic linking. */
485 if (! elf_hash_table (info)->dynamic_sections_created)
487 if (! elf_link_create_dynamic_sections (abfd, info))
493 /* Add a DT_NEEDED entry for this dynamic object. */
494 oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
495 strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
497 if (strindex == (bfd_size_type) -1)
500 if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
503 Elf_External_Dyn *dyncon, *dynconend;
505 /* The hash table size did not change, which means that
506 the dynamic object name was already entered. If we
507 have already included this dynamic object in the
508 link, just ignore it. There is no reason to include
509 a particular dynamic object more than once. */
510 sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
512 BFD_ASSERT (sdyn != NULL);
514 dyncon = (Elf_External_Dyn *) sdyn->contents;
515 dynconend = (Elf_External_Dyn *) (sdyn->contents +
517 for (; dyncon < dynconend; dyncon++)
519 Elf_Internal_Dyn dyn;
521 elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
523 if (dyn.d_tag == DT_NEEDED
524 && dyn.d_un.d_val == strindex)
533 if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
539 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
541 || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
542 != extsymcount * sizeof (Elf_External_Sym)))
547 esymend = buf + extsymcount;
548 for (esym = buf; esym < esymend; esym++, sym_hash++)
550 Elf_Internal_Sym sym;
556 struct elf_link_hash_entry *h;
558 boolean size_change_ok, type_change_ok;
561 elf_swap_symbol_in (abfd, esym, &sym);
563 flags = BSF_NO_FLAGS;
565 value = sym.st_value;
568 bind = ELF_ST_BIND (sym.st_info);
569 if (bind == STB_LOCAL)
571 /* This should be impossible, since ELF requires that all
572 global symbols follow all local symbols, and that sh_info
573 point to the first global symbol. Unfortunatealy, Irix 5
577 else if (bind == STB_GLOBAL)
579 if (sym.st_shndx != SHN_UNDEF
580 && sym.st_shndx != SHN_COMMON)
585 else if (bind == STB_WEAK)
589 /* Leave it up to the processor backend. */
592 if (sym.st_shndx == SHN_UNDEF)
593 sec = bfd_und_section_ptr;
594 else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
596 sec = section_from_elf_index (abfd, sym.st_shndx);
600 sec = bfd_abs_section_ptr;
602 else if (sym.st_shndx == SHN_ABS)
603 sec = bfd_abs_section_ptr;
604 else if (sym.st_shndx == SHN_COMMON)
606 sec = bfd_com_section_ptr;
607 /* What ELF calls the size we call the value. What ELF
608 calls the value we call the alignment. */
613 /* Leave it up to the processor backend. */
616 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
617 if (name == (const char *) NULL)
622 if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
626 /* The hook function sets the name to NULL if this symbol
627 should be skipped for some reason. */
628 if (name == (const char *) NULL)
632 /* Sanity check that all possibilities were handled. */
633 if (sec == (asection *) NULL)
635 bfd_set_error (bfd_error_bad_value);
639 if (bfd_is_und_section (sec)
640 || bfd_is_com_section (sec))
645 size_change_ok = false;
646 type_change_ok = false;
647 if (info->hash->creator->flavour == bfd_target_elf_flavour)
649 /* We need to look up the symbol now in order to get some of
650 the dynamic object handling right. We pass the hash
651 table entry in to _bfd_generic_link_add_one_symbol so
652 that it does not have to look it up again. */
653 h = elf_link_hash_lookup (elf_hash_table (info), name,
659 while (h->root.type == bfd_link_hash_indirect
660 || h->root.type == bfd_link_hash_warning)
661 h = (struct elf_link_hash_entry *) h->root.u.i.link;
663 /* It's OK to change the type if it used to be a weak
665 type_change_ok = (h->root.type == bfd_link_hash_defweak
666 || h->root.type == bfd_link_hash_undefweak);
668 /* It's OK to change the size if it used to be a weak
669 definition, or if it used to be undefined, or if we will
670 be overriding an old definition.
672 size_change_ok = (type_change_ok
673 || h->root.type == bfd_link_hash_undefined);
675 /* If we are looking at a dynamic object, and this is a
676 definition, we need to see if it has already been defined
677 by some other object. If it has, we want to use the
678 existing definition, and we do not want to report a
679 multiple symbol definition error; we do this by
680 clobbering sec to be bfd_und_section_ptr. */
681 if (dynamic && definition)
683 if (h->root.type == bfd_link_hash_defined
684 || h->root.type == bfd_link_hash_defweak
685 || (h->root.type == bfd_link_hash_common
686 && bind == STB_WEAK))
688 sec = bfd_und_section_ptr;
690 size_change_ok = true;
694 /* Similarly, if we are not looking at a dynamic object, and
695 we have a definition, we want to override any definition
696 we may have from a dynamic object. Symbols from regular
697 files always take precedence over symbols from dynamic
698 objects, even if they are defined after the dynamic
699 object in the link. */
702 && (h->root.type == bfd_link_hash_defined
703 || h->root.type == bfd_link_hash_defweak)
704 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
705 && (bfd_get_flavour (h->root.u.def.section->owner)
706 == bfd_target_elf_flavour)
707 && (elf_elfheader (h->root.u.def.section->owner)->e_type
710 /* Change the hash table entry to undefined, and let
711 _bfd_generic_link_add_one_symbol do the right thing
712 with the new definition. */
713 h->root.type = bfd_link_hash_undefined;
714 h->root.u.undef.abfd = h->root.u.def.section->owner;
715 size_change_ok = true;
719 if (! (_bfd_generic_link_add_one_symbol
720 (info, abfd, name, flags, sec, value, (const char *) NULL,
721 false, collect, (struct bfd_link_hash_entry **) sym_hash)))
725 while (h->root.type == bfd_link_hash_indirect
726 || h->root.type == bfd_link_hash_warning)
727 h = (struct elf_link_hash_entry *) h->root.u.i.link;
733 && (flags & BSF_WEAK) != 0
734 && ELF_ST_TYPE (sym.st_info) != STT_FUNC
735 && info->hash->creator->flavour == bfd_target_elf_flavour
736 && h->weakdef == NULL)
738 /* Keep a list of all weak defined non function symbols from
739 a dynamic object, using the weakdef field. Later in this
740 function we will set the weakdef field to the correct
741 value. We only put non-function symbols from dynamic
742 objects on this list, because that happens to be the only
743 time we need to know the normal symbol corresponding to a
744 weak symbol, and the information is time consuming to
745 figure out. If the weakdef field is not already NULL,
746 then this symbol was already defined by some previous
747 dynamic object, and we will be using that previous
748 definition anyhow. */
755 /* Get the alignment of a common symbol. */
756 if (sym.st_shndx == SHN_COMMON
757 && h->root.type == bfd_link_hash_common)
758 h->root.u.c.p->alignment_power = bfd_log2 (sym.st_value);
760 if (info->hash->creator->flavour == bfd_target_elf_flavour)
766 /* Remember the symbol size and type. */
768 && (definition || h->size == 0))
770 if (h->size != 0 && h->size != sym.st_size && ! size_change_ok)
771 (*_bfd_error_handler)
772 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
773 name, (unsigned long) h->size, (unsigned long) sym.st_size,
774 bfd_get_filename (abfd));
776 h->size = sym.st_size;
778 if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE
779 && (definition || h->type == STT_NOTYPE))
781 if (h->type != STT_NOTYPE
782 && h->type != ELF_ST_TYPE (sym.st_info)
784 (*_bfd_error_handler)
785 ("Warning: type of symbol `%s' changed from %d to %d in %s",
786 name, h->type, ELF_ST_TYPE (sym.st_info),
787 bfd_get_filename (abfd));
789 h->type = ELF_ST_TYPE (sym.st_info);
792 /* Set a flag in the hash table entry indicating the type of
793 reference or definition we just found. Keep a count of
794 the number of dynamic symbols we find. A dynamic symbol
795 is one which is referenced or defined by both a regular
796 object and a shared object, or one which is referenced or
797 defined by more than one shared object. */
798 old_flags = h->elf_link_hash_flags;
803 new_flag = ELF_LINK_HASH_REF_REGULAR;
805 new_flag = ELF_LINK_HASH_DEF_REGULAR;
807 || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
808 | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
814 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
816 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
817 if ((old_flags & new_flag) != 0
818 || (old_flags & (ELF_LINK_HASH_DEF_REGULAR
819 | ELF_LINK_HASH_REF_REGULAR)) != 0
820 || (h->weakdef != NULL
821 && (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
822 | ELF_LINK_HASH_REF_DYNAMIC)) != 0))
826 h->elf_link_hash_flags |= new_flag;
827 if (dynsym && h->dynindx == -1)
829 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
831 if (h->weakdef != NULL
833 && h->weakdef->dynindx == -1)
835 if (! _bfd_elf_link_record_dynamic_symbol (info,
843 /* Now set the weakdefs field correctly for all the weak defined
844 symbols we found. The only way to do this is to search all the
845 symbols. Since we only need the information for non functions in
846 dynamic objects, that's the only time we actually put anything on
847 the list WEAKS. We need this information so that if a regular
848 object refers to a symbol defined weakly in a dynamic object, the
849 real symbol in the dynamic object is also put in the dynamic
850 symbols; we also must arrange for both symbols to point to the
851 same memory location. We could handle the general case of symbol
852 aliasing, but a general symbol alias can only be generated in
853 assembler code, handling it correctly would be very time
854 consuming, and other ELF linkers don't handle general aliasing
856 while (weaks != NULL)
858 struct elf_link_hash_entry *hlook;
861 struct elf_link_hash_entry **hpp;
862 struct elf_link_hash_entry **hppend;
865 weaks = hlook->weakdef;
866 hlook->weakdef = NULL;
868 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
869 || hlook->root.type == bfd_link_hash_defweak
870 || hlook->root.type == bfd_link_hash_common
871 || hlook->root.type == bfd_link_hash_indirect);
872 slook = hlook->root.u.def.section;
873 vlook = hlook->root.u.def.value;
875 hpp = elf_sym_hashes (abfd);
876 hppend = hpp + extsymcount;
877 for (; hpp < hppend; hpp++)
879 struct elf_link_hash_entry *h;
882 if (h != NULL && h != hlook
883 && (h->root.type == bfd_link_hash_defined
884 || h->root.type == bfd_link_hash_defweak)
885 && h->root.u.def.section == slook
886 && h->root.u.def.value == vlook)
890 /* If the weak definition is in the list of dynamic
891 symbols, make sure the real definition is put there
893 if (hlook->dynindx != -1
896 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
911 /* If this object is the same format as the output object, and it is
912 not a shared library, then let the backend look through the
915 This is required to build global offset table entries and to
916 arrange for dynamic relocs. It is not required for the
917 particular common case of linking non PIC code, even when linking
918 against shared libraries, but unfortunately there is no way of
919 knowing whether an object file has been compiled PIC or not.
920 Looking through the relocs is not particularly time consuming.
921 The problem is that we must either (1) keep the relocs in memory,
922 which causes the linker to require additional runtime memory or
923 (2) read the relocs twice from the input file, which wastes time.
924 This would be a good case for using mmap.
926 I have no idea how to handle linking PIC code into a file of a
927 different format. It probably can't be done. */
928 check_relocs = get_elf_backend_data (abfd)->check_relocs;
930 && abfd->xvec == info->hash->creator
931 && check_relocs != NULL)
935 for (o = abfd->sections; o != NULL; o = o->next)
937 Elf_Internal_Rela *internal_relocs;
940 if ((o->flags & SEC_RELOC) == 0
941 || o->reloc_count == 0)
944 /* I believe we can ignore the relocs for any section which
945 does not form part of the final process image, such as a
946 debugging section. */
947 if ((o->flags & SEC_ALLOC) == 0)
950 internal_relocs = elf_link_read_relocs (abfd, o, (PTR) NULL,
951 (Elf_Internal_Rela *) NULL,
953 if (internal_relocs == NULL)
956 ok = (*check_relocs) (abfd, info, o, internal_relocs);
958 if (! info->keep_memory)
959 free (internal_relocs);
976 /* Create some sections which will be filled in with dynamic linking
977 information. ABFD is an input file which requires dynamic sections
978 to be created. The dynamic sections take up virtual memory space
979 when the final executable is run, so we need to create them before
980 addresses are assigned to the output sections. We work out the
981 actual contents and size of these sections later. */
984 elf_link_create_dynamic_sections (abfd, info)
986 struct bfd_link_info *info;
989 register asection *s;
990 struct elf_link_hash_entry *h;
991 struct elf_backend_data *bed;
993 if (elf_hash_table (info)->dynamic_sections_created)
996 /* Make sure that all dynamic sections use the same input BFD. */
997 if (elf_hash_table (info)->dynobj == NULL)
998 elf_hash_table (info)->dynobj = abfd;
1000 abfd = elf_hash_table (info)->dynobj;
1002 /* Note that we set the SEC_IN_MEMORY flag for all of these
1004 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1006 /* A dynamically linked executable has a .interp section, but a
1007 shared library does not. */
1010 s = bfd_make_section (abfd, ".interp");
1012 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1016 s = bfd_make_section (abfd, ".dynsym");
1018 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1019 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1022 s = bfd_make_section (abfd, ".dynstr");
1024 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1027 /* Create a strtab to hold the dynamic symbol names. */
1028 if (elf_hash_table (info)->dynstr == NULL)
1030 elf_hash_table (info)->dynstr = elf_stringtab_init ();
1031 if (elf_hash_table (info)->dynstr == NULL)
1035 s = bfd_make_section (abfd, ".dynamic");
1037 || ! bfd_set_section_flags (abfd, s, flags)
1038 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1041 /* The special symbol _DYNAMIC is always set to the start of the
1042 .dynamic section. This call occurs before we have processed the
1043 symbols for any dynamic object, so we don't have to worry about
1044 overriding a dynamic definition. We could set _DYNAMIC in a
1045 linker script, but we only want to define it if we are, in fact,
1046 creating a .dynamic section. We don't want to define it if there
1047 is no .dynamic section, since on some ELF platforms the start up
1048 code examines it to decide how to initialize the process. */
1050 if (! (_bfd_generic_link_add_one_symbol
1051 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
1052 (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
1053 (struct bfd_link_hash_entry **) &h)))
1055 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1056 h->type = STT_OBJECT;
1059 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1062 s = bfd_make_section (abfd, ".hash");
1064 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1065 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1068 /* Let the backend create the rest of the sections. This lets the
1069 backend set the right flags. The backend will normally create
1070 the .got and .plt sections. */
1071 bed = get_elf_backend_data (abfd);
1072 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
1075 elf_hash_table (info)->dynamic_sections_created = true;
1080 /* Add an entry to the .dynamic table. */
1083 elf_add_dynamic_entry (info, tag, val)
1084 struct bfd_link_info *info;
1088 Elf_Internal_Dyn dyn;
1092 bfd_byte *newcontents;
1094 dynobj = elf_hash_table (info)->dynobj;
1096 s = bfd_get_section_by_name (dynobj, ".dynamic");
1097 BFD_ASSERT (s != NULL);
1099 newsize = s->_raw_size + sizeof (Elf_External_Dyn);
1100 if (s->contents == NULL)
1101 newcontents = (bfd_byte *) malloc (newsize);
1103 newcontents = (bfd_byte *) realloc (s->contents, newsize);
1104 if (newcontents == NULL)
1106 bfd_set_error (bfd_error_no_memory);
1111 dyn.d_un.d_val = val;
1112 elf_swap_dyn_out (dynobj, &dyn,
1113 (Elf_External_Dyn *) (newcontents + s->_raw_size));
1115 s->_raw_size = newsize;
1116 s->contents = newcontents;
1121 /* Read and swap the relocs for a section. They may have been cached.
1122 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1123 they are used as buffers to read into. They are known to be large
1124 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1125 value is allocated using either malloc or bfd_alloc, according to
1126 the KEEP_MEMORY argument. */
1128 static Elf_Internal_Rela *
1129 elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
1132 PTR external_relocs;
1133 Elf_Internal_Rela *internal_relocs;
1134 boolean keep_memory;
1136 Elf_Internal_Shdr *rel_hdr;
1138 Elf_Internal_Rela *alloc2 = NULL;
1140 if (elf_section_data (o)->relocs != NULL)
1141 return elf_section_data (o)->relocs;
1143 if (o->reloc_count == 0)
1146 rel_hdr = &elf_section_data (o)->rel_hdr;
1148 if (internal_relocs == NULL)
1152 size = o->reloc_count * sizeof (Elf_Internal_Rela);
1154 internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
1156 internal_relocs = alloc2 = (Elf_Internal_Rela *) malloc (size);
1157 if (internal_relocs == NULL)
1159 bfd_set_error (bfd_error_no_memory);
1164 if (external_relocs == NULL)
1166 alloc1 = (PTR) malloc ((size_t) rel_hdr->sh_size);
1169 bfd_set_error (bfd_error_no_memory);
1172 external_relocs = alloc1;
1175 if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
1176 || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
1177 != rel_hdr->sh_size))
1180 /* Swap in the relocs. For convenience, we always produce an
1181 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1183 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
1185 Elf_External_Rel *erel;
1186 Elf_External_Rel *erelend;
1187 Elf_Internal_Rela *irela;
1189 erel = (Elf_External_Rel *) external_relocs;
1190 erelend = erel + o->reloc_count;
1191 irela = internal_relocs;
1192 for (; erel < erelend; erel++, irela++)
1194 Elf_Internal_Rel irel;
1196 elf_swap_reloc_in (abfd, erel, &irel);
1197 irela->r_offset = irel.r_offset;
1198 irela->r_info = irel.r_info;
1199 irela->r_addend = 0;
1204 Elf_External_Rela *erela;
1205 Elf_External_Rela *erelaend;
1206 Elf_Internal_Rela *irela;
1208 BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
1210 erela = (Elf_External_Rela *) external_relocs;
1211 erelaend = erela + o->reloc_count;
1212 irela = internal_relocs;
1213 for (; erela < erelaend; erela++, irela++)
1214 elf_swap_reloca_in (abfd, erela, irela);
1217 /* Cache the results for next time, if we can. */
1219 elf_section_data (o)->relocs = internal_relocs;
1224 /* Don't free alloc2, since if it was allocated we are passing it
1225 back (under the name of internal_relocs). */
1227 return internal_relocs;
1237 /* Record an assignment to a symbol made by a linker script. We need
1238 this in case some dynamic object refers to this symbol. */
1242 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
1244 struct bfd_link_info *info;
1248 struct elf_link_hash_entry *h;
1250 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1253 h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
1257 /* If this symbol is being provided by the linker script, and it is
1258 currently defined by a dynamic object, but not by a regular
1259 object, then mark it as undefined so that the generic linker will
1260 force the correct value. */
1262 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1263 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1264 h->root.type = bfd_link_hash_undefined;
1266 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1267 h->type = STT_OBJECT;
1269 if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1270 | ELF_LINK_HASH_REF_DYNAMIC)) != 0
1272 && h->dynindx == -1)
1274 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1277 /* If this is a weak defined symbol, and we know a corresponding
1278 real symbol from the same dynamic object, make sure the real
1279 symbol is also made into a dynamic symbol. */
1280 if (h->weakdef != NULL
1281 && h->weakdef->dynindx == -1)
1283 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
1291 /* Array used to determine the number of hash table buckets to use
1292 based on the number of symbols there are. If there are fewer than
1293 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1294 fewer than 37 we use 17 buckets, and so forth. We never use more
1295 than 521 buckets. */
1297 static const size_t elf_buckets[] =
1299 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1302 /* Set up the sizes and contents of the ELF dynamic sections. This is
1303 called by the ELF linker emulation before_allocation routine. We
1304 must set the sizes of the sections before the linker sets the
1305 addresses of the various sections. */
1308 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
1309 export_dynamic, info, sinterpptr)
1313 boolean export_dynamic;
1314 struct bfd_link_info *info;
1315 asection **sinterpptr;
1318 struct elf_backend_data *bed;
1322 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1325 dynobj = elf_hash_table (info)->dynobj;
1327 /* If there were no dynamic objects in the link, there is nothing to
1332 /* If we are supposed to export all symbols into the dynamic symbol
1333 table (this is not the normal case), then do so. */
1336 struct elf_info_failed eif;
1340 elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
1346 if (elf_hash_table (info)->dynamic_sections_created)
1348 struct elf_info_failed eif;
1349 bfd_size_type strsize;
1351 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
1352 BFD_ASSERT (*sinterpptr != NULL || info->shared);
1358 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, soname,
1360 if (indx == (bfd_size_type) -1
1361 || ! elf_add_dynamic_entry (info, DT_SONAME, indx))
1367 if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
1375 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
1377 if (indx == (bfd_size_type) -1
1378 || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
1382 /* Find all symbols which were defined in a dynamic object and make
1383 the backend pick a reasonable value for them. */
1386 elf_link_hash_traverse (elf_hash_table (info),
1387 elf_adjust_dynamic_symbol,
1392 /* Add some entries to the .dynamic section. We fill in some of the
1393 values later, in elf_bfd_final_link, but we must add the entries
1394 now so that we know the final size of the .dynamic section. */
1395 if (elf_link_hash_lookup (elf_hash_table (info), "_init", false,
1396 false, false) != NULL)
1398 if (! elf_add_dynamic_entry (info, DT_INIT, 0))
1401 if (elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
1402 false, false) != NULL)
1404 if (! elf_add_dynamic_entry (info, DT_FINI, 0))
1407 strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1408 if (! elf_add_dynamic_entry (info, DT_HASH, 0)
1409 || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
1410 || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
1411 || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
1412 || ! elf_add_dynamic_entry (info, DT_SYMENT,
1413 sizeof (Elf_External_Sym)))
1417 /* The backend must work out the sizes of all the other dynamic
1419 bed = get_elf_backend_data (output_bfd);
1420 if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
1423 if (elf_hash_table (info)->dynamic_sections_created)
1428 size_t bucketcount = 0;
1429 Elf_Internal_Sym isym;
1431 /* Set the size of the .dynsym and .hash sections. We counted
1432 the number of dynamic symbols in elf_link_add_object_symbols.
1433 We will build the contents of .dynsym and .hash when we build
1434 the final symbol table, because until then we do not know the
1435 correct value to give the symbols. We built the .dynstr
1436 section as we went along in elf_link_add_object_symbols. */
1437 dynsymcount = elf_hash_table (info)->dynsymcount;
1438 s = bfd_get_section_by_name (dynobj, ".dynsym");
1439 BFD_ASSERT (s != NULL);
1440 s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
1441 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1442 if (s->contents == NULL && s->_raw_size != 0)
1444 bfd_set_error (bfd_error_no_memory);
1448 /* The first entry in .dynsym is a dummy symbol. */
1455 elf_swap_symbol_out (output_bfd, &isym,
1456 (PTR) (Elf_External_Sym *) s->contents);
1458 for (i = 0; elf_buckets[i] != 0; i++)
1460 bucketcount = elf_buckets[i];
1461 if (dynsymcount < elf_buckets[i + 1])
1465 s = bfd_get_section_by_name (dynobj, ".hash");
1466 BFD_ASSERT (s != NULL);
1467 s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
1468 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1469 if (s->contents == NULL)
1471 bfd_set_error (bfd_error_no_memory);
1474 memset (s->contents, 0, (size_t) s->_raw_size);
1476 put_word (output_bfd, bucketcount, s->contents);
1477 put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
1479 elf_hash_table (info)->bucketcount = bucketcount;
1481 s = bfd_get_section_by_name (dynobj, ".dynstr");
1482 BFD_ASSERT (s != NULL);
1483 s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1485 if (! elf_add_dynamic_entry (info, DT_NULL, 0))
1492 /* This routine is used to export all defined symbols into the dynamic
1493 symbol table. It is called via elf_link_hash_traverse. */
1496 elf_export_symbol (h, data)
1497 struct elf_link_hash_entry *h;
1500 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1502 if (h->dynindx == -1
1503 && (h->elf_link_hash_flags
1504 & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
1506 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1516 /* Make the backend pick a good value for a dynamic symbol. This is
1517 called via elf_link_hash_traverse, and also calls itself
1521 elf_adjust_dynamic_symbol (h, data)
1522 struct elf_link_hash_entry *h;
1525 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1527 struct elf_backend_data *bed;
1529 /* If -Bsymbolic was used (which means to bind references to global
1530 symbols to the definition within the shared object), and this
1531 symbol was defined in a regular object, then it actually doesn't
1532 need a PLT entry. */
1533 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1534 && eif->info->shared
1535 && eif->info->symbolic
1536 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1537 h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
1539 /* If this symbol does not require a PLT entry, and it is not
1540 defined by a dynamic object, or is not referenced by a regular
1541 object, ignore it. We do have to handle a weak defined symbol,
1542 even if no regular object refers to it, if we decided to add it
1543 to the dynamic symbol table. FIXME: Do we normally need to worry
1544 about symbols which are defined by one dynamic object and
1545 referenced by another one? */
1546 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
1547 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1548 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1549 || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
1550 && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
1553 /* If we've already adjusted this symbol, don't do it again. This
1554 can happen via a recursive call. */
1555 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
1558 /* Don't look at this symbol again. Note that we must set this
1559 after checking the above conditions, because we may look at a
1560 symbol once, decide not to do anything, and then get called
1561 recursively later after REF_REGULAR is set below. */
1562 h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
1564 /* If this is a weak definition, and we know a real definition, and
1565 the real symbol is not itself defined by a regular object file,
1566 then get a good value for the real definition. We handle the
1567 real symbol first, for the convenience of the backend routine.
1569 Note that there is a confusing case here. If the real definition
1570 is defined by a regular object file, we don't get the real symbol
1571 from the dynamic object, but we do get the weak symbol. If the
1572 processor backend uses a COPY reloc, then if some routine in the
1573 dynamic object changes the real symbol, we will not see that
1574 change in the corresponding weak symbol. This is the way other
1575 ELF linkers work as well, and seems to be a result of the shared
1578 I will clarify this issue. Most SVR4 shared libraries define the
1579 variable _timezone and define timezone as a weak synonym. The
1580 tzset call changes _timezone. If you write
1581 extern int timezone;
1583 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1584 you might expect that, since timezone is a synonym for _timezone,
1585 the same number will print both times. However, if the processor
1586 backend uses a COPY reloc, then actually timezone will be copied
1587 into your process image, and, since you define _timezone
1588 yourself, _timezone will not. Thus timezone and _timezone will
1589 wind up at different memory locations. The tzset call will set
1590 _timezone, leaving timezone unchanged. */
1592 if (h->weakdef != NULL)
1594 struct elf_link_hash_entry *weakdef;
1596 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1597 || h->root.type == bfd_link_hash_defweak);
1598 weakdef = h->weakdef;
1599 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
1600 || weakdef->root.type == bfd_link_hash_defweak);
1601 BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
1602 if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1604 /* This symbol is defined by a regular object file, so we
1605 will not do anything special. Clear weakdef for the
1606 convenience of the processor backend. */
1611 /* There is an implicit reference by a regular object file
1612 via the weak symbol. */
1613 weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1614 if (! elf_adjust_dynamic_symbol (weakdef, (PTR) eif))
1619 dynobj = elf_hash_table (eif->info)->dynobj;
1620 bed = get_elf_backend_data (dynobj);
1621 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
1630 /* Final phase of ELF linker. */
1632 /* A structure we use to avoid passing large numbers of arguments. */
1634 struct elf_final_link_info
1636 /* General link information. */
1637 struct bfd_link_info *info;
1640 /* Symbol string table. */
1641 struct bfd_strtab_hash *symstrtab;
1642 /* .dynsym section. */
1643 asection *dynsym_sec;
1644 /* .hash section. */
1646 /* Buffer large enough to hold contents of any section. */
1648 /* Buffer large enough to hold external relocs of any section. */
1649 PTR external_relocs;
1650 /* Buffer large enough to hold internal relocs of any section. */
1651 Elf_Internal_Rela *internal_relocs;
1652 /* Buffer large enough to hold external local symbols of any input
1654 Elf_External_Sym *external_syms;
1655 /* Buffer large enough to hold internal local symbols of any input
1657 Elf_Internal_Sym *internal_syms;
1658 /* Array large enough to hold a symbol index for each local symbol
1659 of any input BFD. */
1661 /* Array large enough to hold a section pointer for each local
1662 symbol of any input BFD. */
1663 asection **sections;
1664 /* Buffer to hold swapped out symbols. */
1665 Elf_External_Sym *symbuf;
1666 /* Number of swapped out symbols in buffer. */
1667 size_t symbuf_count;
1668 /* Number of symbols which fit in symbuf. */
1672 static boolean elf_link_output_sym
1673 PARAMS ((struct elf_final_link_info *, const char *,
1674 Elf_Internal_Sym *, asection *));
1675 static boolean elf_link_flush_output_syms
1676 PARAMS ((struct elf_final_link_info *));
1677 static boolean elf_link_output_extsym
1678 PARAMS ((struct elf_link_hash_entry *, PTR));
1679 static boolean elf_link_input_bfd
1680 PARAMS ((struct elf_final_link_info *, bfd *));
1681 static boolean elf_reloc_link_order
1682 PARAMS ((bfd *, struct bfd_link_info *, asection *,
1683 struct bfd_link_order *));
1685 /* This struct is used to pass information to routines called via
1686 elf_link_hash_traverse which must return failure. */
1688 struct elf_finfo_failed
1691 struct elf_final_link_info *finfo;
1694 /* Do the final step of an ELF link. */
1697 elf_bfd_final_link (abfd, info)
1699 struct bfd_link_info *info;
1703 struct elf_final_link_info finfo;
1704 register asection *o;
1705 register struct bfd_link_order *p;
1707 size_t max_contents_size;
1708 size_t max_external_reloc_size;
1709 size_t max_internal_reloc_count;
1710 size_t max_sym_count;
1712 Elf_Internal_Sym elfsym;
1714 Elf_Internal_Shdr *symtab_hdr;
1715 Elf_Internal_Shdr *symstrtab_hdr;
1716 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1717 struct elf_finfo_failed eif;
1720 abfd->flags |= DYNAMIC;
1722 dynamic = elf_hash_table (info)->dynamic_sections_created;
1723 dynobj = elf_hash_table (info)->dynobj;
1726 finfo.output_bfd = abfd;
1727 finfo.symstrtab = elf_stringtab_init ();
1728 if (finfo.symstrtab == NULL)
1732 finfo.dynsym_sec = NULL;
1733 finfo.hash_sec = NULL;
1737 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
1738 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
1739 BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
1741 finfo.contents = NULL;
1742 finfo.external_relocs = NULL;
1743 finfo.internal_relocs = NULL;
1744 finfo.external_syms = NULL;
1745 finfo.internal_syms = NULL;
1746 finfo.indices = NULL;
1747 finfo.sections = NULL;
1748 finfo.symbuf = NULL;
1749 finfo.symbuf_count = 0;
1751 /* Count up the number of relocations we will output for each output
1752 section, so that we know the sizes of the reloc sections. We
1753 also figure out some maximum sizes. */
1754 max_contents_size = 0;
1755 max_external_reloc_size = 0;
1756 max_internal_reloc_count = 0;
1758 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
1762 for (p = o->link_order_head; p != NULL; p = p->next)
1764 if (p->type == bfd_section_reloc_link_order
1765 || p->type == bfd_symbol_reloc_link_order)
1767 else if (p->type == bfd_indirect_link_order)
1771 sec = p->u.indirect.section;
1773 if (info->relocateable)
1774 o->reloc_count += sec->reloc_count;
1776 if (sec->_raw_size > max_contents_size)
1777 max_contents_size = sec->_raw_size;
1778 if (sec->_cooked_size > max_contents_size)
1779 max_contents_size = sec->_cooked_size;
1781 /* We are interested in just local symbols, not all
1783 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour)
1787 if (elf_bad_symtab (sec->owner))
1788 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
1789 / sizeof (Elf_External_Sym));
1791 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
1793 if (sym_count > max_sym_count)
1794 max_sym_count = sym_count;
1796 if ((sec->flags & SEC_RELOC) != 0)
1800 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
1801 if (ext_size > max_external_reloc_size)
1802 max_external_reloc_size = ext_size;
1803 if (sec->reloc_count > max_internal_reloc_count)
1804 max_internal_reloc_count = sec->reloc_count;
1810 if (o->reloc_count > 0)
1811 o->flags |= SEC_RELOC;
1814 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1815 set it (this is probably a bug) and if it is set
1816 assign_section_numbers will create a reloc section. */
1817 o->flags &=~ SEC_RELOC;
1820 /* If the SEC_ALLOC flag is not set, force the section VMA to
1821 zero. This is done in elf_fake_sections as well, but forcing
1822 the VMA to 0 here will ensure that relocs against these
1823 sections are handled correctly. */
1824 if ((o->flags & SEC_ALLOC) == 0)
1828 /* Figure out the file positions for everything but the symbol table
1829 and the relocs. We set symcount to force assign_section_numbers
1830 to create a symbol table. */
1831 abfd->symcount = info->strip == strip_all ? 0 : 1;
1832 BFD_ASSERT (! abfd->output_has_begun);
1833 if (! _bfd_elf_compute_section_file_positions (abfd, info))
1836 /* That created the reloc sections. Set their sizes, and assign
1837 them file positions, and allocate some buffers. */
1838 for (o = abfd->sections; o != NULL; o = o->next)
1840 if ((o->flags & SEC_RELOC) != 0)
1842 Elf_Internal_Shdr *rel_hdr;
1843 register struct elf_link_hash_entry **p, **pend;
1845 rel_hdr = &elf_section_data (o)->rel_hdr;
1847 rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
1849 /* The contents field must last into write_object_contents,
1850 so we allocate it with bfd_alloc rather than malloc. */
1851 rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
1852 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
1854 bfd_set_error (bfd_error_no_memory);
1858 p = ((struct elf_link_hash_entry **)
1859 malloc (o->reloc_count
1860 * sizeof (struct elf_link_hash_entry *)));
1861 if (p == NULL && o->reloc_count != 0)
1863 bfd_set_error (bfd_error_no_memory);
1866 elf_section_data (o)->rel_hashes = p;
1867 pend = p + o->reloc_count;
1868 for (; p < pend; p++)
1871 /* Use the reloc_count field as an index when outputting the
1877 _bfd_elf_assign_file_positions_for_relocs (abfd);
1879 /* We have now assigned file positions for all the sections except
1880 .symtab and .strtab. We start the .symtab section at the current
1881 file position, and write directly to it. We build the .strtab
1882 section in memory. When we add .dynsym support, we will build
1883 that in memory as well (.dynsym is smaller than .symtab). */
1885 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1886 /* sh_name is set in prep_headers. */
1887 symtab_hdr->sh_type = SHT_SYMTAB;
1888 symtab_hdr->sh_flags = 0;
1889 symtab_hdr->sh_addr = 0;
1890 symtab_hdr->sh_size = 0;
1891 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
1892 /* sh_link is set in assign_section_numbers. */
1893 /* sh_info is set below. */
1894 /* sh_offset is set just below. */
1895 symtab_hdr->sh_addralign = 4; /* FIXME: system dependent? */
1897 off = elf_tdata (abfd)->next_file_pos;
1898 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
1900 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1901 incorrect. We do not yet know the size of the .symtab section.
1902 We correct next_file_pos below, after we do know the size. */
1904 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1905 continuously seeking to the right position in the file. */
1906 if (! info->keep_memory || max_sym_count < 20)
1907 finfo.symbuf_size = 20;
1909 finfo.symbuf_size = max_sym_count;
1910 finfo.symbuf = ((Elf_External_Sym *)
1911 malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
1912 if (finfo.symbuf == NULL)
1914 bfd_set_error (bfd_error_no_memory);
1918 /* Start writing out the symbol table. The first symbol is always a
1920 elfsym.st_value = 0;
1923 elfsym.st_other = 0;
1924 elfsym.st_shndx = SHN_UNDEF;
1925 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1926 &elfsym, bfd_und_section_ptr))
1930 /* Some standard ELF linkers do this, but we don't because it causes
1931 bootstrap comparison failures. */
1932 /* Output a file symbol for the output file as the second symbol.
1933 We output this even if we are discarding local symbols, although
1934 I'm not sure if this is correct. */
1935 elfsym.st_value = 0;
1937 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
1938 elfsym.st_other = 0;
1939 elfsym.st_shndx = SHN_ABS;
1940 if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
1941 &elfsym, bfd_abs_section_ptr))
1945 /* Output a symbol for each section. We output these even if we are
1946 discarding local symbols, since they are used for relocs. These
1947 symbols have no names. We store the index of each one in the
1948 index field of the section, so that we can find it again when
1949 outputting relocs. */
1950 elfsym.st_value = 0;
1952 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1953 elfsym.st_other = 0;
1954 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
1956 o = section_from_elf_index (abfd, i);
1958 o->target_index = abfd->symcount;
1959 elfsym.st_shndx = i;
1960 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1965 /* Allocate some memory to hold information read in from the input
1967 finfo.contents = (bfd_byte *) malloc (max_contents_size);
1968 finfo.external_relocs = (PTR) malloc (max_external_reloc_size);
1969 finfo.internal_relocs = ((Elf_Internal_Rela *)
1970 malloc (max_internal_reloc_count
1971 * sizeof (Elf_Internal_Rela)));
1972 finfo.external_syms = ((Elf_External_Sym *)
1973 malloc (max_sym_count * sizeof (Elf_External_Sym)));
1974 finfo.internal_syms = ((Elf_Internal_Sym *)
1975 malloc (max_sym_count * sizeof (Elf_Internal_Sym)));
1976 finfo.indices = (long *) malloc (max_sym_count * sizeof (long));
1977 finfo.sections = (asection **) malloc (max_sym_count * sizeof (asection *));
1978 if ((finfo.contents == NULL && max_contents_size != 0)
1979 || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
1980 || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
1981 || (finfo.external_syms == NULL && max_sym_count != 0)
1982 || (finfo.internal_syms == NULL && max_sym_count != 0)
1983 || (finfo.indices == NULL && max_sym_count != 0)
1984 || (finfo.sections == NULL && max_sym_count != 0))
1986 bfd_set_error (bfd_error_no_memory);
1990 /* Since ELF permits relocations to be against local symbols, we
1991 must have the local symbols available when we do the relocations.
1992 Since we would rather only read the local symbols once, and we
1993 would rather not keep them in memory, we handle all the
1994 relocations for a single input file at the same time.
1996 Unfortunately, there is no way to know the total number of local
1997 symbols until we have seen all of them, and the local symbol
1998 indices precede the global symbol indices. This means that when
1999 we are generating relocateable output, and we see a reloc against
2000 a global symbol, we can not know the symbol index until we have
2001 finished examining all the local symbols to see which ones we are
2002 going to output. To deal with this, we keep the relocations in
2003 memory, and don't output them until the end of the link. This is
2004 an unfortunate waste of memory, but I don't see a good way around
2005 it. Fortunately, it only happens when performing a relocateable
2006 link, which is not the common case. FIXME: If keep_memory is set
2007 we could write the relocs out and then read them again; I don't
2008 know how bad the memory loss will be. */
2010 for (sub = info->input_bfds; sub != NULL; sub = sub->next)
2011 sub->output_has_begun = false;
2012 for (o = abfd->sections; o != NULL; o = o->next)
2014 for (p = o->link_order_head; p != NULL; p = p->next)
2016 if (p->type == bfd_indirect_link_order
2017 && (bfd_get_flavour (p->u.indirect.section->owner)
2018 == bfd_target_elf_flavour))
2020 sub = p->u.indirect.section->owner;
2021 if (! sub->output_has_begun)
2023 if (! elf_link_input_bfd (&finfo, sub))
2025 sub->output_has_begun = true;
2028 else if (p->type == bfd_section_reloc_link_order
2029 || p->type == bfd_symbol_reloc_link_order)
2031 if (! elf_reloc_link_order (abfd, info, o, p))
2036 if (! _bfd_default_link_order (abfd, info, o, p))
2042 /* That wrote out all the local symbols. Finish up the symbol table
2043 with the global symbols. */
2045 /* The sh_info field records the index of the first non local
2047 symtab_hdr->sh_info = abfd->symcount;
2049 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
2051 /* We get the global symbols from the hash table. */
2054 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
2059 /* Flush all symbols to the file. */
2060 if (! elf_link_flush_output_syms (&finfo))
2063 /* Now we know the size of the symtab section. */
2064 off += symtab_hdr->sh_size;
2066 /* Finish up and write out the symbol string table (.strtab)
2068 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2069 /* sh_name was set in prep_headers. */
2070 symstrtab_hdr->sh_type = SHT_STRTAB;
2071 symstrtab_hdr->sh_flags = 0;
2072 symstrtab_hdr->sh_addr = 0;
2073 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
2074 symstrtab_hdr->sh_entsize = 0;
2075 symstrtab_hdr->sh_link = 0;
2076 symstrtab_hdr->sh_info = 0;
2077 /* sh_offset is set just below. */
2078 symstrtab_hdr->sh_addralign = 1;
2080 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
2081 elf_tdata (abfd)->next_file_pos = off;
2083 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
2084 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
2087 /* Adjust the relocs to have the correct symbol indices. */
2088 for (o = abfd->sections; o != NULL; o = o->next)
2090 struct elf_link_hash_entry **rel_hash;
2091 Elf_Internal_Shdr *rel_hdr;
2093 if ((o->flags & SEC_RELOC) == 0)
2096 rel_hash = elf_section_data (o)->rel_hashes;
2097 rel_hdr = &elf_section_data (o)->rel_hdr;
2098 for (i = 0; i < o->reloc_count; i++, rel_hash++)
2100 if (*rel_hash == NULL)
2103 BFD_ASSERT ((*rel_hash)->indx >= 0);
2105 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2107 Elf_External_Rel *erel;
2108 Elf_Internal_Rel irel;
2110 erel = (Elf_External_Rel *) rel_hdr->contents + i;
2111 elf_swap_reloc_in (abfd, erel, &irel);
2112 irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
2113 ELF_R_TYPE (irel.r_info));
2114 elf_swap_reloc_out (abfd, &irel, erel);
2118 Elf_External_Rela *erela;
2119 Elf_Internal_Rela irela;
2121 BFD_ASSERT (rel_hdr->sh_entsize
2122 == sizeof (Elf_External_Rela));
2124 erela = (Elf_External_Rela *) rel_hdr->contents + i;
2125 elf_swap_reloca_in (abfd, erela, &irela);
2126 irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
2127 ELF_R_TYPE (irela.r_info));
2128 elf_swap_reloca_out (abfd, &irela, erela);
2132 /* Set the reloc_count field to 0 to prevent write_relocs from
2133 trying to swap the relocs out itself. */
2137 /* If we are linking against a dynamic object, or generating a
2138 shared library, finish up the dynamic linking information. */
2141 Elf_External_Dyn *dyncon, *dynconend;
2143 /* Fix up .dynamic entries. */
2144 o = bfd_get_section_by_name (dynobj, ".dynamic");
2145 BFD_ASSERT (o != NULL);
2147 dyncon = (Elf_External_Dyn *) o->contents;
2148 dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
2149 for (; dyncon < dynconend; dyncon++)
2151 Elf_Internal_Dyn dyn;
2155 elf_swap_dyn_in (dynobj, dyncon, &dyn);
2162 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2163 magic _init and _fini symbols. This is pretty ugly,
2164 but we are compatible. */
2172 struct elf_link_hash_entry *h;
2174 h = elf_link_hash_lookup (elf_hash_table (info), name,
2175 false, false, true);
2177 && (h->root.type == bfd_link_hash_defined
2178 || h->root.type == bfd_link_hash_defweak))
2180 dyn.d_un.d_val = h->root.u.def.value;
2181 o = h->root.u.def.section;
2182 if (o->output_section != NULL)
2183 dyn.d_un.d_val += (o->output_section->vma
2184 + o->output_offset);
2187 /* The symbol is imported from another shared
2188 library and does not apply to this one. */
2192 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2206 o = bfd_get_section_by_name (abfd, name);
2207 BFD_ASSERT (o != NULL);
2208 dyn.d_un.d_ptr = o->vma;
2209 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2216 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
2221 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
2223 Elf_Internal_Shdr *hdr;
2225 hdr = elf_elfsections (abfd)[i];
2226 if (hdr->sh_type == type
2227 && (hdr->sh_flags & SHF_ALLOC) != 0)
2229 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
2230 dyn.d_un.d_val += hdr->sh_size;
2233 if (dyn.d_un.d_val == 0
2234 || hdr->sh_addr < dyn.d_un.d_val)
2235 dyn.d_un.d_val = hdr->sh_addr;
2239 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2245 /* If we have created any dynamic sections, then output them. */
2248 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
2251 for (o = dynobj->sections; o != NULL; o = o->next)
2253 if ((o->flags & SEC_HAS_CONTENTS) == 0
2254 || o->_raw_size == 0)
2256 if ((o->flags & SEC_IN_MEMORY) == 0)
2258 /* At this point, we are only interested in sections
2259 created by elf_link_create_dynamic_sections. FIXME:
2260 This test is fragile. */
2263 if ((elf_section_data (o->output_section)->this_hdr.sh_type
2265 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
2267 if (! bfd_set_section_contents (abfd, o->output_section,
2268 o->contents, o->output_offset,
2276 /* The contents of the .dynstr section are actually in a
2278 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
2279 if (bfd_seek (abfd, off, SEEK_SET) != 0
2280 || ! _bfd_stringtab_emit (abfd,
2281 elf_hash_table (info)->dynstr))
2287 if (finfo.symstrtab != NULL)
2288 _bfd_stringtab_free (finfo.symstrtab);
2289 if (finfo.contents != NULL)
2290 free (finfo.contents);
2291 if (finfo.external_relocs != NULL)
2292 free (finfo.external_relocs);
2293 if (finfo.internal_relocs != NULL)
2294 free (finfo.internal_relocs);
2295 if (finfo.external_syms != NULL)
2296 free (finfo.external_syms);
2297 if (finfo.internal_syms != NULL)
2298 free (finfo.internal_syms);
2299 if (finfo.indices != NULL)
2300 free (finfo.indices);
2301 if (finfo.sections != NULL)
2302 free (finfo.sections);
2303 if (finfo.symbuf != NULL)
2304 free (finfo.symbuf);
2305 for (o = abfd->sections; o != NULL; o = o->next)
2307 if ((o->flags & SEC_RELOC) != 0
2308 && elf_section_data (o)->rel_hashes != NULL)
2309 free (elf_section_data (o)->rel_hashes);
2312 elf_tdata (abfd)->linker = true;
2317 if (finfo.symstrtab != NULL)
2318 _bfd_stringtab_free (finfo.symstrtab);
2319 if (finfo.contents != NULL)
2320 free (finfo.contents);
2321 if (finfo.external_relocs != NULL)
2322 free (finfo.external_relocs);
2323 if (finfo.internal_relocs != NULL)
2324 free (finfo.internal_relocs);
2325 if (finfo.external_syms != NULL)
2326 free (finfo.external_syms);
2327 if (finfo.internal_syms != NULL)
2328 free (finfo.internal_syms);
2329 if (finfo.indices != NULL)
2330 free (finfo.indices);
2331 if (finfo.sections != NULL)
2332 free (finfo.sections);
2333 if (finfo.symbuf != NULL)
2334 free (finfo.symbuf);
2335 for (o = abfd->sections; o != NULL; o = o->next)
2337 if ((o->flags & SEC_RELOC) != 0
2338 && elf_section_data (o)->rel_hashes != NULL)
2339 free (elf_section_data (o)->rel_hashes);
2345 /* Add a symbol to the output symbol table. */
2348 elf_link_output_sym (finfo, name, elfsym, input_sec)
2349 struct elf_final_link_info *finfo;
2351 Elf_Internal_Sym *elfsym;
2352 asection *input_sec;
2354 boolean (*output_symbol_hook) PARAMS ((bfd *,
2355 struct bfd_link_info *info,
2360 output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
2361 elf_backend_link_output_symbol_hook;
2362 if (output_symbol_hook != NULL)
2364 if (! ((*output_symbol_hook)
2365 (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
2369 if (name == (const char *) NULL || *name == '\0')
2370 elfsym->st_name = 0;
2373 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
2376 if (elfsym->st_name == (unsigned long) -1)
2380 if (finfo->symbuf_count >= finfo->symbuf_size)
2382 if (! elf_link_flush_output_syms (finfo))
2386 elf_swap_symbol_out (finfo->output_bfd, elfsym,
2387 (PTR) (finfo->symbuf + finfo->symbuf_count));
2388 ++finfo->symbuf_count;
2390 ++finfo->output_bfd->symcount;
2395 /* Flush the output symbols to the file. */
2398 elf_link_flush_output_syms (finfo)
2399 struct elf_final_link_info *finfo;
2401 Elf_Internal_Shdr *symtab;
2403 symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
2405 if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
2407 || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
2408 sizeof (Elf_External_Sym), finfo->output_bfd)
2409 != finfo->symbuf_count * sizeof (Elf_External_Sym)))
2412 symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
2414 finfo->symbuf_count = 0;
2419 /* Add an external symbol to the symbol table. This is called from
2420 the hash table traversal routine. */
2423 elf_link_output_extsym (h, data)
2424 struct elf_link_hash_entry *h;
2427 struct elf_finfo_failed *eif = (struct elf_finfo_failed *) data;
2428 struct elf_final_link_info *finfo = eif->finfo;
2430 Elf_Internal_Sym sym;
2431 asection *input_sec;
2433 /* If we are not creating a shared library, and this symbol is
2434 referenced by a shared library but is not defined anywhere, then
2435 warn that it is undefined. If we do not do this, the runtime
2436 linker will complain that the symbol is undefined when the
2437 program is run. We don't have to worry about symbols that are
2438 referenced by regular files, because we will already have issued
2439 warnings for them. */
2440 if (! finfo->info->relocateable
2441 && ! finfo->info->shared
2442 && h->root.type == bfd_link_hash_undefined
2443 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
2444 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2446 if (! ((*finfo->info->callbacks->undefined_symbol)
2447 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
2448 (asection *) NULL, 0)))
2455 /* We don't want to output symbols that have never been mentioned by
2456 a regular file, or that we have been told to strip. However, if
2457 h->indx is set to -2, the symbol is used by a reloc and we must
2461 else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2462 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2463 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2464 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2466 else if (finfo->info->strip == strip_all
2467 || (finfo->info->strip == strip_some
2468 && bfd_hash_lookup (finfo->info->keep_hash,
2469 h->root.root.string,
2470 false, false) == NULL))
2475 /* If we're stripping it, and it's not a dynamic symbol, there's
2476 nothing else to do. */
2477 if (strip && h->dynindx == -1)
2481 sym.st_size = h->size;
2483 if (h->root.type == bfd_link_hash_undefweak
2484 || h->root.type == bfd_link_hash_defweak)
2485 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
2487 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
2489 switch (h->root.type)
2492 case bfd_link_hash_new:
2496 case bfd_link_hash_undefined:
2497 input_sec = bfd_und_section_ptr;
2498 sym.st_shndx = SHN_UNDEF;
2501 case bfd_link_hash_undefweak:
2502 input_sec = bfd_und_section_ptr;
2503 sym.st_shndx = SHN_UNDEF;
2506 case bfd_link_hash_defined:
2507 case bfd_link_hash_defweak:
2509 input_sec = h->root.u.def.section;
2510 if (input_sec->output_section != NULL)
2513 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
2514 input_sec->output_section);
2515 if (sym.st_shndx == (unsigned short) -1)
2521 /* ELF symbols in relocateable files are section relative,
2522 but in nonrelocateable files they are virtual
2524 sym.st_value = h->root.u.def.value + input_sec->output_offset;
2525 if (! finfo->info->relocateable)
2526 sym.st_value += input_sec->output_section->vma;
2530 BFD_ASSERT ((bfd_get_flavour (input_sec->owner)
2531 == bfd_target_elf_flavour)
2532 && elf_elfheader (input_sec->owner)->e_type == ET_DYN);
2533 sym.st_shndx = SHN_UNDEF;
2534 input_sec = bfd_und_section_ptr;
2539 case bfd_link_hash_common:
2540 input_sec = bfd_com_section_ptr;
2541 sym.st_shndx = SHN_COMMON;
2542 sym.st_value = 1 << h->root.u.c.p->alignment_power;
2545 case bfd_link_hash_indirect:
2546 case bfd_link_hash_warning:
2547 return (elf_link_output_extsym
2548 ((struct elf_link_hash_entry *) h->root.u.i.link, data));
2551 /* If this symbol should be put in the .dynsym section, then put it
2552 there now. We have already know the symbol index. We also fill
2553 in the entry in the .hash section. */
2554 if (h->dynindx != -1
2555 && elf_hash_table (finfo->info)->dynamic_sections_created)
2557 struct elf_backend_data *bed;
2560 bfd_byte *bucketpos;
2563 sym.st_name = h->dynstr_index;
2565 /* Give the processor backend a chance to tweak the symbol
2566 value, and also to finish up anything that needs to be done
2568 bed = get_elf_backend_data (finfo->output_bfd);
2569 if (! ((*bed->elf_backend_finish_dynamic_symbol)
2570 (finfo->output_bfd, finfo->info, h, &sym)))
2576 elf_swap_symbol_out (finfo->output_bfd, &sym,
2577 (PTR) (((Elf_External_Sym *)
2578 finfo->dynsym_sec->contents)
2581 bucketcount = elf_hash_table (finfo->info)->bucketcount;
2582 bucket = (bfd_elf_hash ((const unsigned char *) h->root.root.string)
2584 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
2585 + (bucket + 2) * (ARCH_SIZE / 8));
2586 chain = get_word (finfo->output_bfd, bucketpos);
2587 put_word (finfo->output_bfd, h->dynindx, bucketpos);
2588 put_word (finfo->output_bfd, chain,
2589 ((bfd_byte *) finfo->hash_sec->contents
2590 + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
2593 /* If we're stripping it, then it was just a dynamic symbol, and
2594 there's nothing else to do. */
2598 h->indx = finfo->output_bfd->symcount;
2600 if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
2609 /* Link an input file into the linker output file. This function
2610 handles all the sections and relocations of the input file at once.
2611 This is so that we only have to read the local symbols once, and
2612 don't have to keep them in memory. */
2615 elf_link_input_bfd (finfo, input_bfd)
2616 struct elf_final_link_info *finfo;
2619 boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
2620 bfd *, asection *, bfd_byte *,
2621 Elf_Internal_Rela *,
2622 Elf_Internal_Sym *, asection **));
2624 Elf_Internal_Shdr *symtab_hdr;
2627 Elf_External_Sym *esym;
2628 Elf_External_Sym *esymend;
2629 Elf_Internal_Sym *isym;
2631 asection **ppsection;
2634 output_bfd = finfo->output_bfd;
2636 get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
2638 /* If this is a dynamic object, we don't want to do anything here:
2639 we don't want the local symbols, and we don't want the section
2641 if (elf_elfheader (input_bfd)->e_type == ET_DYN)
2644 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2645 if (elf_bad_symtab (input_bfd))
2647 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
2652 locsymcount = symtab_hdr->sh_info;
2653 extsymoff = symtab_hdr->sh_info;
2656 /* Read the local symbols. */
2658 && (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2659 || (bfd_read (finfo->external_syms, sizeof (Elf_External_Sym),
2660 locsymcount, input_bfd)
2661 != locsymcount * sizeof (Elf_External_Sym))))
2664 /* Swap in the local symbols and write out the ones which we know
2665 are going into the output file. */
2666 esym = finfo->external_syms;
2667 esymend = esym + locsymcount;
2668 isym = finfo->internal_syms;
2669 pindex = finfo->indices;
2670 ppsection = finfo->sections;
2671 for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
2675 Elf_Internal_Sym osym;
2677 elf_swap_symbol_in (input_bfd, esym, isym);
2680 if (elf_bad_symtab (input_bfd))
2682 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
2689 if (isym->st_shndx == SHN_UNDEF)
2690 isec = bfd_und_section_ptr;
2691 else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
2692 isec = section_from_elf_index (input_bfd, isym->st_shndx);
2693 else if (isym->st_shndx == SHN_ABS)
2694 isec = bfd_abs_section_ptr;
2695 else if (isym->st_shndx == SHN_COMMON)
2696 isec = bfd_com_section_ptr;
2705 /* Don't output the first, undefined, symbol. */
2706 if (esym == finfo->external_syms)
2709 /* If we are stripping all symbols, we don't want to output this
2711 if (finfo->info->strip == strip_all)
2714 /* We never output section symbols. Instead, we use the section
2715 symbol of the corresponding section in the output file. */
2716 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2719 /* If we are discarding all local symbols, we don't want to
2720 output this one. If we are generating a relocateable output
2721 file, then some of the local symbols may be required by
2722 relocs; we output them below as we discover that they are
2724 if (finfo->info->discard == discard_all)
2727 /* Get the name of the symbol. */
2728 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
2733 /* See if we are discarding symbols with this name. */
2734 if ((finfo->info->strip == strip_some
2735 && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
2737 || (finfo->info->discard == discard_l
2738 && strncmp (name, finfo->info->lprefix,
2739 finfo->info->lprefix_len) == 0))
2742 /* If we get here, we are going to output this symbol. */
2746 /* Adjust the section index for the output file. */
2747 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
2748 isec->output_section);
2749 if (osym.st_shndx == (unsigned short) -1)
2752 *pindex = output_bfd->symcount;
2754 /* ELF symbols in relocateable files are section relative, but
2755 in executable files they are virtual addresses. Note that
2756 this code assumes that all ELF sections have an associated
2757 BFD section with a reasonable value for output_offset; below
2758 we assume that they also have a reasonable value for
2759 output_section. Any special sections must be set up to meet
2760 these requirements. */
2761 osym.st_value += isec->output_offset;
2762 if (! finfo->info->relocateable)
2763 osym.st_value += isec->output_section->vma;
2765 if (! elf_link_output_sym (finfo, name, &osym, isec))
2769 /* Relocate the contents of each section. */
2770 for (o = input_bfd->sections; o != NULL; o = o->next)
2772 if ((o->flags & SEC_HAS_CONTENTS) == 0)
2775 if ((o->flags & SEC_IN_MEMORY) != 0
2776 && input_bfd == elf_hash_table (finfo->info)->dynobj)
2778 /* Section was created by elf_link_create_dynamic_sections.
2779 FIXME: This test is fragile. */
2783 /* Read the contents of the section. */
2784 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2785 (file_ptr) 0, o->_raw_size))
2788 if ((o->flags & SEC_RELOC) != 0)
2790 Elf_Internal_Rela *internal_relocs;
2792 /* Get the swapped relocs. */
2793 internal_relocs = elf_link_read_relocs (input_bfd, o,
2794 finfo->external_relocs,
2795 finfo->internal_relocs,
2797 if (internal_relocs == NULL
2798 && o->reloc_count > 0)
2801 /* Relocate the section by invoking a back end routine.
2803 The back end routine is responsible for adjusting the
2804 section contents as necessary, and (if using Rela relocs
2805 and generating a relocateable output file) adjusting the
2806 reloc addend as necessary.
2808 The back end routine does not have to worry about setting
2809 the reloc address or the reloc symbol index.
2811 The back end routine is given a pointer to the swapped in
2812 internal symbols, and can access the hash table entries
2813 for the external symbols via elf_sym_hashes (input_bfd).
2815 When generating relocateable output, the back end routine
2816 must handle STB_LOCAL/STT_SECTION symbols specially. The
2817 output symbol is going to be a section symbol
2818 corresponding to the output section, which will require
2819 the addend to be adjusted. */
2821 if (! (*relocate_section) (output_bfd, finfo->info,
2825 finfo->internal_syms,
2829 if (finfo->info->relocateable)
2831 Elf_Internal_Rela *irela;
2832 Elf_Internal_Rela *irelaend;
2833 struct elf_link_hash_entry **rel_hash;
2834 Elf_Internal_Shdr *input_rel_hdr;
2835 Elf_Internal_Shdr *output_rel_hdr;
2837 /* Adjust the reloc addresses and symbol indices. */
2839 irela = internal_relocs;
2840 irelaend = irela + o->reloc_count;
2841 rel_hash = (elf_section_data (o->output_section)->rel_hashes
2842 + o->output_section->reloc_count);
2843 for (; irela < irelaend; irela++, rel_hash++)
2845 unsigned long r_symndx;
2846 Elf_Internal_Sym *isym;
2849 irela->r_offset += o->output_offset;
2851 r_symndx = ELF_R_SYM (irela->r_info);
2856 if (r_symndx >= locsymcount
2857 || (elf_bad_symtab (input_bfd)
2858 && finfo->sections[r_symndx] == NULL))
2862 /* This is a reloc against a global symbol. We
2863 have not yet output all the local symbols, so
2864 we do not know the symbol index of any global
2865 symbol. We set the rel_hash entry for this
2866 reloc to point to the global hash table entry
2867 for this symbol. The symbol index is then
2868 set at the end of elf_bfd_final_link. */
2869 indx = r_symndx - extsymoff;
2870 *rel_hash = elf_sym_hashes (input_bfd)[indx];
2872 /* Setting the index to -2 tells
2873 elf_link_output_extsym that this symbol is
2875 BFD_ASSERT ((*rel_hash)->indx < 0);
2876 (*rel_hash)->indx = -2;
2881 /* This is a reloc against a local symbol. */
2884 isym = finfo->internal_syms + r_symndx;
2885 sec = finfo->sections[r_symndx];
2886 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2888 /* I suppose the backend ought to fill in the
2889 section of any STT_SECTION symbol against a
2890 processor specific section. */
2891 if (sec != NULL && bfd_is_abs_section (sec))
2893 else if (sec == NULL || sec->owner == NULL)
2895 bfd_set_error (bfd_error_bad_value);
2900 r_symndx = sec->output_section->target_index;
2901 BFD_ASSERT (r_symndx != 0);
2906 if (finfo->indices[r_symndx] == -1)
2912 if (finfo->info->strip == strip_all)
2914 /* You can't do ld -r -s. */
2915 bfd_set_error (bfd_error_invalid_operation);
2919 /* This symbol was skipped earlier, but
2920 since it is needed by a reloc, we
2921 must output it now. */
2922 link = symtab_hdr->sh_link;
2923 name = bfd_elf_string_from_elf_section (input_bfd,
2929 osec = sec->output_section;
2931 _bfd_elf_section_from_bfd_section (output_bfd,
2933 if (isym->st_shndx == (unsigned short) -1)
2936 isym->st_value += sec->output_offset;
2937 if (! finfo->info->relocateable)
2938 isym->st_value += osec->vma;
2940 finfo->indices[r_symndx] = output_bfd->symcount;
2942 if (! elf_link_output_sym (finfo, name, isym, sec))
2946 r_symndx = finfo->indices[r_symndx];
2949 irela->r_info = ELF_R_INFO (r_symndx,
2950 ELF_R_TYPE (irela->r_info));
2953 /* Swap out the relocs. */
2954 input_rel_hdr = &elf_section_data (o)->rel_hdr;
2955 output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
2956 BFD_ASSERT (output_rel_hdr->sh_entsize
2957 == input_rel_hdr->sh_entsize);
2958 irela = internal_relocs;
2959 irelaend = irela + o->reloc_count;
2960 if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2962 Elf_External_Rel *erel;
2964 erel = ((Elf_External_Rel *) output_rel_hdr->contents
2965 + o->output_section->reloc_count);
2966 for (; irela < irelaend; irela++, erel++)
2968 Elf_Internal_Rel irel;
2970 irel.r_offset = irela->r_offset;
2971 irel.r_info = irela->r_info;
2972 BFD_ASSERT (irela->r_addend == 0);
2973 elf_swap_reloc_out (output_bfd, &irel, erel);
2978 Elf_External_Rela *erela;
2980 BFD_ASSERT (input_rel_hdr->sh_entsize
2981 == sizeof (Elf_External_Rela));
2982 erela = ((Elf_External_Rela *) output_rel_hdr->contents
2983 + o->output_section->reloc_count);
2984 for (; irela < irelaend; irela++, erela++)
2985 elf_swap_reloca_out (output_bfd, irela, erela);
2988 o->output_section->reloc_count += o->reloc_count;
2992 /* Write out the modified section contents. */
2993 if (! bfd_set_section_contents (output_bfd, o->output_section,
2994 finfo->contents, o->output_offset,
2995 (o->_cooked_size != 0
3004 /* Generate a reloc when linking an ELF file. This is a reloc
3005 requested by the linker, and does come from any input file. This
3006 is used to build constructor and destructor tables when linking
3010 elf_reloc_link_order (output_bfd, info, output_section, link_order)
3012 struct bfd_link_info *info;
3013 asection *output_section;
3014 struct bfd_link_order *link_order;
3016 reloc_howto_type *howto;
3019 struct elf_link_hash_entry **rel_hash_ptr;
3020 Elf_Internal_Shdr *rel_hdr;
3022 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
3025 bfd_set_error (bfd_error_bad_value);
3029 /* If this is an inplace reloc, we must write the addend into the
3031 if (howto->partial_inplace
3032 && link_order->u.reloc.p->addend != 0)
3035 bfd_reloc_status_type rstat;
3039 size = bfd_get_reloc_size (howto);
3040 buf = (bfd_byte *) bfd_zmalloc (size);
3041 if (buf == (bfd_byte *) NULL)
3043 bfd_set_error (bfd_error_no_memory);
3046 rstat = _bfd_relocate_contents (howto, output_bfd,
3047 link_order->u.reloc.p->addend, buf);
3053 case bfd_reloc_outofrange:
3055 case bfd_reloc_overflow:
3056 if (! ((*info->callbacks->reloc_overflow)
3058 (link_order->type == bfd_section_reloc_link_order
3059 ? bfd_section_name (output_bfd,
3060 link_order->u.reloc.p->u.section)
3061 : link_order->u.reloc.p->u.name),
3062 howto->name, link_order->u.reloc.p->addend,
3063 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
3070 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
3071 (file_ptr) link_order->offset, size);
3077 /* Figure out the symbol index. */
3078 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
3079 + output_section->reloc_count);
3080 if (link_order->type == bfd_section_reloc_link_order)
3082 indx = link_order->u.reloc.p->u.section->target_index;
3083 BFD_ASSERT (indx != 0);
3084 *rel_hash_ptr = NULL;
3088 struct elf_link_hash_entry *h;
3090 h = elf_link_hash_lookup (elf_hash_table (info),
3091 link_order->u.reloc.p->u.name,
3092 false, false, true);
3095 /* Setting the index to -2 tells elf_link_output_extsym that
3096 this symbol is used by a reloc. */
3103 if (! ((*info->callbacks->unattached_reloc)
3104 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
3105 (asection *) NULL, (bfd_vma) 0)))
3111 /* The address of a reloc is relative to the section in a
3112 relocateable file, and is a virtual address in an executable
3114 offset = link_order->offset;
3115 if (! info->relocateable)
3116 offset += output_section->vma;
3118 rel_hdr = &elf_section_data (output_section)->rel_hdr;
3120 if (rel_hdr->sh_type == SHT_REL)
3122 Elf_Internal_Rel irel;
3123 Elf_External_Rel *erel;
3125 irel.r_offset = offset;
3126 irel.r_info = ELF_R_INFO (indx, howto->type);
3127 erel = ((Elf_External_Rel *) rel_hdr->contents
3128 + output_section->reloc_count);
3129 elf_swap_reloc_out (output_bfd, &irel, erel);
3133 Elf_Internal_Rela irela;
3134 Elf_External_Rela *erela;
3136 irela.r_offset = offset;
3137 irela.r_info = ELF_R_INFO (indx, howto->type);
3138 irela.r_addend = link_order->u.reloc.p->addend;
3139 erela = ((Elf_External_Rela *) rel_hdr->contents
3140 + output_section->reloc_count);
3141 elf_swap_reloca_out (output_bfd, &irela, erela);
3144 ++output_section->reloc_count;