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_needed_name, we use that. Otherwise, we just use the
384 file name. If the generic linker put a null string into
385 elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
386 even if there is a DT_SONAME entry. */
388 name = bfd_get_filename (abfd);
389 if (elf_dt_needed_name (abfd) != NULL)
391 name = elf_dt_needed_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 (add_needed && 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))
526 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
528 || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
529 != extsymcount * sizeof (Elf_External_Sym)))
534 esymend = buf + extsymcount;
535 for (esym = buf; esym < esymend; esym++, sym_hash++)
537 Elf_Internal_Sym sym;
543 struct elf_link_hash_entry *h;
545 boolean size_change_ok, type_change_ok;
548 elf_swap_symbol_in (abfd, esym, &sym);
550 flags = BSF_NO_FLAGS;
552 value = sym.st_value;
555 bind = ELF_ST_BIND (sym.st_info);
556 if (bind == STB_LOCAL)
558 /* This should be impossible, since ELF requires that all
559 global symbols follow all local symbols, and that sh_info
560 point to the first global symbol. Unfortunatealy, Irix 5
564 else if (bind == STB_GLOBAL)
566 if (sym.st_shndx != SHN_UNDEF
567 && sym.st_shndx != SHN_COMMON)
572 else if (bind == STB_WEAK)
576 /* Leave it up to the processor backend. */
579 if (sym.st_shndx == SHN_UNDEF)
580 sec = bfd_und_section_ptr;
581 else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
583 sec = section_from_elf_index (abfd, sym.st_shndx);
587 sec = bfd_abs_section_ptr;
589 else if (sym.st_shndx == SHN_ABS)
590 sec = bfd_abs_section_ptr;
591 else if (sym.st_shndx == SHN_COMMON)
593 sec = bfd_com_section_ptr;
594 /* What ELF calls the size we call the value. What ELF
595 calls the value we call the alignment. */
600 /* Leave it up to the processor backend. */
603 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
604 if (name == (const char *) NULL)
609 if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
613 /* The hook function sets the name to NULL if this symbol
614 should be skipped for some reason. */
615 if (name == (const char *) NULL)
619 /* Sanity check that all possibilities were handled. */
620 if (sec == (asection *) NULL)
622 bfd_set_error (bfd_error_bad_value);
626 if (bfd_is_und_section (sec)
627 || bfd_is_com_section (sec))
632 size_change_ok = false;
633 type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
634 if (info->hash->creator->flavour == bfd_target_elf_flavour)
636 /* We need to look up the symbol now in order to get some of
637 the dynamic object handling right. We pass the hash
638 table entry in to _bfd_generic_link_add_one_symbol so
639 that it does not have to look it up again. */
640 h = elf_link_hash_lookup (elf_hash_table (info), name,
646 if (h->root.type == bfd_link_hash_new)
647 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
649 while (h->root.type == bfd_link_hash_indirect
650 || h->root.type == bfd_link_hash_warning)
651 h = (struct elf_link_hash_entry *) h->root.u.i.link;
653 /* It's OK to change the type if it used to be a weak
655 if (h->root.type == bfd_link_hash_defweak
656 || h->root.type == bfd_link_hash_undefweak)
657 type_change_ok = true;
659 /* It's OK to change the size if it used to be a weak
660 definition, or if it used to be undefined, or if we will
661 be overriding an old definition. */
663 || h->root.type == bfd_link_hash_undefined)
664 size_change_ok = true;
666 /* If we are looking at a dynamic object, and this is a
667 definition, we need to see if it has already been defined
668 by some other object. If it has, we want to use the
669 existing definition, and we do not want to report a
670 multiple symbol definition error; we do this by
671 clobbering sec to be bfd_und_section_ptr. */
672 if (dynamic && definition)
674 if (h->root.type == bfd_link_hash_defined
675 || h->root.type == bfd_link_hash_defweak
676 || (h->root.type == bfd_link_hash_common
677 && bind == STB_WEAK))
679 sec = bfd_und_section_ptr;
681 size_change_ok = true;
685 /* Similarly, if we are not looking at a dynamic object, and
686 we have a definition, we want to override any definition
687 we may have from a dynamic object. Symbols from regular
688 files always take precedence over symbols from dynamic
689 objects, even if they are defined after the dynamic
690 object in the link. */
693 && (h->root.type == bfd_link_hash_defined
694 || h->root.type == bfd_link_hash_defweak)
695 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
696 && (bfd_get_flavour (h->root.u.def.section->owner)
697 == bfd_target_elf_flavour)
698 && (elf_elfheader (h->root.u.def.section->owner)->e_type
701 /* Change the hash table entry to undefined, and let
702 _bfd_generic_link_add_one_symbol do the right thing
703 with the new definition. */
704 h->root.type = bfd_link_hash_undefined;
705 h->root.u.undef.abfd = h->root.u.def.section->owner;
706 size_change_ok = true;
710 if (! (_bfd_generic_link_add_one_symbol
711 (info, abfd, name, flags, sec, value, (const char *) NULL,
712 false, collect, (struct bfd_link_hash_entry **) sym_hash)))
716 while (h->root.type == bfd_link_hash_indirect
717 || h->root.type == bfd_link_hash_warning)
718 h = (struct elf_link_hash_entry *) h->root.u.i.link;
724 && (flags & BSF_WEAK) != 0
725 && ELF_ST_TYPE (sym.st_info) != STT_FUNC
726 && info->hash->creator->flavour == bfd_target_elf_flavour
727 && h->weakdef == NULL)
729 /* Keep a list of all weak defined non function symbols from
730 a dynamic object, using the weakdef field. Later in this
731 function we will set the weakdef field to the correct
732 value. We only put non-function symbols from dynamic
733 objects on this list, because that happens to be the only
734 time we need to know the normal symbol corresponding to a
735 weak symbol, and the information is time consuming to
736 figure out. If the weakdef field is not already NULL,
737 then this symbol was already defined by some previous
738 dynamic object, and we will be using that previous
739 definition anyhow. */
746 /* Get the alignment of a common symbol. */
747 if (sym.st_shndx == SHN_COMMON
748 && h->root.type == bfd_link_hash_common)
749 h->root.u.c.p->alignment_power = bfd_log2 (sym.st_value);
751 if (info->hash->creator->flavour == bfd_target_elf_flavour)
757 /* Remember the symbol size and type. */
759 && (definition || h->size == 0))
761 if (h->size != 0 && h->size != sym.st_size && ! size_change_ok)
762 (*_bfd_error_handler)
763 ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
764 name, (unsigned long) h->size, (unsigned long) sym.st_size,
765 bfd_get_filename (abfd));
767 h->size = sym.st_size;
769 if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE
770 && (definition || h->type == STT_NOTYPE))
772 if (h->type != STT_NOTYPE
773 && h->type != ELF_ST_TYPE (sym.st_info)
775 (*_bfd_error_handler)
776 ("Warning: type of symbol `%s' changed from %d to %d in %s",
777 name, h->type, ELF_ST_TYPE (sym.st_info),
778 bfd_get_filename (abfd));
780 h->type = ELF_ST_TYPE (sym.st_info);
783 /* Set a flag in the hash table entry indicating the type of
784 reference or definition we just found. Keep a count of
785 the number of dynamic symbols we find. A dynamic symbol
786 is one which is referenced or defined by both a regular
787 object and a shared object, or one which is referenced or
788 defined by more than one shared object. */
789 old_flags = h->elf_link_hash_flags;
794 new_flag = ELF_LINK_HASH_REF_REGULAR;
796 new_flag = ELF_LINK_HASH_DEF_REGULAR;
798 || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
799 | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
805 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
807 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
808 if ((old_flags & new_flag) != 0
809 || (old_flags & (ELF_LINK_HASH_DEF_REGULAR
810 | ELF_LINK_HASH_REF_REGULAR)) != 0
811 || (h->weakdef != NULL
812 && (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
813 | ELF_LINK_HASH_REF_DYNAMIC)) != 0))
817 h->elf_link_hash_flags |= new_flag;
818 if (dynsym && h->dynindx == -1)
820 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
822 if (h->weakdef != NULL
824 && h->weakdef->dynindx == -1)
826 if (! _bfd_elf_link_record_dynamic_symbol (info,
834 /* Now set the weakdefs field correctly for all the weak defined
835 symbols we found. The only way to do this is to search all the
836 symbols. Since we only need the information for non functions in
837 dynamic objects, that's the only time we actually put anything on
838 the list WEAKS. We need this information so that if a regular
839 object refers to a symbol defined weakly in a dynamic object, the
840 real symbol in the dynamic object is also put in the dynamic
841 symbols; we also must arrange for both symbols to point to the
842 same memory location. We could handle the general case of symbol
843 aliasing, but a general symbol alias can only be generated in
844 assembler code, handling it correctly would be very time
845 consuming, and other ELF linkers don't handle general aliasing
847 while (weaks != NULL)
849 struct elf_link_hash_entry *hlook;
852 struct elf_link_hash_entry **hpp;
853 struct elf_link_hash_entry **hppend;
856 weaks = hlook->weakdef;
857 hlook->weakdef = NULL;
859 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
860 || hlook->root.type == bfd_link_hash_defweak
861 || hlook->root.type == bfd_link_hash_common
862 || hlook->root.type == bfd_link_hash_indirect);
863 slook = hlook->root.u.def.section;
864 vlook = hlook->root.u.def.value;
866 hpp = elf_sym_hashes (abfd);
867 hppend = hpp + extsymcount;
868 for (; hpp < hppend; hpp++)
870 struct elf_link_hash_entry *h;
873 if (h != NULL && h != hlook
874 && h->root.type == bfd_link_hash_defined
875 && h->root.u.def.section == slook
876 && h->root.u.def.value == vlook)
880 /* If the weak definition is in the list of dynamic
881 symbols, make sure the real definition is put there
883 if (hlook->dynindx != -1
886 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
901 /* If this object is the same format as the output object, and it is
902 not a shared library, then let the backend look through the
905 This is required to build global offset table entries and to
906 arrange for dynamic relocs. It is not required for the
907 particular common case of linking non PIC code, even when linking
908 against shared libraries, but unfortunately there is no way of
909 knowing whether an object file has been compiled PIC or not.
910 Looking through the relocs is not particularly time consuming.
911 The problem is that we must either (1) keep the relocs in memory,
912 which causes the linker to require additional runtime memory or
913 (2) read the relocs twice from the input file, which wastes time.
914 This would be a good case for using mmap.
916 I have no idea how to handle linking PIC code into a file of a
917 different format. It probably can't be done. */
918 check_relocs = get_elf_backend_data (abfd)->check_relocs;
920 && abfd->xvec == info->hash->creator
921 && check_relocs != NULL)
925 for (o = abfd->sections; o != NULL; o = o->next)
927 Elf_Internal_Rela *internal_relocs;
930 if ((o->flags & SEC_RELOC) == 0
931 || o->reloc_count == 0)
934 /* I believe we can ignore the relocs for any section which
935 does not form part of the final process image, such as a
936 debugging section. */
937 if ((o->flags & SEC_ALLOC) == 0)
940 internal_relocs = elf_link_read_relocs (abfd, o, (PTR) NULL,
941 (Elf_Internal_Rela *) NULL,
943 if (internal_relocs == NULL)
946 ok = (*check_relocs) (abfd, info, o, internal_relocs);
948 if (! info->keep_memory)
949 free (internal_relocs);
966 /* Create some sections which will be filled in with dynamic linking
967 information. ABFD is an input file which requires dynamic sections
968 to be created. The dynamic sections take up virtual memory space
969 when the final executable is run, so we need to create them before
970 addresses are assigned to the output sections. We work out the
971 actual contents and size of these sections later. */
974 elf_link_create_dynamic_sections (abfd, info)
976 struct bfd_link_info *info;
979 register asection *s;
980 struct elf_link_hash_entry *h;
981 struct elf_backend_data *bed;
983 if (elf_hash_table (info)->dynamic_sections_created)
986 /* Make sure that all dynamic sections use the same input BFD. */
987 if (elf_hash_table (info)->dynobj == NULL)
988 elf_hash_table (info)->dynobj = abfd;
990 abfd = elf_hash_table (info)->dynobj;
992 /* Note that we set the SEC_IN_MEMORY flag for all of these
994 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
996 /* A dynamically linked executable has a .interp section, but a
997 shared library does not. */
1000 s = bfd_make_section (abfd, ".interp");
1002 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1006 s = bfd_make_section (abfd, ".dynsym");
1008 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1009 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1012 s = bfd_make_section (abfd, ".dynstr");
1014 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1017 /* Create a strtab to hold the dynamic symbol names. */
1018 if (elf_hash_table (info)->dynstr == NULL)
1020 elf_hash_table (info)->dynstr = elf_stringtab_init ();
1021 if (elf_hash_table (info)->dynstr == NULL)
1025 s = bfd_make_section (abfd, ".dynamic");
1027 || ! bfd_set_section_flags (abfd, s, flags)
1028 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1031 /* The special symbol _DYNAMIC is always set to the start of the
1032 .dynamic section. This call occurs before we have processed the
1033 symbols for any dynamic object, so we don't have to worry about
1034 overriding a dynamic definition. We could set _DYNAMIC in a
1035 linker script, but we only want to define it if we are, in fact,
1036 creating a .dynamic section. We don't want to define it if there
1037 is no .dynamic section, since on some ELF platforms the start up
1038 code examines it to decide how to initialize the process. */
1040 if (! (_bfd_generic_link_add_one_symbol
1041 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
1042 (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
1043 (struct bfd_link_hash_entry **) &h)))
1045 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1046 h->type = STT_OBJECT;
1049 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1052 s = bfd_make_section (abfd, ".hash");
1054 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1055 || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1058 /* Let the backend create the rest of the sections. This lets the
1059 backend set the right flags. The backend will normally create
1060 the .got and .plt sections. */
1061 bed = get_elf_backend_data (abfd);
1062 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
1065 elf_hash_table (info)->dynamic_sections_created = true;
1070 /* Add an entry to the .dynamic table. */
1073 elf_add_dynamic_entry (info, tag, val)
1074 struct bfd_link_info *info;
1078 Elf_Internal_Dyn dyn;
1082 bfd_byte *newcontents;
1084 dynobj = elf_hash_table (info)->dynobj;
1086 s = bfd_get_section_by_name (dynobj, ".dynamic");
1087 BFD_ASSERT (s != NULL);
1089 newsize = s->_raw_size + sizeof (Elf_External_Dyn);
1090 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
1091 if (newcontents == NULL)
1095 dyn.d_un.d_val = val;
1096 elf_swap_dyn_out (dynobj, &dyn,
1097 (Elf_External_Dyn *) (newcontents + s->_raw_size));
1099 s->_raw_size = newsize;
1100 s->contents = newcontents;
1106 /* Read and swap the relocs for a section. They may have been cached.
1107 If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1108 they are used as buffers to read into. They are known to be large
1109 enough. If the INTERNAL_RELOCS relocs argument is NULL, the return
1110 value is allocated using either malloc or bfd_alloc, according to
1111 the KEEP_MEMORY argument. */
1113 static Elf_Internal_Rela *
1114 elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
1117 PTR external_relocs;
1118 Elf_Internal_Rela *internal_relocs;
1119 boolean keep_memory;
1121 Elf_Internal_Shdr *rel_hdr;
1123 Elf_Internal_Rela *alloc2 = NULL;
1125 if (elf_section_data (o)->relocs != NULL)
1126 return elf_section_data (o)->relocs;
1128 if (o->reloc_count == 0)
1131 rel_hdr = &elf_section_data (o)->rel_hdr;
1133 if (internal_relocs == NULL)
1137 size = o->reloc_count * sizeof (Elf_Internal_Rela);
1139 internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
1141 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
1142 if (internal_relocs == NULL)
1146 if (external_relocs == NULL)
1148 alloc1 = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
1151 external_relocs = alloc1;
1154 if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
1155 || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
1156 != rel_hdr->sh_size))
1159 /* Swap in the relocs. For convenience, we always produce an
1160 Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1162 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
1164 Elf_External_Rel *erel;
1165 Elf_External_Rel *erelend;
1166 Elf_Internal_Rela *irela;
1168 erel = (Elf_External_Rel *) external_relocs;
1169 erelend = erel + o->reloc_count;
1170 irela = internal_relocs;
1171 for (; erel < erelend; erel++, irela++)
1173 Elf_Internal_Rel irel;
1175 elf_swap_reloc_in (abfd, erel, &irel);
1176 irela->r_offset = irel.r_offset;
1177 irela->r_info = irel.r_info;
1178 irela->r_addend = 0;
1183 Elf_External_Rela *erela;
1184 Elf_External_Rela *erelaend;
1185 Elf_Internal_Rela *irela;
1187 BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
1189 erela = (Elf_External_Rela *) external_relocs;
1190 erelaend = erela + o->reloc_count;
1191 irela = internal_relocs;
1192 for (; erela < erelaend; erela++, irela++)
1193 elf_swap_reloca_in (abfd, erela, irela);
1196 /* Cache the results for next time, if we can. */
1198 elf_section_data (o)->relocs = internal_relocs;
1203 /* Don't free alloc2, since if it was allocated we are passing it
1204 back (under the name of internal_relocs). */
1206 return internal_relocs;
1217 /* Record an assignment to a symbol made by a linker script. We need
1218 this in case some dynamic object refers to this symbol. */
1222 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
1224 struct bfd_link_info *info;
1228 struct elf_link_hash_entry *h;
1230 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1233 h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
1237 if (h->root.type == bfd_link_hash_new)
1238 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
1240 /* If this symbol is being provided by the linker script, and it is
1241 currently defined by a dynamic object, but not by a regular
1242 object, then mark it as undefined so that the generic linker will
1243 force the correct value. */
1245 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1246 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1247 h->root.type = bfd_link_hash_undefined;
1249 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1250 h->type = STT_OBJECT;
1252 if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1253 | ELF_LINK_HASH_REF_DYNAMIC)) != 0
1255 && h->dynindx == -1)
1257 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1260 /* If this is a weak defined symbol, and we know a corresponding
1261 real symbol from the same dynamic object, make sure the real
1262 symbol is also made into a dynamic symbol. */
1263 if (h->weakdef != NULL
1264 && h->weakdef->dynindx == -1)
1266 if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
1275 /* Array used to determine the number of hash table buckets to use
1276 based on the number of symbols there are. If there are fewer than
1277 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1278 fewer than 37 we use 17 buckets, and so forth. We never use more
1279 than 521 buckets. */
1281 static const size_t elf_buckets[] =
1283 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1286 /* Set up the sizes and contents of the ELF dynamic sections. This is
1287 called by the ELF linker emulation before_allocation routine. We
1288 must set the sizes of the sections before the linker sets the
1289 addresses of the various sections. */
1292 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
1293 export_dynamic, info, sinterpptr)
1297 boolean export_dynamic;
1298 struct bfd_link_info *info;
1299 asection **sinterpptr;
1302 struct elf_backend_data *bed;
1306 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1309 dynobj = elf_hash_table (info)->dynobj;
1311 /* If there were no dynamic objects in the link, there is nothing to
1316 /* If we are supposed to export all symbols into the dynamic symbol
1317 table (this is not the normal case), then do so. */
1320 struct elf_info_failed eif;
1324 elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
1330 if (elf_hash_table (info)->dynamic_sections_created)
1332 struct elf_info_failed eif;
1333 struct elf_link_hash_entry *h;
1334 bfd_size_type strsize;
1336 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
1337 BFD_ASSERT (*sinterpptr != NULL || info->shared);
1343 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, soname,
1345 if (indx == (bfd_size_type) -1
1346 || ! elf_add_dynamic_entry (info, DT_SONAME, indx))
1352 if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
1360 indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
1362 if (indx == (bfd_size_type) -1
1363 || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
1367 /* Find all symbols which were defined in a dynamic object and make
1368 the backend pick a reasonable value for them. */
1371 elf_link_hash_traverse (elf_hash_table (info),
1372 elf_adjust_dynamic_symbol,
1377 /* Add some entries to the .dynamic section. We fill in some of the
1378 values later, in elf_bfd_final_link, but we must add the entries
1379 now so that we know the final size of the .dynamic section. */
1380 h = elf_link_hash_lookup (elf_hash_table (info), "_init", false,
1383 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
1384 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
1386 if (! elf_add_dynamic_entry (info, DT_INIT, 0))
1389 h = elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
1392 && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
1393 | ELF_LINK_HASH_DEF_REGULAR)) != 0)
1395 if (! elf_add_dynamic_entry (info, DT_FINI, 0))
1398 strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1399 if (! elf_add_dynamic_entry (info, DT_HASH, 0)
1400 || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
1401 || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
1402 || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
1403 || ! elf_add_dynamic_entry (info, DT_SYMENT,
1404 sizeof (Elf_External_Sym)))
1408 /* The backend must work out the sizes of all the other dynamic
1410 bed = get_elf_backend_data (output_bfd);
1411 if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
1414 if (elf_hash_table (info)->dynamic_sections_created)
1419 size_t bucketcount = 0;
1420 Elf_Internal_Sym isym;
1422 /* Set the size of the .dynsym and .hash sections. We counted
1423 the number of dynamic symbols in elf_link_add_object_symbols.
1424 We will build the contents of .dynsym and .hash when we build
1425 the final symbol table, because until then we do not know the
1426 correct value to give the symbols. We built the .dynstr
1427 section as we went along in elf_link_add_object_symbols. */
1428 dynsymcount = elf_hash_table (info)->dynsymcount;
1429 s = bfd_get_section_by_name (dynobj, ".dynsym");
1430 BFD_ASSERT (s != NULL);
1431 s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
1432 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1433 if (s->contents == NULL && s->_raw_size != 0)
1436 /* The first entry in .dynsym is a dummy symbol. */
1443 elf_swap_symbol_out (output_bfd, &isym,
1444 (PTR) (Elf_External_Sym *) s->contents);
1446 for (i = 0; elf_buckets[i] != 0; i++)
1448 bucketcount = elf_buckets[i];
1449 if (dynsymcount < elf_buckets[i + 1])
1453 s = bfd_get_section_by_name (dynobj, ".hash");
1454 BFD_ASSERT (s != NULL);
1455 s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
1456 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1457 if (s->contents == NULL)
1459 memset (s->contents, 0, (size_t) s->_raw_size);
1461 put_word (output_bfd, bucketcount, s->contents);
1462 put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
1464 elf_hash_table (info)->bucketcount = bucketcount;
1466 s = bfd_get_section_by_name (dynobj, ".dynstr");
1467 BFD_ASSERT (s != NULL);
1468 s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1470 if (! elf_add_dynamic_entry (info, DT_NULL, 0))
1478 /* This routine is used to export all defined symbols into the dynamic
1479 symbol table. It is called via elf_link_hash_traverse. */
1482 elf_export_symbol (h, data)
1483 struct elf_link_hash_entry *h;
1486 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1488 if (h->dynindx == -1
1489 && (h->elf_link_hash_flags
1490 & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
1492 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1503 /* Make the backend pick a good value for a dynamic symbol. This is
1504 called via elf_link_hash_traverse, and also calls itself
1508 elf_adjust_dynamic_symbol (h, data)
1509 struct elf_link_hash_entry *h;
1512 struct elf_info_failed *eif = (struct elf_info_failed *) data;
1514 struct elf_backend_data *bed;
1516 /* If this symbol was mentioned in a non-ELF file, try to set
1517 DEF_REGULAR and REF_REGULAR correctly. This is the only way to
1518 permit a non-ELF file to correctly refer to a symbol defined in
1519 an ELF dynamic object. */
1520 if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) != 0)
1522 if (h->root.type != bfd_link_hash_defined
1523 && h->root.type != bfd_link_hash_defweak)
1524 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1527 if (h->root.u.def.section->owner != NULL
1528 && (bfd_get_flavour (h->root.u.def.section->owner)
1529 == bfd_target_elf_flavour))
1530 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1532 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1535 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1536 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
1538 if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1546 /* If -Bsymbolic was used (which means to bind references to global
1547 symbols to the definition within the shared object), and this
1548 symbol was defined in a regular object, then it actually doesn't
1549 need a PLT entry. */
1550 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1551 && eif->info->shared
1552 && eif->info->symbolic
1553 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1554 h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
1556 /* If this symbol does not require a PLT entry, and it is not
1557 defined by a dynamic object, or is not referenced by a regular
1558 object, ignore it. We do have to handle a weak defined symbol,
1559 even if no regular object refers to it, if we decided to add it
1560 to the dynamic symbol table. FIXME: Do we normally need to worry
1561 about symbols which are defined by one dynamic object and
1562 referenced by another one? */
1563 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
1564 && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1565 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1566 || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
1567 && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
1570 /* If we've already adjusted this symbol, don't do it again. This
1571 can happen via a recursive call. */
1572 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
1575 /* Don't look at this symbol again. Note that we must set this
1576 after checking the above conditions, because we may look at a
1577 symbol once, decide not to do anything, and then get called
1578 recursively later after REF_REGULAR is set below. */
1579 h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
1581 /* If this is a weak definition, and we know a real definition, and
1582 the real symbol is not itself defined by a regular object file,
1583 then get a good value for the real definition. We handle the
1584 real symbol first, for the convenience of the backend routine.
1586 Note that there is a confusing case here. If the real definition
1587 is defined by a regular object file, we don't get the real symbol
1588 from the dynamic object, but we do get the weak symbol. If the
1589 processor backend uses a COPY reloc, then if some routine in the
1590 dynamic object changes the real symbol, we will not see that
1591 change in the corresponding weak symbol. This is the way other
1592 ELF linkers work as well, and seems to be a result of the shared
1595 I will clarify this issue. Most SVR4 shared libraries define the
1596 variable _timezone and define timezone as a weak synonym. The
1597 tzset call changes _timezone. If you write
1598 extern int timezone;
1600 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1601 you might expect that, since timezone is a synonym for _timezone,
1602 the same number will print both times. However, if the processor
1603 backend uses a COPY reloc, then actually timezone will be copied
1604 into your process image, and, since you define _timezone
1605 yourself, _timezone will not. Thus timezone and _timezone will
1606 wind up at different memory locations. The tzset call will set
1607 _timezone, leaving timezone unchanged. */
1609 if (h->weakdef != NULL)
1611 struct elf_link_hash_entry *weakdef;
1613 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1614 || h->root.type == bfd_link_hash_defweak);
1615 weakdef = h->weakdef;
1616 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
1617 || weakdef->root.type == bfd_link_hash_defweak);
1618 BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
1619 if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1621 /* This symbol is defined by a regular object file, so we
1622 will not do anything special. Clear weakdef for the
1623 convenience of the processor backend. */
1628 /* There is an implicit reference by a regular object file
1629 via the weak symbol. */
1630 weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1631 if (! elf_adjust_dynamic_symbol (weakdef, (PTR) eif))
1636 dynobj = elf_hash_table (eif->info)->dynobj;
1637 bed = get_elf_backend_data (dynobj);
1638 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
1647 /* Final phase of ELF linker. */
1649 /* A structure we use to avoid passing large numbers of arguments. */
1651 struct elf_final_link_info
1653 /* General link information. */
1654 struct bfd_link_info *info;
1657 /* Symbol string table. */
1658 struct bfd_strtab_hash *symstrtab;
1659 /* .dynsym section. */
1660 asection *dynsym_sec;
1661 /* .hash section. */
1663 /* Buffer large enough to hold contents of any section. */
1665 /* Buffer large enough to hold external relocs of any section. */
1666 PTR external_relocs;
1667 /* Buffer large enough to hold internal relocs of any section. */
1668 Elf_Internal_Rela *internal_relocs;
1669 /* Buffer large enough to hold external local symbols of any input
1671 Elf_External_Sym *external_syms;
1672 /* Buffer large enough to hold internal local symbols of any input
1674 Elf_Internal_Sym *internal_syms;
1675 /* Array large enough to hold a symbol index for each local symbol
1676 of any input BFD. */
1678 /* Array large enough to hold a section pointer for each local
1679 symbol of any input BFD. */
1680 asection **sections;
1681 /* Buffer to hold swapped out symbols. */
1682 Elf_External_Sym *symbuf;
1683 /* Number of swapped out symbols in buffer. */
1684 size_t symbuf_count;
1685 /* Number of symbols which fit in symbuf. */
1689 static boolean elf_link_output_sym
1690 PARAMS ((struct elf_final_link_info *, const char *,
1691 Elf_Internal_Sym *, asection *));
1692 static boolean elf_link_flush_output_syms
1693 PARAMS ((struct elf_final_link_info *));
1694 static boolean elf_link_output_extsym
1695 PARAMS ((struct elf_link_hash_entry *, PTR));
1696 static boolean elf_link_input_bfd
1697 PARAMS ((struct elf_final_link_info *, bfd *));
1698 static boolean elf_reloc_link_order
1699 PARAMS ((bfd *, struct bfd_link_info *, asection *,
1700 struct bfd_link_order *));
1702 /* This struct is used to pass information to routines called via
1703 elf_link_hash_traverse which must return failure. */
1705 struct elf_finfo_failed
1708 struct elf_final_link_info *finfo;
1711 /* Do the final step of an ELF link. */
1714 elf_bfd_final_link (abfd, info)
1716 struct bfd_link_info *info;
1720 struct elf_final_link_info finfo;
1721 register asection *o;
1722 register struct bfd_link_order *p;
1724 size_t max_contents_size;
1725 size_t max_external_reloc_size;
1726 size_t max_internal_reloc_count;
1727 size_t max_sym_count;
1729 Elf_Internal_Sym elfsym;
1731 Elf_Internal_Shdr *symtab_hdr;
1732 Elf_Internal_Shdr *symstrtab_hdr;
1733 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1734 struct elf_finfo_failed eif;
1737 abfd->flags |= DYNAMIC;
1739 dynamic = elf_hash_table (info)->dynamic_sections_created;
1740 dynobj = elf_hash_table (info)->dynobj;
1743 finfo.output_bfd = abfd;
1744 finfo.symstrtab = elf_stringtab_init ();
1745 if (finfo.symstrtab == NULL)
1749 finfo.dynsym_sec = NULL;
1750 finfo.hash_sec = NULL;
1754 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
1755 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
1756 BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
1758 finfo.contents = NULL;
1759 finfo.external_relocs = NULL;
1760 finfo.internal_relocs = NULL;
1761 finfo.external_syms = NULL;
1762 finfo.internal_syms = NULL;
1763 finfo.indices = NULL;
1764 finfo.sections = NULL;
1765 finfo.symbuf = NULL;
1766 finfo.symbuf_count = 0;
1768 /* Count up the number of relocations we will output for each output
1769 section, so that we know the sizes of the reloc sections. We
1770 also figure out some maximum sizes. */
1771 max_contents_size = 0;
1772 max_external_reloc_size = 0;
1773 max_internal_reloc_count = 0;
1775 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
1779 for (p = o->link_order_head; p != NULL; p = p->next)
1781 if (p->type == bfd_section_reloc_link_order
1782 || p->type == bfd_symbol_reloc_link_order)
1784 else if (p->type == bfd_indirect_link_order)
1788 sec = p->u.indirect.section;
1790 if (info->relocateable)
1791 o->reloc_count += sec->reloc_count;
1793 if (sec->_raw_size > max_contents_size)
1794 max_contents_size = sec->_raw_size;
1795 if (sec->_cooked_size > max_contents_size)
1796 max_contents_size = sec->_cooked_size;
1798 /* We are interested in just local symbols, not all
1800 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour)
1804 if (elf_bad_symtab (sec->owner))
1805 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
1806 / sizeof (Elf_External_Sym));
1808 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
1810 if (sym_count > max_sym_count)
1811 max_sym_count = sym_count;
1813 if ((sec->flags & SEC_RELOC) != 0)
1817 ext_size = elf_section_data (sec)->rel_hdr.sh_size;
1818 if (ext_size > max_external_reloc_size)
1819 max_external_reloc_size = ext_size;
1820 if (sec->reloc_count > max_internal_reloc_count)
1821 max_internal_reloc_count = sec->reloc_count;
1827 if (o->reloc_count > 0)
1828 o->flags |= SEC_RELOC;
1831 /* Explicitly clear the SEC_RELOC flag. The linker tends to
1832 set it (this is probably a bug) and if it is set
1833 assign_section_numbers will create a reloc section. */
1834 o->flags &=~ SEC_RELOC;
1837 /* If the SEC_ALLOC flag is not set, force the section VMA to
1838 zero. This is done in elf_fake_sections as well, but forcing
1839 the VMA to 0 here will ensure that relocs against these
1840 sections are handled correctly. */
1841 if ((o->flags & SEC_ALLOC) == 0)
1845 /* Figure out the file positions for everything but the symbol table
1846 and the relocs. We set symcount to force assign_section_numbers
1847 to create a symbol table. */
1848 abfd->symcount = info->strip == strip_all ? 0 : 1;
1849 BFD_ASSERT (! abfd->output_has_begun);
1850 if (! _bfd_elf_compute_section_file_positions (abfd, info))
1853 /* That created the reloc sections. Set their sizes, and assign
1854 them file positions, and allocate some buffers. */
1855 for (o = abfd->sections; o != NULL; o = o->next)
1857 if ((o->flags & SEC_RELOC) != 0)
1859 Elf_Internal_Shdr *rel_hdr;
1860 register struct elf_link_hash_entry **p, **pend;
1862 rel_hdr = &elf_section_data (o)->rel_hdr;
1864 rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
1866 /* The contents field must last into write_object_contents,
1867 so we allocate it with bfd_alloc rather than malloc. */
1868 rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
1869 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
1872 p = ((struct elf_link_hash_entry **)
1873 bfd_malloc (o->reloc_count
1874 * sizeof (struct elf_link_hash_entry *)));
1875 if (p == NULL && o->reloc_count != 0)
1877 elf_section_data (o)->rel_hashes = p;
1878 pend = p + o->reloc_count;
1879 for (; p < pend; p++)
1882 /* Use the reloc_count field as an index when outputting the
1888 _bfd_elf_assign_file_positions_for_relocs (abfd);
1890 /* We have now assigned file positions for all the sections except
1891 .symtab and .strtab. We start the .symtab section at the current
1892 file position, and write directly to it. We build the .strtab
1893 section in memory. */
1895 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1896 /* sh_name is set in prep_headers. */
1897 symtab_hdr->sh_type = SHT_SYMTAB;
1898 symtab_hdr->sh_flags = 0;
1899 symtab_hdr->sh_addr = 0;
1900 symtab_hdr->sh_size = 0;
1901 symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
1902 /* sh_link is set in assign_section_numbers. */
1903 /* sh_info is set below. */
1904 /* sh_offset is set just below. */
1905 symtab_hdr->sh_addralign = 4; /* FIXME: system dependent? */
1907 off = elf_tdata (abfd)->next_file_pos;
1908 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
1910 /* Note that at this point elf_tdata (abfd)->next_file_pos is
1911 incorrect. We do not yet know the size of the .symtab section.
1912 We correct next_file_pos below, after we do know the size. */
1914 /* Allocate a buffer to hold swapped out symbols. This is to avoid
1915 continuously seeking to the right position in the file. */
1916 if (! info->keep_memory || max_sym_count < 20)
1917 finfo.symbuf_size = 20;
1919 finfo.symbuf_size = max_sym_count;
1920 finfo.symbuf = ((Elf_External_Sym *)
1921 bfd_malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
1922 if (finfo.symbuf == NULL)
1925 /* Start writing out the symbol table. The first symbol is always a
1927 if (info->strip != strip_all || info->relocateable)
1929 elfsym.st_value = 0;
1932 elfsym.st_other = 0;
1933 elfsym.st_shndx = SHN_UNDEF;
1934 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1935 &elfsym, bfd_und_section_ptr))
1940 /* Some standard ELF linkers do this, but we don't because it causes
1941 bootstrap comparison failures. */
1942 /* Output a file symbol for the output file as the second symbol.
1943 We output this even if we are discarding local symbols, although
1944 I'm not sure if this is correct. */
1945 elfsym.st_value = 0;
1947 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
1948 elfsym.st_other = 0;
1949 elfsym.st_shndx = SHN_ABS;
1950 if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
1951 &elfsym, bfd_abs_section_ptr))
1955 /* Output a symbol for each section. We output these even if we are
1956 discarding local symbols, since they are used for relocs. These
1957 symbols have no names. We store the index of each one in the
1958 index field of the section, so that we can find it again when
1959 outputting relocs. */
1960 if (info->strip != strip_all || info->relocateable)
1962 elfsym.st_value = 0;
1964 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1965 elfsym.st_other = 0;
1966 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
1968 o = section_from_elf_index (abfd, i);
1970 o->target_index = abfd->symcount;
1971 elfsym.st_shndx = i;
1972 if (! elf_link_output_sym (&finfo, (const char *) NULL,
1978 /* Allocate some memory to hold information read in from the input
1980 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
1981 finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
1982 finfo.internal_relocs = ((Elf_Internal_Rela *)
1983 bfd_malloc (max_internal_reloc_count
1984 * sizeof (Elf_Internal_Rela)));
1985 finfo.external_syms = ((Elf_External_Sym *)
1986 bfd_malloc (max_sym_count
1987 * sizeof (Elf_External_Sym)));
1988 finfo.internal_syms = ((Elf_Internal_Sym *)
1989 bfd_malloc (max_sym_count
1990 * sizeof (Elf_Internal_Sym)));
1991 finfo.indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
1992 finfo.sections = ((asection **)
1993 bfd_malloc (max_sym_count * sizeof (asection *)));
1994 if ((finfo.contents == NULL && max_contents_size != 0)
1995 || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
1996 || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
1997 || (finfo.external_syms == NULL && max_sym_count != 0)
1998 || (finfo.internal_syms == NULL && max_sym_count != 0)
1999 || (finfo.indices == NULL && max_sym_count != 0)
2000 || (finfo.sections == NULL && max_sym_count != 0))
2003 /* Since ELF permits relocations to be against local symbols, we
2004 must have the local symbols available when we do the relocations.
2005 Since we would rather only read the local symbols once, and we
2006 would rather not keep them in memory, we handle all the
2007 relocations for a single input file at the same time.
2009 Unfortunately, there is no way to know the total number of local
2010 symbols until we have seen all of them, and the local symbol
2011 indices precede the global symbol indices. This means that when
2012 we are generating relocateable output, and we see a reloc against
2013 a global symbol, we can not know the symbol index until we have
2014 finished examining all the local symbols to see which ones we are
2015 going to output. To deal with this, we keep the relocations in
2016 memory, and don't output them until the end of the link. This is
2017 an unfortunate waste of memory, but I don't see a good way around
2018 it. Fortunately, it only happens when performing a relocateable
2019 link, which is not the common case. FIXME: If keep_memory is set
2020 we could write the relocs out and then read them again; I don't
2021 know how bad the memory loss will be. */
2023 for (sub = info->input_bfds; sub != NULL; sub = sub->next)
2024 sub->output_has_begun = false;
2025 for (o = abfd->sections; o != NULL; o = o->next)
2027 for (p = o->link_order_head; p != NULL; p = p->next)
2029 if (p->type == bfd_indirect_link_order
2030 && (bfd_get_flavour (p->u.indirect.section->owner)
2031 == bfd_target_elf_flavour))
2033 sub = p->u.indirect.section->owner;
2034 if (! sub->output_has_begun)
2036 if (! elf_link_input_bfd (&finfo, sub))
2038 sub->output_has_begun = true;
2041 else if (p->type == bfd_section_reloc_link_order
2042 || p->type == bfd_symbol_reloc_link_order)
2044 if (! elf_reloc_link_order (abfd, info, o, p))
2049 if (! _bfd_default_link_order (abfd, info, o, p))
2055 /* That wrote out all the local symbols. Finish up the symbol table
2056 with the global symbols. */
2058 /* The sh_info field records the index of the first non local
2060 symtab_hdr->sh_info = abfd->symcount;
2062 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
2064 /* We get the global symbols from the hash table. */
2067 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
2072 /* Flush all symbols to the file. */
2073 if (! elf_link_flush_output_syms (&finfo))
2076 /* Now we know the size of the symtab section. */
2077 off += symtab_hdr->sh_size;
2079 /* Finish up and write out the symbol string table (.strtab)
2081 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2082 /* sh_name was set in prep_headers. */
2083 symstrtab_hdr->sh_type = SHT_STRTAB;
2084 symstrtab_hdr->sh_flags = 0;
2085 symstrtab_hdr->sh_addr = 0;
2086 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
2087 symstrtab_hdr->sh_entsize = 0;
2088 symstrtab_hdr->sh_link = 0;
2089 symstrtab_hdr->sh_info = 0;
2090 /* sh_offset is set just below. */
2091 symstrtab_hdr->sh_addralign = 1;
2093 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
2094 elf_tdata (abfd)->next_file_pos = off;
2096 if (abfd->symcount > 0)
2098 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
2099 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
2103 /* Adjust the relocs to have the correct symbol indices. */
2104 for (o = abfd->sections; o != NULL; o = o->next)
2106 struct elf_link_hash_entry **rel_hash;
2107 Elf_Internal_Shdr *rel_hdr;
2109 if ((o->flags & SEC_RELOC) == 0)
2112 rel_hash = elf_section_data (o)->rel_hashes;
2113 rel_hdr = &elf_section_data (o)->rel_hdr;
2114 for (i = 0; i < o->reloc_count; i++, rel_hash++)
2116 if (*rel_hash == NULL)
2119 BFD_ASSERT ((*rel_hash)->indx >= 0);
2121 if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2123 Elf_External_Rel *erel;
2124 Elf_Internal_Rel irel;
2126 erel = (Elf_External_Rel *) rel_hdr->contents + i;
2127 elf_swap_reloc_in (abfd, erel, &irel);
2128 irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
2129 ELF_R_TYPE (irel.r_info));
2130 elf_swap_reloc_out (abfd, &irel, erel);
2134 Elf_External_Rela *erela;
2135 Elf_Internal_Rela irela;
2137 BFD_ASSERT (rel_hdr->sh_entsize
2138 == sizeof (Elf_External_Rela));
2140 erela = (Elf_External_Rela *) rel_hdr->contents + i;
2141 elf_swap_reloca_in (abfd, erela, &irela);
2142 irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
2143 ELF_R_TYPE (irela.r_info));
2144 elf_swap_reloca_out (abfd, &irela, erela);
2148 /* Set the reloc_count field to 0 to prevent write_relocs from
2149 trying to swap the relocs out itself. */
2153 /* If we are linking against a dynamic object, or generating a
2154 shared library, finish up the dynamic linking information. */
2157 Elf_External_Dyn *dyncon, *dynconend;
2159 /* Fix up .dynamic entries. */
2160 o = bfd_get_section_by_name (dynobj, ".dynamic");
2161 BFD_ASSERT (o != NULL);
2163 dyncon = (Elf_External_Dyn *) o->contents;
2164 dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
2165 for (; dyncon < dynconend; dyncon++)
2167 Elf_Internal_Dyn dyn;
2171 elf_swap_dyn_in (dynobj, dyncon, &dyn);
2178 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2179 magic _init and _fini symbols. This is pretty ugly,
2180 but we are compatible. */
2188 struct elf_link_hash_entry *h;
2190 h = elf_link_hash_lookup (elf_hash_table (info), name,
2191 false, false, true);
2193 && (h->root.type == bfd_link_hash_defined
2194 || h->root.type == bfd_link_hash_defweak))
2196 dyn.d_un.d_val = h->root.u.def.value;
2197 o = h->root.u.def.section;
2198 if (o->output_section != NULL)
2199 dyn.d_un.d_val += (o->output_section->vma
2200 + o->output_offset);
2203 /* The symbol is imported from another shared
2204 library and does not apply to this one. */
2208 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2222 o = bfd_get_section_by_name (abfd, name);
2223 BFD_ASSERT (o != NULL);
2224 dyn.d_un.d_ptr = o->vma;
2225 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2232 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
2237 for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
2239 Elf_Internal_Shdr *hdr;
2241 hdr = elf_elfsections (abfd)[i];
2242 if (hdr->sh_type == type
2243 && (hdr->sh_flags & SHF_ALLOC) != 0)
2245 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
2246 dyn.d_un.d_val += hdr->sh_size;
2249 if (dyn.d_un.d_val == 0
2250 || hdr->sh_addr < dyn.d_un.d_val)
2251 dyn.d_un.d_val = hdr->sh_addr;
2255 elf_swap_dyn_out (dynobj, &dyn, dyncon);
2261 /* If we have created any dynamic sections, then output them. */
2264 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
2267 for (o = dynobj->sections; o != NULL; o = o->next)
2269 if ((o->flags & SEC_HAS_CONTENTS) == 0
2270 || o->_raw_size == 0)
2272 if ((o->flags & SEC_IN_MEMORY) == 0)
2274 /* At this point, we are only interested in sections
2275 created by elf_link_create_dynamic_sections. FIXME:
2276 This test is fragile. */
2279 if ((elf_section_data (o->output_section)->this_hdr.sh_type
2281 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
2283 if (! bfd_set_section_contents (abfd, o->output_section,
2284 o->contents, o->output_offset,
2292 /* The contents of the .dynstr section are actually in a
2294 off = elf_section_data (o->output_section)->this_hdr.sh_offset;
2295 if (bfd_seek (abfd, off, SEEK_SET) != 0
2296 || ! _bfd_stringtab_emit (abfd,
2297 elf_hash_table (info)->dynstr))
2303 if (finfo.symstrtab != NULL)
2304 _bfd_stringtab_free (finfo.symstrtab);
2305 if (finfo.contents != NULL)
2306 free (finfo.contents);
2307 if (finfo.external_relocs != NULL)
2308 free (finfo.external_relocs);
2309 if (finfo.internal_relocs != NULL)
2310 free (finfo.internal_relocs);
2311 if (finfo.external_syms != NULL)
2312 free (finfo.external_syms);
2313 if (finfo.internal_syms != NULL)
2314 free (finfo.internal_syms);
2315 if (finfo.indices != NULL)
2316 free (finfo.indices);
2317 if (finfo.sections != NULL)
2318 free (finfo.sections);
2319 if (finfo.symbuf != NULL)
2320 free (finfo.symbuf);
2321 for (o = abfd->sections; o != NULL; o = o->next)
2323 if ((o->flags & SEC_RELOC) != 0
2324 && elf_section_data (o)->rel_hashes != NULL)
2325 free (elf_section_data (o)->rel_hashes);
2328 elf_tdata (abfd)->linker = true;
2333 if (finfo.symstrtab != NULL)
2334 _bfd_stringtab_free (finfo.symstrtab);
2335 if (finfo.contents != NULL)
2336 free (finfo.contents);
2337 if (finfo.external_relocs != NULL)
2338 free (finfo.external_relocs);
2339 if (finfo.internal_relocs != NULL)
2340 free (finfo.internal_relocs);
2341 if (finfo.external_syms != NULL)
2342 free (finfo.external_syms);
2343 if (finfo.internal_syms != NULL)
2344 free (finfo.internal_syms);
2345 if (finfo.indices != NULL)
2346 free (finfo.indices);
2347 if (finfo.sections != NULL)
2348 free (finfo.sections);
2349 if (finfo.symbuf != NULL)
2350 free (finfo.symbuf);
2351 for (o = abfd->sections; o != NULL; o = o->next)
2353 if ((o->flags & SEC_RELOC) != 0
2354 && elf_section_data (o)->rel_hashes != NULL)
2355 free (elf_section_data (o)->rel_hashes);
2361 /* Add a symbol to the output symbol table. */
2364 elf_link_output_sym (finfo, name, elfsym, input_sec)
2365 struct elf_final_link_info *finfo;
2367 Elf_Internal_Sym *elfsym;
2368 asection *input_sec;
2370 boolean (*output_symbol_hook) PARAMS ((bfd *,
2371 struct bfd_link_info *info,
2376 output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
2377 elf_backend_link_output_symbol_hook;
2378 if (output_symbol_hook != NULL)
2380 if (! ((*output_symbol_hook)
2381 (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
2385 if (name == (const char *) NULL || *name == '\0')
2386 elfsym->st_name = 0;
2389 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
2392 if (elfsym->st_name == (unsigned long) -1)
2396 if (finfo->symbuf_count >= finfo->symbuf_size)
2398 if (! elf_link_flush_output_syms (finfo))
2402 elf_swap_symbol_out (finfo->output_bfd, elfsym,
2403 (PTR) (finfo->symbuf + finfo->symbuf_count));
2404 ++finfo->symbuf_count;
2406 ++finfo->output_bfd->symcount;
2411 /* Flush the output symbols to the file. */
2414 elf_link_flush_output_syms (finfo)
2415 struct elf_final_link_info *finfo;
2417 if (finfo->symbuf_count > 0)
2419 Elf_Internal_Shdr *symtab;
2421 symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
2423 if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
2425 || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
2426 sizeof (Elf_External_Sym), finfo->output_bfd)
2427 != finfo->symbuf_count * sizeof (Elf_External_Sym)))
2430 symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
2432 finfo->symbuf_count = 0;
2438 /* Add an external symbol to the symbol table. This is called from
2439 the hash table traversal routine. */
2442 elf_link_output_extsym (h, data)
2443 struct elf_link_hash_entry *h;
2446 struct elf_finfo_failed *eif = (struct elf_finfo_failed *) data;
2447 struct elf_final_link_info *finfo = eif->finfo;
2449 Elf_Internal_Sym sym;
2450 asection *input_sec;
2452 /* If we are not creating a shared library, and this symbol is
2453 referenced by a shared library but is not defined anywhere, then
2454 warn that it is undefined. If we do not do this, the runtime
2455 linker will complain that the symbol is undefined when the
2456 program is run. We don't have to worry about symbols that are
2457 referenced by regular files, because we will already have issued
2458 warnings for them. */
2459 if (! finfo->info->relocateable
2460 && ! finfo->info->shared
2461 && h->root.type == bfd_link_hash_undefined
2462 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
2463 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2465 if (! ((*finfo->info->callbacks->undefined_symbol)
2466 (finfo->info, h->root.root.string, h->root.u.undef.abfd,
2467 (asection *) NULL, 0)))
2474 /* We don't want to output symbols that have never been mentioned by
2475 a regular file, or that we have been told to strip. However, if
2476 h->indx is set to -2, the symbol is used by a reloc and we must
2480 else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2481 || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2482 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2483 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2485 else if (finfo->info->strip == strip_all
2486 || (finfo->info->strip == strip_some
2487 && bfd_hash_lookup (finfo->info->keep_hash,
2488 h->root.root.string,
2489 false, false) == NULL))
2494 /* If we're stripping it, and it's not a dynamic symbol, there's
2495 nothing else to do. */
2496 if (strip && h->dynindx == -1)
2500 sym.st_size = h->size;
2502 if (h->root.type == bfd_link_hash_undefweak
2503 || h->root.type == bfd_link_hash_defweak)
2504 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
2506 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
2508 switch (h->root.type)
2511 case bfd_link_hash_new:
2515 case bfd_link_hash_undefined:
2516 input_sec = bfd_und_section_ptr;
2517 sym.st_shndx = SHN_UNDEF;
2520 case bfd_link_hash_undefweak:
2521 input_sec = bfd_und_section_ptr;
2522 sym.st_shndx = SHN_UNDEF;
2525 case bfd_link_hash_defined:
2526 case bfd_link_hash_defweak:
2528 input_sec = h->root.u.def.section;
2529 if (input_sec->output_section != NULL)
2532 _bfd_elf_section_from_bfd_section (finfo->output_bfd,
2533 input_sec->output_section);
2534 if (sym.st_shndx == (unsigned short) -1)
2540 /* ELF symbols in relocateable files are section relative,
2541 but in nonrelocateable files they are virtual
2543 sym.st_value = h->root.u.def.value + input_sec->output_offset;
2544 if (! finfo->info->relocateable)
2545 sym.st_value += input_sec->output_section->vma;
2549 BFD_ASSERT ((bfd_get_flavour (input_sec->owner)
2550 == bfd_target_elf_flavour)
2551 && elf_elfheader (input_sec->owner)->e_type == ET_DYN);
2552 sym.st_shndx = SHN_UNDEF;
2553 input_sec = bfd_und_section_ptr;
2558 case bfd_link_hash_common:
2559 input_sec = bfd_com_section_ptr;
2560 sym.st_shndx = SHN_COMMON;
2561 sym.st_value = 1 << h->root.u.c.p->alignment_power;
2564 case bfd_link_hash_indirect:
2565 case bfd_link_hash_warning:
2566 /* We can't represent these symbols in ELF. A warning symbol
2567 may have come from a .gnu.warning.SYMBOL section anyhow. We
2568 just put the target symbol in the hash table. If the target
2569 symbol does not really exist, don't do anything. */
2570 if (h->root.u.i.link->type == bfd_link_hash_new)
2572 return (elf_link_output_extsym
2573 ((struct elf_link_hash_entry *) h->root.u.i.link, data));
2576 /* If this symbol should be put in the .dynsym section, then put it
2577 there now. We have already know the symbol index. We also fill
2578 in the entry in the .hash section. */
2579 if (h->dynindx != -1
2580 && elf_hash_table (finfo->info)->dynamic_sections_created)
2582 struct elf_backend_data *bed;
2585 bfd_byte *bucketpos;
2588 sym.st_name = h->dynstr_index;
2590 /* Give the processor backend a chance to tweak the symbol
2591 value, and also to finish up anything that needs to be done
2593 bed = get_elf_backend_data (finfo->output_bfd);
2594 if (! ((*bed->elf_backend_finish_dynamic_symbol)
2595 (finfo->output_bfd, finfo->info, h, &sym)))
2601 elf_swap_symbol_out (finfo->output_bfd, &sym,
2602 (PTR) (((Elf_External_Sym *)
2603 finfo->dynsym_sec->contents)
2606 bucketcount = elf_hash_table (finfo->info)->bucketcount;
2607 bucket = (bfd_elf_hash ((const unsigned char *) h->root.root.string)
2609 bucketpos = ((bfd_byte *) finfo->hash_sec->contents
2610 + (bucket + 2) * (ARCH_SIZE / 8));
2611 chain = get_word (finfo->output_bfd, bucketpos);
2612 put_word (finfo->output_bfd, h->dynindx, bucketpos);
2613 put_word (finfo->output_bfd, chain,
2614 ((bfd_byte *) finfo->hash_sec->contents
2615 + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
2618 /* If we're stripping it, then it was just a dynamic symbol, and
2619 there's nothing else to do. */
2623 h->indx = finfo->output_bfd->symcount;
2625 if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
2634 /* Link an input file into the linker output file. This function
2635 handles all the sections and relocations of the input file at once.
2636 This is so that we only have to read the local symbols once, and
2637 don't have to keep them in memory. */
2640 elf_link_input_bfd (finfo, input_bfd)
2641 struct elf_final_link_info *finfo;
2644 boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
2645 bfd *, asection *, bfd_byte *,
2646 Elf_Internal_Rela *,
2647 Elf_Internal_Sym *, asection **));
2649 Elf_Internal_Shdr *symtab_hdr;
2652 Elf_External_Sym *esym;
2653 Elf_External_Sym *esymend;
2654 Elf_Internal_Sym *isym;
2656 asection **ppsection;
2659 output_bfd = finfo->output_bfd;
2661 get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
2663 /* If this is a dynamic object, we don't want to do anything here:
2664 we don't want the local symbols, and we don't want the section
2666 if (elf_elfheader (input_bfd)->e_type == ET_DYN)
2669 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2670 if (elf_bad_symtab (input_bfd))
2672 locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
2677 locsymcount = symtab_hdr->sh_info;
2678 extsymoff = symtab_hdr->sh_info;
2681 /* Read the local symbols. */
2683 && (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2684 || (bfd_read (finfo->external_syms, sizeof (Elf_External_Sym),
2685 locsymcount, input_bfd)
2686 != locsymcount * sizeof (Elf_External_Sym))))
2689 /* Swap in the local symbols and write out the ones which we know
2690 are going into the output file. */
2691 esym = finfo->external_syms;
2692 esymend = esym + locsymcount;
2693 isym = finfo->internal_syms;
2694 pindex = finfo->indices;
2695 ppsection = finfo->sections;
2696 for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
2700 Elf_Internal_Sym osym;
2702 elf_swap_symbol_in (input_bfd, esym, isym);
2705 if (elf_bad_symtab (input_bfd))
2707 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
2714 if (isym->st_shndx == SHN_UNDEF)
2715 isec = bfd_und_section_ptr;
2716 else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
2717 isec = section_from_elf_index (input_bfd, isym->st_shndx);
2718 else if (isym->st_shndx == SHN_ABS)
2719 isec = bfd_abs_section_ptr;
2720 else if (isym->st_shndx == SHN_COMMON)
2721 isec = bfd_com_section_ptr;
2730 /* Don't output the first, undefined, symbol. */
2731 if (esym == finfo->external_syms)
2734 /* If we are stripping all symbols, we don't want to output this
2736 if (finfo->info->strip == strip_all)
2739 /* We never output section symbols. Instead, we use the section
2740 symbol of the corresponding section in the output file. */
2741 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2744 /* If we are discarding all local symbols, we don't want to
2745 output this one. If we are generating a relocateable output
2746 file, then some of the local symbols may be required by
2747 relocs; we output them below as we discover that they are
2749 if (finfo->info->discard == discard_all)
2752 /* Get the name of the symbol. */
2753 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
2758 /* See if we are discarding symbols with this name. */
2759 if ((finfo->info->strip == strip_some
2760 && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
2762 || (finfo->info->discard == discard_l
2763 && strncmp (name, finfo->info->lprefix,
2764 finfo->info->lprefix_len) == 0))
2767 /* If we get here, we are going to output this symbol. */
2771 /* Adjust the section index for the output file. */
2772 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
2773 isec->output_section);
2774 if (osym.st_shndx == (unsigned short) -1)
2777 *pindex = output_bfd->symcount;
2779 /* ELF symbols in relocateable files are section relative, but
2780 in executable files they are virtual addresses. Note that
2781 this code assumes that all ELF sections have an associated
2782 BFD section with a reasonable value for output_offset; below
2783 we assume that they also have a reasonable value for
2784 output_section. Any special sections must be set up to meet
2785 these requirements. */
2786 osym.st_value += isec->output_offset;
2787 if (! finfo->info->relocateable)
2788 osym.st_value += isec->output_section->vma;
2790 if (! elf_link_output_sym (finfo, name, &osym, isec))
2794 /* Relocate the contents of each section. */
2795 for (o = input_bfd->sections; o != NULL; o = o->next)
2797 if ((o->flags & SEC_HAS_CONTENTS) == 0)
2800 if ((o->flags & SEC_IN_MEMORY) != 0
2801 && input_bfd == elf_hash_table (finfo->info)->dynobj)
2803 /* Section was created by elf_link_create_dynamic_sections.
2804 FIXME: This test is fragile. */
2808 /* Read the contents of the section. */
2809 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2810 (file_ptr) 0, o->_raw_size))
2813 if ((o->flags & SEC_RELOC) != 0)
2815 Elf_Internal_Rela *internal_relocs;
2817 /* Get the swapped relocs. */
2818 internal_relocs = elf_link_read_relocs (input_bfd, o,
2819 finfo->external_relocs,
2820 finfo->internal_relocs,
2822 if (internal_relocs == NULL
2823 && o->reloc_count > 0)
2826 /* Relocate the section by invoking a back end routine.
2828 The back end routine is responsible for adjusting the
2829 section contents as necessary, and (if using Rela relocs
2830 and generating a relocateable output file) adjusting the
2831 reloc addend as necessary.
2833 The back end routine does not have to worry about setting
2834 the reloc address or the reloc symbol index.
2836 The back end routine is given a pointer to the swapped in
2837 internal symbols, and can access the hash table entries
2838 for the external symbols via elf_sym_hashes (input_bfd).
2840 When generating relocateable output, the back end routine
2841 must handle STB_LOCAL/STT_SECTION symbols specially. The
2842 output symbol is going to be a section symbol
2843 corresponding to the output section, which will require
2844 the addend to be adjusted. */
2846 if (! (*relocate_section) (output_bfd, finfo->info,
2850 finfo->internal_syms,
2854 if (finfo->info->relocateable)
2856 Elf_Internal_Rela *irela;
2857 Elf_Internal_Rela *irelaend;
2858 struct elf_link_hash_entry **rel_hash;
2859 Elf_Internal_Shdr *input_rel_hdr;
2860 Elf_Internal_Shdr *output_rel_hdr;
2862 /* Adjust the reloc addresses and symbol indices. */
2864 irela = internal_relocs;
2865 irelaend = irela + o->reloc_count;
2866 rel_hash = (elf_section_data (o->output_section)->rel_hashes
2867 + o->output_section->reloc_count);
2868 for (; irela < irelaend; irela++, rel_hash++)
2870 unsigned long r_symndx;
2871 Elf_Internal_Sym *isym;
2874 irela->r_offset += o->output_offset;
2876 r_symndx = ELF_R_SYM (irela->r_info);
2881 if (r_symndx >= locsymcount
2882 || (elf_bad_symtab (input_bfd)
2883 && finfo->sections[r_symndx] == NULL))
2887 /* This is a reloc against a global symbol. We
2888 have not yet output all the local symbols, so
2889 we do not know the symbol index of any global
2890 symbol. We set the rel_hash entry for this
2891 reloc to point to the global hash table entry
2892 for this symbol. The symbol index is then
2893 set at the end of elf_bfd_final_link. */
2894 indx = r_symndx - extsymoff;
2895 *rel_hash = elf_sym_hashes (input_bfd)[indx];
2897 /* Setting the index to -2 tells
2898 elf_link_output_extsym that this symbol is
2900 BFD_ASSERT ((*rel_hash)->indx < 0);
2901 (*rel_hash)->indx = -2;
2906 /* This is a reloc against a local symbol. */
2909 isym = finfo->internal_syms + r_symndx;
2910 sec = finfo->sections[r_symndx];
2911 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2913 /* I suppose the backend ought to fill in the
2914 section of any STT_SECTION symbol against a
2915 processor specific section. */
2916 if (sec != NULL && bfd_is_abs_section (sec))
2918 else if (sec == NULL || sec->owner == NULL)
2920 bfd_set_error (bfd_error_bad_value);
2925 r_symndx = sec->output_section->target_index;
2926 BFD_ASSERT (r_symndx != 0);
2931 if (finfo->indices[r_symndx] == -1)
2937 if (finfo->info->strip == strip_all)
2939 /* You can't do ld -r -s. */
2940 bfd_set_error (bfd_error_invalid_operation);
2944 /* This symbol was skipped earlier, but
2945 since it is needed by a reloc, we
2946 must output it now. */
2947 link = symtab_hdr->sh_link;
2948 name = bfd_elf_string_from_elf_section (input_bfd,
2954 osec = sec->output_section;
2956 _bfd_elf_section_from_bfd_section (output_bfd,
2958 if (isym->st_shndx == (unsigned short) -1)
2961 isym->st_value += sec->output_offset;
2962 if (! finfo->info->relocateable)
2963 isym->st_value += osec->vma;
2965 finfo->indices[r_symndx] = output_bfd->symcount;
2967 if (! elf_link_output_sym (finfo, name, isym, sec))
2971 r_symndx = finfo->indices[r_symndx];
2974 irela->r_info = ELF_R_INFO (r_symndx,
2975 ELF_R_TYPE (irela->r_info));
2978 /* Swap out the relocs. */
2979 input_rel_hdr = &elf_section_data (o)->rel_hdr;
2980 output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
2981 BFD_ASSERT (output_rel_hdr->sh_entsize
2982 == input_rel_hdr->sh_entsize);
2983 irela = internal_relocs;
2984 irelaend = irela + o->reloc_count;
2985 if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2987 Elf_External_Rel *erel;
2989 erel = ((Elf_External_Rel *) output_rel_hdr->contents
2990 + o->output_section->reloc_count);
2991 for (; irela < irelaend; irela++, erel++)
2993 Elf_Internal_Rel irel;
2995 irel.r_offset = irela->r_offset;
2996 irel.r_info = irela->r_info;
2997 BFD_ASSERT (irela->r_addend == 0);
2998 elf_swap_reloc_out (output_bfd, &irel, erel);
3003 Elf_External_Rela *erela;
3005 BFD_ASSERT (input_rel_hdr->sh_entsize
3006 == sizeof (Elf_External_Rela));
3007 erela = ((Elf_External_Rela *) output_rel_hdr->contents
3008 + o->output_section->reloc_count);
3009 for (; irela < irelaend; irela++, erela++)
3010 elf_swap_reloca_out (output_bfd, irela, erela);
3013 o->output_section->reloc_count += o->reloc_count;
3017 /* Write out the modified section contents. */
3018 if (! bfd_set_section_contents (output_bfd, o->output_section,
3019 finfo->contents, o->output_offset,
3020 (o->_cooked_size != 0
3029 /* Generate a reloc when linking an ELF file. This is a reloc
3030 requested by the linker, and does come from any input file. This
3031 is used to build constructor and destructor tables when linking
3035 elf_reloc_link_order (output_bfd, info, output_section, link_order)
3037 struct bfd_link_info *info;
3038 asection *output_section;
3039 struct bfd_link_order *link_order;
3041 reloc_howto_type *howto;
3045 struct elf_link_hash_entry **rel_hash_ptr;
3046 Elf_Internal_Shdr *rel_hdr;
3048 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
3051 bfd_set_error (bfd_error_bad_value);
3055 addend = link_order->u.reloc.p->addend;
3057 /* Figure out the symbol index. */
3058 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
3059 + output_section->reloc_count);
3060 if (link_order->type == bfd_section_reloc_link_order)
3062 indx = link_order->u.reloc.p->u.section->target_index;
3063 BFD_ASSERT (indx != 0);
3064 *rel_hash_ptr = NULL;
3068 struct elf_link_hash_entry *h;
3070 /* Treat a reloc against a defined symbol as though it were
3071 actually against the section. */
3072 h = elf_link_hash_lookup (elf_hash_table (info),
3073 link_order->u.reloc.p->u.name,
3074 false, false, true);
3076 && (h->root.type == bfd_link_hash_defined
3077 || h->root.type == bfd_link_hash_defweak))
3081 section = h->root.u.def.section;
3082 indx = section->output_section->target_index;
3083 *rel_hash_ptr = NULL;
3084 /* It seems that we ought to add the symbol value to the
3085 addend here, but in practice it has already been added
3086 because it was passed to constructor_callback. */
3087 addend += section->output_section->vma + section->output_offset;
3091 /* Setting the index to -2 tells elf_link_output_extsym that
3092 this symbol is used by a reloc. */
3099 if (! ((*info->callbacks->unattached_reloc)
3100 (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
3101 (asection *) NULL, (bfd_vma) 0)))
3107 /* If this is an inplace reloc, we must write the addend into the
3109 if (howto->partial_inplace && addend != 0)
3112 bfd_reloc_status_type rstat;
3116 size = bfd_get_reloc_size (howto);
3117 buf = (bfd_byte *) bfd_zmalloc (size);
3118 if (buf == (bfd_byte *) NULL)
3120 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
3126 case bfd_reloc_outofrange:
3128 case bfd_reloc_overflow:
3129 if (! ((*info->callbacks->reloc_overflow)
3131 (link_order->type == bfd_section_reloc_link_order
3132 ? bfd_section_name (output_bfd,
3133 link_order->u.reloc.p->u.section)
3134 : link_order->u.reloc.p->u.name),
3135 howto->name, addend, (bfd *) NULL, (asection *) NULL,
3143 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
3144 (file_ptr) link_order->offset, size);
3150 /* The address of a reloc is relative to the section in a
3151 relocateable file, and is a virtual address in an executable
3153 offset = link_order->offset;
3154 if (! info->relocateable)
3155 offset += output_section->vma;
3157 rel_hdr = &elf_section_data (output_section)->rel_hdr;
3159 if (rel_hdr->sh_type == SHT_REL)
3161 Elf_Internal_Rel irel;
3162 Elf_External_Rel *erel;
3164 irel.r_offset = offset;
3165 irel.r_info = ELF_R_INFO (indx, howto->type);
3166 erel = ((Elf_External_Rel *) rel_hdr->contents
3167 + output_section->reloc_count);
3168 elf_swap_reloc_out (output_bfd, &irel, erel);
3172 Elf_Internal_Rela irela;
3173 Elf_External_Rela *erela;
3175 irela.r_offset = offset;
3176 irela.r_info = ELF_R_INFO (indx, howto->type);
3177 irela.r_addend = addend;
3178 erela = ((Elf_External_Rela *) rel_hdr->contents
3179 + output_section->reloc_count);
3180 elf_swap_reloca_out (output_bfd, &irela, erela);
3183 ++output_section->reloc_count;
3189 /* Allocate a pointer to live in a linker created section. */
3192 elf_create_pointer_linker_section (abfd, info, lsect, h, rel)
3194 struct bfd_link_info *info;
3195 elf_linker_section_t *lsect;
3196 struct elf_link_hash_entry *h;
3197 const Elf_Internal_Rela *rel;
3199 elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
3200 elf_linker_section_pointers_t *linker_section_ptr;
3201 unsigned long r_symndx = ELF_R_SYM (rel->r_info);;
3203 BFD_ASSERT (lsect != NULL);
3205 /* Is this a global symbol? */
3208 /* Has this symbol already been allocated, if so, our work is done */
3209 if (_bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
3214 ptr_linker_section_ptr = &h->linker_section_pointer;
3215 /* Make sure this symbol is output as a dynamic symbol. */
3216 if (h->dynindx == -1)
3218 if (! elf_link_record_dynamic_symbol (info, h))
3222 if (lsect->rel_section)
3223 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
3226 else /* Allocation of a pointer to a local symbol */
3228 elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
3230 /* Allocate a table to hold the local symbols if first time */
3233 int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
3234 register unsigned int i;
3236 ptr = (elf_linker_section_pointers_t **)
3237 bfd_alloc (abfd, num_symbols * sizeof (elf_linker_section_pointers_t *));
3242 elf_local_ptr_offsets (abfd) = ptr;
3243 for (i = 0; i < num_symbols; i++)
3244 ptr[i] = (elf_linker_section_pointers_t *)0;
3247 /* Has this symbol already been allocated, if so, our work is done */
3248 if (_bfd_elf_find_pointer_linker_section (ptr[r_symndx],
3253 ptr_linker_section_ptr = &ptr[r_symndx];
3257 /* If we are generating a shared object, we need to
3258 output a R_<xxx>_RELATIVE reloc so that the
3259 dynamic linker can adjust this GOT entry. */
3260 BFD_ASSERT (lsect->rel_section != NULL);
3261 lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
3265 /* Allocate space for a pointer in the linker section, and allocate a new pointer record
3266 from internal memory. */
3267 BFD_ASSERT (ptr_linker_section_ptr != NULL);
3268 linker_section_ptr = (elf_linker_section_pointers_t *)
3269 bfd_alloc (abfd, sizeof (elf_linker_section_pointers_t));
3271 if (!linker_section_ptr)
3274 linker_section_ptr->next = *ptr_linker_section_ptr;
3275 linker_section_ptr->addend = rel->r_addend;
3276 linker_section_ptr->which = lsect->which;
3277 linker_section_ptr->written_address_p = false;
3278 *ptr_linker_section_ptr = linker_section_ptr;
3280 if (lsect->hole_size && lsect->hole_offset < lsect->max_hole_offset)
3282 linker_section_ptr->offset = lsect->section->_raw_size - lsect->hole_size;
3283 lsect->hole_offset += ARCH_SIZE / 8;
3284 lsect->sym_offset += ARCH_SIZE / 8;
3285 if (lsect->sym_hash) /* Bump up symbol value if needed */
3286 lsect->sym_hash->root.u.def.value += ARCH_SIZE / 8;
3289 linker_section_ptr->offset = lsect->section->_raw_size;
3291 lsect->section->_raw_size += ARCH_SIZE / 8;
3294 fprintf (stderr, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
3295 lsect->name, (long)linker_section_ptr->offset, (long)lsect->section->_raw_size);
3303 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
3306 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
3309 /* Fill in the address for a pointer generated in alinker section. */
3312 elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h, relocation, rel, relative_reloc)
3315 struct bfd_link_info *info;
3316 elf_linker_section_t *lsect;
3317 struct elf_link_hash_entry *h;
3319 const Elf_Internal_Rela *rel;
3322 elf_linker_section_pointers_t *linker_section_ptr;
3324 BFD_ASSERT (lsect != NULL);
3326 if (h != NULL) /* global symbol */
3328 linker_section_ptr = _bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
3332 BFD_ASSERT (linker_section_ptr != NULL);
3334 if (! elf_hash_table (info)->dynamic_sections_created
3337 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3339 /* This is actually a static link, or it is a
3340 -Bsymbolic link and the symbol is defined
3341 locally. We must initialize this entry in the
3344 When doing a dynamic link, we create a .rela.<xxx>
3345 relocation entry to initialize the value. This
3346 is done in the finish_dynamic_symbol routine. */
3347 if (!linker_section_ptr->written_address_p)
3349 linker_section_ptr->written_address_p = true;
3350 bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
3351 lsect->section->contents + linker_section_ptr->offset);
3355 else /* local symbol */
3357 unsigned long r_symndx = ELF_R_SYM (rel->r_info);
3358 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
3359 BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
3360 linker_section_ptr = _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd)[r_symndx],
3364 BFD_ASSERT (linker_section_ptr != NULL);
3366 /* Write out pointer if it hasn't been rewritten out before */
3367 if (!linker_section_ptr->written_address_p)
3369 linker_section_ptr->written_address_p = true;
3370 bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
3371 lsect->section->contents + linker_section_ptr->offset);
3375 asection *srel = lsect->rel_section;
3376 Elf_Internal_Rela outrel;
3378 /* We need to generate a relative reloc for the dynamic linker. */
3380 lsect->rel_section = srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
3383 BFD_ASSERT (srel != NULL);
3385 outrel.r_offset = (lsect->section->output_section->vma
3386 + lsect->section->output_offset
3387 + linker_section_ptr->offset);
3388 outrel.r_info = ELF_R_INFO (0, relative_reloc);
3389 outrel.r_addend = 0;
3390 elf_swap_reloca_out (output_bfd, &outrel,
3391 (((Elf_External_Rela *)
3392 lsect->section->contents)
3393 + lsect->section->reloc_count));
3394 ++lsect->section->reloc_count;
3399 relocation = (lsect->section->output_offset
3400 + linker_section_ptr->offset
3401 - lsect->hole_offset
3402 - lsect->sym_offset);
3405 fprintf (stderr, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
3406 lsect->name, (long)relocation, (long)relocation);
3409 /* Subtract out the addend, because it will get added back in by the normal
3411 return relocation - linker_section_ptr->addend;