1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
26 BFD support for ELF formats is being worked on.
27 Currently, the best supported back ends are for sparc and i386
28 (running svr4 or Solaris 2).
30 Documentation of the internals of the support code still needs
31 to be written. The code is changing quickly enough that we
32 haven't bothered yet. */
34 /* For sparc64-cross-sparc32. */
42 #include "libiberty.h"
44 static int elf_sort_sections (const void *, const void *);
45 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
46 static bfd_boolean prep_headers (bfd *);
47 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
48 static bfd_boolean elfcore_read_notes (bfd *, file_ptr, bfd_size_type) ;
50 /* Swap version information in and out. The version information is
51 currently size independent. If that ever changes, this code will
52 need to move into elfcode.h. */
54 /* Swap in a Verdef structure. */
57 _bfd_elf_swap_verdef_in (bfd *abfd,
58 const Elf_External_Verdef *src,
59 Elf_Internal_Verdef *dst)
61 dst->vd_version = H_GET_16 (abfd, src->vd_version);
62 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
63 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
64 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
65 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
66 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
67 dst->vd_next = H_GET_32 (abfd, src->vd_next);
70 /* Swap out a Verdef structure. */
73 _bfd_elf_swap_verdef_out (bfd *abfd,
74 const Elf_Internal_Verdef *src,
75 Elf_External_Verdef *dst)
77 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
78 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
79 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
80 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
81 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
82 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
83 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
86 /* Swap in a Verdaux structure. */
89 _bfd_elf_swap_verdaux_in (bfd *abfd,
90 const Elf_External_Verdaux *src,
91 Elf_Internal_Verdaux *dst)
93 dst->vda_name = H_GET_32 (abfd, src->vda_name);
94 dst->vda_next = H_GET_32 (abfd, src->vda_next);
97 /* Swap out a Verdaux structure. */
100 _bfd_elf_swap_verdaux_out (bfd *abfd,
101 const Elf_Internal_Verdaux *src,
102 Elf_External_Verdaux *dst)
104 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
105 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
108 /* Swap in a Verneed structure. */
111 _bfd_elf_swap_verneed_in (bfd *abfd,
112 const Elf_External_Verneed *src,
113 Elf_Internal_Verneed *dst)
115 dst->vn_version = H_GET_16 (abfd, src->vn_version);
116 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
117 dst->vn_file = H_GET_32 (abfd, src->vn_file);
118 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
119 dst->vn_next = H_GET_32 (abfd, src->vn_next);
122 /* Swap out a Verneed structure. */
125 _bfd_elf_swap_verneed_out (bfd *abfd,
126 const Elf_Internal_Verneed *src,
127 Elf_External_Verneed *dst)
129 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
130 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
131 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
132 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
133 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
136 /* Swap in a Vernaux structure. */
139 _bfd_elf_swap_vernaux_in (bfd *abfd,
140 const Elf_External_Vernaux *src,
141 Elf_Internal_Vernaux *dst)
143 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
144 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
145 dst->vna_other = H_GET_16 (abfd, src->vna_other);
146 dst->vna_name = H_GET_32 (abfd, src->vna_name);
147 dst->vna_next = H_GET_32 (abfd, src->vna_next);
150 /* Swap out a Vernaux structure. */
153 _bfd_elf_swap_vernaux_out (bfd *abfd,
154 const Elf_Internal_Vernaux *src,
155 Elf_External_Vernaux *dst)
157 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
158 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
159 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
160 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
161 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
164 /* Swap in a Versym structure. */
167 _bfd_elf_swap_versym_in (bfd *abfd,
168 const Elf_External_Versym *src,
169 Elf_Internal_Versym *dst)
171 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
174 /* Swap out a Versym structure. */
177 _bfd_elf_swap_versym_out (bfd *abfd,
178 const Elf_Internal_Versym *src,
179 Elf_External_Versym *dst)
181 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
184 /* Standard ELF hash function. Do not change this function; you will
185 cause invalid hash tables to be generated. */
188 bfd_elf_hash (const char *namearg)
190 const unsigned char *name = (const unsigned char *) namearg;
195 while ((ch = *name++) != '\0')
198 if ((g = (h & 0xf0000000)) != 0)
201 /* The ELF ABI says `h &= ~g', but this is equivalent in
202 this case and on some machines one insn instead of two. */
206 return h & 0xffffffff;
209 /* Read a specified number of bytes at a specified offset in an ELF
210 file, into a newly allocated buffer, and return a pointer to the
214 elf_read (bfd *abfd, file_ptr offset, bfd_size_type size)
218 if ((buf = bfd_alloc (abfd, size)) == NULL)
220 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
222 if (bfd_bread (buf, size, abfd) != size)
224 if (bfd_get_error () != bfd_error_system_call)
225 bfd_set_error (bfd_error_file_truncated);
232 bfd_elf_mkobject (bfd *abfd)
234 /* This just does initialization. */
235 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
236 elf_tdata (abfd) = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
237 if (elf_tdata (abfd) == 0)
239 /* Since everything is done at close time, do we need any
246 bfd_elf_mkcorefile (bfd *abfd)
248 /* I think this can be done just like an object file. */
249 return bfd_elf_mkobject (abfd);
253 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
255 Elf_Internal_Shdr **i_shdrp;
256 bfd_byte *shstrtab = NULL;
258 bfd_size_type shstrtabsize;
260 i_shdrp = elf_elfsections (abfd);
261 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
264 shstrtab = i_shdrp[shindex]->contents;
265 if (shstrtab == NULL)
267 /* No cached one, attempt to read, and cache what we read. */
268 offset = i_shdrp[shindex]->sh_offset;
269 shstrtabsize = i_shdrp[shindex]->sh_size;
270 shstrtab = elf_read (abfd, offset, shstrtabsize);
271 i_shdrp[shindex]->contents = shstrtab;
273 return (char *) shstrtab;
277 bfd_elf_string_from_elf_section (bfd *abfd,
278 unsigned int shindex,
279 unsigned int strindex)
281 Elf_Internal_Shdr *hdr;
286 hdr = elf_elfsections (abfd)[shindex];
288 if (hdr->contents == NULL
289 && bfd_elf_get_str_section (abfd, shindex) == NULL)
292 if (strindex >= hdr->sh_size)
294 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
295 (*_bfd_error_handler)
296 (_("%B: invalid string offset %u >= %lu for section `%s'"),
297 abfd, strindex, (unsigned long) hdr->sh_size,
298 (shindex == shstrndx && strindex == hdr->sh_name
300 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
304 return ((char *) hdr->contents) + strindex;
307 /* Read and convert symbols to internal format.
308 SYMCOUNT specifies the number of symbols to read, starting from
309 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
310 are non-NULL, they are used to store the internal symbols, external
311 symbols, and symbol section index extensions, respectively. */
314 bfd_elf_get_elf_syms (bfd *ibfd,
315 Elf_Internal_Shdr *symtab_hdr,
318 Elf_Internal_Sym *intsym_buf,
320 Elf_External_Sym_Shndx *extshndx_buf)
322 Elf_Internal_Shdr *shndx_hdr;
324 const bfd_byte *esym;
325 Elf_External_Sym_Shndx *alloc_extshndx;
326 Elf_External_Sym_Shndx *shndx;
327 Elf_Internal_Sym *isym;
328 Elf_Internal_Sym *isymend;
329 const struct elf_backend_data *bed;
337 /* Normal syms might have section extension entries. */
339 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
340 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
342 /* Read the symbols. */
344 alloc_extshndx = NULL;
345 bed = get_elf_backend_data (ibfd);
346 extsym_size = bed->s->sizeof_sym;
347 amt = symcount * extsym_size;
348 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
349 if (extsym_buf == NULL)
351 alloc_ext = bfd_malloc (amt);
352 extsym_buf = alloc_ext;
354 if (extsym_buf == NULL
355 || bfd_seek (ibfd, pos, SEEK_SET) != 0
356 || bfd_bread (extsym_buf, amt, ibfd) != amt)
362 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
366 amt = symcount * sizeof (Elf_External_Sym_Shndx);
367 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
368 if (extshndx_buf == NULL)
370 alloc_extshndx = bfd_malloc (amt);
371 extshndx_buf = alloc_extshndx;
373 if (extshndx_buf == NULL
374 || bfd_seek (ibfd, pos, SEEK_SET) != 0
375 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
382 if (intsym_buf == NULL)
384 bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
385 intsym_buf = bfd_malloc (amt);
386 if (intsym_buf == NULL)
390 /* Convert the symbols to internal form. */
391 isymend = intsym_buf + symcount;
392 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
394 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
395 (*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym);
398 if (alloc_ext != NULL)
400 if (alloc_extshndx != NULL)
401 free (alloc_extshndx);
406 /* Look up a symbol name. */
408 bfd_elf_sym_name (bfd *abfd,
409 Elf_Internal_Shdr *symtab_hdr,
410 Elf_Internal_Sym *isym,
414 unsigned int iname = isym->st_name;
415 unsigned int shindex = symtab_hdr->sh_link;
417 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
418 /* Check for a bogus st_shndx to avoid crashing. */
419 && isym->st_shndx < elf_numsections (abfd)
420 && !(isym->st_shndx >= SHN_LORESERVE && isym->st_shndx <= SHN_HIRESERVE))
422 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
423 shindex = elf_elfheader (abfd)->e_shstrndx;
426 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
429 else if (sym_sec && *name == '\0')
430 name = bfd_section_name (abfd, sym_sec);
435 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
436 sections. The first element is the flags, the rest are section
439 typedef union elf_internal_group {
440 Elf_Internal_Shdr *shdr;
442 } Elf_Internal_Group;
444 /* Return the name of the group signature symbol. Why isn't the
445 signature just a string? */
448 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
450 Elf_Internal_Shdr *hdr;
451 unsigned char esym[sizeof (Elf64_External_Sym)];
452 Elf_External_Sym_Shndx eshndx;
453 Elf_Internal_Sym isym;
455 /* First we need to ensure the symbol table is available. */
456 if (! bfd_section_from_shdr (abfd, ghdr->sh_link))
459 /* Go read the symbol. */
460 hdr = &elf_tdata (abfd)->symtab_hdr;
461 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
462 &isym, esym, &eshndx) == NULL)
465 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
468 /* Set next_in_group list pointer, and group name for NEWSECT. */
471 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
473 unsigned int num_group = elf_tdata (abfd)->num_group;
475 /* If num_group is zero, read in all SHT_GROUP sections. The count
476 is set to -1 if there are no SHT_GROUP sections. */
479 unsigned int i, shnum;
481 /* First count the number of groups. If we have a SHT_GROUP
482 section with just a flag word (ie. sh_size is 4), ignore it. */
483 shnum = elf_numsections (abfd);
485 for (i = 0; i < shnum; i++)
487 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
488 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
494 num_group = (unsigned) -1;
495 elf_tdata (abfd)->num_group = num_group;
499 /* We keep a list of elf section headers for group sections,
500 so we can find them quickly. */
503 elf_tdata (abfd)->num_group = num_group;
504 amt = num_group * sizeof (Elf_Internal_Shdr *);
505 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
506 if (elf_tdata (abfd)->group_sect_ptr == NULL)
510 for (i = 0; i < shnum; i++)
512 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
513 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
516 Elf_Internal_Group *dest;
518 /* Add to list of sections. */
519 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
522 /* Read the raw contents. */
523 BFD_ASSERT (sizeof (*dest) >= 4);
524 amt = shdr->sh_size * sizeof (*dest) / 4;
525 shdr->contents = bfd_alloc (abfd, amt);
526 if (shdr->contents == NULL
527 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
528 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
532 /* Translate raw contents, a flag word followed by an
533 array of elf section indices all in target byte order,
534 to the flag word followed by an array of elf section
536 src = shdr->contents + shdr->sh_size;
537 dest = (Elf_Internal_Group *) (shdr->contents + amt);
544 idx = H_GET_32 (abfd, src);
545 if (src == shdr->contents)
548 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
549 shdr->bfd_section->flags
550 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
555 ((*_bfd_error_handler)
556 (_("%B: invalid SHT_GROUP entry"), abfd));
559 dest->shdr = elf_elfsections (abfd)[idx];
566 if (num_group != (unsigned) -1)
570 for (i = 0; i < num_group; i++)
572 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
573 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
574 unsigned int n_elt = shdr->sh_size / 4;
576 /* Look through this group's sections to see if current
577 section is a member. */
579 if ((++idx)->shdr == hdr)
583 /* We are a member of this group. Go looking through
584 other members to see if any others are linked via
586 idx = (Elf_Internal_Group *) shdr->contents;
587 n_elt = shdr->sh_size / 4;
589 if ((s = (++idx)->shdr->bfd_section) != NULL
590 && elf_next_in_group (s) != NULL)
594 /* Snarf the group name from other member, and
595 insert current section in circular list. */
596 elf_group_name (newsect) = elf_group_name (s);
597 elf_next_in_group (newsect) = elf_next_in_group (s);
598 elf_next_in_group (s) = newsect;
604 gname = group_signature (abfd, shdr);
607 elf_group_name (newsect) = gname;
609 /* Start a circular list with one element. */
610 elf_next_in_group (newsect) = newsect;
613 /* If the group section has been created, point to the
615 if (shdr->bfd_section != NULL)
616 elf_next_in_group (shdr->bfd_section) = newsect;
624 if (elf_group_name (newsect) == NULL)
626 (*_bfd_error_handler) (_("%B: no group info for section %A"),
633 _bfd_elf_setup_group_pointers (bfd *abfd)
636 unsigned int num_group = elf_tdata (abfd)->num_group;
637 bfd_boolean result = TRUE;
639 if (num_group == (unsigned) -1)
642 for (i = 0; i < num_group; i++)
644 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
645 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
646 unsigned int n_elt = shdr->sh_size / 4;
649 if ((++idx)->shdr->bfd_section)
650 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
651 else if (idx->shdr->sh_type == SHT_RELA
652 || idx->shdr->sh_type == SHT_REL)
653 /* We won't include relocation sections in section groups in
654 output object files. We adjust the group section size here
655 so that relocatable link will work correctly when
656 relocation sections are in section group in input object
658 shdr->bfd_section->size -= 4;
661 /* There are some unknown sections in the group. */
662 (*_bfd_error_handler)
663 (_("%B: unknown [%d] section `%s' in group [%s]"),
665 (unsigned int) idx->shdr->sh_type,
666 bfd_elf_string_from_elf_section (abfd,
667 (elf_elfheader (abfd)
670 shdr->bfd_section->name);
678 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
680 return elf_next_in_group (sec) != NULL;
683 /* Make a BFD section from an ELF section. We store a pointer to the
684 BFD section in the bfd_section field of the header. */
687 _bfd_elf_make_section_from_shdr (bfd *abfd,
688 Elf_Internal_Shdr *hdr,
694 const struct elf_backend_data *bed;
696 if (hdr->bfd_section != NULL)
698 BFD_ASSERT (strcmp (name,
699 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
703 newsect = bfd_make_section_anyway (abfd, name);
707 hdr->bfd_section = newsect;
708 elf_section_data (newsect)->this_hdr = *hdr;
709 elf_section_data (newsect)->this_idx = shindex;
711 /* Always use the real type/flags. */
712 elf_section_type (newsect) = hdr->sh_type;
713 elf_section_flags (newsect) = hdr->sh_flags;
715 newsect->filepos = hdr->sh_offset;
717 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
718 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
719 || ! bfd_set_section_alignment (abfd, newsect,
720 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
723 flags = SEC_NO_FLAGS;
724 if (hdr->sh_type != SHT_NOBITS)
725 flags |= SEC_HAS_CONTENTS;
726 if (hdr->sh_type == SHT_GROUP)
727 flags |= SEC_GROUP | SEC_EXCLUDE;
728 if ((hdr->sh_flags & SHF_ALLOC) != 0)
731 if (hdr->sh_type != SHT_NOBITS)
734 if ((hdr->sh_flags & SHF_WRITE) == 0)
735 flags |= SEC_READONLY;
736 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
738 else if ((flags & SEC_LOAD) != 0)
740 if ((hdr->sh_flags & SHF_MERGE) != 0)
743 newsect->entsize = hdr->sh_entsize;
744 if ((hdr->sh_flags & SHF_STRINGS) != 0)
745 flags |= SEC_STRINGS;
747 if (hdr->sh_flags & SHF_GROUP)
748 if (!setup_group (abfd, hdr, newsect))
750 if ((hdr->sh_flags & SHF_TLS) != 0)
751 flags |= SEC_THREAD_LOCAL;
753 if ((flags & SEC_ALLOC) == 0)
755 /* The debugging sections appear to be recognized only by name,
756 not any sort of flag. Their SEC_ALLOC bits are cleared. */
761 } debug_sections [] =
763 { "debug", 5 }, /* 'd' */
764 { NULL, 0 }, /* 'e' */
765 { NULL, 0 }, /* 'f' */
766 { "gnu.linkonce.wi.", 17 }, /* 'g' */
767 { NULL, 0 }, /* 'h' */
768 { NULL, 0 }, /* 'i' */
769 { NULL, 0 }, /* 'j' */
770 { NULL, 0 }, /* 'k' */
771 { "line", 4 }, /* 'l' */
772 { NULL, 0 }, /* 'm' */
773 { NULL, 0 }, /* 'n' */
774 { NULL, 0 }, /* 'o' */
775 { NULL, 0 }, /* 'p' */
776 { NULL, 0 }, /* 'q' */
777 { NULL, 0 }, /* 'r' */
778 { "stab", 4 } /* 's' */
783 int i = name [1] - 'd';
785 && i < (int) ARRAY_SIZE (debug_sections)
786 && debug_sections [i].name != NULL
787 && strncmp (&name [1], debug_sections [i].name,
788 debug_sections [i].len) == 0)
789 flags |= SEC_DEBUGGING;
793 /* As a GNU extension, if the name begins with .gnu.linkonce, we
794 only link a single copy of the section. This is used to support
795 g++. g++ will emit each template expansion in its own section.
796 The symbols will be defined as weak, so that multiple definitions
797 are permitted. The GNU linker extension is to actually discard
798 all but one of the sections. */
799 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
800 && elf_next_in_group (newsect) == NULL)
801 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
803 bed = get_elf_backend_data (abfd);
804 if (bed->elf_backend_section_flags)
805 if (! bed->elf_backend_section_flags (&flags, hdr))
808 if (! bfd_set_section_flags (abfd, newsect, flags))
811 if ((flags & SEC_ALLOC) != 0)
813 Elf_Internal_Phdr *phdr;
816 /* Look through the phdrs to see if we need to adjust the lma.
817 If all the p_paddr fields are zero, we ignore them, since
818 some ELF linkers produce such output. */
819 phdr = elf_tdata (abfd)->phdr;
820 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
822 if (phdr->p_paddr != 0)
825 if (i < elf_elfheader (abfd)->e_phnum)
827 phdr = elf_tdata (abfd)->phdr;
828 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
830 /* This section is part of this segment if its file
831 offset plus size lies within the segment's memory
832 span and, if the section is loaded, the extent of the
833 loaded data lies within the extent of the segment.
835 Note - we used to check the p_paddr field as well, and
836 refuse to set the LMA if it was 0. This is wrong
837 though, as a perfectly valid initialised segment can
838 have a p_paddr of zero. Some architectures, eg ARM,
839 place special significance on the address 0 and
840 executables need to be able to have a segment which
841 covers this address. */
842 if (phdr->p_type == PT_LOAD
843 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
844 && (hdr->sh_offset + hdr->sh_size
845 <= phdr->p_offset + phdr->p_memsz)
846 && ((flags & SEC_LOAD) == 0
847 || (hdr->sh_offset + hdr->sh_size
848 <= phdr->p_offset + phdr->p_filesz)))
850 if ((flags & SEC_LOAD) == 0)
851 newsect->lma = (phdr->p_paddr
852 + hdr->sh_addr - phdr->p_vaddr);
854 /* We used to use the same adjustment for SEC_LOAD
855 sections, but that doesn't work if the segment
856 is packed with code from multiple VMAs.
857 Instead we calculate the section LMA based on
858 the segment LMA. It is assumed that the
859 segment will contain sections with contiguous
860 LMAs, even if the VMAs are not. */
861 newsect->lma = (phdr->p_paddr
862 + hdr->sh_offset - phdr->p_offset);
864 /* With contiguous segments, we can't tell from file
865 offsets whether a section with zero size should
866 be placed at the end of one segment or the
867 beginning of the next. Decide based on vaddr. */
868 if (hdr->sh_addr >= phdr->p_vaddr
869 && (hdr->sh_addr + hdr->sh_size
870 <= phdr->p_vaddr + phdr->p_memsz))
885 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
888 Helper functions for GDB to locate the string tables.
889 Since BFD hides string tables from callers, GDB needs to use an
890 internal hook to find them. Sun's .stabstr, in particular,
891 isn't even pointed to by the .stab section, so ordinary
892 mechanisms wouldn't work to find it, even if we had some.
895 struct elf_internal_shdr *
896 bfd_elf_find_section (bfd *abfd, char *name)
898 Elf_Internal_Shdr **i_shdrp;
903 i_shdrp = elf_elfsections (abfd);
906 shstrtab = bfd_elf_get_str_section (abfd,
907 elf_elfheader (abfd)->e_shstrndx);
908 if (shstrtab != NULL)
910 max = elf_numsections (abfd);
911 for (i = 1; i < max; i++)
912 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
919 const char *const bfd_elf_section_type_names[] = {
920 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
921 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
922 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
925 /* ELF relocs are against symbols. If we are producing relocatable
926 output, and the reloc is against an external symbol, and nothing
927 has given us any additional addend, the resulting reloc will also
928 be against the same symbol. In such a case, we don't want to
929 change anything about the way the reloc is handled, since it will
930 all be done at final link time. Rather than put special case code
931 into bfd_perform_relocation, all the reloc types use this howto
932 function. It just short circuits the reloc if producing
933 relocatable output against an external symbol. */
935 bfd_reloc_status_type
936 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
937 arelent *reloc_entry,
939 void *data ATTRIBUTE_UNUSED,
940 asection *input_section,
942 char **error_message ATTRIBUTE_UNUSED)
944 if (output_bfd != NULL
945 && (symbol->flags & BSF_SECTION_SYM) == 0
946 && (! reloc_entry->howto->partial_inplace
947 || reloc_entry->addend == 0))
949 reloc_entry->address += input_section->output_offset;
953 return bfd_reloc_continue;
956 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
959 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
962 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
963 sec->sec_info_type = ELF_INFO_TYPE_NONE;
966 /* Finish SHF_MERGE section merging. */
969 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
974 if (!is_elf_hash_table (info->hash))
977 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
978 if ((ibfd->flags & DYNAMIC) == 0)
979 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
980 if ((sec->flags & SEC_MERGE) != 0
981 && !bfd_is_abs_section (sec->output_section))
983 struct bfd_elf_section_data *secdata;
985 secdata = elf_section_data (sec);
986 if (! _bfd_add_merge_section (abfd,
987 &elf_hash_table (info)->merge_info,
988 sec, &secdata->sec_info))
990 else if (secdata->sec_info)
991 sec->sec_info_type = ELF_INFO_TYPE_MERGE;
994 if (elf_hash_table (info)->merge_info != NULL)
995 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
996 merge_sections_remove_hook);
1001 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
1003 sec->output_section = bfd_abs_section_ptr;
1004 sec->output_offset = sec->vma;
1005 if (!is_elf_hash_table (info->hash))
1008 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
1011 /* Copy the program header and other data from one object module to
1015 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1017 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1018 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1021 BFD_ASSERT (!elf_flags_init (obfd)
1022 || (elf_elfheader (obfd)->e_flags
1023 == elf_elfheader (ibfd)->e_flags));
1025 elf_gp (obfd) = elf_gp (ibfd);
1026 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1027 elf_flags_init (obfd) = TRUE;
1031 /* Print out the program headers. */
1034 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1037 Elf_Internal_Phdr *p;
1039 bfd_byte *dynbuf = NULL;
1041 p = elf_tdata (abfd)->phdr;
1046 fprintf (f, _("\nProgram Header:\n"));
1047 c = elf_elfheader (abfd)->e_phnum;
1048 for (i = 0; i < c; i++, p++)
1055 case PT_NULL: pt = "NULL"; break;
1056 case PT_LOAD: pt = "LOAD"; break;
1057 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1058 case PT_INTERP: pt = "INTERP"; break;
1059 case PT_NOTE: pt = "NOTE"; break;
1060 case PT_SHLIB: pt = "SHLIB"; break;
1061 case PT_PHDR: pt = "PHDR"; break;
1062 case PT_TLS: pt = "TLS"; break;
1063 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1064 case PT_GNU_STACK: pt = "STACK"; break;
1065 case PT_GNU_RELRO: pt = "RELRO"; break;
1066 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
1068 fprintf (f, "%8s off 0x", pt);
1069 bfd_fprintf_vma (abfd, f, p->p_offset);
1070 fprintf (f, " vaddr 0x");
1071 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1072 fprintf (f, " paddr 0x");
1073 bfd_fprintf_vma (abfd, f, p->p_paddr);
1074 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1075 fprintf (f, " filesz 0x");
1076 bfd_fprintf_vma (abfd, f, p->p_filesz);
1077 fprintf (f, " memsz 0x");
1078 bfd_fprintf_vma (abfd, f, p->p_memsz);
1079 fprintf (f, " flags %c%c%c",
1080 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1081 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1082 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1083 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1084 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1089 s = bfd_get_section_by_name (abfd, ".dynamic");
1093 unsigned long shlink;
1094 bfd_byte *extdyn, *extdynend;
1096 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1098 fprintf (f, _("\nDynamic Section:\n"));
1100 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1103 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1106 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1108 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1109 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1112 extdynend = extdyn + s->size;
1113 for (; extdyn < extdynend; extdyn += extdynsize)
1115 Elf_Internal_Dyn dyn;
1118 bfd_boolean stringp;
1120 (*swap_dyn_in) (abfd, extdyn, &dyn);
1122 if (dyn.d_tag == DT_NULL)
1129 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1133 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1134 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1135 case DT_PLTGOT: name = "PLTGOT"; break;
1136 case DT_HASH: name = "HASH"; break;
1137 case DT_STRTAB: name = "STRTAB"; break;
1138 case DT_SYMTAB: name = "SYMTAB"; break;
1139 case DT_RELA: name = "RELA"; break;
1140 case DT_RELASZ: name = "RELASZ"; break;
1141 case DT_RELAENT: name = "RELAENT"; break;
1142 case DT_STRSZ: name = "STRSZ"; break;
1143 case DT_SYMENT: name = "SYMENT"; break;
1144 case DT_INIT: name = "INIT"; break;
1145 case DT_FINI: name = "FINI"; break;
1146 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1147 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1148 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1149 case DT_REL: name = "REL"; break;
1150 case DT_RELSZ: name = "RELSZ"; break;
1151 case DT_RELENT: name = "RELENT"; break;
1152 case DT_PLTREL: name = "PLTREL"; break;
1153 case DT_DEBUG: name = "DEBUG"; break;
1154 case DT_TEXTREL: name = "TEXTREL"; break;
1155 case DT_JMPREL: name = "JMPREL"; break;
1156 case DT_BIND_NOW: name = "BIND_NOW"; break;
1157 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1158 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1159 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1160 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1161 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1162 case DT_FLAGS: name = "FLAGS"; break;
1163 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1164 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1165 case DT_CHECKSUM: name = "CHECKSUM"; break;
1166 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1167 case DT_MOVEENT: name = "MOVEENT"; break;
1168 case DT_MOVESZ: name = "MOVESZ"; break;
1169 case DT_FEATURE: name = "FEATURE"; break;
1170 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1171 case DT_SYMINSZ: name = "SYMINSZ"; break;
1172 case DT_SYMINENT: name = "SYMINENT"; break;
1173 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1174 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1175 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1176 case DT_PLTPAD: name = "PLTPAD"; break;
1177 case DT_MOVETAB: name = "MOVETAB"; break;
1178 case DT_SYMINFO: name = "SYMINFO"; break;
1179 case DT_RELACOUNT: name = "RELACOUNT"; break;
1180 case DT_RELCOUNT: name = "RELCOUNT"; break;
1181 case DT_FLAGS_1: name = "FLAGS_1"; break;
1182 case DT_VERSYM: name = "VERSYM"; break;
1183 case DT_VERDEF: name = "VERDEF"; break;
1184 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1185 case DT_VERNEED: name = "VERNEED"; break;
1186 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1187 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1188 case DT_USED: name = "USED"; break;
1189 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1192 fprintf (f, " %-11s ", name);
1194 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1198 unsigned int tagv = dyn.d_un.d_val;
1200 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1203 fprintf (f, "%s", string);
1212 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1213 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1215 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1219 if (elf_dynverdef (abfd) != 0)
1221 Elf_Internal_Verdef *t;
1223 fprintf (f, _("\nVersion definitions:\n"));
1224 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1226 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1227 t->vd_flags, t->vd_hash, t->vd_nodename);
1228 if (t->vd_auxptr->vda_nextptr != NULL)
1230 Elf_Internal_Verdaux *a;
1233 for (a = t->vd_auxptr->vda_nextptr;
1236 fprintf (f, "%s ", a->vda_nodename);
1242 if (elf_dynverref (abfd) != 0)
1244 Elf_Internal_Verneed *t;
1246 fprintf (f, _("\nVersion References:\n"));
1247 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1249 Elf_Internal_Vernaux *a;
1251 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1252 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1253 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1254 a->vna_flags, a->vna_other, a->vna_nodename);
1266 /* Display ELF-specific fields of a symbol. */
1269 bfd_elf_print_symbol (bfd *abfd,
1272 bfd_print_symbol_type how)
1277 case bfd_print_symbol_name:
1278 fprintf (file, "%s", symbol->name);
1280 case bfd_print_symbol_more:
1281 fprintf (file, "elf ");
1282 bfd_fprintf_vma (abfd, file, symbol->value);
1283 fprintf (file, " %lx", (long) symbol->flags);
1285 case bfd_print_symbol_all:
1287 const char *section_name;
1288 const char *name = NULL;
1289 const struct elf_backend_data *bed;
1290 unsigned char st_other;
1293 section_name = symbol->section ? symbol->section->name : "(*none*)";
1295 bed = get_elf_backend_data (abfd);
1296 if (bed->elf_backend_print_symbol_all)
1297 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1301 name = symbol->name;
1302 bfd_print_symbol_vandf (abfd, file, symbol);
1305 fprintf (file, " %s\t", section_name);
1306 /* Print the "other" value for a symbol. For common symbols,
1307 we've already printed the size; now print the alignment.
1308 For other symbols, we have no specified alignment, and
1309 we've printed the address; now print the size. */
1310 if (bfd_is_com_section (symbol->section))
1311 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1313 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1314 bfd_fprintf_vma (abfd, file, val);
1316 /* If we have version information, print it. */
1317 if (elf_tdata (abfd)->dynversym_section != 0
1318 && (elf_tdata (abfd)->dynverdef_section != 0
1319 || elf_tdata (abfd)->dynverref_section != 0))
1321 unsigned int vernum;
1322 const char *version_string;
1324 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1327 version_string = "";
1328 else if (vernum == 1)
1329 version_string = "Base";
1330 else if (vernum <= elf_tdata (abfd)->cverdefs)
1332 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1335 Elf_Internal_Verneed *t;
1337 version_string = "";
1338 for (t = elf_tdata (abfd)->verref;
1342 Elf_Internal_Vernaux *a;
1344 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1346 if (a->vna_other == vernum)
1348 version_string = a->vna_nodename;
1355 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1356 fprintf (file, " %-11s", version_string);
1361 fprintf (file, " (%s)", version_string);
1362 for (i = 10 - strlen (version_string); i > 0; --i)
1367 /* If the st_other field is not zero, print it. */
1368 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1373 case STV_INTERNAL: fprintf (file, " .internal"); break;
1374 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1375 case STV_PROTECTED: fprintf (file, " .protected"); break;
1377 /* Some other non-defined flags are also present, so print
1379 fprintf (file, " 0x%02x", (unsigned int) st_other);
1382 fprintf (file, " %s", name);
1388 /* Create an entry in an ELF linker hash table. */
1390 struct bfd_hash_entry *
1391 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1392 struct bfd_hash_table *table,
1395 /* Allocate the structure if it has not already been allocated by a
1399 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1404 /* Call the allocation method of the superclass. */
1405 entry = _bfd_link_hash_newfunc (entry, table, string);
1408 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1409 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1411 /* Set local fields. */
1414 ret->got = ret->plt = htab->init_refcount;
1415 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
1416 - offsetof (struct elf_link_hash_entry, size)));
1417 /* Assume that we have been called by a non-ELF symbol reader.
1418 This flag is then reset by the code which reads an ELF input
1419 file. This ensures that a symbol created by a non-ELF symbol
1420 reader will have the flag set correctly. */
1427 /* Copy data from an indirect symbol to its direct symbol, hiding the
1428 old indirect symbol. Also used for copying flags to a weakdef. */
1431 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data *bed,
1432 struct elf_link_hash_entry *dir,
1433 struct elf_link_hash_entry *ind)
1436 bfd_signed_vma lowest_valid = bed->can_refcount;
1438 /* Copy down any references that we may have already seen to the
1439 symbol which just became indirect. */
1441 dir->ref_dynamic |= ind->ref_dynamic;
1442 dir->ref_regular |= ind->ref_regular;
1443 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1444 dir->non_got_ref |= ind->non_got_ref;
1445 dir->needs_plt |= ind->needs_plt;
1446 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1448 if (ind->root.type != bfd_link_hash_indirect)
1451 /* Copy over the global and procedure linkage table refcount entries.
1452 These may have been already set up by a check_relocs routine. */
1453 tmp = dir->got.refcount;
1454 if (tmp < lowest_valid)
1456 dir->got.refcount = ind->got.refcount;
1457 ind->got.refcount = tmp;
1460 BFD_ASSERT (ind->got.refcount < lowest_valid);
1462 tmp = dir->plt.refcount;
1463 if (tmp < lowest_valid)
1465 dir->plt.refcount = ind->plt.refcount;
1466 ind->plt.refcount = tmp;
1469 BFD_ASSERT (ind->plt.refcount < lowest_valid);
1471 if (dir->dynindx == -1)
1473 dir->dynindx = ind->dynindx;
1474 dir->dynstr_index = ind->dynstr_index;
1476 ind->dynstr_index = 0;
1479 BFD_ASSERT (ind->dynindx == -1);
1483 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
1484 struct elf_link_hash_entry *h,
1485 bfd_boolean force_local)
1487 h->plt = elf_hash_table (info)->init_offset;
1491 h->forced_local = 1;
1492 if (h->dynindx != -1)
1495 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1501 /* Initialize an ELF linker hash table. */
1504 _bfd_elf_link_hash_table_init
1505 (struct elf_link_hash_table *table,
1507 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
1508 struct bfd_hash_table *,
1513 table->dynamic_sections_created = FALSE;
1514 table->dynobj = NULL;
1515 /* Make sure can_refcount is extended to the width and signedness of
1516 init_refcount before we subtract one from it. */
1517 table->init_refcount.refcount = get_elf_backend_data (abfd)->can_refcount;
1518 table->init_refcount.refcount -= 1;
1519 table->init_offset.offset = -(bfd_vma) 1;
1520 /* The first dynamic symbol is a dummy. */
1521 table->dynsymcount = 1;
1522 table->dynstr = NULL;
1523 table->bucketcount = 0;
1524 table->needed = NULL;
1526 table->merge_info = NULL;
1527 memset (&table->stab_info, 0, sizeof (table->stab_info));
1528 memset (&table->eh_info, 0, sizeof (table->eh_info));
1529 table->dynlocal = NULL;
1530 table->runpath = NULL;
1531 table->tls_sec = NULL;
1532 table->tls_size = 0;
1533 table->loaded = NULL;
1534 table->is_relocatable_executable = FALSE;
1536 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
1537 table->root.type = bfd_link_elf_hash_table;
1542 /* Create an ELF linker hash table. */
1544 struct bfd_link_hash_table *
1545 _bfd_elf_link_hash_table_create (bfd *abfd)
1547 struct elf_link_hash_table *ret;
1548 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1550 ret = bfd_malloc (amt);
1554 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1563 /* This is a hook for the ELF emulation code in the generic linker to
1564 tell the backend linker what file name to use for the DT_NEEDED
1565 entry for a dynamic object. */
1568 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
1570 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1571 && bfd_get_format (abfd) == bfd_object)
1572 elf_dt_name (abfd) = name;
1576 bfd_elf_get_dyn_lib_class (bfd *abfd)
1579 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1580 && bfd_get_format (abfd) == bfd_object)
1581 lib_class = elf_dyn_lib_class (abfd);
1588 bfd_elf_set_dyn_lib_class (bfd *abfd, int lib_class)
1590 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1591 && bfd_get_format (abfd) == bfd_object)
1592 elf_dyn_lib_class (abfd) = lib_class;
1595 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1596 the linker ELF emulation code. */
1598 struct bfd_link_needed_list *
1599 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1600 struct bfd_link_info *info)
1602 if (! is_elf_hash_table (info->hash))
1604 return elf_hash_table (info)->needed;
1607 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1608 hook for the linker ELF emulation code. */
1610 struct bfd_link_needed_list *
1611 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
1612 struct bfd_link_info *info)
1614 if (! is_elf_hash_table (info->hash))
1616 return elf_hash_table (info)->runpath;
1619 /* Get the name actually used for a dynamic object for a link. This
1620 is the SONAME entry if there is one. Otherwise, it is the string
1621 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1624 bfd_elf_get_dt_soname (bfd *abfd)
1626 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1627 && bfd_get_format (abfd) == bfd_object)
1628 return elf_dt_name (abfd);
1632 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1633 the ELF linker emulation code. */
1636 bfd_elf_get_bfd_needed_list (bfd *abfd,
1637 struct bfd_link_needed_list **pneeded)
1640 bfd_byte *dynbuf = NULL;
1642 unsigned long shlink;
1643 bfd_byte *extdyn, *extdynend;
1645 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1649 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1650 || bfd_get_format (abfd) != bfd_object)
1653 s = bfd_get_section_by_name (abfd, ".dynamic");
1654 if (s == NULL || s->size == 0)
1657 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1660 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1664 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1666 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1667 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1670 extdynend = extdyn + s->size;
1671 for (; extdyn < extdynend; extdyn += extdynsize)
1673 Elf_Internal_Dyn dyn;
1675 (*swap_dyn_in) (abfd, extdyn, &dyn);
1677 if (dyn.d_tag == DT_NULL)
1680 if (dyn.d_tag == DT_NEEDED)
1683 struct bfd_link_needed_list *l;
1684 unsigned int tagv = dyn.d_un.d_val;
1687 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1692 l = bfd_alloc (abfd, amt);
1713 /* Allocate an ELF string table--force the first byte to be zero. */
1715 struct bfd_strtab_hash *
1716 _bfd_elf_stringtab_init (void)
1718 struct bfd_strtab_hash *ret;
1720 ret = _bfd_stringtab_init ();
1725 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1726 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1727 if (loc == (bfd_size_type) -1)
1729 _bfd_stringtab_free (ret);
1736 /* ELF .o/exec file reading */
1738 /* Create a new bfd section from an ELF section header. */
1741 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1743 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1744 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1745 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1748 name = bfd_elf_string_from_elf_section (abfd,
1749 elf_elfheader (abfd)->e_shstrndx,
1752 switch (hdr->sh_type)
1755 /* Inactive section. Throw it away. */
1758 case SHT_PROGBITS: /* Normal section with contents. */
1759 case SHT_NOBITS: /* .bss section. */
1760 case SHT_HASH: /* .hash section. */
1761 case SHT_NOTE: /* .note section. */
1762 case SHT_INIT_ARRAY: /* .init_array section. */
1763 case SHT_FINI_ARRAY: /* .fini_array section. */
1764 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1765 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1766 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1768 case SHT_DYNAMIC: /* Dynamic linking information. */
1769 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1771 if (hdr->sh_link > elf_numsections (abfd)
1772 || elf_elfsections (abfd)[hdr->sh_link] == NULL)
1774 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1776 Elf_Internal_Shdr *dynsymhdr;
1778 /* The shared libraries distributed with hpux11 have a bogus
1779 sh_link field for the ".dynamic" section. Find the
1780 string table for the ".dynsym" section instead. */
1781 if (elf_dynsymtab (abfd) != 0)
1783 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1784 hdr->sh_link = dynsymhdr->sh_link;
1788 unsigned int i, num_sec;
1790 num_sec = elf_numsections (abfd);
1791 for (i = 1; i < num_sec; i++)
1793 dynsymhdr = elf_elfsections (abfd)[i];
1794 if (dynsymhdr->sh_type == SHT_DYNSYM)
1796 hdr->sh_link = dynsymhdr->sh_link;
1804 case SHT_SYMTAB: /* A symbol table */
1805 if (elf_onesymtab (abfd) == shindex)
1808 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1809 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1810 elf_onesymtab (abfd) = shindex;
1811 elf_tdata (abfd)->symtab_hdr = *hdr;
1812 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1813 abfd->flags |= HAS_SYMS;
1815 /* Sometimes a shared object will map in the symbol table. If
1816 SHF_ALLOC is set, and this is a shared object, then we also
1817 treat this section as a BFD section. We can not base the
1818 decision purely on SHF_ALLOC, because that flag is sometimes
1819 set in a relocatable object file, which would confuse the
1821 if ((hdr->sh_flags & SHF_ALLOC) != 0
1822 && (abfd->flags & DYNAMIC) != 0
1823 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1827 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1828 can't read symbols without that section loaded as well. It
1829 is most likely specified by the next section header. */
1830 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1832 unsigned int i, num_sec;
1834 num_sec = elf_numsections (abfd);
1835 for (i = shindex + 1; i < num_sec; i++)
1837 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1838 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1839 && hdr2->sh_link == shindex)
1843 for (i = 1; i < shindex; i++)
1845 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1846 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1847 && hdr2->sh_link == shindex)
1851 return bfd_section_from_shdr (abfd, i);
1855 case SHT_DYNSYM: /* A dynamic symbol table */
1856 if (elf_dynsymtab (abfd) == shindex)
1859 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1860 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1861 elf_dynsymtab (abfd) = shindex;
1862 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1863 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1864 abfd->flags |= HAS_SYMS;
1866 /* Besides being a symbol table, we also treat this as a regular
1867 section, so that objcopy can handle it. */
1868 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1870 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1871 if (elf_symtab_shndx (abfd) == shindex)
1874 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1875 elf_symtab_shndx (abfd) = shindex;
1876 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1877 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1880 case SHT_STRTAB: /* A string table */
1881 if (hdr->bfd_section != NULL)
1883 if (ehdr->e_shstrndx == shindex)
1885 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1886 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1889 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1892 elf_tdata (abfd)->strtab_hdr = *hdr;
1893 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1896 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1899 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1900 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1901 elf_elfsections (abfd)[shindex] = hdr;
1902 /* We also treat this as a regular section, so that objcopy
1904 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1908 /* If the string table isn't one of the above, then treat it as a
1909 regular section. We need to scan all the headers to be sure,
1910 just in case this strtab section appeared before the above. */
1911 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1913 unsigned int i, num_sec;
1915 num_sec = elf_numsections (abfd);
1916 for (i = 1; i < num_sec; i++)
1918 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1919 if (hdr2->sh_link == shindex)
1921 if (! bfd_section_from_shdr (abfd, i))
1923 if (elf_onesymtab (abfd) == i)
1925 if (elf_dynsymtab (abfd) == i)
1926 goto dynsymtab_strtab;
1930 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1934 /* *These* do a lot of work -- but build no sections! */
1936 asection *target_sect;
1937 Elf_Internal_Shdr *hdr2;
1938 unsigned int num_sec = elf_numsections (abfd);
1940 /* Check for a bogus link to avoid crashing. */
1941 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1942 || hdr->sh_link >= num_sec)
1944 ((*_bfd_error_handler)
1945 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1946 abfd, hdr->sh_link, name, shindex));
1947 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1951 /* For some incomprehensible reason Oracle distributes
1952 libraries for Solaris in which some of the objects have
1953 bogus sh_link fields. It would be nice if we could just
1954 reject them, but, unfortunately, some people need to use
1955 them. We scan through the section headers; if we find only
1956 one suitable symbol table, we clobber the sh_link to point
1957 to it. I hope this doesn't break anything. */
1958 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1959 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1965 for (scan = 1; scan < num_sec; scan++)
1967 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1968 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1979 hdr->sh_link = found;
1982 /* Get the symbol table. */
1983 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1984 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1985 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1988 /* If this reloc section does not use the main symbol table we
1989 don't treat it as a reloc section. BFD can't adequately
1990 represent such a section, so at least for now, we don't
1991 try. We just present it as a normal section. We also
1992 can't use it as a reloc section if it points to the null
1994 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1995 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1998 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2000 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2001 if (target_sect == NULL)
2004 if ((target_sect->flags & SEC_RELOC) == 0
2005 || target_sect->reloc_count == 0)
2006 hdr2 = &elf_section_data (target_sect)->rel_hdr;
2010 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
2011 amt = sizeof (*hdr2);
2012 hdr2 = bfd_alloc (abfd, amt);
2013 elf_section_data (target_sect)->rel_hdr2 = hdr2;
2016 elf_elfsections (abfd)[shindex] = hdr2;
2017 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
2018 target_sect->flags |= SEC_RELOC;
2019 target_sect->relocation = NULL;
2020 target_sect->rel_filepos = hdr->sh_offset;
2021 /* In the section to which the relocations apply, mark whether
2022 its relocations are of the REL or RELA variety. */
2023 if (hdr->sh_size != 0)
2024 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
2025 abfd->flags |= HAS_RELOC;
2030 case SHT_GNU_verdef:
2031 elf_dynverdef (abfd) = shindex;
2032 elf_tdata (abfd)->dynverdef_hdr = *hdr;
2033 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2036 case SHT_GNU_versym:
2037 elf_dynversym (abfd) = shindex;
2038 elf_tdata (abfd)->dynversym_hdr = *hdr;
2039 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2042 case SHT_GNU_verneed:
2043 elf_dynverref (abfd) = shindex;
2044 elf_tdata (abfd)->dynverref_hdr = *hdr;
2045 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2052 /* We need a BFD section for objcopy and relocatable linking,
2053 and it's handy to have the signature available as the section
2055 name = group_signature (abfd, hdr);
2058 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2060 if (hdr->contents != NULL)
2062 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2063 unsigned int n_elt = hdr->sh_size / 4;
2066 if (idx->flags & GRP_COMDAT)
2067 hdr->bfd_section->flags
2068 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2070 /* We try to keep the same section order as it comes in. */
2072 while (--n_elt != 0)
2073 if ((s = (--idx)->shdr->bfd_section) != NULL
2074 && elf_next_in_group (s) != NULL)
2076 elf_next_in_group (hdr->bfd_section) = s;
2083 /* Check for any processor-specific section types. */
2084 return bed->elf_backend_section_from_shdr (abfd, hdr, name,
2091 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2092 Return SEC for sections that have no elf section, and NULL on error. */
2095 bfd_section_from_r_symndx (bfd *abfd,
2096 struct sym_sec_cache *cache,
2098 unsigned long r_symndx)
2100 Elf_Internal_Shdr *symtab_hdr;
2101 unsigned char esym[sizeof (Elf64_External_Sym)];
2102 Elf_External_Sym_Shndx eshndx;
2103 Elf_Internal_Sym isym;
2104 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2106 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2107 return cache->sec[ent];
2109 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2110 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2111 &isym, esym, &eshndx) == NULL)
2114 if (cache->abfd != abfd)
2116 memset (cache->indx, -1, sizeof (cache->indx));
2119 cache->indx[ent] = r_symndx;
2120 cache->sec[ent] = sec;
2121 if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2122 || isym.st_shndx > SHN_HIRESERVE)
2125 s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2127 cache->sec[ent] = s;
2129 return cache->sec[ent];
2132 /* Given an ELF section number, retrieve the corresponding BFD
2136 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2138 if (index >= elf_numsections (abfd))
2140 return elf_elfsections (abfd)[index]->bfd_section;
2143 static struct bfd_elf_special_section const special_sections_b[] =
2145 { ".bss", 4, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2146 { NULL, 0, 0, 0, 0 }
2149 static struct bfd_elf_special_section const special_sections_c[] =
2151 { ".comment", 8, 0, SHT_PROGBITS, 0 },
2152 { NULL, 0, 0, 0, 0 }
2155 static struct bfd_elf_special_section const special_sections_d[] =
2157 { ".data", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2158 { ".data1", 6, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2159 { ".debug", 6, 0, SHT_PROGBITS, 0 },
2160 { ".debug_line", 11, 0, SHT_PROGBITS, 0 },
2161 { ".debug_info", 11, 0, SHT_PROGBITS, 0 },
2162 { ".debug_abbrev", 13, 0, SHT_PROGBITS, 0 },
2163 { ".debug_aranges", 14, 0, SHT_PROGBITS, 0 },
2164 { ".dynamic", 8, 0, SHT_DYNAMIC, SHF_ALLOC },
2165 { ".dynstr", 7, 0, SHT_STRTAB, SHF_ALLOC },
2166 { ".dynsym", 7, 0, SHT_DYNSYM, SHF_ALLOC },
2167 { NULL, 0, 0, 0, 0 }
2170 static struct bfd_elf_special_section const special_sections_f[] =
2172 { ".fini", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2173 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2174 { NULL, 0, 0, 0, 0 }
2177 static struct bfd_elf_special_section const special_sections_g[] =
2179 { ".gnu.linkonce.b",15, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2180 { ".got", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2181 { ".gnu.version", 12, 0, SHT_GNU_versym, 0 },
2182 { ".gnu.version_d", 14, 0, SHT_GNU_verdef, 0 },
2183 { ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },
2184 { ".gnu.liblist", 12, 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2185 { ".gnu.conflict", 13, 0, SHT_RELA, SHF_ALLOC },
2186 { NULL, 0, 0, 0, 0 }
2189 static struct bfd_elf_special_section const special_sections_h[] =
2191 { ".hash", 5, 0, SHT_HASH, SHF_ALLOC },
2192 { NULL, 0, 0, 0, 0 }
2195 static struct bfd_elf_special_section const special_sections_i[] =
2197 { ".init", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2198 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2199 { ".interp", 7, 0, SHT_PROGBITS, 0 },
2200 { NULL, 0, 0, 0, 0 }
2203 static struct bfd_elf_special_section const special_sections_l[] =
2205 { ".line", 5, 0, SHT_PROGBITS, 0 },
2206 { NULL, 0, 0, 0, 0 }
2209 static struct bfd_elf_special_section const special_sections_n[] =
2211 { ".note.GNU-stack",15, 0, SHT_PROGBITS, 0 },
2212 { ".note", 5, -1, SHT_NOTE, 0 },
2213 { NULL, 0, 0, 0, 0 }
2216 static struct bfd_elf_special_section const special_sections_p[] =
2218 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2219 { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2220 { NULL, 0, 0, 0, 0 }
2223 static struct bfd_elf_special_section const special_sections_r[] =
2225 { ".rodata", 7, -2, SHT_PROGBITS, SHF_ALLOC },
2226 { ".rodata1", 8, 0, SHT_PROGBITS, SHF_ALLOC },
2227 { ".rela", 5, -1, SHT_RELA, 0 },
2228 { ".rel", 4, -1, SHT_REL, 0 },
2229 { NULL, 0, 0, 0, 0 }
2232 static struct bfd_elf_special_section const special_sections_s[] =
2234 { ".shstrtab", 9, 0, SHT_STRTAB, 0 },
2235 { ".strtab", 7, 0, SHT_STRTAB, 0 },
2236 { ".symtab", 7, 0, SHT_SYMTAB, 0 },
2237 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2238 { NULL, 0, 0, 0, 0 }
2241 static struct bfd_elf_special_section const special_sections_t[] =
2243 { ".text", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2244 { ".tbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2245 { ".tdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2246 { NULL, 0, 0, 0, 0 }
2249 static struct bfd_elf_special_section const *special_sections [27] =
2252 special_sections_b, /* 'b' */
2253 special_sections_c, /* 'b' */
2254 special_sections_d, /* 'd' */
2256 special_sections_f, /* 'f' */
2257 special_sections_g, /* 'g' */
2258 special_sections_h, /* 'h' */
2259 special_sections_i, /* 'i' */
2262 special_sections_l, /* 'l' */
2264 special_sections_n, /* 'n' */
2266 special_sections_p, /* 'p' */
2268 special_sections_r, /* 'r' */
2269 special_sections_s, /* 's' */
2270 special_sections_t, /* 't' */
2280 static const struct bfd_elf_special_section *
2281 get_special_section (const char *name,
2282 const struct bfd_elf_special_section **special_sections_p,
2287 const struct bfd_elf_special_section *special_sections;
2289 if (name [0] == '.')
2292 if (i < 0 || i > 25)
2298 special_sections = special_sections_p [i];
2300 if (!special_sections)
2301 return special_sections;
2305 for (i = 0; special_sections[i].prefix != NULL; i++)
2308 int prefix_len = special_sections[i].prefix_length;
2310 if (len < prefix_len)
2312 if (memcmp (name, special_sections[i].prefix, prefix_len) != 0)
2315 suffix_len = special_sections[i].suffix_length;
2316 if (suffix_len <= 0)
2318 if (name[prefix_len] != 0)
2320 if (suffix_len == 0)
2322 if (name[prefix_len] != '.'
2323 && (suffix_len == -2
2324 || (rela && special_sections[i].type == SHT_REL)))
2330 if (len < prefix_len + suffix_len)
2332 if (memcmp (name + len - suffix_len,
2333 special_sections[i].prefix + prefix_len,
2337 return &special_sections[i];
2343 const struct bfd_elf_special_section *
2344 _bfd_elf_get_sec_type_attr (bfd *abfd, const char *name)
2346 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2347 const struct bfd_elf_special_section *ssect = NULL;
2349 /* See if this is one of the special sections. */
2352 unsigned int rela = bed->default_use_rela_p;
2354 if (bed->special_sections)
2355 ssect = get_special_section (name, bed->special_sections, rela);
2358 ssect = get_special_section (name, special_sections, rela);
2365 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2367 struct bfd_elf_section_data *sdata;
2368 const struct bfd_elf_special_section *ssect;
2370 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2373 sdata = bfd_zalloc (abfd, sizeof (*sdata));
2376 sec->used_by_bfd = sdata;
2379 /* When we read a file, we don't need section type and flags unless
2380 it is a linker created section. They will be overridden in
2381 _bfd_elf_make_section_from_shdr anyway. */
2382 if (abfd->direction != read_direction
2383 || (sec->flags & SEC_LINKER_CREATED) != 0)
2385 ssect = _bfd_elf_get_sec_type_attr (abfd, sec->name);
2388 elf_section_type (sec) = ssect->type;
2389 elf_section_flags (sec) = ssect->attr;
2393 /* Indicate whether or not this section should use RELA relocations. */
2394 sec->use_rela_p = get_elf_backend_data (abfd)->default_use_rela_p;
2399 /* Create a new bfd section from an ELF program header.
2401 Since program segments have no names, we generate a synthetic name
2402 of the form segment<NUM>, where NUM is generally the index in the
2403 program header table. For segments that are split (see below) we
2404 generate the names segment<NUM>a and segment<NUM>b.
2406 Note that some program segments may have a file size that is different than
2407 (less than) the memory size. All this means is that at execution the
2408 system must allocate the amount of memory specified by the memory size,
2409 but only initialize it with the first "file size" bytes read from the
2410 file. This would occur for example, with program segments consisting
2411 of combined data+bss.
2413 To handle the above situation, this routine generates TWO bfd sections
2414 for the single program segment. The first has the length specified by
2415 the file size of the segment, and the second has the length specified
2416 by the difference between the two sizes. In effect, the segment is split
2417 into it's initialized and uninitialized parts.
2422 _bfd_elf_make_section_from_phdr (bfd *abfd,
2423 Elf_Internal_Phdr *hdr,
2425 const char *typename)
2433 split = ((hdr->p_memsz > 0)
2434 && (hdr->p_filesz > 0)
2435 && (hdr->p_memsz > hdr->p_filesz));
2436 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2437 len = strlen (namebuf) + 1;
2438 name = bfd_alloc (abfd, len);
2441 memcpy (name, namebuf, len);
2442 newsect = bfd_make_section (abfd, name);
2443 if (newsect == NULL)
2445 newsect->vma = hdr->p_vaddr;
2446 newsect->lma = hdr->p_paddr;
2447 newsect->size = hdr->p_filesz;
2448 newsect->filepos = hdr->p_offset;
2449 newsect->flags |= SEC_HAS_CONTENTS;
2450 newsect->alignment_power = bfd_log2 (hdr->p_align);
2451 if (hdr->p_type == PT_LOAD)
2453 newsect->flags |= SEC_ALLOC;
2454 newsect->flags |= SEC_LOAD;
2455 if (hdr->p_flags & PF_X)
2457 /* FIXME: all we known is that it has execute PERMISSION,
2459 newsect->flags |= SEC_CODE;
2462 if (!(hdr->p_flags & PF_W))
2464 newsect->flags |= SEC_READONLY;
2469 sprintf (namebuf, "%s%db", typename, index);
2470 len = strlen (namebuf) + 1;
2471 name = bfd_alloc (abfd, len);
2474 memcpy (name, namebuf, len);
2475 newsect = bfd_make_section (abfd, name);
2476 if (newsect == NULL)
2478 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2479 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2480 newsect->size = hdr->p_memsz - hdr->p_filesz;
2481 if (hdr->p_type == PT_LOAD)
2483 newsect->flags |= SEC_ALLOC;
2484 if (hdr->p_flags & PF_X)
2485 newsect->flags |= SEC_CODE;
2487 if (!(hdr->p_flags & PF_W))
2488 newsect->flags |= SEC_READONLY;
2495 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2497 const struct elf_backend_data *bed;
2499 switch (hdr->p_type)
2502 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2505 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2508 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2511 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2514 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2516 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2521 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2524 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2526 case PT_GNU_EH_FRAME:
2527 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2531 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2534 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2537 /* Check for any processor-specific program segment types. */
2538 bed = get_elf_backend_data (abfd);
2539 return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2543 /* Initialize REL_HDR, the section-header for new section, containing
2544 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2545 relocations; otherwise, we use REL relocations. */
2548 _bfd_elf_init_reloc_shdr (bfd *abfd,
2549 Elf_Internal_Shdr *rel_hdr,
2551 bfd_boolean use_rela_p)
2554 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2555 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2557 name = bfd_alloc (abfd, amt);
2560 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2562 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2564 if (rel_hdr->sh_name == (unsigned int) -1)
2566 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2567 rel_hdr->sh_entsize = (use_rela_p
2568 ? bed->s->sizeof_rela
2569 : bed->s->sizeof_rel);
2570 rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2571 rel_hdr->sh_flags = 0;
2572 rel_hdr->sh_addr = 0;
2573 rel_hdr->sh_size = 0;
2574 rel_hdr->sh_offset = 0;
2579 /* Set up an ELF internal section header for a section. */
2582 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2584 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2585 bfd_boolean *failedptr = failedptrarg;
2586 Elf_Internal_Shdr *this_hdr;
2590 /* We already failed; just get out of the bfd_map_over_sections
2595 this_hdr = &elf_section_data (asect)->this_hdr;
2597 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2598 asect->name, FALSE);
2599 if (this_hdr->sh_name == (unsigned int) -1)
2605 this_hdr->sh_flags = 0;
2607 if ((asect->flags & SEC_ALLOC) != 0
2608 || asect->user_set_vma)
2609 this_hdr->sh_addr = asect->vma;
2611 this_hdr->sh_addr = 0;
2613 this_hdr->sh_offset = 0;
2614 this_hdr->sh_size = asect->size;
2615 this_hdr->sh_link = 0;
2616 this_hdr->sh_addralign = 1 << asect->alignment_power;
2617 /* The sh_entsize and sh_info fields may have been set already by
2618 copy_private_section_data. */
2620 this_hdr->bfd_section = asect;
2621 this_hdr->contents = NULL;
2623 /* If the section type is unspecified, we set it based on
2625 if (this_hdr->sh_type == SHT_NULL)
2627 if ((asect->flags & SEC_GROUP) != 0)
2629 /* We also need to mark SHF_GROUP here for relocatable
2631 struct bfd_link_order *l;
2634 for (l = asect->map_head.link_order; l != NULL; l = l->next)
2635 if (l->type == bfd_indirect_link_order
2636 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2639 /* The name is not important. Anything will do. */
2640 elf_group_name (elt->output_section) = "G";
2641 elf_section_flags (elt->output_section) |= SHF_GROUP;
2643 elt = elf_next_in_group (elt);
2644 /* During a relocatable link, the lists are
2647 while (elt != elf_next_in_group (l->u.indirect.section));
2649 this_hdr->sh_type = SHT_GROUP;
2651 else if ((asect->flags & SEC_ALLOC) != 0
2652 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2653 || (asect->flags & SEC_NEVER_LOAD) != 0))
2654 this_hdr->sh_type = SHT_NOBITS;
2656 this_hdr->sh_type = SHT_PROGBITS;
2659 switch (this_hdr->sh_type)
2665 case SHT_INIT_ARRAY:
2666 case SHT_FINI_ARRAY:
2667 case SHT_PREINIT_ARRAY:
2674 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2678 this_hdr->sh_entsize = bed->s->sizeof_sym;
2682 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2686 if (get_elf_backend_data (abfd)->may_use_rela_p)
2687 this_hdr->sh_entsize = bed->s->sizeof_rela;
2691 if (get_elf_backend_data (abfd)->may_use_rel_p)
2692 this_hdr->sh_entsize = bed->s->sizeof_rel;
2695 case SHT_GNU_versym:
2696 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2699 case SHT_GNU_verdef:
2700 this_hdr->sh_entsize = 0;
2701 /* objcopy or strip will copy over sh_info, but may not set
2702 cverdefs. The linker will set cverdefs, but sh_info will be
2704 if (this_hdr->sh_info == 0)
2705 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2707 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2708 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2711 case SHT_GNU_verneed:
2712 this_hdr->sh_entsize = 0;
2713 /* objcopy or strip will copy over sh_info, but may not set
2714 cverrefs. The linker will set cverrefs, but sh_info will be
2716 if (this_hdr->sh_info == 0)
2717 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2719 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2720 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2724 this_hdr->sh_entsize = 4;
2728 if ((asect->flags & SEC_ALLOC) != 0)
2729 this_hdr->sh_flags |= SHF_ALLOC;
2730 if ((asect->flags & SEC_READONLY) == 0)
2731 this_hdr->sh_flags |= SHF_WRITE;
2732 if ((asect->flags & SEC_CODE) != 0)
2733 this_hdr->sh_flags |= SHF_EXECINSTR;
2734 if ((asect->flags & SEC_MERGE) != 0)
2736 this_hdr->sh_flags |= SHF_MERGE;
2737 this_hdr->sh_entsize = asect->entsize;
2738 if ((asect->flags & SEC_STRINGS) != 0)
2739 this_hdr->sh_flags |= SHF_STRINGS;
2741 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2742 this_hdr->sh_flags |= SHF_GROUP;
2743 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2745 this_hdr->sh_flags |= SHF_TLS;
2746 if (asect->size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2748 struct bfd_link_order *o;
2750 this_hdr->sh_size = 0;
2751 for (o = asect->map_head.link_order; o != NULL; o = o->next)
2752 if (this_hdr->sh_size < o->offset + o->size)
2753 this_hdr->sh_size = o->offset + o->size;
2754 if (this_hdr->sh_size)
2755 this_hdr->sh_type = SHT_NOBITS;
2759 /* Check for processor-specific section types. */
2760 if (bed->elf_backend_fake_sections
2761 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2764 /* If the section has relocs, set up a section header for the
2765 SHT_REL[A] section. If two relocation sections are required for
2766 this section, it is up to the processor-specific back-end to
2767 create the other. */
2768 if ((asect->flags & SEC_RELOC) != 0
2769 && !_bfd_elf_init_reloc_shdr (abfd,
2770 &elf_section_data (asect)->rel_hdr,
2776 /* Fill in the contents of a SHT_GROUP section. */
2779 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2781 bfd_boolean *failedptr = failedptrarg;
2782 unsigned long symindx;
2783 asection *elt, *first;
2785 struct bfd_link_order *l;
2788 /* Ignore linker created group section. See elfNN_ia64_object_p in
2790 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2795 if (elf_group_id (sec) != NULL)
2796 symindx = elf_group_id (sec)->udata.i;
2800 /* If called from the assembler, swap_out_syms will have set up
2801 elf_section_syms; If called for "ld -r", use target_index. */
2802 if (elf_section_syms (abfd) != NULL)
2803 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2805 symindx = sec->target_index;
2807 elf_section_data (sec)->this_hdr.sh_info = symindx;
2809 /* The contents won't be allocated for "ld -r" or objcopy. */
2811 if (sec->contents == NULL)
2814 sec->contents = bfd_alloc (abfd, sec->size);
2816 /* Arrange for the section to be written out. */
2817 elf_section_data (sec)->this_hdr.contents = sec->contents;
2818 if (sec->contents == NULL)
2825 loc = sec->contents + sec->size;
2827 /* Get the pointer to the first section in the group that gas
2828 squirreled away here. objcopy arranges for this to be set to the
2829 start of the input section group. */
2830 first = elt = elf_next_in_group (sec);
2832 /* First element is a flag word. Rest of section is elf section
2833 indices for all the sections of the group. Write them backwards
2834 just to keep the group in the same order as given in .section
2835 directives, not that it matters. */
2844 s = s->output_section;
2847 idx = elf_section_data (s)->this_idx;
2848 H_PUT_32 (abfd, idx, loc);
2849 elt = elf_next_in_group (elt);
2854 /* If this is a relocatable link, then the above did nothing because
2855 SEC is the output section. Look through the input sections
2857 for (l = sec->map_head.link_order; l != NULL; l = l->next)
2858 if (l->type == bfd_indirect_link_order
2859 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2864 elf_section_data (elt->output_section)->this_idx, loc);
2865 elt = elf_next_in_group (elt);
2866 /* During a relocatable link, the lists are circular. */
2868 while (elt != elf_next_in_group (l->u.indirect.section));
2870 if ((loc -= 4) != sec->contents)
2873 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2876 /* Assign all ELF section numbers. The dummy first section is handled here
2877 too. The link/info pointers for the standard section types are filled
2878 in here too, while we're at it. */
2881 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2883 struct elf_obj_tdata *t = elf_tdata (abfd);
2885 unsigned int section_number, secn;
2886 Elf_Internal_Shdr **i_shdrp;
2888 struct bfd_elf_section_data *d;
2892 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2894 /* SHT_GROUP sections are in relocatable files only. */
2895 if (link_info == NULL || link_info->relocatable)
2897 /* Put SHT_GROUP sections first. */
2898 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2900 d = elf_section_data (sec);
2902 if (d->this_hdr.sh_type == SHT_GROUP)
2904 if (sec->flags & SEC_LINKER_CREATED)
2906 /* Remove the linker created SHT_GROUP sections. */
2907 bfd_section_list_remove (abfd, sec);
2908 abfd->section_count--;
2912 if (section_number == SHN_LORESERVE)
2913 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2914 d->this_idx = section_number++;
2920 for (sec = abfd->sections; sec; sec = sec->next)
2922 d = elf_section_data (sec);
2924 if (d->this_hdr.sh_type != SHT_GROUP)
2926 if (section_number == SHN_LORESERVE)
2927 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2928 d->this_idx = section_number++;
2930 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2931 if ((sec->flags & SEC_RELOC) == 0)
2935 if (section_number == SHN_LORESERVE)
2936 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2937 d->rel_idx = section_number++;
2938 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2943 if (section_number == SHN_LORESERVE)
2944 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2945 d->rel_idx2 = section_number++;
2946 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2952 if (section_number == SHN_LORESERVE)
2953 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2954 t->shstrtab_section = section_number++;
2955 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2956 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2958 if (bfd_get_symcount (abfd) > 0)
2960 if (section_number == SHN_LORESERVE)
2961 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2962 t->symtab_section = section_number++;
2963 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2964 if (section_number > SHN_LORESERVE - 2)
2966 if (section_number == SHN_LORESERVE)
2967 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2968 t->symtab_shndx_section = section_number++;
2969 t->symtab_shndx_hdr.sh_name
2970 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2971 ".symtab_shndx", FALSE);
2972 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2975 if (section_number == SHN_LORESERVE)
2976 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2977 t->strtab_section = section_number++;
2978 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2981 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2982 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2984 elf_numsections (abfd) = section_number;
2985 elf_elfheader (abfd)->e_shnum = section_number;
2986 if (section_number > SHN_LORESERVE)
2987 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2989 /* Set up the list of section header pointers, in agreement with the
2991 amt = section_number * sizeof (Elf_Internal_Shdr *);
2992 i_shdrp = bfd_zalloc (abfd, amt);
2993 if (i_shdrp == NULL)
2996 amt = sizeof (Elf_Internal_Shdr);
2997 i_shdrp[0] = bfd_zalloc (abfd, amt);
2998 if (i_shdrp[0] == NULL)
3000 bfd_release (abfd, i_shdrp);
3004 elf_elfsections (abfd) = i_shdrp;
3006 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3007 if (bfd_get_symcount (abfd) > 0)
3009 i_shdrp[t->symtab_section] = &t->symtab_hdr;
3010 if (elf_numsections (abfd) > SHN_LORESERVE)
3012 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3013 t->symtab_shndx_hdr.sh_link = t->symtab_section;
3015 i_shdrp[t->strtab_section] = &t->strtab_hdr;
3016 t->symtab_hdr.sh_link = t->strtab_section;
3019 for (sec = abfd->sections; sec; sec = sec->next)
3021 struct bfd_elf_section_data *d = elf_section_data (sec);
3025 i_shdrp[d->this_idx] = &d->this_hdr;
3026 if (d->rel_idx != 0)
3027 i_shdrp[d->rel_idx] = &d->rel_hdr;
3028 if (d->rel_idx2 != 0)
3029 i_shdrp[d->rel_idx2] = d->rel_hdr2;
3031 /* Fill in the sh_link and sh_info fields while we're at it. */
3033 /* sh_link of a reloc section is the section index of the symbol
3034 table. sh_info is the section index of the section to which
3035 the relocation entries apply. */
3036 if (d->rel_idx != 0)
3038 d->rel_hdr.sh_link = t->symtab_section;
3039 d->rel_hdr.sh_info = d->this_idx;
3041 if (d->rel_idx2 != 0)
3043 d->rel_hdr2->sh_link = t->symtab_section;
3044 d->rel_hdr2->sh_info = d->this_idx;
3047 /* We need to set up sh_link for SHF_LINK_ORDER. */
3048 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3050 s = elf_linked_to_section (sec);
3052 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3055 struct bfd_link_order *p;
3057 /* Find out what the corresponding section in output
3059 for (p = sec->map_head.link_order; p != NULL; p = p->next)
3061 s = p->u.indirect.section;
3062 if (p->type == bfd_indirect_link_order
3063 && (bfd_get_flavour (s->owner)
3064 == bfd_target_elf_flavour))
3066 Elf_Internal_Shdr ** const elf_shdrp
3067 = elf_elfsections (s->owner);
3069 = _bfd_elf_section_from_bfd_section (s->owner, s);
3070 elfsec = elf_shdrp[elfsec]->sh_link;
3072 The Intel C compiler generates SHT_IA_64_UNWIND with
3073 SHF_LINK_ORDER. But it doesn't set the sh_link or
3074 sh_info fields. Hence we could get the situation
3075 where elfsec is 0. */
3078 const struct elf_backend_data *bed
3079 = get_elf_backend_data (abfd);
3080 if (bed->link_order_error_handler)
3081 bed->link_order_error_handler
3082 (_("%B: warning: sh_link not set for section `%A'"),
3087 s = elf_shdrp[elfsec]->bfd_section;
3088 if (elf_discarded_section (s))
3091 (*_bfd_error_handler)
3092 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3093 abfd, d->this_hdr.bfd_section,
3095 /* Point to the kept section if it has
3096 the same size as the discarded
3098 kept = _bfd_elf_check_kept_section (s);
3101 bfd_set_error (bfd_error_bad_value);
3106 s = s->output_section;
3107 BFD_ASSERT (s != NULL);
3108 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3116 switch (d->this_hdr.sh_type)
3120 /* A reloc section which we are treating as a normal BFD
3121 section. sh_link is the section index of the symbol
3122 table. sh_info is the section index of the section to
3123 which the relocation entries apply. We assume that an
3124 allocated reloc section uses the dynamic symbol table.
3125 FIXME: How can we be sure? */
3126 s = bfd_get_section_by_name (abfd, ".dynsym");
3128 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3130 /* We look up the section the relocs apply to by name. */
3132 if (d->this_hdr.sh_type == SHT_REL)
3136 s = bfd_get_section_by_name (abfd, name);
3138 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3142 /* We assume that a section named .stab*str is a stabs
3143 string section. We look for a section with the same name
3144 but without the trailing ``str'', and set its sh_link
3145 field to point to this section. */
3146 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
3147 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3152 len = strlen (sec->name);
3153 alc = bfd_malloc (len - 2);
3156 memcpy (alc, sec->name, len - 3);
3157 alc[len - 3] = '\0';
3158 s = bfd_get_section_by_name (abfd, alc);
3162 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3164 /* This is a .stab section. */
3165 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3166 elf_section_data (s)->this_hdr.sh_entsize
3167 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3174 case SHT_GNU_verneed:
3175 case SHT_GNU_verdef:
3176 /* sh_link is the section header index of the string table
3177 used for the dynamic entries, or the symbol table, or the
3179 s = bfd_get_section_by_name (abfd, ".dynstr");
3181 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3184 case SHT_GNU_LIBLIST:
3185 /* sh_link is the section header index of the prelink library
3187 used for the dynamic entries, or the symbol table, or the
3189 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3190 ? ".dynstr" : ".gnu.libstr");
3192 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3196 case SHT_GNU_versym:
3197 /* sh_link is the section header index of the symbol table
3198 this hash table or version table is for. */
3199 s = bfd_get_section_by_name (abfd, ".dynsym");
3201 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3205 d->this_hdr.sh_link = t->symtab_section;
3209 for (secn = 1; secn < section_number; ++secn)
3210 if (i_shdrp[secn] == NULL)
3211 i_shdrp[secn] = i_shdrp[0];
3213 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3214 i_shdrp[secn]->sh_name);
3218 /* Map symbol from it's internal number to the external number, moving
3219 all local symbols to be at the head of the list. */
3222 sym_is_global (bfd *abfd, asymbol *sym)
3224 /* If the backend has a special mapping, use it. */
3225 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3226 if (bed->elf_backend_sym_is_global)
3227 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3229 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3230 || bfd_is_und_section (bfd_get_section (sym))
3231 || bfd_is_com_section (bfd_get_section (sym)));
3235 elf_map_symbols (bfd *abfd)
3237 unsigned int symcount = bfd_get_symcount (abfd);
3238 asymbol **syms = bfd_get_outsymbols (abfd);
3239 asymbol **sect_syms;
3240 unsigned int num_locals = 0;
3241 unsigned int num_globals = 0;
3242 unsigned int num_locals2 = 0;
3243 unsigned int num_globals2 = 0;
3251 fprintf (stderr, "elf_map_symbols\n");
3255 for (asect = abfd->sections; asect; asect = asect->next)
3257 if (max_index < asect->index)
3258 max_index = asect->index;
3262 amt = max_index * sizeof (asymbol *);
3263 sect_syms = bfd_zalloc (abfd, amt);
3264 if (sect_syms == NULL)
3266 elf_section_syms (abfd) = sect_syms;
3267 elf_num_section_syms (abfd) = max_index;
3269 /* Init sect_syms entries for any section symbols we have already
3270 decided to output. */
3271 for (idx = 0; idx < symcount; idx++)
3273 asymbol *sym = syms[idx];
3275 if ((sym->flags & BSF_SECTION_SYM) != 0
3282 if (sec->owner != NULL)
3284 if (sec->owner != abfd)
3286 if (sec->output_offset != 0)
3289 sec = sec->output_section;
3291 /* Empty sections in the input files may have had a
3292 section symbol created for them. (See the comment
3293 near the end of _bfd_generic_link_output_symbols in
3294 linker.c). If the linker script discards such
3295 sections then we will reach this point. Since we know
3296 that we cannot avoid this case, we detect it and skip
3297 the abort and the assignment to the sect_syms array.
3298 To reproduce this particular case try running the
3299 linker testsuite test ld-scripts/weak.exp for an ELF
3300 port that uses the generic linker. */
3301 if (sec->owner == NULL)
3304 BFD_ASSERT (sec->owner == abfd);
3306 sect_syms[sec->index] = syms[idx];
3311 /* Classify all of the symbols. */
3312 for (idx = 0; idx < symcount; idx++)
3314 if (!sym_is_global (abfd, syms[idx]))
3320 /* We will be adding a section symbol for each BFD section. Most normal
3321 sections will already have a section symbol in outsymbols, but
3322 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3323 at least in that case. */
3324 for (asect = abfd->sections; asect; asect = asect->next)
3326 if (sect_syms[asect->index] == NULL)
3328 if (!sym_is_global (abfd, asect->symbol))
3335 /* Now sort the symbols so the local symbols are first. */
3336 amt = (num_locals + num_globals) * sizeof (asymbol *);
3337 new_syms = bfd_alloc (abfd, amt);
3339 if (new_syms == NULL)
3342 for (idx = 0; idx < symcount; idx++)
3344 asymbol *sym = syms[idx];
3347 if (!sym_is_global (abfd, sym))
3350 i = num_locals + num_globals2++;
3352 sym->udata.i = i + 1;
3354 for (asect = abfd->sections; asect; asect = asect->next)
3356 if (sect_syms[asect->index] == NULL)
3358 asymbol *sym = asect->symbol;
3361 sect_syms[asect->index] = sym;
3362 if (!sym_is_global (abfd, sym))
3365 i = num_locals + num_globals2++;
3367 sym->udata.i = i + 1;
3371 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3373 elf_num_locals (abfd) = num_locals;
3374 elf_num_globals (abfd) = num_globals;
3378 /* Align to the maximum file alignment that could be required for any
3379 ELF data structure. */
3381 static inline file_ptr
3382 align_file_position (file_ptr off, int align)
3384 return (off + align - 1) & ~(align - 1);
3387 /* Assign a file position to a section, optionally aligning to the
3388 required section alignment. */
3391 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3399 al = i_shdrp->sh_addralign;
3401 offset = BFD_ALIGN (offset, al);
3403 i_shdrp->sh_offset = offset;
3404 if (i_shdrp->bfd_section != NULL)
3405 i_shdrp->bfd_section->filepos = offset;
3406 if (i_shdrp->sh_type != SHT_NOBITS)
3407 offset += i_shdrp->sh_size;
3411 /* Compute the file positions we are going to put the sections at, and
3412 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3413 is not NULL, this is being called by the ELF backend linker. */
3416 _bfd_elf_compute_section_file_positions (bfd *abfd,
3417 struct bfd_link_info *link_info)
3419 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3421 struct bfd_strtab_hash *strtab = NULL;
3422 Elf_Internal_Shdr *shstrtab_hdr;
3424 if (abfd->output_has_begun)
3427 /* Do any elf backend specific processing first. */
3428 if (bed->elf_backend_begin_write_processing)
3429 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3431 if (! prep_headers (abfd))
3434 /* Post process the headers if necessary. */
3435 if (bed->elf_backend_post_process_headers)
3436 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3439 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3443 if (!assign_section_numbers (abfd, link_info))
3446 /* The backend linker builds symbol table information itself. */
3447 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3449 /* Non-zero if doing a relocatable link. */
3450 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3452 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3456 if (link_info == NULL)
3458 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3463 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3464 /* sh_name was set in prep_headers. */
3465 shstrtab_hdr->sh_type = SHT_STRTAB;
3466 shstrtab_hdr->sh_flags = 0;
3467 shstrtab_hdr->sh_addr = 0;
3468 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3469 shstrtab_hdr->sh_entsize = 0;
3470 shstrtab_hdr->sh_link = 0;
3471 shstrtab_hdr->sh_info = 0;
3472 /* sh_offset is set in assign_file_positions_except_relocs. */
3473 shstrtab_hdr->sh_addralign = 1;
3475 if (!assign_file_positions_except_relocs (abfd, link_info))
3478 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3481 Elf_Internal_Shdr *hdr;
3483 off = elf_tdata (abfd)->next_file_pos;
3485 hdr = &elf_tdata (abfd)->symtab_hdr;
3486 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3488 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3489 if (hdr->sh_size != 0)
3490 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3492 hdr = &elf_tdata (abfd)->strtab_hdr;
3493 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3495 elf_tdata (abfd)->next_file_pos = off;
3497 /* Now that we know where the .strtab section goes, write it
3499 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3500 || ! _bfd_stringtab_emit (abfd, strtab))
3502 _bfd_stringtab_free (strtab);
3505 abfd->output_has_begun = TRUE;
3510 /* Create a mapping from a set of sections to a program segment. */
3512 static struct elf_segment_map *
3513 make_mapping (bfd *abfd,
3514 asection **sections,
3519 struct elf_segment_map *m;
3524 amt = sizeof (struct elf_segment_map);
3525 amt += (to - from - 1) * sizeof (asection *);
3526 m = bfd_zalloc (abfd, amt);
3530 m->p_type = PT_LOAD;
3531 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3532 m->sections[i - from] = *hdrpp;
3533 m->count = to - from;
3535 if (from == 0 && phdr)
3537 /* Include the headers in the first PT_LOAD segment. */
3538 m->includes_filehdr = 1;
3539 m->includes_phdrs = 1;
3545 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3548 struct elf_segment_map *
3549 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3551 struct elf_segment_map *m;
3553 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3557 m->p_type = PT_DYNAMIC;
3559 m->sections[0] = dynsec;
3564 /* Set up a mapping from BFD sections to program segments. */
3567 map_sections_to_segments (bfd *abfd)
3569 asection **sections = NULL;
3573 struct elf_segment_map *mfirst;
3574 struct elf_segment_map **pm;
3575 struct elf_segment_map *m;
3578 unsigned int phdr_index;
3579 bfd_vma maxpagesize;
3581 bfd_boolean phdr_in_segment = TRUE;
3582 bfd_boolean writable;
3584 asection *first_tls = NULL;
3585 asection *dynsec, *eh_frame_hdr;
3588 if (elf_tdata (abfd)->segment_map != NULL)
3591 if (bfd_count_sections (abfd) == 0)
3594 /* Select the allocated sections, and sort them. */
3596 amt = bfd_count_sections (abfd) * sizeof (asection *);
3597 sections = bfd_malloc (amt);
3598 if (sections == NULL)
3602 for (s = abfd->sections; s != NULL; s = s->next)
3604 if ((s->flags & SEC_ALLOC) != 0)
3610 BFD_ASSERT (i <= bfd_count_sections (abfd));
3613 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3615 /* Build the mapping. */
3620 /* If we have a .interp section, then create a PT_PHDR segment for
3621 the program headers and a PT_INTERP segment for the .interp
3623 s = bfd_get_section_by_name (abfd, ".interp");
3624 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3626 amt = sizeof (struct elf_segment_map);
3627 m = bfd_zalloc (abfd, amt);
3631 m->p_type = PT_PHDR;
3632 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3633 m->p_flags = PF_R | PF_X;
3634 m->p_flags_valid = 1;
3635 m->includes_phdrs = 1;
3640 amt = sizeof (struct elf_segment_map);
3641 m = bfd_zalloc (abfd, amt);
3645 m->p_type = PT_INTERP;
3653 /* Look through the sections. We put sections in the same program
3654 segment when the start of the second section can be placed within
3655 a few bytes of the end of the first section. */
3659 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3661 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3663 && (dynsec->flags & SEC_LOAD) == 0)
3666 /* Deal with -Ttext or something similar such that the first section
3667 is not adjacent to the program headers. This is an
3668 approximation, since at this point we don't know exactly how many
3669 program headers we will need. */
3672 bfd_size_type phdr_size;
3674 phdr_size = elf_tdata (abfd)->program_header_size;
3676 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3677 if ((abfd->flags & D_PAGED) == 0
3678 || sections[0]->lma < phdr_size
3679 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3680 phdr_in_segment = FALSE;
3683 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3686 bfd_boolean new_segment;
3690 /* See if this section and the last one will fit in the same
3693 if (last_hdr == NULL)
3695 /* If we don't have a segment yet, then we don't need a new
3696 one (we build the last one after this loop). */
3697 new_segment = FALSE;
3699 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3701 /* If this section has a different relation between the
3702 virtual address and the load address, then we need a new
3706 else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3707 < BFD_ALIGN (hdr->lma, maxpagesize))
3709 /* If putting this section in this segment would force us to
3710 skip a page in the segment, then we need a new segment. */
3713 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3714 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3716 /* We don't want to put a loadable section after a
3717 nonloadable section in the same segment.
3718 Consider .tbss sections as loadable for this purpose. */
3721 else if ((abfd->flags & D_PAGED) == 0)
3723 /* If the file is not demand paged, which means that we
3724 don't require the sections to be correctly aligned in the
3725 file, then there is no other reason for a new segment. */
3726 new_segment = FALSE;
3729 && (hdr->flags & SEC_READONLY) == 0
3730 && (((last_hdr->lma + last_size - 1)
3731 & ~(maxpagesize - 1))
3732 != (hdr->lma & ~(maxpagesize - 1))))
3734 /* We don't want to put a writable section in a read only
3735 segment, unless they are on the same page in memory
3736 anyhow. We already know that the last section does not
3737 bring us past the current section on the page, so the
3738 only case in which the new section is not on the same
3739 page as the previous section is when the previous section
3740 ends precisely on a page boundary. */
3745 /* Otherwise, we can use the same segment. */
3746 new_segment = FALSE;
3751 if ((hdr->flags & SEC_READONLY) == 0)
3754 /* .tbss sections effectively have zero size. */
3755 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3756 last_size = hdr->size;
3762 /* We need a new program segment. We must create a new program
3763 header holding all the sections from phdr_index until hdr. */
3765 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3772 if ((hdr->flags & SEC_READONLY) == 0)
3778 /* .tbss sections effectively have zero size. */
3779 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3780 last_size = hdr->size;
3784 phdr_in_segment = FALSE;
3787 /* Create a final PT_LOAD program segment. */
3788 if (last_hdr != NULL)
3790 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3798 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3801 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3808 /* For each loadable .note section, add a PT_NOTE segment. We don't
3809 use bfd_get_section_by_name, because if we link together
3810 nonloadable .note sections and loadable .note sections, we will
3811 generate two .note sections in the output file. FIXME: Using
3812 names for section types is bogus anyhow. */
3813 for (s = abfd->sections; s != NULL; s = s->next)
3815 if ((s->flags & SEC_LOAD) != 0
3816 && strncmp (s->name, ".note", 5) == 0)
3818 amt = sizeof (struct elf_segment_map);
3819 m = bfd_zalloc (abfd, amt);
3823 m->p_type = PT_NOTE;
3830 if (s->flags & SEC_THREAD_LOCAL)
3838 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3843 amt = sizeof (struct elf_segment_map);
3844 amt += (tls_count - 1) * sizeof (asection *);
3845 m = bfd_zalloc (abfd, amt);
3850 m->count = tls_count;
3851 /* Mandated PF_R. */
3853 m->p_flags_valid = 1;
3854 for (i = 0; i < tls_count; ++i)
3856 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3857 m->sections[i] = first_tls;
3858 first_tls = first_tls->next;
3865 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3867 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3868 if (eh_frame_hdr != NULL
3869 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3871 amt = sizeof (struct elf_segment_map);
3872 m = bfd_zalloc (abfd, amt);
3876 m->p_type = PT_GNU_EH_FRAME;
3878 m->sections[0] = eh_frame_hdr->output_section;
3884 if (elf_tdata (abfd)->stack_flags)
3886 amt = sizeof (struct elf_segment_map);
3887 m = bfd_zalloc (abfd, amt);
3891 m->p_type = PT_GNU_STACK;
3892 m->p_flags = elf_tdata (abfd)->stack_flags;
3893 m->p_flags_valid = 1;
3899 if (elf_tdata (abfd)->relro)
3901 amt = sizeof (struct elf_segment_map);
3902 m = bfd_zalloc (abfd, amt);
3906 m->p_type = PT_GNU_RELRO;
3908 m->p_flags_valid = 1;
3917 elf_tdata (abfd)->segment_map = mfirst;
3921 if (sections != NULL)
3926 /* Sort sections by address. */
3929 elf_sort_sections (const void *arg1, const void *arg2)
3931 const asection *sec1 = *(const asection **) arg1;
3932 const asection *sec2 = *(const asection **) arg2;
3933 bfd_size_type size1, size2;
3935 /* Sort by LMA first, since this is the address used to
3936 place the section into a segment. */
3937 if (sec1->lma < sec2->lma)
3939 else if (sec1->lma > sec2->lma)
3942 /* Then sort by VMA. Normally the LMA and the VMA will be
3943 the same, and this will do nothing. */
3944 if (sec1->vma < sec2->vma)
3946 else if (sec1->vma > sec2->vma)
3949 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3951 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3957 /* If the indicies are the same, do not return 0
3958 here, but continue to try the next comparison. */
3959 if (sec1->target_index - sec2->target_index != 0)
3960 return sec1->target_index - sec2->target_index;
3965 else if (TOEND (sec2))
3970 /* Sort by size, to put zero sized sections
3971 before others at the same address. */
3973 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
3974 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
3981 return sec1->target_index - sec2->target_index;
3984 /* Ian Lance Taylor writes:
3986 We shouldn't be using % with a negative signed number. That's just
3987 not good. We have to make sure either that the number is not
3988 negative, or that the number has an unsigned type. When the types
3989 are all the same size they wind up as unsigned. When file_ptr is a
3990 larger signed type, the arithmetic winds up as signed long long,
3993 What we're trying to say here is something like ``increase OFF by
3994 the least amount that will cause it to be equal to the VMA modulo
3996 /* In other words, something like:
3998 vma_offset = m->sections[0]->vma % bed->maxpagesize;
3999 off_offset = off % bed->maxpagesize;
4000 if (vma_offset < off_offset)
4001 adjustment = vma_offset + bed->maxpagesize - off_offset;
4003 adjustment = vma_offset - off_offset;
4005 which can can be collapsed into the expression below. */
4008 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4010 return ((vma - off) % maxpagesize);
4013 /* Assign file positions to the sections based on the mapping from
4014 sections to segments. This function also sets up some fields in
4015 the file header, and writes out the program headers. */
4018 assign_file_positions_for_segments (bfd *abfd, struct bfd_link_info *link_info)
4020 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4022 struct elf_segment_map *m;
4024 Elf_Internal_Phdr *phdrs;
4026 bfd_vma filehdr_vaddr, filehdr_paddr;
4027 bfd_vma phdrs_vaddr, phdrs_paddr;
4028 Elf_Internal_Phdr *p;
4031 if (elf_tdata (abfd)->segment_map == NULL)
4033 if (! map_sections_to_segments (abfd))
4038 /* The placement algorithm assumes that non allocated sections are
4039 not in PT_LOAD segments. We ensure this here by removing such
4040 sections from the segment map. */
4041 for (m = elf_tdata (abfd)->segment_map;
4045 unsigned int new_count;
4048 if (m->p_type != PT_LOAD)
4052 for (i = 0; i < m->count; i ++)
4054 if ((m->sections[i]->flags & SEC_ALLOC) != 0)
4057 m->sections[new_count] = m->sections[i];
4063 if (new_count != m->count)
4064 m->count = new_count;
4068 if (bed->elf_backend_modify_segment_map)
4070 if (! (*bed->elf_backend_modify_segment_map) (abfd, link_info))
4075 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4078 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4079 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4080 elf_elfheader (abfd)->e_phnum = count;
4084 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4088 /* If we already counted the number of program segments, make sure
4089 that we allocated enough space. This happens when SIZEOF_HEADERS
4090 is used in a linker script. */
4091 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
4092 if (alloc != 0 && count > alloc)
4094 ((*_bfd_error_handler)
4095 (_("%B: Not enough room for program headers (allocated %u, need %u)"),
4096 abfd, alloc, count));
4097 bfd_set_error (bfd_error_bad_value);
4104 amt = alloc * sizeof (Elf_Internal_Phdr);
4105 phdrs = bfd_alloc (abfd, amt);
4109 off = bed->s->sizeof_ehdr;
4110 off += alloc * bed->s->sizeof_phdr;
4117 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4124 /* If elf_segment_map is not from map_sections_to_segments, the
4125 sections may not be correctly ordered. NOTE: sorting should
4126 not be done to the PT_NOTE section of a corefile, which may
4127 contain several pseudo-sections artificially created by bfd.
4128 Sorting these pseudo-sections breaks things badly. */
4130 && !(elf_elfheader (abfd)->e_type == ET_CORE
4131 && m->p_type == PT_NOTE))
4132 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4135 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4136 number of sections with contents contributing to both p_filesz
4137 and p_memsz, followed by a number of sections with no contents
4138 that just contribute to p_memsz. In this loop, OFF tracks next
4139 available file offset for PT_LOAD and PT_NOTE segments. VOFF is
4140 an adjustment we use for segments that have no file contents
4141 but need zero filled memory allocation. */
4143 p->p_type = m->p_type;
4144 p->p_flags = m->p_flags;
4146 if (p->p_type == PT_LOAD
4149 bfd_size_type align;
4152 if ((abfd->flags & D_PAGED) != 0)
4153 align = bed->maxpagesize;
4156 unsigned int align_power = 0;
4157 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4159 unsigned int secalign;
4161 secalign = bfd_get_section_alignment (abfd, *secpp);
4162 if (secalign > align_power)
4163 align_power = secalign;
4165 align = (bfd_size_type) 1 << align_power;
4168 adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4171 && !m->includes_filehdr
4172 && !m->includes_phdrs
4173 && (ufile_ptr) off >= align)
4175 /* If the first section isn't loadable, the same holds for
4176 any other sections. Since the segment won't need file
4177 space, we can make p_offset overlap some prior segment.
4178 However, .tbss is special. If a segment starts with
4179 .tbss, we need to look at the next section to decide
4180 whether the segment has any loadable sections. */
4182 while ((m->sections[i]->flags & SEC_LOAD) == 0)
4184 if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
4188 voff = adjust - align;
4194 /* Make sure the .dynamic section is the first section in the
4195 PT_DYNAMIC segment. */
4196 else if (p->p_type == PT_DYNAMIC
4198 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4201 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4203 bfd_set_error (bfd_error_bad_value);
4210 p->p_vaddr = m->sections[0]->vma;
4212 if (m->p_paddr_valid)
4213 p->p_paddr = m->p_paddr;
4214 else if (m->count == 0)
4217 p->p_paddr = m->sections[0]->lma;
4219 if (p->p_type == PT_LOAD
4220 && (abfd->flags & D_PAGED) != 0)
4221 p->p_align = bed->maxpagesize;
4222 else if (m->count == 0)
4223 p->p_align = 1 << bed->s->log_file_align;
4231 if (m->includes_filehdr)
4233 if (! m->p_flags_valid)
4236 p->p_filesz = bed->s->sizeof_ehdr;
4237 p->p_memsz = bed->s->sizeof_ehdr;
4240 BFD_ASSERT (p->p_type == PT_LOAD);
4242 if (p->p_vaddr < (bfd_vma) off)
4244 (*_bfd_error_handler)
4245 (_("%B: Not enough room for program headers, try linking with -N"),
4247 bfd_set_error (bfd_error_bad_value);
4252 if (! m->p_paddr_valid)
4255 if (p->p_type == PT_LOAD)
4257 filehdr_vaddr = p->p_vaddr;
4258 filehdr_paddr = p->p_paddr;
4262 if (m->includes_phdrs)
4264 if (! m->p_flags_valid)
4267 if (m->includes_filehdr)
4269 if (p->p_type == PT_LOAD)
4271 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4272 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4277 p->p_offset = bed->s->sizeof_ehdr;
4281 BFD_ASSERT (p->p_type == PT_LOAD);
4282 p->p_vaddr -= off - p->p_offset;
4283 if (! m->p_paddr_valid)
4284 p->p_paddr -= off - p->p_offset;
4287 if (p->p_type == PT_LOAD)
4289 phdrs_vaddr = p->p_vaddr;
4290 phdrs_paddr = p->p_paddr;
4293 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4296 p->p_filesz += alloc * bed->s->sizeof_phdr;
4297 p->p_memsz += alloc * bed->s->sizeof_phdr;
4300 if (p->p_type == PT_LOAD
4301 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4303 if (! m->includes_filehdr && ! m->includes_phdrs)
4304 p->p_offset = off + voff;
4309 adjust = off - (p->p_offset + p->p_filesz);
4310 p->p_filesz += adjust;
4311 p->p_memsz += adjust;
4315 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4319 bfd_size_type align;
4323 align = 1 << bfd_get_section_alignment (abfd, sec);
4325 if (p->p_type == PT_LOAD
4326 || p->p_type == PT_TLS)
4328 bfd_signed_vma adjust;
4330 if ((flags & SEC_LOAD) != 0)
4332 adjust = sec->lma - (p->p_paddr + p->p_filesz);
4335 (*_bfd_error_handler)
4336 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4337 abfd, sec, (unsigned long) sec->lma);
4341 p->p_filesz += adjust;
4342 p->p_memsz += adjust;
4344 /* .tbss is special. It doesn't contribute to p_memsz of
4346 else if ((flags & SEC_THREAD_LOCAL) == 0
4347 || p->p_type == PT_TLS)
4349 /* The section VMA must equal the file position
4350 modulo the page size. */
4351 bfd_size_type page = align;
4352 if ((abfd->flags & D_PAGED) != 0)
4353 page = bed->maxpagesize;
4354 adjust = vma_page_aligned_bias (sec->vma,
4355 p->p_vaddr + p->p_memsz,
4357 p->p_memsz += adjust;
4361 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4363 /* The section at i == 0 is the one that actually contains
4369 p->p_filesz = sec->size;
4375 /* The rest are fake sections that shouldn't be written. */
4384 if (p->p_type == PT_LOAD)
4387 /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4388 1997, and the exact reason for it isn't clear. One
4389 plausible explanation is that it is to work around
4390 a problem we have with linker scripts using data
4391 statements in NOLOAD sections. I don't think it
4392 makes a great deal of sense to have such a section
4393 assigned to a PT_LOAD segment, but apparently
4394 people do this. The data statement results in a
4395 bfd_data_link_order being built, and these need
4396 section contents to write into. Eventually, we get
4397 to _bfd_elf_write_object_contents which writes any
4398 section with contents to the output. Make room
4399 here for the write, so that following segments are
4401 if ((flags & SEC_LOAD) != 0
4402 || (flags & SEC_HAS_CONTENTS) != 0)
4406 if ((flags & SEC_LOAD) != 0)
4408 p->p_filesz += sec->size;
4409 p->p_memsz += sec->size;
4411 /* PR ld/594: Sections in note segments which are not loaded
4412 contribute to the file size but not the in-memory size. */
4413 else if (p->p_type == PT_NOTE
4414 && (flags & SEC_HAS_CONTENTS) != 0)
4415 p->p_filesz += sec->size;
4417 /* .tbss is special. It doesn't contribute to p_memsz of
4419 else if ((flags & SEC_THREAD_LOCAL) == 0
4420 || p->p_type == PT_TLS)
4421 p->p_memsz += sec->size;
4423 if (p->p_type == PT_TLS
4425 && (sec->flags & SEC_HAS_CONTENTS) == 0)
4427 struct bfd_link_order *o;
4428 bfd_vma tbss_size = 0;
4430 for (o = sec->map_head.link_order; o != NULL; o = o->next)
4431 if (tbss_size < o->offset + o->size)
4432 tbss_size = o->offset + o->size;
4434 p->p_memsz += tbss_size;
4437 if (align > p->p_align
4438 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
4442 if (! m->p_flags_valid)
4445 if ((flags & SEC_CODE) != 0)
4447 if ((flags & SEC_READONLY) == 0)
4453 /* Now that we have set the section file positions, we can set up
4454 the file positions for the non PT_LOAD segments. */
4455 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4459 if (p->p_type != PT_LOAD && m->count > 0)
4461 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
4462 /* If the section has not yet been assigned a file position,
4463 do so now. The ARM BPABI requires that .dynamic section
4464 not be marked SEC_ALLOC because it is not part of any
4465 PT_LOAD segment, so it will not be processed above. */
4466 if (p->p_type == PT_DYNAMIC && m->sections[0]->filepos == 0)
4469 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4472 while (i_shdrpp[i]->bfd_section != m->sections[0])
4474 off = (_bfd_elf_assign_file_position_for_section
4475 (i_shdrpp[i], off, TRUE));
4476 p->p_filesz = m->sections[0]->size;
4478 p->p_offset = m->sections[0]->filepos;
4482 if (m->includes_filehdr)
4484 p->p_vaddr = filehdr_vaddr;
4485 if (! m->p_paddr_valid)
4486 p->p_paddr = filehdr_paddr;
4488 else if (m->includes_phdrs)
4490 p->p_vaddr = phdrs_vaddr;
4491 if (! m->p_paddr_valid)
4492 p->p_paddr = phdrs_paddr;
4494 else if (p->p_type == PT_GNU_RELRO)
4496 Elf_Internal_Phdr *lp;
4498 for (lp = phdrs; lp < phdrs + count; ++lp)
4500 if (lp->p_type == PT_LOAD
4501 && lp->p_vaddr <= link_info->relro_end
4502 && lp->p_vaddr >= link_info->relro_start
4503 && lp->p_vaddr + lp->p_filesz
4504 >= link_info->relro_end)
4508 if (lp < phdrs + count
4509 && link_info->relro_end > lp->p_vaddr)
4511 p->p_vaddr = lp->p_vaddr;
4512 p->p_paddr = lp->p_paddr;
4513 p->p_offset = lp->p_offset;
4514 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4515 p->p_memsz = p->p_filesz;
4517 p->p_flags = (lp->p_flags & ~PF_W);
4521 memset (p, 0, sizeof *p);
4522 p->p_type = PT_NULL;
4528 /* Clear out any program headers we allocated but did not use. */
4529 for (; count < alloc; count++, p++)
4531 memset (p, 0, sizeof *p);
4532 p->p_type = PT_NULL;
4535 elf_tdata (abfd)->phdr = phdrs;
4537 elf_tdata (abfd)->next_file_pos = off;
4539 /* Write out the program headers. */
4540 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4541 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4547 /* Get the size of the program header.
4549 If this is called by the linker before any of the section VMA's are set, it
4550 can't calculate the correct value for a strange memory layout. This only
4551 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4552 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4553 data segment (exclusive of .interp and .dynamic).
4555 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4556 will be two segments. */
4558 static bfd_size_type
4559 get_program_header_size (bfd *abfd)
4563 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4565 /* We can't return a different result each time we're called. */
4566 if (elf_tdata (abfd)->program_header_size != 0)
4567 return elf_tdata (abfd)->program_header_size;
4569 if (elf_tdata (abfd)->segment_map != NULL)
4571 struct elf_segment_map *m;
4574 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4576 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4577 return elf_tdata (abfd)->program_header_size;
4580 /* Assume we will need exactly two PT_LOAD segments: one for text
4581 and one for data. */
4584 s = bfd_get_section_by_name (abfd, ".interp");
4585 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4587 /* If we have a loadable interpreter section, we need a
4588 PT_INTERP segment. In this case, assume we also need a
4589 PT_PHDR segment, although that may not be true for all
4594 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4596 /* We need a PT_DYNAMIC segment. */
4600 if (elf_tdata (abfd)->eh_frame_hdr)
4602 /* We need a PT_GNU_EH_FRAME segment. */
4606 if (elf_tdata (abfd)->stack_flags)
4608 /* We need a PT_GNU_STACK segment. */
4612 if (elf_tdata (abfd)->relro)
4614 /* We need a PT_GNU_RELRO segment. */
4618 for (s = abfd->sections; s != NULL; s = s->next)
4620 if ((s->flags & SEC_LOAD) != 0
4621 && strncmp (s->name, ".note", 5) == 0)
4623 /* We need a PT_NOTE segment. */
4628 for (s = abfd->sections; s != NULL; s = s->next)
4630 if (s->flags & SEC_THREAD_LOCAL)
4632 /* We need a PT_TLS segment. */
4638 /* Let the backend count up any program headers it might need. */
4639 if (bed->elf_backend_additional_program_headers)
4643 a = (*bed->elf_backend_additional_program_headers) (abfd);
4649 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4650 return elf_tdata (abfd)->program_header_size;
4653 /* Work out the file positions of all the sections. This is called by
4654 _bfd_elf_compute_section_file_positions. All the section sizes and
4655 VMAs must be known before this is called.
4657 Reloc sections come in two flavours: Those processed specially as
4658 "side-channel" data attached to a section to which they apply, and
4659 those that bfd doesn't process as relocations. The latter sort are
4660 stored in a normal bfd section by bfd_section_from_shdr. We don't
4661 consider the former sort here, unless they form part of the loadable
4662 image. Reloc sections not assigned here will be handled later by
4663 assign_file_positions_for_relocs.
4665 We also don't set the positions of the .symtab and .strtab here. */
4668 assign_file_positions_except_relocs (bfd *abfd,
4669 struct bfd_link_info *link_info)
4671 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4672 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4673 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4674 unsigned int num_sec = elf_numsections (abfd);
4676 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4678 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4679 && bfd_get_format (abfd) != bfd_core)
4681 Elf_Internal_Shdr **hdrpp;
4684 /* Start after the ELF header. */
4685 off = i_ehdrp->e_ehsize;
4687 /* We are not creating an executable, which means that we are
4688 not creating a program header, and that the actual order of
4689 the sections in the file is unimportant. */
4690 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4692 Elf_Internal_Shdr *hdr;
4695 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4696 && hdr->bfd_section == NULL)
4697 || i == tdata->symtab_section
4698 || i == tdata->symtab_shndx_section
4699 || i == tdata->strtab_section)
4701 hdr->sh_offset = -1;
4704 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4706 if (i == SHN_LORESERVE - 1)
4708 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4709 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4716 Elf_Internal_Shdr **hdrpp;
4718 /* Assign file positions for the loaded sections based on the
4719 assignment of sections to segments. */
4720 if (! assign_file_positions_for_segments (abfd, link_info))
4723 /* Assign file positions for the other sections. */
4725 off = elf_tdata (abfd)->next_file_pos;
4726 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4728 Elf_Internal_Shdr *hdr;
4731 if (hdr->bfd_section != NULL
4732 && hdr->bfd_section->filepos != 0)
4733 hdr->sh_offset = hdr->bfd_section->filepos;
4734 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4736 ((*_bfd_error_handler)
4737 (_("%B: warning: allocated section `%s' not in segment"),
4739 (hdr->bfd_section == NULL
4741 : hdr->bfd_section->name)));
4742 if ((abfd->flags & D_PAGED) != 0)
4743 off += vma_page_aligned_bias (hdr->sh_addr, off,
4746 off += vma_page_aligned_bias (hdr->sh_addr, off,
4748 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4751 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4752 && hdr->bfd_section == NULL)
4753 || hdr == i_shdrpp[tdata->symtab_section]
4754 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4755 || hdr == i_shdrpp[tdata->strtab_section])
4756 hdr->sh_offset = -1;
4758 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4760 if (i == SHN_LORESERVE - 1)
4762 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4763 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4768 /* Place the section headers. */
4769 off = align_file_position (off, 1 << bed->s->log_file_align);
4770 i_ehdrp->e_shoff = off;
4771 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4773 elf_tdata (abfd)->next_file_pos = off;
4779 prep_headers (bfd *abfd)
4781 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4782 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4783 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
4784 struct elf_strtab_hash *shstrtab;
4785 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4787 i_ehdrp = elf_elfheader (abfd);
4788 i_shdrp = elf_elfsections (abfd);
4790 shstrtab = _bfd_elf_strtab_init ();
4791 if (shstrtab == NULL)
4794 elf_shstrtab (abfd) = shstrtab;
4796 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4797 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4798 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4799 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4801 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4802 i_ehdrp->e_ident[EI_DATA] =
4803 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4804 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4806 if ((abfd->flags & DYNAMIC) != 0)
4807 i_ehdrp->e_type = ET_DYN;
4808 else if ((abfd->flags & EXEC_P) != 0)
4809 i_ehdrp->e_type = ET_EXEC;
4810 else if (bfd_get_format (abfd) == bfd_core)
4811 i_ehdrp->e_type = ET_CORE;
4813 i_ehdrp->e_type = ET_REL;
4815 switch (bfd_get_arch (abfd))
4817 case bfd_arch_unknown:
4818 i_ehdrp->e_machine = EM_NONE;
4821 /* There used to be a long list of cases here, each one setting
4822 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4823 in the corresponding bfd definition. To avoid duplication,
4824 the switch was removed. Machines that need special handling
4825 can generally do it in elf_backend_final_write_processing(),
4826 unless they need the information earlier than the final write.
4827 Such need can generally be supplied by replacing the tests for
4828 e_machine with the conditions used to determine it. */
4830 i_ehdrp->e_machine = bed->elf_machine_code;
4833 i_ehdrp->e_version = bed->s->ev_current;
4834 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4836 /* No program header, for now. */
4837 i_ehdrp->e_phoff = 0;
4838 i_ehdrp->e_phentsize = 0;
4839 i_ehdrp->e_phnum = 0;
4841 /* Each bfd section is section header entry. */
4842 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4843 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4845 /* If we're building an executable, we'll need a program header table. */
4846 if (abfd->flags & EXEC_P)
4847 /* It all happens later. */
4851 i_ehdrp->e_phentsize = 0;
4853 i_ehdrp->e_phoff = 0;
4856 elf_tdata (abfd)->symtab_hdr.sh_name =
4857 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4858 elf_tdata (abfd)->strtab_hdr.sh_name =
4859 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4860 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4861 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4862 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4863 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4864 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4870 /* Assign file positions for all the reloc sections which are not part
4871 of the loadable file image. */
4874 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4877 unsigned int i, num_sec;
4878 Elf_Internal_Shdr **shdrpp;
4880 off = elf_tdata (abfd)->next_file_pos;
4882 num_sec = elf_numsections (abfd);
4883 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4885 Elf_Internal_Shdr *shdrp;
4888 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4889 && shdrp->sh_offset == -1)
4890 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4893 elf_tdata (abfd)->next_file_pos = off;
4897 _bfd_elf_write_object_contents (bfd *abfd)
4899 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4900 Elf_Internal_Ehdr *i_ehdrp;
4901 Elf_Internal_Shdr **i_shdrp;
4903 unsigned int count, num_sec;
4905 if (! abfd->output_has_begun
4906 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4909 i_shdrp = elf_elfsections (abfd);
4910 i_ehdrp = elf_elfheader (abfd);
4913 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4917 _bfd_elf_assign_file_positions_for_relocs (abfd);
4919 /* After writing the headers, we need to write the sections too... */
4920 num_sec = elf_numsections (abfd);
4921 for (count = 1; count < num_sec; count++)
4923 if (bed->elf_backend_section_processing)
4924 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4925 if (i_shdrp[count]->contents)
4927 bfd_size_type amt = i_shdrp[count]->sh_size;
4929 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4930 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4933 if (count == SHN_LORESERVE - 1)
4934 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4937 /* Write out the section header names. */
4938 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4939 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4942 if (bed->elf_backend_final_write_processing)
4943 (*bed->elf_backend_final_write_processing) (abfd,
4944 elf_tdata (abfd)->linker);
4946 return bed->s->write_shdrs_and_ehdr (abfd);
4950 _bfd_elf_write_corefile_contents (bfd *abfd)
4952 /* Hopefully this can be done just like an object file. */
4953 return _bfd_elf_write_object_contents (abfd);
4956 /* Given a section, search the header to find them. */
4959 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4961 const struct elf_backend_data *bed;
4964 if (elf_section_data (asect) != NULL
4965 && elf_section_data (asect)->this_idx != 0)
4966 return elf_section_data (asect)->this_idx;
4968 if (bfd_is_abs_section (asect))
4970 else if (bfd_is_com_section (asect))
4972 else if (bfd_is_und_section (asect))
4977 bed = get_elf_backend_data (abfd);
4978 if (bed->elf_backend_section_from_bfd_section)
4982 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4987 bfd_set_error (bfd_error_nonrepresentable_section);
4992 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4996 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4998 asymbol *asym_ptr = *asym_ptr_ptr;
5000 flagword flags = asym_ptr->flags;
5002 /* When gas creates relocations against local labels, it creates its
5003 own symbol for the section, but does put the symbol into the
5004 symbol chain, so udata is 0. When the linker is generating
5005 relocatable output, this section symbol may be for one of the
5006 input sections rather than the output section. */
5007 if (asym_ptr->udata.i == 0
5008 && (flags & BSF_SECTION_SYM)
5009 && asym_ptr->section)
5013 if (asym_ptr->section->output_section != NULL)
5014 indx = asym_ptr->section->output_section->index;
5016 indx = asym_ptr->section->index;
5017 if (indx < elf_num_section_syms (abfd)
5018 && elf_section_syms (abfd)[indx] != NULL)
5019 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5022 idx = asym_ptr->udata.i;
5026 /* This case can occur when using --strip-symbol on a symbol
5027 which is used in a relocation entry. */
5028 (*_bfd_error_handler)
5029 (_("%B: symbol `%s' required but not present"),
5030 abfd, bfd_asymbol_name (asym_ptr));
5031 bfd_set_error (bfd_error_no_symbols);
5038 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5039 (long) asym_ptr, asym_ptr->name, idx, flags,
5040 elf_symbol_flags (flags));
5048 /* Copy private BFD data. This copies any program header information. */
5051 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5053 Elf_Internal_Ehdr *iehdr;
5054 struct elf_segment_map *map;
5055 struct elf_segment_map *map_first;
5056 struct elf_segment_map **pointer_to_map;
5057 Elf_Internal_Phdr *segment;
5060 unsigned int num_segments;
5061 bfd_boolean phdr_included = FALSE;
5062 bfd_vma maxpagesize;
5063 struct elf_segment_map *phdr_adjust_seg = NULL;
5064 unsigned int phdr_adjust_num = 0;
5065 const struct elf_backend_data *bed;
5067 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5068 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5071 if (elf_tdata (ibfd)->phdr == NULL)
5074 bed = get_elf_backend_data (ibfd);
5075 iehdr = elf_elfheader (ibfd);
5078 pointer_to_map = &map_first;
5080 num_segments = elf_elfheader (ibfd)->e_phnum;
5081 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5083 /* Returns the end address of the segment + 1. */
5084 #define SEGMENT_END(segment, start) \
5085 (start + (segment->p_memsz > segment->p_filesz \
5086 ? segment->p_memsz : segment->p_filesz))
5088 #define SECTION_SIZE(section, segment) \
5089 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5090 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5091 ? section->size : 0)
5093 /* Returns TRUE if the given section is contained within
5094 the given segment. VMA addresses are compared. */
5095 #define IS_CONTAINED_BY_VMA(section, segment) \
5096 (section->vma >= segment->p_vaddr \
5097 && (section->vma + SECTION_SIZE (section, segment) \
5098 <= (SEGMENT_END (segment, segment->p_vaddr))))
5100 /* Returns TRUE if the given section is contained within
5101 the given segment. LMA addresses are compared. */
5102 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5103 (section->lma >= base \
5104 && (section->lma + SECTION_SIZE (section, segment) \
5105 <= SEGMENT_END (segment, base)))
5107 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
5108 #define IS_COREFILE_NOTE(p, s) \
5109 (p->p_type == PT_NOTE \
5110 && bfd_get_format (ibfd) == bfd_core \
5111 && s->vma == 0 && s->lma == 0 \
5112 && (bfd_vma) s->filepos >= p->p_offset \
5113 && ((bfd_vma) s->filepos + s->size \
5114 <= p->p_offset + p->p_filesz))
5116 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5117 linker, which generates a PT_INTERP section with p_vaddr and
5118 p_memsz set to 0. */
5119 #define IS_SOLARIS_PT_INTERP(p, s) \
5121 && p->p_paddr == 0 \
5122 && p->p_memsz == 0 \
5123 && p->p_filesz > 0 \
5124 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5126 && (bfd_vma) s->filepos >= p->p_offset \
5127 && ((bfd_vma) s->filepos + s->size \
5128 <= p->p_offset + p->p_filesz))
5130 /* Decide if the given section should be included in the given segment.
5131 A section will be included if:
5132 1. It is within the address space of the segment -- we use the LMA
5133 if that is set for the segment and the VMA otherwise,
5134 2. It is an allocated segment,
5135 3. There is an output section associated with it,
5136 4. The section has not already been allocated to a previous segment.
5137 5. PT_GNU_STACK segments do not include any sections.
5138 6. PT_TLS segment includes only SHF_TLS sections.
5139 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5140 8. PT_DYNAMIC should not contain empty sections at the beginning
5141 (with the possible exception of .dynamic). */
5142 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5143 ((((segment->p_paddr \
5144 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5145 : IS_CONTAINED_BY_VMA (section, segment)) \
5146 && (section->flags & SEC_ALLOC) != 0) \
5147 || IS_COREFILE_NOTE (segment, section)) \
5148 && section->output_section != NULL \
5149 && segment->p_type != PT_GNU_STACK \
5150 && (segment->p_type != PT_TLS \
5151 || (section->flags & SEC_THREAD_LOCAL)) \
5152 && (segment->p_type == PT_LOAD \
5153 || segment->p_type == PT_TLS \
5154 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5155 && (segment->p_type != PT_DYNAMIC \
5156 || SECTION_SIZE (section, segment) > 0 \
5157 || (segment->p_paddr \
5158 ? segment->p_paddr != section->lma \
5159 : segment->p_vaddr != section->vma) \
5160 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5162 && ! section->segment_mark)
5164 /* Returns TRUE iff seg1 starts after the end of seg2. */
5165 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5166 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5168 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5169 their VMA address ranges and their LMA address ranges overlap.
5170 It is possible to have overlapping VMA ranges without overlapping LMA
5171 ranges. RedBoot images for example can have both .data and .bss mapped
5172 to the same VMA range, but with the .data section mapped to a different
5174 #define SEGMENT_OVERLAPS(seg1, seg2) \
5175 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5176 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5177 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5178 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5180 /* Initialise the segment mark field. */
5181 for (section = ibfd->sections; section != NULL; section = section->next)
5182 section->segment_mark = FALSE;
5184 /* Scan through the segments specified in the program header
5185 of the input BFD. For this first scan we look for overlaps
5186 in the loadable segments. These can be created by weird
5187 parameters to objcopy. Also, fix some solaris weirdness. */
5188 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5193 Elf_Internal_Phdr *segment2;
5195 if (segment->p_type == PT_INTERP)
5196 for (section = ibfd->sections; section; section = section->next)
5197 if (IS_SOLARIS_PT_INTERP (segment, section))
5199 /* Mininal change so that the normal section to segment
5200 assignment code will work. */
5201 segment->p_vaddr = section->vma;
5205 if (segment->p_type != PT_LOAD)
5208 /* Determine if this segment overlaps any previous segments. */
5209 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5211 bfd_signed_vma extra_length;
5213 if (segment2->p_type != PT_LOAD
5214 || ! SEGMENT_OVERLAPS (segment, segment2))
5217 /* Merge the two segments together. */
5218 if (segment2->p_vaddr < segment->p_vaddr)
5220 /* Extend SEGMENT2 to include SEGMENT and then delete
5223 SEGMENT_END (segment, segment->p_vaddr)
5224 - SEGMENT_END (segment2, segment2->p_vaddr);
5226 if (extra_length > 0)
5228 segment2->p_memsz += extra_length;
5229 segment2->p_filesz += extra_length;
5232 segment->p_type = PT_NULL;
5234 /* Since we have deleted P we must restart the outer loop. */
5236 segment = elf_tdata (ibfd)->phdr;
5241 /* Extend SEGMENT to include SEGMENT2 and then delete
5244 SEGMENT_END (segment2, segment2->p_vaddr)
5245 - SEGMENT_END (segment, segment->p_vaddr);
5247 if (extra_length > 0)
5249 segment->p_memsz += extra_length;
5250 segment->p_filesz += extra_length;
5253 segment2->p_type = PT_NULL;
5258 /* The second scan attempts to assign sections to segments. */
5259 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5263 unsigned int section_count;
5264 asection ** sections;
5265 asection * output_section;
5267 bfd_vma matching_lma;
5268 bfd_vma suggested_lma;
5272 if (segment->p_type == PT_NULL)
5275 /* Compute how many sections might be placed into this segment. */
5276 for (section = ibfd->sections, section_count = 0;
5278 section = section->next)
5279 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5282 /* Allocate a segment map big enough to contain
5283 all of the sections we have selected. */
5284 amt = sizeof (struct elf_segment_map);
5285 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5286 map = bfd_alloc (obfd, amt);
5290 /* Initialise the fields of the segment map. Default to
5291 using the physical address of the segment in the input BFD. */
5293 map->p_type = segment->p_type;
5294 map->p_flags = segment->p_flags;
5295 map->p_flags_valid = 1;
5296 map->p_paddr = segment->p_paddr;
5297 map->p_paddr_valid = 1;
5299 /* Determine if this segment contains the ELF file header
5300 and if it contains the program headers themselves. */
5301 map->includes_filehdr = (segment->p_offset == 0
5302 && segment->p_filesz >= iehdr->e_ehsize);
5304 map->includes_phdrs = 0;
5306 if (! phdr_included || segment->p_type != PT_LOAD)
5308 map->includes_phdrs =
5309 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5310 && (segment->p_offset + segment->p_filesz
5311 >= ((bfd_vma) iehdr->e_phoff
5312 + iehdr->e_phnum * iehdr->e_phentsize)));
5314 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5315 phdr_included = TRUE;
5318 if (section_count == 0)
5320 /* Special segments, such as the PT_PHDR segment, may contain
5321 no sections, but ordinary, loadable segments should contain
5322 something. They are allowed by the ELF spec however, so only
5323 a warning is produced. */
5324 if (segment->p_type == PT_LOAD)
5325 (*_bfd_error_handler)
5326 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5330 *pointer_to_map = map;
5331 pointer_to_map = &map->next;
5336 /* Now scan the sections in the input BFD again and attempt
5337 to add their corresponding output sections to the segment map.
5338 The problem here is how to handle an output section which has
5339 been moved (ie had its LMA changed). There are four possibilities:
5341 1. None of the sections have been moved.
5342 In this case we can continue to use the segment LMA from the
5345 2. All of the sections have been moved by the same amount.
5346 In this case we can change the segment's LMA to match the LMA
5347 of the first section.
5349 3. Some of the sections have been moved, others have not.
5350 In this case those sections which have not been moved can be
5351 placed in the current segment which will have to have its size,
5352 and possibly its LMA changed, and a new segment or segments will
5353 have to be created to contain the other sections.
5355 4. The sections have been moved, but not by the same amount.
5356 In this case we can change the segment's LMA to match the LMA
5357 of the first section and we will have to create a new segment
5358 or segments to contain the other sections.
5360 In order to save time, we allocate an array to hold the section
5361 pointers that we are interested in. As these sections get assigned
5362 to a segment, they are removed from this array. */
5364 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5365 to work around this long long bug. */
5366 amt = section_count * sizeof (asection *);
5367 sections = bfd_malloc (amt);
5368 if (sections == NULL)
5371 /* Step One: Scan for segment vs section LMA conflicts.
5372 Also add the sections to the section array allocated above.
5373 Also add the sections to the current segment. In the common
5374 case, where the sections have not been moved, this means that
5375 we have completely filled the segment, and there is nothing
5381 for (j = 0, section = ibfd->sections;
5383 section = section->next)
5385 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5387 output_section = section->output_section;
5389 sections[j ++] = section;
5391 /* The Solaris native linker always sets p_paddr to 0.
5392 We try to catch that case here, and set it to the
5393 correct value. Note - some backends require that
5394 p_paddr be left as zero. */
5395 if (segment->p_paddr == 0
5396 && segment->p_vaddr != 0
5397 && (! bed->want_p_paddr_set_to_zero)
5399 && output_section->lma != 0
5400 && (output_section->vma == (segment->p_vaddr
5401 + (map->includes_filehdr
5404 + (map->includes_phdrs
5406 * iehdr->e_phentsize)
5408 map->p_paddr = segment->p_vaddr;
5410 /* Match up the physical address of the segment with the
5411 LMA address of the output section. */
5412 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5413 || IS_COREFILE_NOTE (segment, section)
5414 || (bed->want_p_paddr_set_to_zero &&
5415 IS_CONTAINED_BY_VMA (output_section, segment))
5418 if (matching_lma == 0)
5419 matching_lma = output_section->lma;
5421 /* We assume that if the section fits within the segment
5422 then it does not overlap any other section within that
5424 map->sections[isec ++] = output_section;
5426 else if (suggested_lma == 0)
5427 suggested_lma = output_section->lma;
5431 BFD_ASSERT (j == section_count);
5433 /* Step Two: Adjust the physical address of the current segment,
5435 if (isec == section_count)
5437 /* All of the sections fitted within the segment as currently
5438 specified. This is the default case. Add the segment to
5439 the list of built segments and carry on to process the next
5440 program header in the input BFD. */
5441 map->count = section_count;
5442 *pointer_to_map = map;
5443 pointer_to_map = &map->next;
5450 if (matching_lma != 0)
5452 /* At least one section fits inside the current segment.
5453 Keep it, but modify its physical address to match the
5454 LMA of the first section that fitted. */
5455 map->p_paddr = matching_lma;
5459 /* None of the sections fitted inside the current segment.
5460 Change the current segment's physical address to match
5461 the LMA of the first section. */
5462 map->p_paddr = suggested_lma;
5465 /* Offset the segment physical address from the lma
5466 to allow for space taken up by elf headers. */
5467 if (map->includes_filehdr)
5468 map->p_paddr -= iehdr->e_ehsize;
5470 if (map->includes_phdrs)
5472 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5474 /* iehdr->e_phnum is just an estimate of the number
5475 of program headers that we will need. Make a note
5476 here of the number we used and the segment we chose
5477 to hold these headers, so that we can adjust the
5478 offset when we know the correct value. */
5479 phdr_adjust_num = iehdr->e_phnum;
5480 phdr_adjust_seg = map;
5484 /* Step Three: Loop over the sections again, this time assigning
5485 those that fit to the current segment and removing them from the
5486 sections array; but making sure not to leave large gaps. Once all
5487 possible sections have been assigned to the current segment it is
5488 added to the list of built segments and if sections still remain
5489 to be assigned, a new segment is constructed before repeating
5497 /* Fill the current segment with sections that fit. */
5498 for (j = 0; j < section_count; j++)
5500 section = sections[j];
5502 if (section == NULL)
5505 output_section = section->output_section;
5507 BFD_ASSERT (output_section != NULL);
5509 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5510 || IS_COREFILE_NOTE (segment, section))
5512 if (map->count == 0)
5514 /* If the first section in a segment does not start at
5515 the beginning of the segment, then something is
5517 if (output_section->lma !=
5519 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5520 + (map->includes_phdrs
5521 ? iehdr->e_phnum * iehdr->e_phentsize
5527 asection * prev_sec;
5529 prev_sec = map->sections[map->count - 1];
5531 /* If the gap between the end of the previous section
5532 and the start of this section is more than
5533 maxpagesize then we need to start a new segment. */
5534 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5536 < BFD_ALIGN (output_section->lma, maxpagesize))
5537 || ((prev_sec->lma + prev_sec->size)
5538 > output_section->lma))
5540 if (suggested_lma == 0)
5541 suggested_lma = output_section->lma;
5547 map->sections[map->count++] = output_section;
5550 section->segment_mark = TRUE;
5552 else if (suggested_lma == 0)
5553 suggested_lma = output_section->lma;
5556 BFD_ASSERT (map->count > 0);
5558 /* Add the current segment to the list of built segments. */
5559 *pointer_to_map = map;
5560 pointer_to_map = &map->next;
5562 if (isec < section_count)
5564 /* We still have not allocated all of the sections to
5565 segments. Create a new segment here, initialise it
5566 and carry on looping. */
5567 amt = sizeof (struct elf_segment_map);
5568 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5569 map = bfd_alloc (obfd, amt);
5576 /* Initialise the fields of the segment map. Set the physical
5577 physical address to the LMA of the first section that has
5578 not yet been assigned. */
5580 map->p_type = segment->p_type;
5581 map->p_flags = segment->p_flags;
5582 map->p_flags_valid = 1;
5583 map->p_paddr = suggested_lma;
5584 map->p_paddr_valid = 1;
5585 map->includes_filehdr = 0;
5586 map->includes_phdrs = 0;
5589 while (isec < section_count);
5594 /* The Solaris linker creates program headers in which all the
5595 p_paddr fields are zero. When we try to objcopy or strip such a
5596 file, we get confused. Check for this case, and if we find it
5597 reset the p_paddr_valid fields. */
5598 for (map = map_first; map != NULL; map = map->next)
5599 if (map->p_paddr != 0)
5602 for (map = map_first; map != NULL; map = map->next)
5603 map->p_paddr_valid = 0;
5605 elf_tdata (obfd)->segment_map = map_first;
5607 /* If we had to estimate the number of program headers that were
5608 going to be needed, then check our estimate now and adjust
5609 the offset if necessary. */
5610 if (phdr_adjust_seg != NULL)
5614 for (count = 0, map = map_first; map != NULL; map = map->next)
5617 if (count > phdr_adjust_num)
5618 phdr_adjust_seg->p_paddr
5619 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5624 #undef IS_CONTAINED_BY_VMA
5625 #undef IS_CONTAINED_BY_LMA
5626 #undef IS_COREFILE_NOTE
5627 #undef IS_SOLARIS_PT_INTERP
5628 #undef INCLUDE_SECTION_IN_SEGMENT
5629 #undef SEGMENT_AFTER_SEGMENT
5630 #undef SEGMENT_OVERLAPS
5634 /* Copy private section information. This copies over the entsize
5635 field, and sometimes the info field. */
5638 _bfd_elf_copy_private_section_data (bfd *ibfd,
5643 Elf_Internal_Shdr *ihdr, *ohdr;
5645 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5646 || obfd->xvec->flavour != bfd_target_elf_flavour)
5649 ihdr = &elf_section_data (isec)->this_hdr;
5650 ohdr = &elf_section_data (osec)->this_hdr;
5652 ohdr->sh_entsize = ihdr->sh_entsize;
5654 if (ihdr->sh_type == SHT_SYMTAB
5655 || ihdr->sh_type == SHT_DYNSYM
5656 || ihdr->sh_type == SHT_GNU_verneed
5657 || ihdr->sh_type == SHT_GNU_verdef)
5658 ohdr->sh_info = ihdr->sh_info;
5660 /* Set things up for objcopy. The output SHT_GROUP section will
5661 have its elf_next_in_group pointing back to the input group
5662 members. Ignore linker created group section. See
5663 elfNN_ia64_object_p in elfxx-ia64.c. */
5664 if (elf_sec_group (isec) == NULL
5665 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5667 elf_next_in_group (osec) = elf_next_in_group (isec);
5668 elf_group_name (osec) = elf_group_name (isec);
5671 osec->use_rela_p = isec->use_rela_p;
5676 /* Copy private header information. */
5679 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5681 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5682 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5685 /* Copy over private BFD data if it has not already been copied.
5686 This must be done here, rather than in the copy_private_bfd_data
5687 entry point, because the latter is called after the section
5688 contents have been set, which means that the program headers have
5689 already been worked out. */
5690 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5692 if (! copy_private_bfd_data (ibfd, obfd))
5699 /* Copy private symbol information. If this symbol is in a section
5700 which we did not map into a BFD section, try to map the section
5701 index correctly. We use special macro definitions for the mapped
5702 section indices; these definitions are interpreted by the
5703 swap_out_syms function. */
5705 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5706 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5707 #define MAP_STRTAB (SHN_HIOS + 3)
5708 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5709 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5712 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5717 elf_symbol_type *isym, *osym;
5719 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5720 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5723 isym = elf_symbol_from (ibfd, isymarg);
5724 osym = elf_symbol_from (obfd, osymarg);
5728 && bfd_is_abs_section (isym->symbol.section))
5732 shndx = isym->internal_elf_sym.st_shndx;
5733 if (shndx == elf_onesymtab (ibfd))
5734 shndx = MAP_ONESYMTAB;
5735 else if (shndx == elf_dynsymtab (ibfd))
5736 shndx = MAP_DYNSYMTAB;
5737 else if (shndx == elf_tdata (ibfd)->strtab_section)
5739 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5740 shndx = MAP_SHSTRTAB;
5741 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5742 shndx = MAP_SYM_SHNDX;
5743 osym->internal_elf_sym.st_shndx = shndx;
5749 /* Swap out the symbols. */
5752 swap_out_syms (bfd *abfd,
5753 struct bfd_strtab_hash **sttp,
5756 const struct elf_backend_data *bed;
5759 struct bfd_strtab_hash *stt;
5760 Elf_Internal_Shdr *symtab_hdr;
5761 Elf_Internal_Shdr *symtab_shndx_hdr;
5762 Elf_Internal_Shdr *symstrtab_hdr;
5763 bfd_byte *outbound_syms;
5764 bfd_byte *outbound_shndx;
5767 bfd_boolean name_local_sections;
5769 if (!elf_map_symbols (abfd))
5772 /* Dump out the symtabs. */
5773 stt = _bfd_elf_stringtab_init ();
5777 bed = get_elf_backend_data (abfd);
5778 symcount = bfd_get_symcount (abfd);
5779 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5780 symtab_hdr->sh_type = SHT_SYMTAB;
5781 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5782 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5783 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5784 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5786 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5787 symstrtab_hdr->sh_type = SHT_STRTAB;
5789 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5790 outbound_syms = bfd_alloc (abfd, amt);
5791 if (outbound_syms == NULL)
5793 _bfd_stringtab_free (stt);
5796 symtab_hdr->contents = outbound_syms;
5798 outbound_shndx = NULL;
5799 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5800 if (symtab_shndx_hdr->sh_name != 0)
5802 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5803 outbound_shndx = bfd_zalloc (abfd, amt);
5804 if (outbound_shndx == NULL)
5806 _bfd_stringtab_free (stt);
5810 symtab_shndx_hdr->contents = outbound_shndx;
5811 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5812 symtab_shndx_hdr->sh_size = amt;
5813 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5814 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5817 /* Now generate the data (for "contents"). */
5819 /* Fill in zeroth symbol and swap it out. */
5820 Elf_Internal_Sym sym;
5826 sym.st_shndx = SHN_UNDEF;
5827 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5828 outbound_syms += bed->s->sizeof_sym;
5829 if (outbound_shndx != NULL)
5830 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5834 = (bed->elf_backend_name_local_section_symbols
5835 && bed->elf_backend_name_local_section_symbols (abfd));
5837 syms = bfd_get_outsymbols (abfd);
5838 for (idx = 0; idx < symcount; idx++)
5840 Elf_Internal_Sym sym;
5841 bfd_vma value = syms[idx]->value;
5842 elf_symbol_type *type_ptr;
5843 flagword flags = syms[idx]->flags;
5846 if (!name_local_sections
5847 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5849 /* Local section symbols have no name. */
5854 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5857 if (sym.st_name == (unsigned long) -1)
5859 _bfd_stringtab_free (stt);
5864 type_ptr = elf_symbol_from (abfd, syms[idx]);
5866 if ((flags & BSF_SECTION_SYM) == 0
5867 && bfd_is_com_section (syms[idx]->section))
5869 /* ELF common symbols put the alignment into the `value' field,
5870 and the size into the `size' field. This is backwards from
5871 how BFD handles it, so reverse it here. */
5872 sym.st_size = value;
5873 if (type_ptr == NULL
5874 || type_ptr->internal_elf_sym.st_value == 0)
5875 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5877 sym.st_value = type_ptr->internal_elf_sym.st_value;
5878 sym.st_shndx = _bfd_elf_section_from_bfd_section
5879 (abfd, syms[idx]->section);
5883 asection *sec = syms[idx]->section;
5886 if (sec->output_section)
5888 value += sec->output_offset;
5889 sec = sec->output_section;
5892 /* Don't add in the section vma for relocatable output. */
5893 if (! relocatable_p)
5895 sym.st_value = value;
5896 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5898 if (bfd_is_abs_section (sec)
5900 && type_ptr->internal_elf_sym.st_shndx != 0)
5902 /* This symbol is in a real ELF section which we did
5903 not create as a BFD section. Undo the mapping done
5904 by copy_private_symbol_data. */
5905 shndx = type_ptr->internal_elf_sym.st_shndx;
5909 shndx = elf_onesymtab (abfd);
5912 shndx = elf_dynsymtab (abfd);
5915 shndx = elf_tdata (abfd)->strtab_section;
5918 shndx = elf_tdata (abfd)->shstrtab_section;
5921 shndx = elf_tdata (abfd)->symtab_shndx_section;
5929 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5935 /* Writing this would be a hell of a lot easier if
5936 we had some decent documentation on bfd, and
5937 knew what to expect of the library, and what to
5938 demand of applications. For example, it
5939 appears that `objcopy' might not set the
5940 section of a symbol to be a section that is
5941 actually in the output file. */
5942 sec2 = bfd_get_section_by_name (abfd, sec->name);
5945 _bfd_error_handler (_("\
5946 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5947 syms[idx]->name ? syms[idx]->name : "<Local sym>",
5949 bfd_set_error (bfd_error_invalid_operation);
5950 _bfd_stringtab_free (stt);
5954 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5955 BFD_ASSERT (shndx != -1);
5959 sym.st_shndx = shndx;
5962 if ((flags & BSF_THREAD_LOCAL) != 0)
5964 else if ((flags & BSF_FUNCTION) != 0)
5966 else if ((flags & BSF_OBJECT) != 0)
5971 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5974 /* Processor-specific types. */
5975 if (type_ptr != NULL
5976 && bed->elf_backend_get_symbol_type)
5977 type = ((*bed->elf_backend_get_symbol_type)
5978 (&type_ptr->internal_elf_sym, type));
5980 if (flags & BSF_SECTION_SYM)
5982 if (flags & BSF_GLOBAL)
5983 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5985 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5987 else if (bfd_is_com_section (syms[idx]->section))
5988 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5989 else if (bfd_is_und_section (syms[idx]->section))
5990 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5994 else if (flags & BSF_FILE)
5995 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5998 int bind = STB_LOCAL;
6000 if (flags & BSF_LOCAL)
6002 else if (flags & BSF_WEAK)
6004 else if (flags & BSF_GLOBAL)
6007 sym.st_info = ELF_ST_INFO (bind, type);
6010 if (type_ptr != NULL)
6011 sym.st_other = type_ptr->internal_elf_sym.st_other;
6015 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6016 outbound_syms += bed->s->sizeof_sym;
6017 if (outbound_shndx != NULL)
6018 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6022 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6023 symstrtab_hdr->sh_type = SHT_STRTAB;
6025 symstrtab_hdr->sh_flags = 0;
6026 symstrtab_hdr->sh_addr = 0;
6027 symstrtab_hdr->sh_entsize = 0;
6028 symstrtab_hdr->sh_link = 0;
6029 symstrtab_hdr->sh_info = 0;
6030 symstrtab_hdr->sh_addralign = 1;
6035 /* Return the number of bytes required to hold the symtab vector.
6037 Note that we base it on the count plus 1, since we will null terminate
6038 the vector allocated based on this size. However, the ELF symbol table
6039 always has a dummy entry as symbol #0, so it ends up even. */
6042 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6046 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6048 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6049 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6051 symtab_size -= sizeof (asymbol *);
6057 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6061 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6063 if (elf_dynsymtab (abfd) == 0)
6065 bfd_set_error (bfd_error_invalid_operation);
6069 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6070 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6072 symtab_size -= sizeof (asymbol *);
6078 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6081 return (asect->reloc_count + 1) * sizeof (arelent *);
6084 /* Canonicalize the relocs. */
6087 _bfd_elf_canonicalize_reloc (bfd *abfd,
6094 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6096 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6099 tblptr = section->relocation;
6100 for (i = 0; i < section->reloc_count; i++)
6101 *relptr++ = tblptr++;
6105 return section->reloc_count;
6109 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6111 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6112 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6115 bfd_get_symcount (abfd) = symcount;
6120 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6121 asymbol **allocation)
6123 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6124 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6127 bfd_get_dynamic_symcount (abfd) = symcount;
6131 /* Return the size required for the dynamic reloc entries. Any loadable
6132 section that was actually installed in the BFD, and has type SHT_REL
6133 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6134 dynamic reloc section. */
6137 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6142 if (elf_dynsymtab (abfd) == 0)
6144 bfd_set_error (bfd_error_invalid_operation);
6148 ret = sizeof (arelent *);
6149 for (s = abfd->sections; s != NULL; s = s->next)
6150 if ((s->flags & SEC_LOAD) != 0
6151 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6152 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6153 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6154 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6155 * sizeof (arelent *));
6160 /* Canonicalize the dynamic relocation entries. Note that we return the
6161 dynamic relocations as a single block, although they are actually
6162 associated with particular sections; the interface, which was
6163 designed for SunOS style shared libraries, expects that there is only
6164 one set of dynamic relocs. Any loadable section that was actually
6165 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6166 dynamic symbol table, is considered to be a dynamic reloc section. */
6169 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6173 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6177 if (elf_dynsymtab (abfd) == 0)
6179 bfd_set_error (bfd_error_invalid_operation);
6183 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6185 for (s = abfd->sections; s != NULL; s = s->next)
6187 if ((s->flags & SEC_LOAD) != 0
6188 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6189 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6190 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6195 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6197 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6199 for (i = 0; i < count; i++)
6210 /* Read in the version information. */
6213 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6215 bfd_byte *contents = NULL;
6217 unsigned int freeidx = 0;
6219 if (elf_dynverref (abfd) != 0)
6221 Elf_Internal_Shdr *hdr;
6222 Elf_External_Verneed *everneed;
6223 Elf_Internal_Verneed *iverneed;
6226 hdr = &elf_tdata (abfd)->dynverref_hdr;
6228 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
6229 elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
6230 if (elf_tdata (abfd)->verref == NULL)
6233 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6235 contents = bfd_malloc (hdr->sh_size);
6236 if (contents == NULL)
6238 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6239 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6242 everneed = (Elf_External_Verneed *) contents;
6243 iverneed = elf_tdata (abfd)->verref;
6244 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6246 Elf_External_Vernaux *evernaux;
6247 Elf_Internal_Vernaux *ivernaux;
6250 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6252 iverneed->vn_bfd = abfd;
6254 iverneed->vn_filename =
6255 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6257 if (iverneed->vn_filename == NULL)
6260 amt = iverneed->vn_cnt;
6261 amt *= sizeof (Elf_Internal_Vernaux);
6262 iverneed->vn_auxptr = bfd_alloc (abfd, amt);
6264 evernaux = ((Elf_External_Vernaux *)
6265 ((bfd_byte *) everneed + iverneed->vn_aux));
6266 ivernaux = iverneed->vn_auxptr;
6267 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6269 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6271 ivernaux->vna_nodename =
6272 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6273 ivernaux->vna_name);
6274 if (ivernaux->vna_nodename == NULL)
6277 if (j + 1 < iverneed->vn_cnt)
6278 ivernaux->vna_nextptr = ivernaux + 1;
6280 ivernaux->vna_nextptr = NULL;
6282 evernaux = ((Elf_External_Vernaux *)
6283 ((bfd_byte *) evernaux + ivernaux->vna_next));
6285 if (ivernaux->vna_other > freeidx)
6286 freeidx = ivernaux->vna_other;
6289 if (i + 1 < hdr->sh_info)
6290 iverneed->vn_nextref = iverneed + 1;
6292 iverneed->vn_nextref = NULL;
6294 everneed = ((Elf_External_Verneed *)
6295 ((bfd_byte *) everneed + iverneed->vn_next));
6302 if (elf_dynverdef (abfd) != 0)
6304 Elf_Internal_Shdr *hdr;
6305 Elf_External_Verdef *everdef;
6306 Elf_Internal_Verdef *iverdef;
6307 Elf_Internal_Verdef *iverdefarr;
6308 Elf_Internal_Verdef iverdefmem;
6310 unsigned int maxidx;
6312 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6314 contents = bfd_malloc (hdr->sh_size);
6315 if (contents == NULL)
6317 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6318 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6321 /* We know the number of entries in the section but not the maximum
6322 index. Therefore we have to run through all entries and find
6324 everdef = (Elf_External_Verdef *) contents;
6326 for (i = 0; i < hdr->sh_info; ++i)
6328 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6330 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6331 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6333 everdef = ((Elf_External_Verdef *)
6334 ((bfd_byte *) everdef + iverdefmem.vd_next));
6337 if (default_imported_symver)
6339 if (freeidx > maxidx)
6344 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
6345 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6346 if (elf_tdata (abfd)->verdef == NULL)
6349 elf_tdata (abfd)->cverdefs = maxidx;
6351 everdef = (Elf_External_Verdef *) contents;
6352 iverdefarr = elf_tdata (abfd)->verdef;
6353 for (i = 0; i < hdr->sh_info; i++)
6355 Elf_External_Verdaux *everdaux;
6356 Elf_Internal_Verdaux *iverdaux;
6359 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6361 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6362 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6364 iverdef->vd_bfd = abfd;
6366 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
6367 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6368 if (iverdef->vd_auxptr == NULL)
6371 everdaux = ((Elf_External_Verdaux *)
6372 ((bfd_byte *) everdef + iverdef->vd_aux));
6373 iverdaux = iverdef->vd_auxptr;
6374 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6376 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6378 iverdaux->vda_nodename =
6379 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6380 iverdaux->vda_name);
6381 if (iverdaux->vda_nodename == NULL)
6384 if (j + 1 < iverdef->vd_cnt)
6385 iverdaux->vda_nextptr = iverdaux + 1;
6387 iverdaux->vda_nextptr = NULL;
6389 everdaux = ((Elf_External_Verdaux *)
6390 ((bfd_byte *) everdaux + iverdaux->vda_next));
6393 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6395 if (i + 1 < hdr->sh_info)
6396 iverdef->vd_nextdef = iverdef + 1;
6398 iverdef->vd_nextdef = NULL;
6400 everdef = ((Elf_External_Verdef *)
6401 ((bfd_byte *) everdef + iverdef->vd_next));
6407 else if (default_imported_symver)
6414 amt = (bfd_size_type) freeidx * sizeof (Elf_Internal_Verdef);
6415 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6416 if (elf_tdata (abfd)->verdef == NULL)
6419 elf_tdata (abfd)->cverdefs = freeidx;
6422 /* Create a default version based on the soname. */
6423 if (default_imported_symver)
6425 Elf_Internal_Verdef *iverdef;
6426 Elf_Internal_Verdaux *iverdaux;
6428 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6430 iverdef->vd_version = VER_DEF_CURRENT;
6431 iverdef->vd_flags = 0;
6432 iverdef->vd_ndx = freeidx;
6433 iverdef->vd_cnt = 1;
6435 iverdef->vd_bfd = abfd;
6437 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6438 if (iverdef->vd_nodename == NULL)
6440 iverdef->vd_nextdef = NULL;
6441 amt = (bfd_size_type) sizeof (Elf_Internal_Verdaux);
6442 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6444 iverdaux = iverdef->vd_auxptr;
6445 iverdaux->vda_nodename = iverdef->vd_nodename;
6446 iverdaux->vda_nextptr = NULL;
6452 if (contents != NULL)
6458 _bfd_elf_make_empty_symbol (bfd *abfd)
6460 elf_symbol_type *newsym;
6461 bfd_size_type amt = sizeof (elf_symbol_type);
6463 newsym = bfd_zalloc (abfd, amt);
6468 newsym->symbol.the_bfd = abfd;
6469 return &newsym->symbol;
6474 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6478 bfd_symbol_info (symbol, ret);
6481 /* Return whether a symbol name implies a local symbol. Most targets
6482 use this function for the is_local_label_name entry point, but some
6486 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6489 /* Normal local symbols start with ``.L''. */
6490 if (name[0] == '.' && name[1] == 'L')
6493 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6494 DWARF debugging symbols starting with ``..''. */
6495 if (name[0] == '.' && name[1] == '.')
6498 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6499 emitting DWARF debugging output. I suspect this is actually a
6500 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6501 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6502 underscore to be emitted on some ELF targets). For ease of use,
6503 we treat such symbols as local. */
6504 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6511 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6512 asymbol *symbol ATTRIBUTE_UNUSED)
6519 _bfd_elf_set_arch_mach (bfd *abfd,
6520 enum bfd_architecture arch,
6521 unsigned long machine)
6523 /* If this isn't the right architecture for this backend, and this
6524 isn't the generic backend, fail. */
6525 if (arch != get_elf_backend_data (abfd)->arch
6526 && arch != bfd_arch_unknown
6527 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6530 return bfd_default_set_arch_mach (abfd, arch, machine);
6533 /* Find the function to a particular section and offset,
6534 for error reporting. */
6537 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6541 const char **filename_ptr,
6542 const char **functionname_ptr)
6544 const char *filename;
6545 asymbol *func, *file;
6548 /* ??? Given multiple file symbols, it is impossible to reliably
6549 choose the right file name for global symbols. File symbols are
6550 local symbols, and thus all file symbols must sort before any
6551 global symbols. The ELF spec may be interpreted to say that a
6552 file symbol must sort before other local symbols, but currently
6553 ld -r doesn't do this. So, for ld -r output, it is possible to
6554 make a better choice of file name for local symbols by ignoring
6555 file symbols appearing after a given local symbol. */
6556 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6562 state = nothing_seen;
6564 for (p = symbols; *p != NULL; p++)
6568 q = (elf_symbol_type *) *p;
6570 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6576 if (state == symbol_seen)
6577 state = file_after_symbol_seen;
6583 if (bfd_get_section (&q->symbol) == section
6584 && q->symbol.value >= low_func
6585 && q->symbol.value <= offset)
6587 func = (asymbol *) q;
6588 low_func = q->symbol.value;
6591 else if (ELF_ST_BIND (q->internal_elf_sym.st_info) != STB_LOCAL
6592 && state == file_after_symbol_seen)
6595 filename = bfd_asymbol_name (file);
6599 if (state == nothing_seen)
6600 state = symbol_seen;
6607 *filename_ptr = filename;
6608 if (functionname_ptr)
6609 *functionname_ptr = bfd_asymbol_name (func);
6614 /* Find the nearest line to a particular section and offset,
6615 for error reporting. */
6618 _bfd_elf_find_nearest_line (bfd *abfd,
6622 const char **filename_ptr,
6623 const char **functionname_ptr,
6624 unsigned int *line_ptr)
6628 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6629 filename_ptr, functionname_ptr,
6632 if (!*functionname_ptr)
6633 elf_find_function (abfd, section, symbols, offset,
6634 *filename_ptr ? NULL : filename_ptr,
6640 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6641 filename_ptr, functionname_ptr,
6643 &elf_tdata (abfd)->dwarf2_find_line_info))
6645 if (!*functionname_ptr)
6646 elf_find_function (abfd, section, symbols, offset,
6647 *filename_ptr ? NULL : filename_ptr,
6653 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6654 &found, filename_ptr,
6655 functionname_ptr, line_ptr,
6656 &elf_tdata (abfd)->line_info))
6658 if (found && (*functionname_ptr || *line_ptr))
6661 if (symbols == NULL)
6664 if (! elf_find_function (abfd, section, symbols, offset,
6665 filename_ptr, functionname_ptr))
6673 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
6677 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6679 ret += get_program_header_size (abfd);
6684 _bfd_elf_set_section_contents (bfd *abfd,
6686 const void *location,
6688 bfd_size_type count)
6690 Elf_Internal_Shdr *hdr;
6693 if (! abfd->output_has_begun
6694 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6697 hdr = &elf_section_data (section)->this_hdr;
6698 pos = hdr->sh_offset + offset;
6699 if (bfd_seek (abfd, pos, SEEK_SET) != 0
6700 || bfd_bwrite (location, count, abfd) != count)
6707 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6708 arelent *cache_ptr ATTRIBUTE_UNUSED,
6709 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6714 /* Try to convert a non-ELF reloc into an ELF one. */
6717 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6719 /* Check whether we really have an ELF howto. */
6721 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6723 bfd_reloc_code_real_type code;
6724 reloc_howto_type *howto;
6726 /* Alien reloc: Try to determine its type to replace it with an
6727 equivalent ELF reloc. */
6729 if (areloc->howto->pc_relative)
6731 switch (areloc->howto->bitsize)
6734 code = BFD_RELOC_8_PCREL;
6737 code = BFD_RELOC_12_PCREL;
6740 code = BFD_RELOC_16_PCREL;
6743 code = BFD_RELOC_24_PCREL;
6746 code = BFD_RELOC_32_PCREL;
6749 code = BFD_RELOC_64_PCREL;
6755 howto = bfd_reloc_type_lookup (abfd, code);
6757 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6759 if (howto->pcrel_offset)
6760 areloc->addend += areloc->address;
6762 areloc->addend -= areloc->address; /* addend is unsigned!! */
6767 switch (areloc->howto->bitsize)
6773 code = BFD_RELOC_14;
6776 code = BFD_RELOC_16;
6779 code = BFD_RELOC_26;
6782 code = BFD_RELOC_32;
6785 code = BFD_RELOC_64;
6791 howto = bfd_reloc_type_lookup (abfd, code);
6795 areloc->howto = howto;
6803 (*_bfd_error_handler)
6804 (_("%B: unsupported relocation type %s"),
6805 abfd, areloc->howto->name);
6806 bfd_set_error (bfd_error_bad_value);
6811 _bfd_elf_close_and_cleanup (bfd *abfd)
6813 if (bfd_get_format (abfd) == bfd_object)
6815 if (elf_shstrtab (abfd) != NULL)
6816 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6817 _bfd_dwarf2_cleanup_debug_info (abfd);
6820 return _bfd_generic_close_and_cleanup (abfd);
6823 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6824 in the relocation's offset. Thus we cannot allow any sort of sanity
6825 range-checking to interfere. There is nothing else to do in processing
6828 bfd_reloc_status_type
6829 _bfd_elf_rel_vtable_reloc_fn
6830 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
6831 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
6832 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6833 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
6835 return bfd_reloc_ok;
6838 /* Elf core file support. Much of this only works on native
6839 toolchains, since we rely on knowing the
6840 machine-dependent procfs structure in order to pick
6841 out details about the corefile. */
6843 #ifdef HAVE_SYS_PROCFS_H
6844 # include <sys/procfs.h>
6847 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6850 elfcore_make_pid (bfd *abfd)
6852 return ((elf_tdata (abfd)->core_lwpid << 16)
6853 + (elf_tdata (abfd)->core_pid));
6856 /* If there isn't a section called NAME, make one, using
6857 data from SECT. Note, this function will generate a
6858 reference to NAME, so you shouldn't deallocate or
6862 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
6866 if (bfd_get_section_by_name (abfd, name) != NULL)
6869 sect2 = bfd_make_section (abfd, name);
6873 sect2->size = sect->size;
6874 sect2->filepos = sect->filepos;
6875 sect2->flags = sect->flags;
6876 sect2->alignment_power = sect->alignment_power;
6880 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6881 actually creates up to two pseudosections:
6882 - For the single-threaded case, a section named NAME, unless
6883 such a section already exists.
6884 - For the multi-threaded case, a section named "NAME/PID", where
6885 PID is elfcore_make_pid (abfd).
6886 Both pseudosections have identical contents. */
6888 _bfd_elfcore_make_pseudosection (bfd *abfd,
6894 char *threaded_name;
6898 /* Build the section name. */
6900 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6901 len = strlen (buf) + 1;
6902 threaded_name = bfd_alloc (abfd, len);
6903 if (threaded_name == NULL)
6905 memcpy (threaded_name, buf, len);
6907 sect = bfd_make_section_anyway (abfd, threaded_name);
6911 sect->filepos = filepos;
6912 sect->flags = SEC_HAS_CONTENTS;
6913 sect->alignment_power = 2;
6915 return elfcore_maybe_make_sect (abfd, name, sect);
6918 /* prstatus_t exists on:
6920 linux 2.[01] + glibc
6924 #if defined (HAVE_PRSTATUS_T)
6927 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6932 if (note->descsz == sizeof (prstatus_t))
6936 size = sizeof (prstat.pr_reg);
6937 offset = offsetof (prstatus_t, pr_reg);
6938 memcpy (&prstat, note->descdata, sizeof (prstat));
6940 /* Do not overwrite the core signal if it
6941 has already been set by another thread. */
6942 if (elf_tdata (abfd)->core_signal == 0)
6943 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6944 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6946 /* pr_who exists on:
6949 pr_who doesn't exist on:
6952 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6953 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6956 #if defined (HAVE_PRSTATUS32_T)
6957 else if (note->descsz == sizeof (prstatus32_t))
6959 /* 64-bit host, 32-bit corefile */
6960 prstatus32_t prstat;
6962 size = sizeof (prstat.pr_reg);
6963 offset = offsetof (prstatus32_t, pr_reg);
6964 memcpy (&prstat, note->descdata, sizeof (prstat));
6966 /* Do not overwrite the core signal if it
6967 has already been set by another thread. */
6968 if (elf_tdata (abfd)->core_signal == 0)
6969 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6970 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6972 /* pr_who exists on:
6975 pr_who doesn't exist on:
6978 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6979 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6982 #endif /* HAVE_PRSTATUS32_T */
6985 /* Fail - we don't know how to handle any other
6986 note size (ie. data object type). */
6990 /* Make a ".reg/999" section and a ".reg" section. */
6991 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6992 size, note->descpos + offset);
6994 #endif /* defined (HAVE_PRSTATUS_T) */
6996 /* Create a pseudosection containing the exact contents of NOTE. */
6998 elfcore_make_note_pseudosection (bfd *abfd,
7000 Elf_Internal_Note *note)
7002 return _bfd_elfcore_make_pseudosection (abfd, name,
7003 note->descsz, note->descpos);
7006 /* There isn't a consistent prfpregset_t across platforms,
7007 but it doesn't matter, because we don't have to pick this
7008 data structure apart. */
7011 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7013 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7016 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7017 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7021 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7023 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7026 #if defined (HAVE_PRPSINFO_T)
7027 typedef prpsinfo_t elfcore_psinfo_t;
7028 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7029 typedef prpsinfo32_t elfcore_psinfo32_t;
7033 #if defined (HAVE_PSINFO_T)
7034 typedef psinfo_t elfcore_psinfo_t;
7035 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7036 typedef psinfo32_t elfcore_psinfo32_t;
7040 /* return a malloc'ed copy of a string at START which is at
7041 most MAX bytes long, possibly without a terminating '\0'.
7042 the copy will always have a terminating '\0'. */
7045 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7048 char *end = memchr (start, '\0', max);
7056 dups = bfd_alloc (abfd, len + 1);
7060 memcpy (dups, start, len);
7066 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7068 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7070 if (note->descsz == sizeof (elfcore_psinfo_t))
7072 elfcore_psinfo_t psinfo;
7074 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7076 elf_tdata (abfd)->core_program
7077 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7078 sizeof (psinfo.pr_fname));
7080 elf_tdata (abfd)->core_command
7081 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7082 sizeof (psinfo.pr_psargs));
7084 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7085 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7087 /* 64-bit host, 32-bit corefile */
7088 elfcore_psinfo32_t psinfo;
7090 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7092 elf_tdata (abfd)->core_program
7093 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7094 sizeof (psinfo.pr_fname));
7096 elf_tdata (abfd)->core_command
7097 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7098 sizeof (psinfo.pr_psargs));
7104 /* Fail - we don't know how to handle any other
7105 note size (ie. data object type). */
7109 /* Note that for some reason, a spurious space is tacked
7110 onto the end of the args in some (at least one anyway)
7111 implementations, so strip it off if it exists. */
7114 char *command = elf_tdata (abfd)->core_command;
7115 int n = strlen (command);
7117 if (0 < n && command[n - 1] == ' ')
7118 command[n - 1] = '\0';
7123 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7125 #if defined (HAVE_PSTATUS_T)
7127 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7129 if (note->descsz == sizeof (pstatus_t)
7130 #if defined (HAVE_PXSTATUS_T)
7131 || note->descsz == sizeof (pxstatus_t)
7137 memcpy (&pstat, note->descdata, sizeof (pstat));
7139 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7141 #if defined (HAVE_PSTATUS32_T)
7142 else if (note->descsz == sizeof (pstatus32_t))
7144 /* 64-bit host, 32-bit corefile */
7147 memcpy (&pstat, note->descdata, sizeof (pstat));
7149 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7152 /* Could grab some more details from the "representative"
7153 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7154 NT_LWPSTATUS note, presumably. */
7158 #endif /* defined (HAVE_PSTATUS_T) */
7160 #if defined (HAVE_LWPSTATUS_T)
7162 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7164 lwpstatus_t lwpstat;
7170 if (note->descsz != sizeof (lwpstat)
7171 #if defined (HAVE_LWPXSTATUS_T)
7172 && note->descsz != sizeof (lwpxstatus_t)
7177 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7179 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7180 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7182 /* Make a ".reg/999" section. */
7184 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7185 len = strlen (buf) + 1;
7186 name = bfd_alloc (abfd, len);
7189 memcpy (name, buf, len);
7191 sect = bfd_make_section_anyway (abfd, name);
7195 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7196 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7197 sect->filepos = note->descpos
7198 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7201 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7202 sect->size = sizeof (lwpstat.pr_reg);
7203 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7206 sect->flags = SEC_HAS_CONTENTS;
7207 sect->alignment_power = 2;
7209 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7212 /* Make a ".reg2/999" section */
7214 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7215 len = strlen (buf) + 1;
7216 name = bfd_alloc (abfd, len);
7219 memcpy (name, buf, len);
7221 sect = bfd_make_section_anyway (abfd, name);
7225 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7226 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7227 sect->filepos = note->descpos
7228 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7231 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7232 sect->size = sizeof (lwpstat.pr_fpreg);
7233 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7236 sect->flags = SEC_HAS_CONTENTS;
7237 sect->alignment_power = 2;
7239 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7241 #endif /* defined (HAVE_LWPSTATUS_T) */
7243 #if defined (HAVE_WIN32_PSTATUS_T)
7245 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7251 win32_pstatus_t pstatus;
7253 if (note->descsz < sizeof (pstatus))
7256 memcpy (&pstatus, note->descdata, sizeof (pstatus));
7258 switch (pstatus.data_type)
7260 case NOTE_INFO_PROCESS:
7261 /* FIXME: need to add ->core_command. */
7262 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7263 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7266 case NOTE_INFO_THREAD:
7267 /* Make a ".reg/999" section. */
7268 sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
7270 len = strlen (buf) + 1;
7271 name = bfd_alloc (abfd, len);
7275 memcpy (name, buf, len);
7277 sect = bfd_make_section_anyway (abfd, name);
7281 sect->size = sizeof (pstatus.data.thread_info.thread_context);
7282 sect->filepos = (note->descpos
7283 + offsetof (struct win32_pstatus,
7284 data.thread_info.thread_context));
7285 sect->flags = SEC_HAS_CONTENTS;
7286 sect->alignment_power = 2;
7288 if (pstatus.data.thread_info.is_active_thread)
7289 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7293 case NOTE_INFO_MODULE:
7294 /* Make a ".module/xxxxxxxx" section. */
7295 sprintf (buf, ".module/%08lx",
7296 (long) pstatus.data.module_info.base_address);
7298 len = strlen (buf) + 1;
7299 name = bfd_alloc (abfd, len);
7303 memcpy (name, buf, len);
7305 sect = bfd_make_section_anyway (abfd, name);
7310 sect->size = note->descsz;
7311 sect->filepos = note->descpos;
7312 sect->flags = SEC_HAS_CONTENTS;
7313 sect->alignment_power = 2;
7322 #endif /* HAVE_WIN32_PSTATUS_T */
7325 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7327 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7335 if (bed->elf_backend_grok_prstatus)
7336 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7338 #if defined (HAVE_PRSTATUS_T)
7339 return elfcore_grok_prstatus (abfd, note);
7344 #if defined (HAVE_PSTATUS_T)
7346 return elfcore_grok_pstatus (abfd, note);
7349 #if defined (HAVE_LWPSTATUS_T)
7351 return elfcore_grok_lwpstatus (abfd, note);
7354 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7355 return elfcore_grok_prfpreg (abfd, note);
7357 #if defined (HAVE_WIN32_PSTATUS_T)
7358 case NT_WIN32PSTATUS:
7359 return elfcore_grok_win32pstatus (abfd, note);
7362 case NT_PRXFPREG: /* Linux SSE extension */
7363 if (note->namesz == 6
7364 && strcmp (note->namedata, "LINUX") == 0)
7365 return elfcore_grok_prxfpreg (abfd, note);
7371 if (bed->elf_backend_grok_psinfo)
7372 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7374 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7375 return elfcore_grok_psinfo (abfd, note);
7382 asection *sect = bfd_make_section_anyway (abfd, ".auxv");
7386 sect->size = note->descsz;
7387 sect->filepos = note->descpos;
7388 sect->flags = SEC_HAS_CONTENTS;
7389 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7397 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7401 cp = strchr (note->namedata, '@');
7404 *lwpidp = atoi(cp + 1);
7411 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7414 /* Signal number at offset 0x08. */
7415 elf_tdata (abfd)->core_signal
7416 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7418 /* Process ID at offset 0x50. */
7419 elf_tdata (abfd)->core_pid
7420 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7422 /* Command name at 0x7c (max 32 bytes, including nul). */
7423 elf_tdata (abfd)->core_command
7424 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7426 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7431 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7435 if (elfcore_netbsd_get_lwpid (note, &lwp))
7436 elf_tdata (abfd)->core_lwpid = lwp;
7438 if (note->type == NT_NETBSDCORE_PROCINFO)
7440 /* NetBSD-specific core "procinfo". Note that we expect to
7441 find this note before any of the others, which is fine,
7442 since the kernel writes this note out first when it
7443 creates a core file. */
7445 return elfcore_grok_netbsd_procinfo (abfd, note);
7448 /* As of Jan 2002 there are no other machine-independent notes
7449 defined for NetBSD core files. If the note type is less
7450 than the start of the machine-dependent note types, we don't
7453 if (note->type < NT_NETBSDCORE_FIRSTMACH)
7457 switch (bfd_get_arch (abfd))
7459 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7460 PT_GETFPREGS == mach+2. */
7462 case bfd_arch_alpha:
7463 case bfd_arch_sparc:
7466 case NT_NETBSDCORE_FIRSTMACH+0:
7467 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7469 case NT_NETBSDCORE_FIRSTMACH+2:
7470 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7476 /* On all other arch's, PT_GETREGS == mach+1 and
7477 PT_GETFPREGS == mach+3. */
7482 case NT_NETBSDCORE_FIRSTMACH+1:
7483 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7485 case NT_NETBSDCORE_FIRSTMACH+3:
7486 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7496 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
7498 void *ddata = note->descdata;
7505 /* nto_procfs_status 'pid' field is at offset 0. */
7506 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7508 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7509 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7511 /* nto_procfs_status 'flags' field is at offset 8. */
7512 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7514 /* nto_procfs_status 'what' field is at offset 14. */
7515 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7517 elf_tdata (abfd)->core_signal = sig;
7518 elf_tdata (abfd)->core_lwpid = *tid;
7521 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7522 do not come from signals so we make sure we set the current
7523 thread just in case. */
7524 if (flags & 0x00000080)
7525 elf_tdata (abfd)->core_lwpid = *tid;
7527 /* Make a ".qnx_core_status/%d" section. */
7528 sprintf (buf, ".qnx_core_status/%ld", (long) *tid);
7530 name = bfd_alloc (abfd, strlen (buf) + 1);
7535 sect = bfd_make_section_anyway (abfd, name);
7539 sect->size = note->descsz;
7540 sect->filepos = note->descpos;
7541 sect->flags = SEC_HAS_CONTENTS;
7542 sect->alignment_power = 2;
7544 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7548 elfcore_grok_nto_regs (bfd *abfd,
7549 Elf_Internal_Note *note,
7557 /* Make a "(base)/%d" section. */
7558 sprintf (buf, "%s/%ld", base, (long) tid);
7560 name = bfd_alloc (abfd, strlen (buf) + 1);
7565 sect = bfd_make_section_anyway (abfd, name);
7569 sect->size = note->descsz;
7570 sect->filepos = note->descpos;
7571 sect->flags = SEC_HAS_CONTENTS;
7572 sect->alignment_power = 2;
7574 /* This is the current thread. */
7575 if (elf_tdata (abfd)->core_lwpid == tid)
7576 return elfcore_maybe_make_sect (abfd, base, sect);
7581 #define BFD_QNT_CORE_INFO 7
7582 #define BFD_QNT_CORE_STATUS 8
7583 #define BFD_QNT_CORE_GREG 9
7584 #define BFD_QNT_CORE_FPREG 10
7587 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
7589 /* Every GREG section has a STATUS section before it. Store the
7590 tid from the previous call to pass down to the next gregs
7592 static pid_t tid = 1;
7596 case BFD_QNT_CORE_INFO:
7597 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7598 case BFD_QNT_CORE_STATUS:
7599 return elfcore_grok_nto_status (abfd, note, &tid);
7600 case BFD_QNT_CORE_GREG:
7601 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
7602 case BFD_QNT_CORE_FPREG:
7603 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
7609 /* Function: elfcore_write_note
7616 size of data for note
7619 End of buffer containing note. */
7622 elfcore_write_note (bfd *abfd,
7630 Elf_External_Note *xnp;
7640 const struct elf_backend_data *bed;
7642 namesz = strlen (name) + 1;
7643 bed = get_elf_backend_data (abfd);
7644 pad = -namesz & ((1 << bed->s->log_file_align) - 1);
7647 newspace = 12 + namesz + pad + size;
7649 p = realloc (buf, *bufsiz + newspace);
7651 *bufsiz += newspace;
7652 xnp = (Elf_External_Note *) dest;
7653 H_PUT_32 (abfd, namesz, xnp->namesz);
7654 H_PUT_32 (abfd, size, xnp->descsz);
7655 H_PUT_32 (abfd, type, xnp->type);
7659 memcpy (dest, name, namesz);
7667 memcpy (dest, input, size);
7671 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7673 elfcore_write_prpsinfo (bfd *abfd,
7680 char *note_name = "CORE";
7682 #if defined (HAVE_PSINFO_T)
7684 note_type = NT_PSINFO;
7687 note_type = NT_PRPSINFO;
7690 memset (&data, 0, sizeof (data));
7691 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7692 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7693 return elfcore_write_note (abfd, buf, bufsiz,
7694 note_name, note_type, &data, sizeof (data));
7696 #endif /* PSINFO_T or PRPSINFO_T */
7698 #if defined (HAVE_PRSTATUS_T)
7700 elfcore_write_prstatus (bfd *abfd,
7708 char *note_name = "CORE";
7710 memset (&prstat, 0, sizeof (prstat));
7711 prstat.pr_pid = pid;
7712 prstat.pr_cursig = cursig;
7713 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7714 return elfcore_write_note (abfd, buf, bufsiz,
7715 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7717 #endif /* HAVE_PRSTATUS_T */
7719 #if defined (HAVE_LWPSTATUS_T)
7721 elfcore_write_lwpstatus (bfd *abfd,
7728 lwpstatus_t lwpstat;
7729 char *note_name = "CORE";
7731 memset (&lwpstat, 0, sizeof (lwpstat));
7732 lwpstat.pr_lwpid = pid >> 16;
7733 lwpstat.pr_cursig = cursig;
7734 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7735 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7736 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7738 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7739 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7741 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7742 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7745 return elfcore_write_note (abfd, buf, bufsiz, note_name,
7746 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7748 #endif /* HAVE_LWPSTATUS_T */
7750 #if defined (HAVE_PSTATUS_T)
7752 elfcore_write_pstatus (bfd *abfd,
7760 char *note_name = "CORE";
7762 memset (&pstat, 0, sizeof (pstat));
7763 pstat.pr_pid = pid & 0xffff;
7764 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7765 NT_PSTATUS, &pstat, sizeof (pstat));
7768 #endif /* HAVE_PSTATUS_T */
7771 elfcore_write_prfpreg (bfd *abfd,
7777 char *note_name = "CORE";
7778 return elfcore_write_note (abfd, buf, bufsiz,
7779 note_name, NT_FPREGSET, fpregs, size);
7783 elfcore_write_prxfpreg (bfd *abfd,
7786 const void *xfpregs,
7789 char *note_name = "LINUX";
7790 return elfcore_write_note (abfd, buf, bufsiz,
7791 note_name, NT_PRXFPREG, xfpregs, size);
7795 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
7803 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7806 buf = bfd_malloc (size);
7810 if (bfd_bread (buf, size, abfd) != size)
7818 while (p < buf + size)
7820 /* FIXME: bad alignment assumption. */
7821 Elf_External_Note *xnp = (Elf_External_Note *) p;
7822 Elf_Internal_Note in;
7824 in.type = H_GET_32 (abfd, xnp->type);
7826 in.namesz = H_GET_32 (abfd, xnp->namesz);
7827 in.namedata = xnp->name;
7829 in.descsz = H_GET_32 (abfd, xnp->descsz);
7830 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7831 in.descpos = offset + (in.descdata - buf);
7833 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7835 if (! elfcore_grok_netbsd_note (abfd, &in))
7838 else if (strncmp (in.namedata, "QNX", 3) == 0)
7840 if (! elfcore_grok_nto_note (abfd, &in))
7845 if (! elfcore_grok_note (abfd, &in))
7849 p = in.descdata + BFD_ALIGN (in.descsz, 4);
7856 /* Providing external access to the ELF program header table. */
7858 /* Return an upper bound on the number of bytes required to store a
7859 copy of ABFD's program header table entries. Return -1 if an error
7860 occurs; bfd_get_error will return an appropriate code. */
7863 bfd_get_elf_phdr_upper_bound (bfd *abfd)
7865 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7867 bfd_set_error (bfd_error_wrong_format);
7871 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7874 /* Copy ABFD's program header table entries to *PHDRS. The entries
7875 will be stored as an array of Elf_Internal_Phdr structures, as
7876 defined in include/elf/internal.h. To find out how large the
7877 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7879 Return the number of program header table entries read, or -1 if an
7880 error occurs; bfd_get_error will return an appropriate code. */
7883 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
7887 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7889 bfd_set_error (bfd_error_wrong_format);
7893 num_phdrs = elf_elfheader (abfd)->e_phnum;
7894 memcpy (phdrs, elf_tdata (abfd)->phdr,
7895 num_phdrs * sizeof (Elf_Internal_Phdr));
7901 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
7904 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7906 i_ehdrp = elf_elfheader (abfd);
7907 if (i_ehdrp == NULL)
7908 sprintf_vma (buf, value);
7911 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7913 #if BFD_HOST_64BIT_LONG
7914 sprintf (buf, "%016lx", value);
7916 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7917 _bfd_int64_low (value));
7921 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7924 sprintf_vma (buf, value);
7929 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
7932 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7934 i_ehdrp = elf_elfheader (abfd);
7935 if (i_ehdrp == NULL)
7936 fprintf_vma ((FILE *) stream, value);
7939 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7941 #if BFD_HOST_64BIT_LONG
7942 fprintf ((FILE *) stream, "%016lx", value);
7944 fprintf ((FILE *) stream, "%08lx%08lx",
7945 _bfd_int64_high (value), _bfd_int64_low (value));
7949 fprintf ((FILE *) stream, "%08lx",
7950 (unsigned long) (value & 0xffffffff));
7953 fprintf_vma ((FILE *) stream, value);
7957 enum elf_reloc_type_class
7958 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
7960 return reloc_class_normal;
7963 /* For RELA architectures, return the relocation value for a
7964 relocation against a local symbol. */
7967 _bfd_elf_rela_local_sym (bfd *abfd,
7968 Elf_Internal_Sym *sym,
7970 Elf_Internal_Rela *rel)
7972 asection *sec = *psec;
7975 relocation = (sec->output_section->vma
7976 + sec->output_offset
7978 if ((sec->flags & SEC_MERGE)
7979 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
7980 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
7983 _bfd_merged_section_offset (abfd, psec,
7984 elf_section_data (sec)->sec_info,
7985 sym->st_value + rel->r_addend);
7988 /* If we have changed the section, and our original section is
7989 marked with SEC_EXCLUDE, it means that the original
7990 SEC_MERGE section has been completely subsumed in some
7991 other SEC_MERGE section. In this case, we need to leave
7992 some info around for --emit-relocs. */
7993 if ((sec->flags & SEC_EXCLUDE) != 0)
7994 sec->kept_section = *psec;
7997 rel->r_addend -= relocation;
7998 rel->r_addend += sec->output_section->vma + sec->output_offset;
8004 _bfd_elf_rel_local_sym (bfd *abfd,
8005 Elf_Internal_Sym *sym,
8009 asection *sec = *psec;
8011 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8012 return sym->st_value + addend;
8014 return _bfd_merged_section_offset (abfd, psec,
8015 elf_section_data (sec)->sec_info,
8016 sym->st_value + addend);
8020 _bfd_elf_section_offset (bfd *abfd,
8021 struct bfd_link_info *info,
8025 switch (sec->sec_info_type)
8027 case ELF_INFO_TYPE_STABS:
8028 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8030 case ELF_INFO_TYPE_EH_FRAME:
8031 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8037 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8038 reconstruct an ELF file by reading the segments out of remote memory
8039 based on the ELF file header at EHDR_VMA and the ELF program headers it
8040 points to. If not null, *LOADBASEP is filled in with the difference
8041 between the VMAs from which the segments were read, and the VMAs the
8042 file headers (and hence BFD's idea of each section's VMA) put them at.
8044 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8045 remote memory at target address VMA into the local buffer at MYADDR; it
8046 should return zero on success or an `errno' code on failure. TEMPL must
8047 be a BFD for an ELF target with the word size and byte order found in
8048 the remote memory. */
8051 bfd_elf_bfd_from_remote_memory
8055 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8057 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8058 (templ, ehdr_vma, loadbasep, target_read_memory);
8062 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8063 long symcount ATTRIBUTE_UNUSED,
8064 asymbol **syms ATTRIBUTE_UNUSED,
8069 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8072 const char *relplt_name;
8073 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8077 Elf_Internal_Shdr *hdr;
8083 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8086 if (dynsymcount <= 0)
8089 if (!bed->plt_sym_val)
8092 relplt_name = bed->relplt_name;
8093 if (relplt_name == NULL)
8094 relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8095 relplt = bfd_get_section_by_name (abfd, relplt_name);
8099 hdr = &elf_section_data (relplt)->this_hdr;
8100 if (hdr->sh_link != elf_dynsymtab (abfd)
8101 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8104 plt = bfd_get_section_by_name (abfd, ".plt");
8108 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8109 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8112 count = relplt->size / hdr->sh_entsize;
8113 size = count * sizeof (asymbol);
8114 p = relplt->relocation;
8115 for (i = 0; i < count; i++, s++, p++)
8116 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8118 s = *ret = bfd_malloc (size);
8122 names = (char *) (s + count);
8123 p = relplt->relocation;
8125 for (i = 0; i < count; i++, s++, p++)
8130 addr = bed->plt_sym_val (i, plt, p);
8131 if (addr == (bfd_vma) -1)
8134 *s = **p->sym_ptr_ptr;
8136 s->value = addr - plt->vma;
8138 len = strlen ((*p->sym_ptr_ptr)->name);
8139 memcpy (names, (*p->sym_ptr_ptr)->name, len);
8141 memcpy (names, "@plt", sizeof ("@plt"));
8142 names += sizeof ("@plt");
8149 /* Sort symbol by binding and section. We want to put definitions
8150 sorted by section at the beginning. */
8153 elf_sort_elf_symbol (const void *arg1, const void *arg2)
8155 const Elf_Internal_Sym *s1;
8156 const Elf_Internal_Sym *s2;
8159 /* Make sure that undefined symbols are at the end. */
8160 s1 = (const Elf_Internal_Sym *) arg1;
8161 if (s1->st_shndx == SHN_UNDEF)
8163 s2 = (const Elf_Internal_Sym *) arg2;
8164 if (s2->st_shndx == SHN_UNDEF)
8167 /* Sorted by section index. */
8168 shndx = s1->st_shndx - s2->st_shndx;
8172 /* Sorted by binding. */
8173 return ELF_ST_BIND (s1->st_info) - ELF_ST_BIND (s2->st_info);
8178 Elf_Internal_Sym *sym;
8183 elf_sym_name_compare (const void *arg1, const void *arg2)
8185 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
8186 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
8187 return strcmp (s1->name, s2->name);
8190 /* Check if 2 sections define the same set of local and global
8194 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2)
8197 const struct elf_backend_data *bed1, *bed2;
8198 Elf_Internal_Shdr *hdr1, *hdr2;
8199 bfd_size_type symcount1, symcount2;
8200 Elf_Internal_Sym *isymbuf1, *isymbuf2;
8201 Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
8202 Elf_Internal_Sym *isymend;
8203 struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
8204 bfd_size_type count1, count2, i;
8211 /* If both are .gnu.linkonce sections, they have to have the same
8213 if (strncmp (sec1->name, ".gnu.linkonce",
8214 sizeof ".gnu.linkonce" - 1) == 0
8215 && strncmp (sec2->name, ".gnu.linkonce",
8216 sizeof ".gnu.linkonce" - 1) == 0)
8217 return strcmp (sec1->name + sizeof ".gnu.linkonce",
8218 sec2->name + sizeof ".gnu.linkonce") == 0;
8220 /* Both sections have to be in ELF. */
8221 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8222 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8225 if (elf_section_type (sec1) != elf_section_type (sec2))
8228 if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8229 && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8231 /* If both are members of section groups, they have to have the
8233 if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8237 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8238 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8239 if (shndx1 == -1 || shndx2 == -1)
8242 bed1 = get_elf_backend_data (bfd1);
8243 bed2 = get_elf_backend_data (bfd2);
8244 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8245 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8246 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8247 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8249 if (symcount1 == 0 || symcount2 == 0)
8252 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8254 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
8258 if (isymbuf1 == NULL || isymbuf2 == NULL)
8261 /* Sort symbols by binding and section. Global definitions are at
8263 qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
8264 elf_sort_elf_symbol);
8265 qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
8266 elf_sort_elf_symbol);
8268 /* Count definitions in the section. */
8270 for (isym = isymbuf1, isymend = isym + symcount1;
8271 isym < isymend; isym++)
8273 if (isym->st_shndx == (unsigned int) shndx1)
8280 if (count1 && isym->st_shndx != (unsigned int) shndx1)
8285 for (isym = isymbuf2, isymend = isym + symcount2;
8286 isym < isymend; isym++)
8288 if (isym->st_shndx == (unsigned int) shndx2)
8295 if (count2 && isym->st_shndx != (unsigned int) shndx2)
8299 if (count1 == 0 || count2 == 0 || count1 != count2)
8302 symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8303 symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8305 if (symtable1 == NULL || symtable2 == NULL)
8309 for (isym = isymstart1, isymend = isym + count1;
8310 isym < isymend; isym++)
8313 symp->name = bfd_elf_string_from_elf_section (bfd1,
8320 for (isym = isymstart2, isymend = isym + count1;
8321 isym < isymend; isym++)
8324 symp->name = bfd_elf_string_from_elf_section (bfd2,
8330 /* Sort symbol by name. */
8331 qsort (symtable1, count1, sizeof (struct elf_symbol),
8332 elf_sym_name_compare);
8333 qsort (symtable2, count1, sizeof (struct elf_symbol),
8334 elf_sym_name_compare);
8336 for (i = 0; i < count1; i++)
8337 /* Two symbols must have the same binding, type and name. */
8338 if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8339 || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8340 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)