2 Copyright 1995, 1996 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);
63 /* Add symbols from an ELF archive file to the linker hash table. We
64 don't use _bfd_generic_link_add_archive_symbols because of a
65 problem which arises on UnixWare. The UnixWare libc.so is an
66 archive which includes an entry libc.so.1 which defines a bunch of
67 symbols. The libc.so archive also includes a number of other
68 object files, which also define symbols, some of which are the same
69 as those defined in libc.so.1. Correct linking requires that we
70 consider each object file in turn, and include it if it defines any
71 symbols we need. _bfd_generic_link_add_archive_symbols does not do
72 this; it looks through the list of undefined symbols, and includes
73 any object file which defines them. When this algorithm is used on
74 UnixWare, it winds up pulling in libc.so.1 early and defining a
75 bunch of symbols. This means that some of the other objects in the
76 archive are not included in the link, which is incorrect since they
77 precede libc.so.1 in the archive.
79 Fortunately, ELF archive handling is simpler than that done by
80 _bfd_generic_link_add_archive_symbols, which has to allow for a.out
81 oddities. In ELF, if we find a symbol in the archive map, and the
82 symbol is currently undefined, we know that we must pull in that
85 Unfortunately, we do have to make multiple passes over the symbol
86 table until nothing further is resolved. */
89 elf_link_add_archive_symbols (abfd, info)
91 struct bfd_link_info *info;
94 boolean *defined = NULL;
95 boolean *included = NULL;
99 if (! bfd_has_map (abfd))
101 /* An empty archive is a special case. */
102 if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
104 bfd_set_error (bfd_error_no_armap);
108 /* Keep track of all symbols we know to be already defined, and all
109 files we know to be already included. This is to speed up the
110 second and subsequent passes. */
111 c = bfd_ardata (abfd)->symdef_count;
114 defined = (boolean *) bfd_malloc (c * sizeof (boolean));
115 included = (boolean *) bfd_malloc (c * sizeof (boolean));
116 if (defined == (boolean *) NULL || included == (boolean *) NULL)
118 memset (defined, 0, c * sizeof (boolean));
119 memset (included, 0, c * sizeof (boolean));
121 symdefs = bfd_ardata (abfd)->symdefs;
134 symdefend = symdef + c;
135 for (i = 0; symdef < symdefend; symdef++, i++)
137 struct elf_link_hash_entry *h;
139 struct bfd_link_hash_entry *undefs_tail;
142 if (defined[i] || included[i])
144 if (symdef->file_offset == last)
150 h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
151 false, false, false);
152 if (h == (struct elf_link_hash_entry *) NULL)
154 if (h->root.type != bfd_link_hash_undefined)
156 if (h->root.type != bfd_link_hash_undefweak)
161 /* We need to include this archive member. */
163 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
164 if (element == (bfd *) NULL)
167 if (! bfd_check_format (element, bfd_object))
170 /* Doublecheck that we have not included this object
171 already--it should be impossible, but there may be
172 something wrong with the archive. */
173 if (element->archive_pass != 0)
175 bfd_set_error (bfd_error_bad_value);
178 element->archive_pass = 1;
180 undefs_tail = info->hash->undefs_tail;
182 if (! (*info->callbacks->add_archive_element) (info, element,
185 if (! elf_link_add_object_symbols (element, info))
188 /* If there are any new undefined symbols, we need to make
189 another pass through the archive in order to see whether
190 they can be defined. FIXME: This isn't perfect, because
191 common symbols wind up on undefs_tail and because an
192 undefined symbol which is defined later on in this pass
193 does not require another pass. This isn't a bug, but it
194 does make the code less efficient than it could be. */
195 if (undefs_tail != info->hash->undefs_tail)
198 /* Look backward to mark all symbols from this object file
199 which we have already seen in this pass. */
203 included[mark] = true;
208 while (symdefs[mark].file_offset == symdef->file_offset);
210 /* We mark subsequent symbols from this object file as we go
211 on through the loop. */
212 last = symdef->file_offset;
223 if (defined != (boolean *) NULL)
225 if (included != (boolean *) NULL)
230 /* Add symbols from an ELF object file to the linker hash table. */
233 elf_link_add_object_symbols (abfd, info)
235 struct bfd_link_info *info;
237 boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
238 const Elf_Internal_Sym *,
239 const char **, flagword *,
240 asection **, bfd_vma *));
241 boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
242 asection *, const Elf_Internal_Rela *));
244 Elf_Internal_Shdr *hdr;
248 Elf_External_Sym *buf = NULL;
249 struct elf_link_hash_entry **sym_hash;
251 Elf_External_Dyn *dynbuf = NULL;
252 struct elf_link_hash_entry *weaks;
253 Elf_External_Sym *esym;
254 Elf_External_Sym *esymend;
256 add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
257 collect = get_elf_backend_data (abfd)->collect;
259 /* As a GNU extension, any input sections which are named
260 .gnu.warning.SYMBOL are treated as warning symbols for the given
261 symbol. This differs from .gnu.warning sections, which generate
262 warnings when they are included in an output file. */
267 for (s = abfd->sections; s != NULL; s = s->next)
271 name = bfd_get_section_name (abfd, s);
272 if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
277 sz = bfd_section_size (abfd, s);
278 msg = (char *) bfd_alloc (abfd, sz);
282 if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
285 if (! (_bfd_generic_link_add_one_symbol
287 name + sizeof ".gnu.warning." - 1,
288 BSF_WARNING, s, (bfd_vma) 0, msg, false, collect,
289 (struct bfd_link_hash_entry **) NULL)))
292 if (! info->relocateable)
294 /* Clobber the section size so that the warning does
295 not get copied into the output file. */
302 /* A stripped shared library might only have a dynamic symbol table,
303 not a regular symbol table. In that case we can still go ahead
304 and link using the dynamic symbol table. */
305 if (elf_onesymtab (abfd) == 0
306 && elf_dynsymtab (abfd) != 0)
308 elf_onesymtab (abfd) = elf_dynsymtab (abfd);
309 elf_tdata (abfd)->symtab_hdr = elf_tdata (abfd)->dynsymtab_hdr;
312 hdr = &elf_tdata (abfd)->symtab_hdr;
313 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
315 /* The sh_info field of the symtab header tells us where the
316 external symbols start. We don't care about the local symbols at
318 if (elf_bad_symtab (abfd))
320 extsymcount = symcount;
325 extsymcount = symcount - hdr->sh_info;
326 extsymoff = hdr->sh_info;
329 buf = ((Elf_External_Sym *)
330 bfd_malloc (extsymcount * sizeof (Elf_External_Sym)));
331 if (buf == NULL && extsymcount != 0)
334 /* We store a pointer to the hash table entry for each external
336 sym_hash = ((struct elf_link_hash_entry **)
338 extsymcount * sizeof (struct elf_link_hash_entry *)));
339 if (sym_hash == NULL)
341 elf_sym_hashes (abfd) = sym_hash;
343 if (elf_elfheader (abfd)->e_type != ET_DYN)
347 /* If we are creating a shared library, create all the dynamic
348 sections immediately. We need to attach them to something,
349 so we attach them to this BFD, provided it is the right
350 format. FIXME: If there are no input BFD's of the same
351 format as the output, we can't make a shared library. */
353 && ! elf_hash_table (info)->dynamic_sections_created
354 && abfd->xvec == info->hash->creator)
356 if (! elf_link_create_dynamic_sections (abfd, info))
365 bfd_size_type oldsize;
366 bfd_size_type strindex;
370 /* You can't use -r against a dynamic object. Also, there's no
371 hope of using a dynamic object which does not exactly match
372 the format of the output file. */
373 if (info->relocateable
374 || info->hash->creator != abfd->xvec)
376 bfd_set_error (bfd_error_invalid_operation);
380 /* Find the name to use in a DT_NEEDED entry that refers to this
381 object. If the object has a DT_SONAME entry, we use it.
382 Otherwise, if the generic linker stuck something in
383 elf_dt_name, we use that. Otherwise, we just use the file
384 name. If the generic linker put a null string into
385 elf_dt_name, we don't make a DT_NEEDED entry at all, even if
386 there is a DT_SONAME entry. */
388 name = bfd_get_filename (abfd);
389 if (elf_dt_name (abfd) != NULL)
391 name = elf_dt_name (abfd);
395 s = bfd_get_section_by_name (abfd, ".dynamic");
398 Elf_External_Dyn *extdyn;
399 Elf_External_Dyn *extdynend;
403 dynbuf = (Elf_External_Dyn *) bfd_malloc ((size_t) s->_raw_size);
407 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
408 (file_ptr) 0, s->_raw_size))
411 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
414 link = elf_elfsections (abfd)[elfsec]->sh_link;
417 extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
418 for (; extdyn < extdynend; extdyn++)
420 Elf_Internal_Dyn dyn;
422 elf_swap_dyn_in (abfd, extdyn, &dyn);
423 if (dyn.d_tag == DT_SONAME)
425 name = bfd_elf_string_from_elf_section (abfd, link,
430 if (dyn.d_tag == DT_NEEDED)
432 struct bfd_link_needed_list *n, **pn;
435 n = ((struct bfd_link_needed_list *)
436 bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
437 fnm = bfd_elf_string_from_elf_section (abfd, link,
439 if (n == NULL || fnm == NULL)
441 anm = bfd_alloc (abfd, strlen (fnm) + 1);
448 for (pn = &elf_hash_table (info)->needed;
460 /* We do not want to include any of the sections in a dynamic
461 object in the output file. We hack by simply clobbering the
462 list of sections in the BFD. This could be handled more
463 cleanly by, say, a new section flag; the existing
464 SEC_NEVER_LOAD flag is not the one we want, because that one
465 still implies that the section takes up space in the output
467 abfd->sections = NULL;
468 abfd->section_count = 0;
470 /* If this is the first dynamic object found in the link, create
471 the special sections required for dynamic linking. */
472 if (! elf_hash_table (info)->dynamic_sections_created)
474 if (! elf_link_create_dynamic_sections (abfd, info))
480 /* Add a DT_NEEDED entry for this dynamic object. */
481 oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
482 strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
484 if (strindex == (bfd_size_type) -1)
487 if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
490 Elf_External_Dyn *dyncon, *dynconend;
492 /* The hash table size did not change, which means that
493 the dynamic object name was already entered. If we
494 have already included this dynamic object in the
495 link, just ignore it. There is no reason to include
496 a particular dynamic object more than once. */
497 sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
499 BFD_ASSERT (sdyn != NULL);
501 dyncon = (Elf_External_Dyn *) sdyn->contents;
502 dynconend = (Elf_External_Dyn *) (sdyn->contents +
504 for (; dyncon < dynconend; dyncon++)
506 Elf_Internal_Dyn dyn;
508 elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
510 if (dyn.d_tag == DT_NEEDED
511 && dyn.d_un.d_val == strindex)
520 if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
524 /* Save the SONAME, if there is one, because sometimes the
525 linker emulation code will need to know it. */
527 name = bfd_get_filename (abfd);
528 elf_dt_name (abfd) = name;
532 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
534 || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
535 != extsymcount * sizeof (Elf_External_Sym)))
540 esymend = buf + extsymcount;
541 for (esym = buf; esym < esymend; esym++, sym_hash++)
543 Elf_Internal_Sym sym;
549 struct elf_link_hash_entry *h;
551 boolean size_change_ok, type_change_ok;
554 elf_swap_symbol_in (abfd, esym, &sym);
556 flags = BSF_NO_FLAGS;
558 value = sym.st_value;
561 bind = ELF_ST_BIND (sym.st_info);
562 if (bind == STB_LOCAL)
564 /* This should be impossible, since ELF requires that all
565 global symbols follow all local symbols, and that sh_info
566 point to the first global symbol. Unfortunatealy, Irix 5
570 else if (bind == STB_GLOBAL)
572 if (sym.st_shndx != SHN_UNDEF
573 && sym.st_shndx != SHN_COMMON)
578 else if (bind == STB_WEAK)
582 /* Leave it up to the processor backend. */
585 if (sym.st_shndx == SHN_UNDEF)
586 sec = bfd_und_section_ptr;
587 else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
589 sec = section_from_elf_index (abfd, sym.st_shndx);
593 sec = bfd_abs_section_ptr;
595 else if (sym.st_shndx == SHN_ABS)
596 sec = bfd_abs_section_ptr;
597 else if (sym.st_shndx == SHN_COMMON)
599 sec = bfd_com_section_ptr;
600 /* What ELF calls the size we call the value. What ELF
601 calls the value we call the alignment. */
606 /* Leave it up to the processor backend. */
609 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
610 if (name == (const char *) NULL)
615 if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
619 /* The hook function sets the name to NULL if this symbol
620 should be skipped for some reason. */
621 if (name == (const char *) NULL)
625 /* Sanity check that all possibilities were handled. */
626 if (sec == (asection *) NULL)
628 bfd_set_error (bfd_error_bad_value);
632 if (bfd_is_und_section (sec)
633 || bfd_is_com_section (sec))
638 size_change_ok = false;
639 type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
640 if (info->hash->creator->flavour == bfd_target_elf_flavour)
642 /* We need to look up the symbol now in order to get some of
643 the dynamic object handling right. We pass the hash
644 table entry in to _bfd_generic_link_add_one_symbol so
645 that it does not have to look it up again. */
646 if (! bfd_is_und_section (sec))
647 h = elf_link_hash_lookup (elf_hash_table (info), name,
650 h = ((struct elf_link_hash_entry *)
651 bfd_wrapped_link_hash_lookup (abfd, info, name, true,
657 if (h->root.type == bfd_link_hash_new)
658 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
660 while (h->root.type == bfd_link_hash_indirect
661 || h->root.type == bfd_link_hash_warning)
662 h = (struct elf_link_hash_entry *) h->root.u.i.link;
664 /* It's OK to change the type if it used to be a weak
666 if (h->root.type == bfd_link_hash_defweak
667 || h->root.type == bfd_link_hash_undefweak)
668 type_change_ok = true;
670 /* It's OK to change the size if it used to be a weak
671 definition, or if it used to be undefined, or if we will
672 be overriding an old definition. */
674 || h->root.type == bfd_link_hash_undefined)
675 size_change_ok = true;
677 /* If we are looking at a dynamic object, and this is a
678 definition, we need to see if it has already been defined
679 by some other object. If it has, we want to use the
680 existing definition, and we do not want to report a
681 multiple symbol definition error; we do this by
682 clobbering sec to be bfd_und_section_ptr. */
683 if (dynamic && definition)
685 if (h->root.type == bfd_link_hash_defined
686 || h->root.type == bfd_link_hash_defweak
687 || (h->root.type == bfd_link_hash_common
688 && bind == STB_WEAK))
690 sec = bfd_und_section_ptr;
692 size_change_ok = true;
696 /* Similarly, if we are not looking at a dynamic object, and
697 we have a definition, we want to override any definition
698 we may have from a dynamic object. Symbols from regular
699 files always take precedence over symbols from dynamic
700 objects, even if they are defined after the dynamic
701 object in the link. */
704 && (h->root.type == bfd_link_hash_defined
705 || h->root.type == bfd_link_hash_defweak)
706 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
707 && (bfd_get_flavour (h->root.u.def.section->owner)
708 == bfd_target_elf_flavour)
709 && (elf_elfheader (h->root.u.def.section->owner)->e_type
712 /* Change the hash table entry to undefined, and let
713 _bfd_generic_link_add_one_symbol do the right thing
714 with the new definition. */
715 h->root.type = bfd_link_hash_undefined;
716 h->root.u.undef.abfd = h->root.u.def.section->owner;
717 size_change_ok = true;
721 if (! (_bfd_generic_link_add_one_symbol
722 (info, abfd, name, flags, sec, value, (const char *) NULL,
723 false, collect, (struct bfd_link_hash_entry **) sym_hash)))
727 while (h->root.type == bfd_link_hash_indirect
728 || h->root.type == bfd_link_hash_warning)
729 h = (struct elf_link_hash_entry *) h->root.u.i.link;
735 && (flags & BSF_WEAK) != 0
736 && ELF_ST_TYPE (sym.st_info) != STT_FUNC
737 && info->hash->creator->flavour == bfd_target_elf_flavour
738 && h->weakdef == NULL)
740 /* Keep a list of all weak defined non function symbols from
741 a dynamic object, using the weakdef field. Later in this
742 function we will set the weakdef field to the correct
743 value. We only put non-function symbols from dynamic
744 objects on this list, because that happens to be the only
745 time we need to know the normal symbol corresponding to a
746 weak symbol, and the information is time consuming to
747 figure out. If the weakdef field is not already NULL,
748 then this symbol was already defined by some previous
749 dynamic object, and we will be using that previous
750 definition anyhow. */
757 /* Get the alignment of a common symbol. */
758 if (sym.st_shndx == SHN_COMMON
759 && h->root.type == bfd_link_hash_common)
760 h->root.u.c.p->alignment_power = bfd_log2 (sym.st_value);
762 if (info->hash->creator->flavour == bfd_target_elf_flavour)
768 /* Remember the symbol size and type. */
770 && (definition || h->size == 0))
772 if (h->size != 0 && h->size != sym.st_size && ! size_change_ok)
773 (*_bfd_error_handler)
774 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
775 name, (unsigned long) h->size, (unsigned long) sym.st_size,
776 bfd_get_filename (abfd));
778 h->size = sym.st_size;
780 if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE
781 && (definition || h->type == STT_NOTYPE))
783 if (h->type != STT_NOTYPE
784 && h->type != ELF_ST_TYPE (sym.st_info)
786 (*_bfd_error_handler)
787 ("Warning: type of symbol `%s' changed from %d to %d in %s",
788 name, h->type, ELF_ST_TYPE (sym.st_info),
789 bfd_get_filename (abfd));
791 h->type = ELF_ST_TYPE (sym.st_info);
794 /* Set a flag in the hash table entry indicating the type of
795 reference or definition we just found. Keep a count of
796 the number of dynamic symbols we find. A dynamic symbol
797 is one which is referenced or defined by both a regular
798 object and a shared object, or one which is referenced or
799 defined by more than one shared object. */
800 old_flags = h->elf_link_hash_flags;
805 new_flag = ELF_LINK_HASH_REF_REGULAR;
807 new_flag = ELF_LINK_HASH_DEF_REGULAR;
809 || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
810 | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
816 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
818 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
819 if ((old_flags & new_flag) != 0
820 || (old_flags & (ELF_LINK_HASH_DEF_REGULAR
821 | ELF_LINK_HASH_REF_REGULAR)) != 0
822 || (h->weakdef != NULL
823 && (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
824 | ELF_LINK_HASH_REF_DYNAMIC)) != 0))
828 h->elf_link_hash_flags |= new_flag;
829 if (dynsym && h->dynindx == -1)
831 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
833 if (h->weakdef != NULL
835 && h->weakdef->dynindx == -1)
837 if (! _bfd_elf_link_record_dynamic_symbol (info,
845 /* Now set the weakdefs field correctly for all the weak defined
846 symbols we found. The only way to do this is to search all the
847 symbols. Since we only need the information for non functions in
848 dynamic objects, that's the only time we actually put anything on
849 the list WEAKS. We need this information so that if a regular
850 object refers to a symbol defined weakly in a dynamic object, the
851 real symbol in the dynamic object is also put in the dynamic
852 symbols; we also must arrange for both symbols to point to the
853 same memory location. We could handle the general case of symbol
854 aliasing, but a general symbol alias can only be generated in
855 assembler code, handling it correctly would be very time
856 consuming, and other ELF linkers don't handle general aliasing
858 while (weaks != NULL)
860 struct elf_link_hash_entry *hlook;
863 struct elf_link_hash_entry **hpp;
864 struct elf_link_hash_entry **hppend;
867 weaks = hlook->weakdef;
868 hlook->weakdef = NULL;
870 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
871 || hlook->root.type == bfd_link_hash_defweak
872 || hlook->root.type == bfd_link_hash_common
873 || hlook->root.type == bfd_link_hash_indirect);
874 slook = hlook->root.u.def.section;
875 vlook = hlook->root.u.def.value;
877 hpp = elf_sym_hashes (abfd);
878 hppend = hpp + extsymcount;
879 for (; hpp < hppend; hpp++)
881 struct elf_link_hash_entry *h;
884 if (h != NULL && h != hlook
885 && h->root.type == bfd_link_hash_defined
886 && h->root.u.def.section == slook
887 && h->root.u.def.value == vlook)
891 /* If the weak definition is in the list of dynamic
892 symbols, make sure the real definition is put there
894 if (hlook->dynindx != -1
897 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
912 /* If this object is the same format as the output object, and it is
913 not a shared library, then let the backend look through the
916 This is required to build global offset table entries and to
917 arrange for dynamic relocs. It is not required for the
918 particular common case of linking non PIC code, even when linking
919 against shared libraries, but unfortunately there is no way of
920 knowing whether an object file has been compiled PIC or not.
921 Looking through the relocs is not particularly time consuming.
922 The problem is that we must either (1) keep the relocs in memory,
923 which causes the linker to require additional runtime memory or
924 (2) read the relocs twice from the input file, which wastes time.
925 This would be a good case for using mmap.
927 I have no idea how to handle linking PIC code into a file of a
928 different format. It probably can't be done. */
929 check_relocs = get_elf_backend_data (abfd)->check_relocs;
931 && abfd->xvec == info->hash->creator
932 && check_relocs != NULL)
936 for (o = abfd->sections; o != NULL; o = o->next)
938 Elf_Internal_Rela *internal_relocs;
941 if ((o->flags & SEC_RELOC) == 0
942 || o->reloc_count == 0)
945 /* I believe we can ignore the relocs for any section which
946 does not form part of the final process image, such as a
947 debugging section. */
948 if ((o->flags & SEC_ALLOC) == 0)
951 internal_relocs = elf_link_read_relocs (abfd, o, (PTR) NULL,
952 (Elf_Internal_Rela *) NULL,
954 if (internal_relocs == NULL)
957 ok = (*check_relocs) (abfd, info, o, internal_relocs);
959 if (! info->keep_memory)
960 free (internal_relocs);
967 /* If this is a non-traditional, non-relocateable link, try to
968 optimize the handling of the .stab/.stabstr sections. */
970 && ! info->relocateable
971 && ! info->traditional_format
972 && info->hash->creator->flavour == bfd_target_elf_flavour
973 && (info->strip != strip_all && info->strip != strip_debugger))
975 asection *stab, *stabstr;
977 stab = bfd_get_section_by_name (abfd, ".stab");
980 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
984 struct bfd_elf_section_data *secdata;
986 secdata = elf_section_data (stab);
987 if (! _bfd_link_section_stabs (abfd,
988 &elf_hash_table (info)->stab_info,
990 &secdata->stab_info))
1006 /* Create some sections which will be filled in with dynamic linking
1007 information. ABFD is an input file which requires dynamic sections
1008 to be created. The dynamic sections take up virtual memory space
1009 when the final executable is run, so we need to create them before
1010 addresses are assigned to the output sections. We work out the
1011 actual contents and size of these sections later. */
1014 elf_link_create_dynamic_sections (abfd, info)
1016 struct bfd_link_info *info;
1019 register asection *s;
1020 struct elf_link_hash_entry *h;
1021 struct elf_backend_data *bed;
1023 if (elf_hash_table (info)->dynamic_sections_created)
1026 /* Make sure that all dynamic sections use the same input BFD. */
1027 if (elf_hash_table (info)->dynobj == NULL)
1028 elf_hash_table (info)->dynobj = abfd;
1030 abfd = elf_hash_table (info)->dynobj;
1032 /* Note that we set the SEC_IN_MEMORY flag for all of these
1034 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1036 /* A dynamically linked executable has a .interp section, but a
1037 shared library does not. */
1040 s = bfd_make_section (abfd, ".interp");
1042 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1046 s = bfd_make_section (abfd, ".dynsym");
1048 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1049 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1052 s = bfd_make_section (abfd, ".dynstr");
1054 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1057 /* Create a strtab to hold the dynamic symbol names. */
1058 if (elf_hash_table (info)->dynstr == NULL)
1060 elf_hash_table (info)->dynstr = elf_stringtab_init ();
1061 if (elf_hash_table (info)->dynstr == NULL)
1065 s = bfd_make_section (abfd, ".dynamic");
1067 || ! bfd_set_section_flags (abfd, s, flags)
1068 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1071 /* The special symbol _DYNAMIC is always set to the start of the
1072 .dynamic section. This call occurs before we have processed the
1073 symbols for any dynamic object, so we don't have to worry about
1074 overriding a dynamic definition. We could set _DYNAMIC in a
1075 linker script, but we only want to define it if we are, in fact,
1076 creating a .dynamic section. We don't want to define it if there
1077 is no .dynamic section, since on some ELF platforms the start up
1078 code examines it to decide how to initialize the process. */
1080 if (! (_bfd_generic_link_add_one_symbol
1081 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
1082 (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
1083 (struct bfd_link_hash_entry **) &h)))
1085 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1086 h->type = STT_OBJECT;
1089 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1092 s = bfd_make_section (abfd, ".hash");
1094 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1095 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1098 /* Let the backend create the rest of the sections. This lets the
1099 backend set the right flags. The backend will normally create
1100 the .got and .plt sections. */
1101 bed = get_elf_backend_data (abfd);
1102 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
1105 elf_hash_table (info)->dynamic_sections_created = true;
1110 /* Add an entry to the .dynamic table. */
1113 elf_add_dynamic_entry (info, tag, val)
1114 struct bfd_link_info *info;
1118 Elf_Internal_Dyn dyn;
1122 bfd_byte *newcontents;
1124 dynobj = elf_hash_table (info)->dynobj;
1126 s = bfd_get_section_by_name (dynobj, ".dynamic");
1127 BFD_ASSERT (s != NULL);
1129 newsize = s->_raw_size + sizeof (Elf_External_Dyn);
1130 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
1131 if (newcontents == NULL)
1135 dyn.d_un.d_val = val;
1136 elf_swap_dyn_out (dynobj, &dyn,
1137 (Elf_External_Dyn *) (newcontents + s->_raw_size));
1139 s->_raw_size = newsize;
1140 s->contents = newcontents;
1146 /* Read and swap the relocs for a section. They may have been cached.
1147 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1148 they are used as buffers to read into. They are known to be large
1149 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1150 value is allocated using either malloc or bfd_alloc, according to
1151 the KEEP_MEMORY argument. */
1153 static Elf_Internal_Rela *
1154 elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
1157 PTR external_relocs;
1158 Elf_Internal_Rela *internal_relocs;
1159 boolean keep_memory;
1161 Elf_Internal_Shdr *rel_hdr;
1163 Elf_Internal_Rela *alloc2 = NULL;
1165 if (elf_section_data (o)->relocs != NULL)
1166 return elf_section_data (o)->relocs;
1168 if (o->reloc_count == 0)
1171 rel_hdr = &elf_section_data (o)->rel_hdr;
1173 if (internal_relocs == NULL)
1177 size = o->reloc_count * sizeof (Elf_Internal_Rela);
1179 internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
1181 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
1182 if (internal_relocs == NULL)
1186 if (external_relocs == NULL)
1188 alloc1 = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
1191 external_relocs = alloc1;
1194 if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
1195 || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
1196 != rel_hdr->sh_size))
1199 /* Swap in the relocs. For convenience, we always produce an
1200 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1202 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
1204 Elf_External_Rel *erel;
1205 Elf_External_Rel *erelend;
1206 Elf_Internal_Rela *irela;
1208 erel = (Elf_External_Rel *) external_relocs;
1209 erelend = erel + o->reloc_count;
1210 irela = internal_relocs;
1211 for (; erel < erelend; erel++, irela++)
1213 Elf_Internal_Rel irel;
1215 elf_swap_reloc_in (abfd, erel, &irel);
1216 irela->r_offset = irel.r_offset;
1217 irela->r_info = irel.r_info;
1218 irela->r_addend = 0;
1223 Elf_External_Rela *erela;
1224 Elf_External_Rela *erelaend;
1225 Elf_Internal_Rela *irela;
1227 BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
1229 erela = (Elf_External_Rela *) external_relocs;
1230 erelaend = erela + o->reloc_count;
1231 irela = internal_relocs;
1232 for (; erela < erelaend; erela++, irela++)
1233 elf_swap_reloca_in (abfd, erela, irela);
1236 /* Cache the results for next time, if we can. */
1238 elf_section_data (o)->relocs = internal_relocs;
1243 /* Don't free alloc2, since if it was allocated we are passing it
1244 back (under the name of internal_relocs). */
1246 return internal_relocs;
1257 /* Record an assignment to a symbol made by a linker script. We need
1258 this in case some dynamic object refers to this symbol. */
1262 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
1264 struct bfd_link_info *info;
1268 struct elf_link_hash_entry *h;
1270 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1273 h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
1277 if (h->root.type == bfd_link_hash_new)
1278 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
1280 /* If this symbol is being provided by the linker script, and it is
1281 currently defined by a dynamic object, but not by a regular
1282 object, then mark it as undefined so that the generic linker will
1283 force the correct value. */
1285 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1286 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1287 h->root.type = bfd_link_hash_undefined;
1289 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1290 h->type = STT_OBJECT;
1292 if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1293 | ELF_LINK_HASH_REF_DYNAMIC)) != 0
1295 && h->dynindx == -1)
1297 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1300 /* If this is a weak defined symbol, and we know a corresponding
1301 real symbol from the same dynamic object, make sure the real
1302 symbol is also made into a dynamic symbol. */
1303 if (h->weakdef != NULL
1304 && h->weakdef->dynindx == -1)
1306 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
1315 /* Array used to determine the number of hash table buckets to use
1316 based on the number of symbols there are. If there are fewer than
1317 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1318 fewer than 37 we use 17 buckets, and so forth. We never use more
1319 than 521 buckets. */
1321 static const size_t elf_buckets[] =
1323 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1326 /* Set up the sizes and contents of the ELF dynamic sections. This is
1327 called by the ELF linker emulation before_allocation routine. We
1328 must set the sizes of the sections before the linker sets the
1329 addresses of the various sections. */
1332 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
1333 export_dynamic, info, sinterpptr)
1337 boolean export_dynamic;
1338 struct bfd_link_info *info;
1339 asection **sinterpptr;
1342 struct elf_backend_data *bed;
1346 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1349 dynobj = elf_hash_table (info)->dynobj;
1351 /* If there were no dynamic objects in the link, there is nothing to
1356 /* If we are supposed to export all symbols into the dynamic symbol
1357 table (this is not the normal case), then do so. */
1360 struct elf_info_failed eif;
1364 elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
1370 if (elf_hash_table (info)->dynamic_sections_created)
1372 struct elf_info_failed eif;
1373 struct elf_link_hash_entry *h;
1374 bfd_size_type strsize;
1376 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
1377 BFD_ASSERT (*sinterpptr != NULL || info->shared);
1383 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, soname,
1385 if (indx == (bfd_size_type) -1
1386 || ! elf_add_dynamic_entry (info, DT_SONAME, indx))
1392 if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
1400 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
1402 if (indx == (bfd_size_type) -1
1403 || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
1407 /* Find all symbols which were defined in a dynamic object and make
1408 the backend pick a reasonable value for them. */
1411 elf_link_hash_traverse (elf_hash_table (info),
1412 elf_adjust_dynamic_symbol,
1417 /* Add some entries to the .dynamic section. We fill in some of the
1418 values later, in elf_bfd_final_link, but we must add the entries
1419 now so that we know the final size of the .dynamic section. */
1420 h = elf_link_hash_lookup (elf_hash_table (info), "_init", false,
1423 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
1424 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
1426 if (! elf_add_dynamic_entry (info, DT_INIT, 0))
1429 h = elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
1432 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
1433 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
1435 if (! elf_add_dynamic_entry (info, DT_FINI, 0))
1438 strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1439 if (! elf_add_dynamic_entry (info, DT_HASH, 0)
1440 || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
1441 || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
1442 || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
1443 || ! elf_add_dynamic_entry (info, DT_SYMENT,
1444 sizeof (Elf_External_Sym)))
1448 /* The backend must work out the sizes of all the other dynamic
1450 bed = get_elf_backend_data (output_bfd);
1451 if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
1454 if (elf_hash_table (info)->dynamic_sections_created)
1459 size_t bucketcount = 0;
1460 Elf_Internal_Sym isym;
1462 /* Set the size of the .dynsym and .hash sections. We counted
1463 the number of dynamic symbols in elf_link_add_object_symbols.
1464 We will build the contents of .dynsym and .hash when we build
1465 the final symbol table, because until then we do not know the
1466 correct value to give the symbols. We built the .dynstr
1467 section as we went along in elf_link_add_object_symbols. */
1468 dynsymcount = elf_hash_table (info)->dynsymcount;
1469 s = bfd_get_section_by_name (dynobj, ".dynsym");
1470 BFD_ASSERT (s != NULL);
1471 s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
1472 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1473 if (s->contents == NULL && s->_raw_size != 0)
1476 /* The first entry in .dynsym is a dummy symbol. */
1483 elf_swap_symbol_out (output_bfd, &isym,
1484 (PTR) (Elf_External_Sym *) s->contents);
1486 for (i = 0; elf_buckets[i] != 0; i++)
1488 bucketcount = elf_buckets[i];
1489 if (dynsymcount < elf_buckets[i + 1])
1493 s = bfd_get_section_by_name (dynobj, ".hash");
1494 BFD_ASSERT (s != NULL);
1495 s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
1496 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1497 if (s->contents == NULL)
1499 memset (s->contents, 0, (size_t) s->_raw_size);
1501 put_word (output_bfd, bucketcount, s->contents);
1502 put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
1504 elf_hash_table (info)->bucketcount = bucketcount;
1506 s = bfd_get_section_by_name (dynobj, ".dynstr");
1507 BFD_ASSERT (s != NULL);
1508 s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1510 if (! elf_add_dynamic_entry (info, DT_NULL, 0))
1518 /* This routine is used to export all defined symbols into the dynamic
1519 symbol table. It is called via elf_link_hash_traverse. */
1522 elf_export_symbol (h, data)
1523 struct elf_link_hash_entry *h;
1526 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1528 if (h->dynindx == -1
1529 && (h->elf_link_hash_flags
1530 & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
1532 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1543 /* Make the backend pick a good value for a dynamic symbol. This is
1544 called via elf_link_hash_traverse, and also calls itself
1548 elf_adjust_dynamic_symbol (h, data)
1549 struct elf_link_hash_entry *h;
1552 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1554 struct elf_backend_data *bed;
1556 /* If this symbol was mentioned in a non-ELF file, try to set
1557 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1558 permit a non-ELF file to correctly refer to a symbol defined in
1559 an ELF dynamic object. */
1560 if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) != 0)
1562 if (h->root.type != bfd_link_hash_defined
1563 && h->root.type != bfd_link_hash_defweak)
1564 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1567 if (h->root.u.def.section->owner != NULL
1568 && (bfd_get_flavour (h->root.u.def.section->owner)
1569 == bfd_target_elf_flavour))
1570 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1572 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1575 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1576 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
1578 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1586 /* If this is a final link, and the symbol was defined as a common
1587 symbol in a regular object file, and there was no definition in
1588 any dynamic object, then the linker will have allocated space for
1589 the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
1590 flag will not have been set. */
1591 if (h->root.type == bfd_link_hash_defined
1592 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1593 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
1594 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1595 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
1596 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1598 /* If -Bsymbolic was used (which means to bind references to global
1599 symbols to the definition within the shared object), and this
1600 symbol was defined in a regular object, then it actually doesn't
1601 need a PLT entry. */
1602 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1603 && eif->info->shared
1604 && eif->info->symbolic
1605 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1606 h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
1608 /* If this symbol does not require a PLT entry, and it is not
1609 defined by a dynamic object, or is not referenced by a regular
1610 object, ignore it. We do have to handle a weak defined symbol,
1611 even if no regular object refers to it, if we decided to add it
1612 to the dynamic symbol table. FIXME: Do we normally need to worry
1613 about symbols which are defined by one dynamic object and
1614 referenced by another one? */
1615 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
1616 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1617 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1618 || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
1619 && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
1622 /* If we've already adjusted this symbol, don't do it again. This
1623 can happen via a recursive call. */
1624 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
1627 /* Don't look at this symbol again. Note that we must set this
1628 after checking the above conditions, because we may look at a
1629 symbol once, decide not to do anything, and then get called
1630 recursively later after REF_REGULAR is set below. */
1631 h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
1633 /* If this is a weak definition, and we know a real definition, and
1634 the real symbol is not itself defined by a regular object file,
1635 then get a good value for the real definition. We handle the
1636 real symbol first, for the convenience of the backend routine.
1638 Note that there is a confusing case here. If the real definition
1639 is defined by a regular object file, we don't get the real symbol
1640 from the dynamic object, but we do get the weak symbol. If the
1641 processor backend uses a COPY reloc, then if some routine in the
1642 dynamic object changes the real symbol, we will not see that
1643 change in the corresponding weak symbol. This is the way other
1644 ELF linkers work as well, and seems to be a result of the shared
1647 I will clarify this issue. Most SVR4 shared libraries define the
1648 variable _timezone and define timezone as a weak synonym. The
1649 tzset call changes _timezone. If you write
1650 extern int timezone;
1652 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1653 you might expect that, since timezone is a synonym for _timezone,
1654 the same number will print both times. However, if the processor
1655 backend uses a COPY reloc, then actually timezone will be copied
1656 into your process image, and, since you define _timezone
1657 yourself, _timezone will not. Thus timezone and _timezone will
1658 wind up at different memory locations. The tzset call will set
1659 _timezone, leaving timezone unchanged. */
1661 if (h->weakdef != NULL)
1663 struct elf_link_hash_entry *weakdef;
1665 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1666 || h->root.type == bfd_link_hash_defweak);
1667 weakdef = h->weakdef;
1668 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
1669 || weakdef->root.type == bfd_link_hash_defweak);
1670 BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
1671 if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1673 /* This symbol is defined by a regular object file, so we
1674 will not do anything special. Clear weakdef for the
1675 convenience of the processor backend. */
1680 /* There is an implicit reference by a regular object file
1681 via the weak symbol. */
1682 weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1683 if (! elf_adjust_dynamic_symbol (weakdef, (PTR) eif))
1688 dynobj = elf_hash_table (eif->info)->dynobj;
1689 bed = get_elf_backend_data (dynobj);
1690 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
1699 /* Final phase of ELF linker. */
1701 /* A structure we use to avoid passing large numbers of arguments. */
1703 struct elf_final_link_info
1705 /* General link information. */
1706 struct bfd_link_info *info;
1709 /* Symbol string table. */
1710 struct bfd_strtab_hash *symstrtab;
1711 /* .dynsym section. */
1712 asection *dynsym_sec;
1713 /* .hash section. */
1715 /* Buffer large enough to hold contents of any section. */
1717 /* Buffer large enough to hold external relocs of any section. */
1718 PTR external_relocs;
1719 /* Buffer large enough to hold internal relocs of any section. */
1720 Elf_Internal_Rela *internal_relocs;
1721 /* Buffer large enough to hold external local symbols of any input
1723 Elf_External_Sym *external_syms;
1724 /* Buffer large enough to hold internal local symbols of any input
1726 Elf_Internal_Sym *internal_syms;
1727 /* Array large enough to hold a symbol index for each local symbol
1728 of any input BFD. */
1730 /* Array large enough to hold a section pointer for each local
1731 symbol of any input BFD. */
1732 asection **sections;
1733 /* Buffer to hold swapped out symbols. */
1734 Elf_External_Sym *symbuf;
1735 /* Number of swapped out symbols in buffer. */
1736 size_t symbuf_count;
1737 /* Number of symbols which fit in symbuf. */
1741 static boolean elf_link_output_sym
1742 PARAMS ((struct elf_final_link_info *, const char *,
1743 Elf_Internal_Sym *, asection *));
1744 static boolean elf_link_flush_output_syms
1745 PARAMS ((struct elf_final_link_info *));
1746 static boolean elf_link_output_extsym
1747 PARAMS ((struct elf_link_hash_entry *, PTR));
1748 static boolean elf_link_input_bfd
1749 PARAMS ((struct elf_final_link_info *, bfd *));
1750 static boolean elf_reloc_link_order
1751 PARAMS ((bfd *, struct bfd_link_info *, asection *,
1752 struct bfd_link_order *));
1754 /* This struct is used to pass information to routines called via
1755 elf_link_hash_traverse which must return failure. */
1757 struct elf_finfo_failed
1760 struct elf_final_link_info *finfo;
1763 /* Do the final step of an ELF link. */
1766 elf_bfd_final_link (abfd, info)
1768 struct bfd_link_info *info;
1772 struct elf_final_link_info finfo;
1773 register asection *o;
1774 register struct bfd_link_order *p;
1776 size_t max_contents_size;
1777 size_t max_external_reloc_size;
1778 size_t max_internal_reloc_count;
1779 size_t max_sym_count;
1781 Elf_Internal_Sym elfsym;
1783 Elf_Internal_Shdr *symtab_hdr;
1784 Elf_Internal_Shdr *symstrtab_hdr;
1785 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1786 struct elf_finfo_failed eif;
1789 abfd->flags |= DYNAMIC;
1791 dynamic = elf_hash_table (info)->dynamic_sections_created;
1792 dynobj = elf_hash_table (info)->dynobj;
1795 finfo.output_bfd = abfd;
1796 finfo.symstrtab = elf_stringtab_init ();
1797 if (finfo.symstrtab == NULL)
1801 finfo.dynsym_sec = NULL;
1802 finfo.hash_sec = NULL;
1806 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
1807 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
1808 BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
1810 finfo.contents = NULL;
1811 finfo.external_relocs = NULL;
1812 finfo.internal_relocs = NULL;
1813 finfo.external_syms = NULL;
1814 finfo.internal_syms = NULL;
1815 finfo.indices = NULL;
1816 finfo.sections = NULL;
1817 finfo.symbuf = NULL;
1818 finfo.symbuf_count = 0;
1820 /* Count up the number of relocations we will output for each output
1821 section, so that we know the sizes of the reloc sections. We
1822 also figure out some maximum sizes. */
1823 max_contents_size = 0;
1824 max_external_reloc_size = 0;
1825 max_internal_reloc_count = 0;
1827 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
1831 for (p = o->link_order_head; p != NULL; p = p->next)
1833 if (p->type == bfd_section_reloc_link_order
1834 || p->type == bfd_symbol_reloc_link_order)
1836 else if (p->type == bfd_indirect_link_order)
1840 sec = p->u.indirect.section;
1842 /* Mark all sections which are to be included in the
1843 link. This will normally be every section. We need
1844 to do this so that we can identify any sections which
1845 the linker has decided to not include. */
1846 sec->linker_mark = true;
1848 if (info->relocateable)
1849 o->reloc_count += sec->reloc_count;
1851 if (sec->_raw_size > max_contents_size)
1852 max_contents_size = sec->_raw_size;
1853 if (sec->_cooked_size > max_contents_size)
1854 max_contents_size = sec->_cooked_size;
1856 /* We are interested in just local symbols, not all
1858 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour)
1862 if (elf_bad_symtab (sec->owner))
1863 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
1864 / sizeof (Elf_External_Sym));
1866 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
1868 if (sym_count > max_sym_count)
1869 max_sym_count = sym_count;
1871 if ((sec->flags & SEC_RELOC) != 0)
1875 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
1876 if (ext_size > max_external_reloc_size)
1877 max_external_reloc_size = ext_size;
1878 if (sec->reloc_count > max_internal_reloc_count)
1879 max_internal_reloc_count = sec->reloc_count;
1885 if (o->reloc_count > 0)
1886 o->flags |= SEC_RELOC;
1889 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1890 set it (this is probably a bug) and if it is set
1891 assign_section_numbers will create a reloc section. */
1892 o->flags &=~ SEC_RELOC;
1895 /* If the SEC_ALLOC flag is not set, force the section VMA to
1896 zero. This is done in elf_fake_sections as well, but forcing
1897 the VMA to 0 here will ensure that relocs against these
1898 sections are handled correctly. */
1899 if ((o->flags & SEC_ALLOC) == 0
1900 && ! o->user_set_vma)
1904 /* Figure out the file positions for everything but the symbol table
1905 and the relocs. We set symcount to force assign_section_numbers
1906 to create a symbol table. */
1907 abfd->symcount = info->strip == strip_all ? 0 : 1;
1908 BFD_ASSERT (! abfd->output_has_begun);
1909 if (! _bfd_elf_compute_section_file_positions (abfd, info))
1912 /* That created the reloc sections. Set their sizes, and assign
1913 them file positions, and allocate some buffers. */
1914 for (o = abfd->sections; o != NULL; o = o->next)
1916 if ((o->flags & SEC_RELOC) != 0)
1918 Elf_Internal_Shdr *rel_hdr;
1919 register struct elf_link_hash_entry **p, **pend;
1921 rel_hdr = &elf_section_data (o)->rel_hdr;
1923 rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
1925 /* The contents field must last into write_object_contents,
1926 so we allocate it with bfd_alloc rather than malloc. */
1927 rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
1928 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
1931 p = ((struct elf_link_hash_entry **)
1932 bfd_malloc (o->reloc_count
1933 * sizeof (struct elf_link_hash_entry *)));
1934 if (p == NULL && o->reloc_count != 0)
1936 elf_section_data (o)->rel_hashes = p;
1937 pend = p + o->reloc_count;
1938 for (; p < pend; p++)
1941 /* Use the reloc_count field as an index when outputting the
1947 _bfd_elf_assign_file_positions_for_relocs (abfd);
1949 /* We have now assigned file positions for all the sections except
1950 .symtab and .strtab. We start the .symtab section at the current
1951 file position, and write directly to it. We build the .strtab
1952 section in memory. */
1954 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1955 /* sh_name is set in prep_headers. */
1956 symtab_hdr->sh_type = SHT_SYMTAB;
1957 symtab_hdr->sh_flags = 0;
1958 symtab_hdr->sh_addr = 0;
1959 symtab_hdr->sh_size = 0;
1960 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
1961 /* sh_link is set in assign_section_numbers. */
1962 /* sh_info is set below. */
1963 /* sh_offset is set just below. */
1964 symtab_hdr->sh_addralign = 4; /* FIXME: system dependent? */
1966 off = elf_tdata (abfd)->next_file_pos;
1967 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
1969 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1970 incorrect. We do not yet know the size of the .symtab section.
1971 We correct next_file_pos below, after we do know the size. */
1973 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1974 continuously seeking to the right position in the file. */
1975 if (! info->keep_memory || max_sym_count < 20)
1976 finfo.symbuf_size = 20;
1978 finfo.symbuf_size = max_sym_count;
1979 finfo.symbuf = ((Elf_External_Sym *)
1980 bfd_malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
1981 if (finfo.symbuf == NULL)
1984 /* Start writing out the symbol table. The first symbol is always a
1986 if (info->strip != strip_all || info->relocateable)
1988 elfsym.st_value = 0;
1991 elfsym.st_other = 0;
1992 elfsym.st_shndx = SHN_UNDEF;
1993 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1994 &elfsym, bfd_und_section_ptr))
1999 /* Some standard ELF linkers do this, but we don't because it causes
2000 bootstrap comparison failures. */
2001 /* Output a file symbol for the output file as the second symbol.
2002 We output this even if we are discarding local symbols, although
2003 I'm not sure if this is correct. */
2004 elfsym.st_value = 0;
2006 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
2007 elfsym.st_other = 0;
2008 elfsym.st_shndx = SHN_ABS;
2009 if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
2010 &elfsym, bfd_abs_section_ptr))
2014 /* Output a symbol for each section. We output these even if we are
2015 discarding local symbols, since they are used for relocs. These
2016 symbols have no names. We store the index of each one in the
2017 index field of the section, so that we can find it again when
2018 outputting relocs. */
2019 if (info->strip != strip_all || info->relocateable)
2021 elfsym.st_value = 0;
2023 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
2024 elfsym.st_other = 0;
2025 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
2027 o = section_from_elf_index (abfd, i);
2029 o->target_index = abfd->symcount;
2030 elfsym.st_shndx = i;
2031 if (! elf_link_output_sym (&finfo, (const char *) NULL,
2037 /* Allocate some memory to hold information read in from the input
2039 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
2040 finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
2041 finfo.internal_relocs = ((Elf_Internal_Rela *)
2042 bfd_malloc (max_internal_reloc_count
2043 * sizeof (Elf_Internal_Rela)));
2044 finfo.external_syms = ((Elf_External_Sym *)
2045 bfd_malloc (max_sym_count
2046 * sizeof (Elf_External_Sym)));
2047 finfo.internal_syms = ((Elf_Internal_Sym *)
2048 bfd_malloc (max_sym_count
2049 * sizeof (Elf_Internal_Sym)));
2050 finfo.indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
2051 finfo.sections = ((asection **)
2052 bfd_malloc (max_sym_count * sizeof (asection *)));
2053 if ((finfo.contents == NULL && max_contents_size != 0)
2054 || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
2055 || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
2056 || (finfo.external_syms == NULL && max_sym_count != 0)
2057 || (finfo.internal_syms == NULL && max_sym_count != 0)
2058 || (finfo.indices == NULL && max_sym_count != 0)
2059 || (finfo.sections == NULL && max_sym_count != 0))
2062 /* Since ELF permits relocations to be against local symbols, we
2063 must have the local symbols available when we do the relocations.
2064 Since we would rather only read the local symbols once, and we
2065 would rather not keep them in memory, we handle all the
2066 relocations for a single input file at the same time.
2068 Unfortunately, there is no way to know the total number of local
2069 symbols until we have seen all of them, and the local symbol
2070 indices precede the global symbol indices. This means that when
2071 we are generating relocateable output, and we see a reloc against
2072 a global symbol, we can not know the symbol index until we have
2073 finished examining all the local symbols to see which ones we are
2074 going to output. To deal with this, we keep the relocations in
2075 memory, and don't output them until the end of the link. This is
2076 an unfortunate waste of memory, but I don't see a good way around
2077 it. Fortunately, it only happens when performing a relocateable
2078 link, which is not the common case. FIXME: If keep_memory is set
2079 we could write the relocs out and then read them again; I don't
2080 know how bad the memory loss will be. */
2082 for (sub = info->input_bfds; sub != NULL; sub = sub->next)
2083 sub->output_has_begun = false;
2084 for (o = abfd->sections; o != NULL; o = o->next)
2086 for (p = o->link_order_head; p != NULL; p = p->next)
2088 if (p->type == bfd_indirect_link_order
2089 && (bfd_get_flavour (p->u.indirect.section->owner)
2090 == bfd_target_elf_flavour))
2092 sub = p->u.indirect.section->owner;
2093 if (! sub->output_has_begun)
2095 if (! elf_link_input_bfd (&finfo, sub))
2097 sub->output_has_begun = true;
2100 else if (p->type == bfd_section_reloc_link_order
2101 || p->type == bfd_symbol_reloc_link_order)
2103 if (! elf_reloc_link_order (abfd, info, o, p))
2108 if (! _bfd_default_link_order (abfd, info, o, p))
2114 /* That wrote out all the local symbols. Finish up the symbol table
2115 with the global symbols. */
2117 /* The sh_info field records the index of the first non local
2119 symtab_hdr->sh_info = abfd->symcount;
2121 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
2123 /* We get the global symbols from the hash table. */
2126 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
2131 /* Flush all symbols to the file. */
2132 if (! elf_link_flush_output_syms (&finfo))
2135 /* Now we know the size of the symtab section. */
2136 off += symtab_hdr->sh_size;
2138 /* Finish up and write out the symbol string table (.strtab)
2140 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2141 /* sh_name was set in prep_headers. */
2142 symstrtab_hdr->sh_type = SHT_STRTAB;
2143 symstrtab_hdr->sh_flags = 0;
2144 symstrtab_hdr->sh_addr = 0;
2145 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
2146 symstrtab_hdr->sh_entsize = 0;
2147 symstrtab_hdr->sh_link = 0;
2148 symstrtab_hdr->sh_info = 0;
2149 /* sh_offset is set just below. */
2150 symstrtab_hdr->sh_addralign = 1;
2152 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
2153 elf_tdata (abfd)->next_file_pos = off;
2155 if (abfd->symcount > 0)
2157 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
2158 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
2162 /* Adjust the relocs to have the correct symbol indices. */
2163 for (o = abfd->sections; o != NULL; o = o->next)
2165 struct elf_link_hash_entry **rel_hash;
2166 Elf_Internal_Shdr *rel_hdr;
2168 if ((o->flags & SEC_RELOC) == 0)
2171 rel_hash = elf_section_data (o)->rel_hashes;
2172 rel_hdr = &elf_section_data (o)->rel_hdr;
2173 for (i = 0; i < o->reloc_count; i++, rel_hash++)
2175 if (*rel_hash == NULL)
2178 BFD_ASSERT ((*rel_hash)->indx >= 0);
2180 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2182 Elf_External_Rel *erel;
2183 Elf_Internal_Rel irel;
2185 erel = (Elf_External_Rel *) rel_hdr->contents + i;
2186 elf_swap_reloc_in (abfd, erel, &irel);
2187 irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
2188 ELF_R_TYPE (irel.r_info));
2189 elf_swap_reloc_out (abfd, &irel, erel);
2193 Elf_External_Rela *erela;
2194 Elf_Internal_Rela irela;
2196 BFD_ASSERT (rel_hdr->sh_entsize
2197 == sizeof (Elf_External_Rela));
2199 erela = (Elf_External_Rela *) rel_hdr->contents + i;
2200 elf_swap_reloca_in (abfd, erela, &irela);
2201 irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
2202 ELF_R_TYPE (irela.r_info));
2203 elf_swap_reloca_out (abfd, &irela, erela);
2207 /* Set the reloc_count field to 0 to prevent write_relocs from
2208 trying to swap the relocs out itself. */
2212 /* If we are linking against a dynamic object, or generating a
2213 shared library, finish up the dynamic linking information. */
2216 Elf_External_Dyn *dyncon, *dynconend;
2218 /* Fix up .dynamic entries. */
2219 o = bfd_get_section_by_name (dynobj, ".dynamic");
2220 BFD_ASSERT (o != NULL);
2222 dyncon = (Elf_External_Dyn *) o->contents;
2223 dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
2224 for (; dyncon < dynconend; dyncon++)
2226 Elf_Internal_Dyn dyn;
2230 elf_swap_dyn_in (dynobj, dyncon, &dyn);
2237 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2238 magic _init and _fini symbols. This is pretty ugly,
2239 but we are compatible. */
2247 struct elf_link_hash_entry *h;
2249 h = elf_link_hash_lookup (elf_hash_table (info), name,
2250 false, false, true);
2252 && (h->root.type == bfd_link_hash_defined
2253 || h->root.type == bfd_link_hash_defweak))
2255 dyn.d_un.d_val = h->root.u.def.value;
2256 o = h->root.u.def.section;
2257 if (o->output_section != NULL)
2258 dyn.d_un.d_val += (o->output_section->vma
2259 + o->output_offset);
2262 /* The symbol is imported from another shared
2263 library and does not apply to this one. */
2267 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2281 o = bfd_get_section_by_name (abfd, name);
2282 BFD_ASSERT (o != NULL);
2283 dyn.d_un.d_ptr = o->vma;
2284 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2291 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
2296 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
2298 Elf_Internal_Shdr *hdr;
2300 hdr = elf_elfsections (abfd)[i];
2301 if (hdr->sh_type == type
2302 && (hdr->sh_flags & SHF_ALLOC) != 0)
2304 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
2305 dyn.d_un.d_val += hdr->sh_size;
2308 if (dyn.d_un.d_val == 0
2309 || hdr->sh_addr < dyn.d_un.d_val)
2310 dyn.d_un.d_val = hdr->sh_addr;
2314 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2320 /* If we have created any dynamic sections, then output them. */
2323 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
2326 for (o = dynobj->sections; o != NULL; o = o->next)
2328 if ((o->flags & SEC_HAS_CONTENTS) == 0
2329 || o->_raw_size == 0)
2331 if ((o->flags & SEC_IN_MEMORY) == 0)
2333 /* At this point, we are only interested in sections
2334 created by elf_link_create_dynamic_sections. FIXME:
2335 This test is fragile. */
2338 if ((elf_section_data (o->output_section)->this_hdr.sh_type
2340 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
2342 if (! bfd_set_section_contents (abfd, o->output_section,
2343 o->contents, o->output_offset,
2351 /* The contents of the .dynstr section are actually in a
2353 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
2354 if (bfd_seek (abfd, off, SEEK_SET) != 0
2355 || ! _bfd_stringtab_emit (abfd,
2356 elf_hash_table (info)->dynstr))
2362 /* If we have optimized stabs strings, output them. */
2363 if (elf_hash_table (info)->stab_info != NULL)
2365 if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
2369 if (finfo.symstrtab != NULL)
2370 _bfd_stringtab_free (finfo.symstrtab);
2371 if (finfo.contents != NULL)
2372 free (finfo.contents);
2373 if (finfo.external_relocs != NULL)
2374 free (finfo.external_relocs);
2375 if (finfo.internal_relocs != NULL)
2376 free (finfo.internal_relocs);
2377 if (finfo.external_syms != NULL)
2378 free (finfo.external_syms);
2379 if (finfo.internal_syms != NULL)
2380 free (finfo.internal_syms);
2381 if (finfo.indices != NULL)
2382 free (finfo.indices);
2383 if (finfo.sections != NULL)
2384 free (finfo.sections);
2385 if (finfo.symbuf != NULL)
2386 free (finfo.symbuf);
2387 for (o = abfd->sections; o != NULL; o = o->next)
2389 if ((o->flags & SEC_RELOC) != 0
2390 && elf_section_data (o)->rel_hashes != NULL)
2391 free (elf_section_data (o)->rel_hashes);
2394 elf_tdata (abfd)->linker = true;
2399 if (finfo.symstrtab != NULL)
2400 _bfd_stringtab_free (finfo.symstrtab);
2401 if (finfo.contents != NULL)
2402 free (finfo.contents);
2403 if (finfo.external_relocs != NULL)
2404 free (finfo.external_relocs);
2405 if (finfo.internal_relocs != NULL)
2406 free (finfo.internal_relocs);
2407 if (finfo.external_syms != NULL)
2408 free (finfo.external_syms);
2409 if (finfo.internal_syms != NULL)
2410 free (finfo.internal_syms);
2411 if (finfo.indices != NULL)
2412 free (finfo.indices);
2413 if (finfo.sections != NULL)
2414 free (finfo.sections);
2415 if (finfo.symbuf != NULL)
2416 free (finfo.symbuf);
2417 for (o = abfd->sections; o != NULL; o = o->next)
2419 if ((o->flags & SEC_RELOC) != 0
2420 && elf_section_data (o)->rel_hashes != NULL)
2421 free (elf_section_data (o)->rel_hashes);
2427 /* Add a symbol to the output symbol table. */
2430 elf_link_output_sym (finfo, name, elfsym, input_sec)
2431 struct elf_final_link_info *finfo;
2433 Elf_Internal_Sym *elfsym;
2434 asection *input_sec;
2436 boolean (*output_symbol_hook) PARAMS ((bfd *,
2437 struct bfd_link_info *info,
2442 output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
2443 elf_backend_link_output_symbol_hook;
2444 if (output_symbol_hook != NULL)
2446 if (! ((*output_symbol_hook)
2447 (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
2451 if (name == (const char *) NULL || *name == '\0')
2452 elfsym->st_name = 0;
2455 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
2458 if (elfsym->st_name == (unsigned long) -1)
2462 if (finfo->symbuf_count >= finfo->symbuf_size)
2464 if (! elf_link_flush_output_syms (finfo))
2468 elf_swap_symbol_out (finfo->output_bfd, elfsym,
2469 (PTR) (finfo->symbuf + finfo->symbuf_count));
2470 ++finfo->symbuf_count;
2472 ++finfo->output_bfd->symcount;
2477 /* Flush the output symbols to the file. */
2480 elf_link_flush_output_syms (finfo)
2481 struct elf_final_link_info *finfo;
2483 if (finfo->symbuf_count > 0)
2485 Elf_Internal_Shdr *symtab;
2487 symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
2489 if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
2491 || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
2492 sizeof (Elf_External_Sym), finfo->output_bfd)
2493 != finfo->symbuf_count * sizeof (Elf_External_Sym)))
2496 symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
2498 finfo->symbuf_count = 0;
2504 /* Add an external symbol to the symbol table. This is called from
2505 the hash table traversal routine. */
2508 elf_link_output_extsym (h, data)
2509 struct elf_link_hash_entry *h;
2512 struct elf_finfo_failed *eif = (struct elf_finfo_failed *) data;
2513 struct elf_final_link_info *finfo = eif->finfo;
2515 Elf_Internal_Sym sym;
2516 asection *input_sec;
2518 /* If we are not creating a shared library, and this symbol is
2519 referenced by a shared library but is not defined anywhere, then
2520 warn that it is undefined. If we do not do this, the runtime
2521 linker will complain that the symbol is undefined when the
2522 program is run. We don't have to worry about symbols that are
2523 referenced by regular files, because we will already have issued
2524 warnings for them. */
2525 if (! finfo->info->relocateable
2526 && ! finfo->info->shared
2527 && h->root.type == bfd_link_hash_undefined
2528 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
2529 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2531 if (! ((*finfo->info->callbacks->undefined_symbol)
2532 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
2533 (asection *) NULL, 0)))
2540 /* We don't want to output symbols that have never been mentioned by
2541 a regular file, or that we have been told to strip. However, if
2542 h->indx is set to -2, the symbol is used by a reloc and we must
2546 else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2547 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2548 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2549 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2551 else if (finfo->info->strip == strip_all
2552 || (finfo->info->strip == strip_some
2553 && bfd_hash_lookup (finfo->info->keep_hash,
2554 h->root.root.string,
2555 false, false) == NULL))
2560 /* If we're stripping it, and it's not a dynamic symbol, there's
2561 nothing else to do. */
2562 if (strip && h->dynindx == -1)
2566 sym.st_size = h->size;
2568 if (h->root.type == bfd_link_hash_undefweak
2569 || h->root.type == bfd_link_hash_defweak)
2570 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
2572 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
2574 switch (h->root.type)
2577 case bfd_link_hash_new:
2581 case bfd_link_hash_undefined:
2582 input_sec = bfd_und_section_ptr;
2583 sym.st_shndx = SHN_UNDEF;
2586 case bfd_link_hash_undefweak:
2587 input_sec = bfd_und_section_ptr;
2588 sym.st_shndx = SHN_UNDEF;
2591 case bfd_link_hash_defined:
2592 case bfd_link_hash_defweak:
2594 input_sec = h->root.u.def.section;
2595 if (input_sec->output_section != NULL)
2598 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
2599 input_sec->output_section);
2600 if (sym.st_shndx == (unsigned short) -1)
2606 /* ELF symbols in relocateable files are section relative,
2607 but in nonrelocateable files they are virtual
2609 sym.st_value = h->root.u.def.value + input_sec->output_offset;
2610 if (! finfo->info->relocateable)
2611 sym.st_value += input_sec->output_section->vma;
2615 BFD_ASSERT ((bfd_get_flavour (input_sec->owner)
2616 == bfd_target_elf_flavour)
2617 && elf_elfheader (input_sec->owner)->e_type == ET_DYN);
2618 sym.st_shndx = SHN_UNDEF;
2619 input_sec = bfd_und_section_ptr;
2624 case bfd_link_hash_common:
2625 input_sec = bfd_com_section_ptr;
2626 sym.st_shndx = SHN_COMMON;
2627 sym.st_value = 1 << h->root.u.c.p->alignment_power;
2630 case bfd_link_hash_indirect:
2631 case bfd_link_hash_warning:
2632 /* We can't represent these symbols in ELF. A warning symbol
2633 may have come from a .gnu.warning.SYMBOL section anyhow. We
2634 just put the target symbol in the hash table. If the target
2635 symbol does not really exist, don't do anything. */
2636 if (h->root.u.i.link->type == bfd_link_hash_new)
2638 return (elf_link_output_extsym
2639 ((struct elf_link_hash_entry *) h->root.u.i.link, data));
2642 /* If this symbol should be put in the .dynsym section, then put it
2643 there now. We have already know the symbol index. We also fill
2644 in the entry in the .hash section. */
2645 if (h->dynindx != -1
2646 && elf_hash_table (finfo->info)->dynamic_sections_created)
2648 struct elf_backend_data *bed;
2651 bfd_byte *bucketpos;
2654 sym.st_name = h->dynstr_index;
2656 /* Give the processor backend a chance to tweak the symbol
2657 value, and also to finish up anything that needs to be done
2659 bed = get_elf_backend_data (finfo->output_bfd);
2660 if (! ((*bed->elf_backend_finish_dynamic_symbol)
2661 (finfo->output_bfd, finfo->info, h, &sym)))
2667 elf_swap_symbol_out (finfo->output_bfd, &sym,
2668 (PTR) (((Elf_External_Sym *)
2669 finfo->dynsym_sec->contents)
2672 bucketcount = elf_hash_table (finfo->info)->bucketcount;
2673 bucket = (bfd_elf_hash ((const unsigned char *) h->root.root.string)
2675 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
2676 + (bucket + 2) * (ARCH_SIZE / 8));
2677 chain = get_word (finfo->output_bfd, bucketpos);
2678 put_word (finfo->output_bfd, h->dynindx, bucketpos);
2679 put_word (finfo->output_bfd, chain,
2680 ((bfd_byte *) finfo->hash_sec->contents
2681 + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
2684 /* If we're stripping it, then it was just a dynamic symbol, and
2685 there's nothing else to do. */
2689 h->indx = finfo->output_bfd->symcount;
2691 if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
2700 /* Link an input file into the linker output file. This function
2701 handles all the sections and relocations of the input file at once.
2702 This is so that we only have to read the local symbols once, and
2703 don't have to keep them in memory. */
2706 elf_link_input_bfd (finfo, input_bfd)
2707 struct elf_final_link_info *finfo;
2710 boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
2711 bfd *, asection *, bfd_byte *,
2712 Elf_Internal_Rela *,
2713 Elf_Internal_Sym *, asection **));
2715 Elf_Internal_Shdr *symtab_hdr;
2718 Elf_External_Sym *esym;
2719 Elf_External_Sym *esymend;
2720 Elf_Internal_Sym *isym;
2722 asection **ppsection;
2725 output_bfd = finfo->output_bfd;
2727 get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
2729 /* If this is a dynamic object, we don't want to do anything here:
2730 we don't want the local symbols, and we don't want the section
2732 if (elf_elfheader (input_bfd)->e_type == ET_DYN)
2735 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2736 if (elf_bad_symtab (input_bfd))
2738 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
2743 locsymcount = symtab_hdr->sh_info;
2744 extsymoff = symtab_hdr->sh_info;
2747 /* Read the local symbols. */
2749 && (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2750 || (bfd_read (finfo->external_syms, sizeof (Elf_External_Sym),
2751 locsymcount, input_bfd)
2752 != locsymcount * sizeof (Elf_External_Sym))))
2755 /* Swap in the local symbols and write out the ones which we know
2756 are going into the output file. */
2757 esym = finfo->external_syms;
2758 esymend = esym + locsymcount;
2759 isym = finfo->internal_syms;
2760 pindex = finfo->indices;
2761 ppsection = finfo->sections;
2762 for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
2766 Elf_Internal_Sym osym;
2768 elf_swap_symbol_in (input_bfd, esym, isym);
2771 if (elf_bad_symtab (input_bfd))
2773 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
2780 if (isym->st_shndx == SHN_UNDEF)
2781 isec = bfd_und_section_ptr;
2782 else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
2783 isec = section_from_elf_index (input_bfd, isym->st_shndx);
2784 else if (isym->st_shndx == SHN_ABS)
2785 isec = bfd_abs_section_ptr;
2786 else if (isym->st_shndx == SHN_COMMON)
2787 isec = bfd_com_section_ptr;
2796 /* Don't output the first, undefined, symbol. */
2797 if (esym == finfo->external_syms)
2800 /* If we are stripping all symbols, we don't want to output this
2802 if (finfo->info->strip == strip_all)
2805 /* We never output section symbols. Instead, we use the section
2806 symbol of the corresponding section in the output file. */
2807 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2810 /* If we are discarding all local symbols, we don't want to
2811 output this one. If we are generating a relocateable output
2812 file, then some of the local symbols may be required by
2813 relocs; we output them below as we discover that they are
2815 if (finfo->info->discard == discard_all)
2818 /* Get the name of the symbol. */
2819 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
2824 /* See if we are discarding symbols with this name. */
2825 if ((finfo->info->strip == strip_some
2826 && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
2828 || (finfo->info->discard == discard_l
2829 && strncmp (name, finfo->info->lprefix,
2830 finfo->info->lprefix_len) == 0))
2833 /* If we get here, we are going to output this symbol. */
2837 /* Adjust the section index for the output file. */
2838 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
2839 isec->output_section);
2840 if (osym.st_shndx == (unsigned short) -1)
2843 *pindex = output_bfd->symcount;
2845 /* ELF symbols in relocateable files are section relative, but
2846 in executable files they are virtual addresses. Note that
2847 this code assumes that all ELF sections have an associated
2848 BFD section with a reasonable value for output_offset; below
2849 we assume that they also have a reasonable value for
2850 output_section. Any special sections must be set up to meet
2851 these requirements. */
2852 osym.st_value += isec->output_offset;
2853 if (! finfo->info->relocateable)
2854 osym.st_value += isec->output_section->vma;
2856 if (! elf_link_output_sym (finfo, name, &osym, isec))
2860 /* Relocate the contents of each section. */
2861 for (o = input_bfd->sections; o != NULL; o = o->next)
2863 if (! o->linker_mark)
2865 /* This section was omitted from the link. */
2869 if ((o->flags & SEC_HAS_CONTENTS) == 0
2870 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
2873 if ((o->flags & SEC_IN_MEMORY) != 0
2874 && input_bfd == elf_hash_table (finfo->info)->dynobj)
2876 /* Section was created by elf_link_create_dynamic_sections.
2877 FIXME: This test is fragile. */
2881 /* Read the contents of the section. */
2882 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2883 (file_ptr) 0, o->_raw_size))
2886 if ((o->flags & SEC_RELOC) != 0)
2888 Elf_Internal_Rela *internal_relocs;
2890 /* Get the swapped relocs. */
2891 internal_relocs = elf_link_read_relocs (input_bfd, o,
2892 finfo->external_relocs,
2893 finfo->internal_relocs,
2895 if (internal_relocs == NULL
2896 && o->reloc_count > 0)
2899 /* Relocate the section by invoking a back end routine.
2901 The back end routine is responsible for adjusting the
2902 section contents as necessary, and (if using Rela relocs
2903 and generating a relocateable output file) adjusting the
2904 reloc addend as necessary.
2906 The back end routine does not have to worry about setting
2907 the reloc address or the reloc symbol index.
2909 The back end routine is given a pointer to the swapped in
2910 internal symbols, and can access the hash table entries
2911 for the external symbols via elf_sym_hashes (input_bfd).
2913 When generating relocateable output, the back end routine
2914 must handle STB_LOCAL/STT_SECTION symbols specially. The
2915 output symbol is going to be a section symbol
2916 corresponding to the output section, which will require
2917 the addend to be adjusted. */
2919 if (! (*relocate_section) (output_bfd, finfo->info,
2923 finfo->internal_syms,
2927 if (finfo->info->relocateable)
2929 Elf_Internal_Rela *irela;
2930 Elf_Internal_Rela *irelaend;
2931 struct elf_link_hash_entry **rel_hash;
2932 Elf_Internal_Shdr *input_rel_hdr;
2933 Elf_Internal_Shdr *output_rel_hdr;
2935 /* Adjust the reloc addresses and symbol indices. */
2937 irela = internal_relocs;
2938 irelaend = irela + o->reloc_count;
2939 rel_hash = (elf_section_data (o->output_section)->rel_hashes
2940 + o->output_section->reloc_count);
2941 for (; irela < irelaend; irela++, rel_hash++)
2943 unsigned long r_symndx;
2944 Elf_Internal_Sym *isym;
2947 irela->r_offset += o->output_offset;
2949 r_symndx = ELF_R_SYM (irela->r_info);
2954 if (r_symndx >= locsymcount
2955 || (elf_bad_symtab (input_bfd)
2956 && finfo->sections[r_symndx] == NULL))
2960 /* This is a reloc against a global symbol. We
2961 have not yet output all the local symbols, so
2962 we do not know the symbol index of any global
2963 symbol. We set the rel_hash entry for this
2964 reloc to point to the global hash table entry
2965 for this symbol. The symbol index is then
2966 set at the end of elf_bfd_final_link. */
2967 indx = r_symndx - extsymoff;
2968 *rel_hash = elf_sym_hashes (input_bfd)[indx];
2970 /* Setting the index to -2 tells
2971 elf_link_output_extsym that this symbol is
2973 BFD_ASSERT ((*rel_hash)->indx < 0);
2974 (*rel_hash)->indx = -2;
2979 /* This is a reloc against a local symbol. */
2982 isym = finfo->internal_syms + r_symndx;
2983 sec = finfo->sections[r_symndx];
2984 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2986 /* I suppose the backend ought to fill in the
2987 section of any STT_SECTION symbol against a
2988 processor specific section. */
2989 if (sec != NULL && bfd_is_abs_section (sec))
2991 else if (sec == NULL || sec->owner == NULL)
2993 bfd_set_error (bfd_error_bad_value);
2998 r_symndx = sec->output_section->target_index;
2999 BFD_ASSERT (r_symndx != 0);
3004 if (finfo->indices[r_symndx] == -1)
3010 if (finfo->info->strip == strip_all)
3012 /* You can't do ld -r -s. */
3013 bfd_set_error (bfd_error_invalid_operation);
3017 /* This symbol was skipped earlier, but
3018 since it is needed by a reloc, we
3019 must output it now. */
3020 link = symtab_hdr->sh_link;
3021 name = bfd_elf_string_from_elf_section (input_bfd,
3027 osec = sec->output_section;
3029 _bfd_elf_section_from_bfd_section (output_bfd,
3031 if (isym->st_shndx == (unsigned short) -1)
3034 isym->st_value += sec->output_offset;
3035 if (! finfo->info->relocateable)
3036 isym->st_value += osec->vma;
3038 finfo->indices[r_symndx] = output_bfd->symcount;
3040 if (! elf_link_output_sym (finfo, name, isym, sec))
3044 r_symndx = finfo->indices[r_symndx];
3047 irela->r_info = ELF_R_INFO (r_symndx,
3048 ELF_R_TYPE (irela->r_info));
3051 /* Swap out the relocs. */
3052 input_rel_hdr = &elf_section_data (o)->rel_hdr;
3053 output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
3054 BFD_ASSERT (output_rel_hdr->sh_entsize
3055 == input_rel_hdr->sh_entsize);
3056 irela = internal_relocs;
3057 irelaend = irela + o->reloc_count;
3058 if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
3060 Elf_External_Rel *erel;
3062 erel = ((Elf_External_Rel *) output_rel_hdr->contents
3063 + o->output_section->reloc_count);
3064 for (; irela < irelaend; irela++, erel++)
3066 Elf_Internal_Rel irel;
3068 irel.r_offset = irela->r_offset;
3069 irel.r_info = irela->r_info;
3070 BFD_ASSERT (irela->r_addend == 0);
3071 elf_swap_reloc_out (output_bfd, &irel, erel);
3076 Elf_External_Rela *erela;
3078 BFD_ASSERT (input_rel_hdr->sh_entsize
3079 == sizeof (Elf_External_Rela));
3080 erela = ((Elf_External_Rela *) output_rel_hdr->contents
3081 + o->output_section->reloc_count);
3082 for (; irela < irelaend; irela++, erela++)
3083 elf_swap_reloca_out (output_bfd, irela, erela);
3086 o->output_section->reloc_count += o->reloc_count;
3090 /* Write out the modified section contents. */
3091 if (elf_section_data (o)->stab_info == NULL)
3093 if (! bfd_set_section_contents (output_bfd, o->output_section,
3094 finfo->contents, o->output_offset,
3095 (o->_cooked_size != 0
3102 if (! _bfd_write_section_stabs (output_bfd, o,
3103 &elf_section_data (o)->stab_info,
3112 /* Generate a reloc when linking an ELF file. This is a reloc
3113 requested by the linker, and does come from any input file. This
3114 is used to build constructor and destructor tables when linking
3118 elf_reloc_link_order (output_bfd, info, output_section, link_order)
3120 struct bfd_link_info *info;
3121 asection *output_section;
3122 struct bfd_link_order *link_order;
3124 reloc_howto_type *howto;
3128 struct elf_link_hash_entry **rel_hash_ptr;
3129 Elf_Internal_Shdr *rel_hdr;
3131 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
3134 bfd_set_error (bfd_error_bad_value);
3138 addend = link_order->u.reloc.p->addend;
3140 /* Figure out the symbol index. */
3141 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
3142 + output_section->reloc_count);
3143 if (link_order->type == bfd_section_reloc_link_order)
3145 indx = link_order->u.reloc.p->u.section->target_index;
3146 BFD_ASSERT (indx != 0);
3147 *rel_hash_ptr = NULL;
3151 struct elf_link_hash_entry *h;
3153 /* Treat a reloc against a defined symbol as though it were
3154 actually against the section. */
3155 h = ((struct elf_link_hash_entry *)
3156 bfd_wrapped_link_hash_lookup (output_bfd, info,
3157 link_order->u.reloc.p->u.name,
3158 false, false, true));
3160 && (h->root.type == bfd_link_hash_defined
3161 || h->root.type == bfd_link_hash_defweak))
3165 section = h->root.u.def.section;
3166 indx = section->output_section->target_index;
3167 *rel_hash_ptr = NULL;
3168 /* It seems that we ought to add the symbol value to the
3169 addend here, but in practice it has already been added
3170 because it was passed to constructor_callback. */
3171 addend += section->output_section->vma + section->output_offset;
3175 /* Setting the index to -2 tells elf_link_output_extsym that
3176 this symbol is used by a reloc. */
3183 if (! ((*info->callbacks->unattached_reloc)
3184 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
3185 (asection *) NULL, (bfd_vma) 0)))
3191 /* If this is an inplace reloc, we must write the addend into the
3193 if (howto->partial_inplace && addend != 0)
3196 bfd_reloc_status_type rstat;
3200 size = bfd_get_reloc_size (howto);
3201 buf = (bfd_byte *) bfd_zmalloc (size);
3202 if (buf == (bfd_byte *) NULL)
3204 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
3210 case bfd_reloc_outofrange:
3212 case bfd_reloc_overflow:
3213 if (! ((*info->callbacks->reloc_overflow)
3215 (link_order->type == bfd_section_reloc_link_order
3216 ? bfd_section_name (output_bfd,
3217 link_order->u.reloc.p->u.section)
3218 : link_order->u.reloc.p->u.name),
3219 howto->name, addend, (bfd *) NULL, (asection *) NULL,
3227 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
3228 (file_ptr) link_order->offset, size);
3234 /* The address of a reloc is relative to the section in a
3235 relocateable file, and is a virtual address in an executable
3237 offset = link_order->offset;
3238 if (! info->relocateable)
3239 offset += output_section->vma;
3241 rel_hdr = &elf_section_data (output_section)->rel_hdr;
3243 if (rel_hdr->sh_type == SHT_REL)
3245 Elf_Internal_Rel irel;
3246 Elf_External_Rel *erel;
3248 irel.r_offset = offset;
3249 irel.r_info = ELF_R_INFO (indx, howto->type);
3250 erel = ((Elf_External_Rel *) rel_hdr->contents
3251 + output_section->reloc_count);
3252 elf_swap_reloc_out (output_bfd, &irel, erel);
3256 Elf_Internal_Rela irela;
3257 Elf_External_Rela *erela;
3259 irela.r_offset = offset;
3260 irela.r_info = ELF_R_INFO (indx, howto->type);
3261 irela.r_addend = addend;
3262 erela = ((Elf_External_Rela *) rel_hdr->contents
3263 + output_section->reloc_count);
3264 elf_swap_reloca_out (output_bfd, &irela, erela);
3267 ++output_section->reloc_count;
3273 /* Allocate a pointer to live in a linker created section. */
3276 elf_create_pointer_linker_section (abfd, info, lsect, h, rel)
3278 struct bfd_link_info *info;
3279 elf_linker_section_t *lsect;
3280 struct elf_link_hash_entry *h;
3281 const Elf_Internal_Rela *rel;
3283 elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
3284 elf_linker_section_pointers_t *linker_section_ptr;
3285 unsigned long r_symndx = ELF_R_SYM (rel->r_info);;
3287 BFD_ASSERT (lsect != NULL);
3289 /* Is this a global symbol? */
3292 /* Has this symbol already been allocated, if so, our work is done */
3293 if (_bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
3298 ptr_linker_section_ptr = &h->linker_section_pointer;
3299 /* Make sure this symbol is output as a dynamic symbol. */
3300 if (h->dynindx == -1)
3302 if (! elf_link_record_dynamic_symbol (info, h))
3306 if (lsect->rel_section)
3307 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
3310 else /* Allocation of a pointer to a local symbol */
3312 elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
3314 /* Allocate a table to hold the local symbols if first time */
3317 int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
3318 register unsigned int i;
3320 ptr = (elf_linker_section_pointers_t **)
3321 bfd_alloc (abfd, num_symbols * sizeof (elf_linker_section_pointers_t *));
3326 elf_local_ptr_offsets (abfd) = ptr;
3327 for (i = 0; i < num_symbols; i++)
3328 ptr[i] = (elf_linker_section_pointers_t *)0;
3331 /* Has this symbol already been allocated, if so, our work is done */
3332 if (_bfd_elf_find_pointer_linker_section (ptr[r_symndx],
3337 ptr_linker_section_ptr = &ptr[r_symndx];
3341 /* If we are generating a shared object, we need to
3342 output a R_<xxx>_RELATIVE reloc so that the
3343 dynamic linker can adjust this GOT entry. */
3344 BFD_ASSERT (lsect->rel_section != NULL);
3345 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
3349 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3350 from internal memory. */
3351 BFD_ASSERT (ptr_linker_section_ptr != NULL);
3352 linker_section_ptr = (elf_linker_section_pointers_t *)
3353 bfd_alloc (abfd, sizeof (elf_linker_section_pointers_t));
3355 if (!linker_section_ptr)
3358 linker_section_ptr->next = *ptr_linker_section_ptr;
3359 linker_section_ptr->addend = rel->r_addend;
3360 linker_section_ptr->which = lsect->which;
3361 linker_section_ptr->written_address_p = false;
3362 *ptr_linker_section_ptr = linker_section_ptr;
3364 if (lsect->hole_size && lsect->hole_offset < lsect->max_hole_offset)
3366 linker_section_ptr->offset = lsect->section->_raw_size - lsect->hole_size;
3367 lsect->hole_offset += ARCH_SIZE / 8;
3368 lsect->sym_offset += ARCH_SIZE / 8;
3369 if (lsect->sym_hash) /* Bump up symbol value if needed */
3370 lsect->sym_hash->root.u.def.value += ARCH_SIZE / 8;
3373 linker_section_ptr->offset = lsect->section->_raw_size;
3375 lsect->section->_raw_size += ARCH_SIZE / 8;
3378 fprintf (stderr, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3379 lsect->name, (long)linker_section_ptr->offset, (long)lsect->section->_raw_size);
3387 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3390 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3393 /* Fill in the address for a pointer generated in alinker section. */
3396 elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h, relocation, rel, relative_reloc)
3399 struct bfd_link_info *info;
3400 elf_linker_section_t *lsect;
3401 struct elf_link_hash_entry *h;
3403 const Elf_Internal_Rela *rel;
3406 elf_linker_section_pointers_t *linker_section_ptr;
3408 BFD_ASSERT (lsect != NULL);
3410 if (h != NULL) /* global symbol */
3412 linker_section_ptr = _bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
3416 BFD_ASSERT (linker_section_ptr != NULL);
3418 if (! elf_hash_table (info)->dynamic_sections_created
3421 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3423 /* This is actually a static link, or it is a
3424 -Bsymbolic link and the symbol is defined
3425 locally. We must initialize this entry in the
3428 When doing a dynamic link, we create a .rela.<xxx>
3429 relocation entry to initialize the value. This
3430 is done in the finish_dynamic_symbol routine. */
3431 if (!linker_section_ptr->written_address_p)
3433 linker_section_ptr->written_address_p = true;
3434 bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
3435 lsect->section->contents + linker_section_ptr->offset);
3439 else /* local symbol */
3441 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
3442 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
3443 BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
3444 linker_section_ptr = _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd)[r_symndx],
3448 BFD_ASSERT (linker_section_ptr != NULL);
3450 /* Write out pointer if it hasn't been rewritten out before */
3451 if (!linker_section_ptr->written_address_p)
3453 linker_section_ptr->written_address_p = true;
3454 bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
3455 lsect->section->contents + linker_section_ptr->offset);
3459 asection *srel = lsect->rel_section;
3460 Elf_Internal_Rela outrel;
3462 /* We need to generate a relative reloc for the dynamic linker. */
3464 lsect->rel_section = srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
3467 BFD_ASSERT (srel != NULL);
3469 outrel.r_offset = (lsect->section->output_section->vma
3470 + lsect->section->output_offset
3471 + linker_section_ptr->offset);
3472 outrel.r_info = ELF_R_INFO (0, relative_reloc);
3473 outrel.r_addend = 0;
3474 elf_swap_reloca_out (output_bfd, &outrel,
3475 (((Elf_External_Rela *)
3476 lsect->section->contents)
3477 + lsect->section->reloc_count));
3478 ++lsect->section->reloc_count;
3483 relocation = (lsect->section->output_offset
3484 + linker_section_ptr->offset
3485 - lsect->hole_offset
3486 - lsect->sym_offset);
3489 fprintf (stderr, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3490 lsect->name, (long)relocation, (long)relocation);
3493 /* Subtract out the addend, because it will get added back in by the normal
3495 return relocation - linker_section_ptr->addend;