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. Make sure
456 that it is a symbol table section. */
457 hdr = elf_elfsections (abfd) [ghdr->sh_link];
458 if (hdr->sh_type != SHT_SYMTAB
459 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
462 /* Go read the symbol. */
463 hdr = &elf_tdata (abfd)->symtab_hdr;
464 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
465 &isym, esym, &eshndx) == NULL)
468 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
471 /* Set next_in_group list pointer, and group name for NEWSECT. */
474 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
476 unsigned int num_group = elf_tdata (abfd)->num_group;
478 /* If num_group is zero, read in all SHT_GROUP sections. The count
479 is set to -1 if there are no SHT_GROUP sections. */
482 unsigned int i, shnum;
484 /* First count the number of groups. If we have a SHT_GROUP
485 section with just a flag word (ie. sh_size is 4), ignore it. */
486 shnum = elf_numsections (abfd);
488 for (i = 0; i < shnum; i++)
490 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
491 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
497 num_group = (unsigned) -1;
498 elf_tdata (abfd)->num_group = num_group;
502 /* We keep a list of elf section headers for group sections,
503 so we can find them quickly. */
506 elf_tdata (abfd)->num_group = num_group;
507 amt = num_group * sizeof (Elf_Internal_Shdr *);
508 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
509 if (elf_tdata (abfd)->group_sect_ptr == NULL)
513 for (i = 0; i < shnum; i++)
515 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
516 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
519 Elf_Internal_Group *dest;
521 /* Add to list of sections. */
522 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
525 /* Read the raw contents. */
526 BFD_ASSERT (sizeof (*dest) >= 4);
527 amt = shdr->sh_size * sizeof (*dest) / 4;
528 shdr->contents = bfd_alloc (abfd, amt);
529 if (shdr->contents == NULL
530 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
531 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
535 /* Translate raw contents, a flag word followed by an
536 array of elf section indices all in target byte order,
537 to the flag word followed by an array of elf section
539 src = shdr->contents + shdr->sh_size;
540 dest = (Elf_Internal_Group *) (shdr->contents + amt);
547 idx = H_GET_32 (abfd, src);
548 if (src == shdr->contents)
551 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
552 shdr->bfd_section->flags
553 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
558 ((*_bfd_error_handler)
559 (_("%B: invalid SHT_GROUP entry"), abfd));
562 dest->shdr = elf_elfsections (abfd)[idx];
569 if (num_group != (unsigned) -1)
573 for (i = 0; i < num_group; i++)
575 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
576 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
577 unsigned int n_elt = shdr->sh_size / 4;
579 /* Look through this group's sections to see if current
580 section is a member. */
582 if ((++idx)->shdr == hdr)
586 /* We are a member of this group. Go looking through
587 other members to see if any others are linked via
589 idx = (Elf_Internal_Group *) shdr->contents;
590 n_elt = shdr->sh_size / 4;
592 if ((s = (++idx)->shdr->bfd_section) != NULL
593 && elf_next_in_group (s) != NULL)
597 /* Snarf the group name from other member, and
598 insert current section in circular list. */
599 elf_group_name (newsect) = elf_group_name (s);
600 elf_next_in_group (newsect) = elf_next_in_group (s);
601 elf_next_in_group (s) = newsect;
607 gname = group_signature (abfd, shdr);
610 elf_group_name (newsect) = gname;
612 /* Start a circular list with one element. */
613 elf_next_in_group (newsect) = newsect;
616 /* If the group section has been created, point to the
618 if (shdr->bfd_section != NULL)
619 elf_next_in_group (shdr->bfd_section) = newsect;
627 if (elf_group_name (newsect) == NULL)
629 (*_bfd_error_handler) (_("%B: no group info for section %A"),
636 _bfd_elf_setup_group_pointers (bfd *abfd)
639 unsigned int num_group = elf_tdata (abfd)->num_group;
640 bfd_boolean result = TRUE;
642 if (num_group == (unsigned) -1)
645 for (i = 0; i < num_group; i++)
647 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
648 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
649 unsigned int n_elt = shdr->sh_size / 4;
652 if ((++idx)->shdr->bfd_section)
653 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
654 else if (idx->shdr->sh_type == SHT_RELA
655 || idx->shdr->sh_type == SHT_REL)
656 /* We won't include relocation sections in section groups in
657 output object files. We adjust the group section size here
658 so that relocatable link will work correctly when
659 relocation sections are in section group in input object
661 shdr->bfd_section->size -= 4;
664 /* There are some unknown sections in the group. */
665 (*_bfd_error_handler)
666 (_("%B: unknown [%d] section `%s' in group [%s]"),
668 (unsigned int) idx->shdr->sh_type,
669 bfd_elf_string_from_elf_section (abfd,
670 (elf_elfheader (abfd)
673 shdr->bfd_section->name);
681 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
683 return elf_next_in_group (sec) != NULL;
686 /* Make a BFD section from an ELF section. We store a pointer to the
687 BFD section in the bfd_section field of the header. */
690 _bfd_elf_make_section_from_shdr (bfd *abfd,
691 Elf_Internal_Shdr *hdr,
697 const struct elf_backend_data *bed;
699 if (hdr->bfd_section != NULL)
701 BFD_ASSERT (strcmp (name,
702 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
706 newsect = bfd_make_section_anyway (abfd, name);
710 hdr->bfd_section = newsect;
711 elf_section_data (newsect)->this_hdr = *hdr;
712 elf_section_data (newsect)->this_idx = shindex;
714 /* Always use the real type/flags. */
715 elf_section_type (newsect) = hdr->sh_type;
716 elf_section_flags (newsect) = hdr->sh_flags;
718 newsect->filepos = hdr->sh_offset;
720 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
721 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
722 || ! bfd_set_section_alignment (abfd, newsect,
723 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
726 flags = SEC_NO_FLAGS;
727 if (hdr->sh_type != SHT_NOBITS)
728 flags |= SEC_HAS_CONTENTS;
729 if (hdr->sh_type == SHT_GROUP)
730 flags |= SEC_GROUP | SEC_EXCLUDE;
731 if ((hdr->sh_flags & SHF_ALLOC) != 0)
734 if (hdr->sh_type != SHT_NOBITS)
737 if ((hdr->sh_flags & SHF_WRITE) == 0)
738 flags |= SEC_READONLY;
739 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
741 else if ((flags & SEC_LOAD) != 0)
743 if ((hdr->sh_flags & SHF_MERGE) != 0)
746 newsect->entsize = hdr->sh_entsize;
747 if ((hdr->sh_flags & SHF_STRINGS) != 0)
748 flags |= SEC_STRINGS;
750 if (hdr->sh_flags & SHF_GROUP)
751 if (!setup_group (abfd, hdr, newsect))
753 if ((hdr->sh_flags & SHF_TLS) != 0)
754 flags |= SEC_THREAD_LOCAL;
756 if ((flags & SEC_ALLOC) == 0)
758 /* The debugging sections appear to be recognized only by name,
759 not any sort of flag. Their SEC_ALLOC bits are cleared. */
764 } debug_sections [] =
766 { "debug", 5 }, /* 'd' */
767 { NULL, 0 }, /* 'e' */
768 { NULL, 0 }, /* 'f' */
769 { "gnu.linkonce.wi.", 17 }, /* 'g' */
770 { NULL, 0 }, /* 'h' */
771 { NULL, 0 }, /* 'i' */
772 { NULL, 0 }, /* 'j' */
773 { NULL, 0 }, /* 'k' */
774 { "line", 4 }, /* 'l' */
775 { NULL, 0 }, /* 'm' */
776 { NULL, 0 }, /* 'n' */
777 { NULL, 0 }, /* 'o' */
778 { NULL, 0 }, /* 'p' */
779 { NULL, 0 }, /* 'q' */
780 { NULL, 0 }, /* 'r' */
781 { "stab", 4 } /* 's' */
786 int i = name [1] - 'd';
788 && i < (int) ARRAY_SIZE (debug_sections)
789 && debug_sections [i].name != NULL
790 && strncmp (&name [1], debug_sections [i].name,
791 debug_sections [i].len) == 0)
792 flags |= SEC_DEBUGGING;
796 /* As a GNU extension, if the name begins with .gnu.linkonce, we
797 only link a single copy of the section. This is used to support
798 g++. g++ will emit each template expansion in its own section.
799 The symbols will be defined as weak, so that multiple definitions
800 are permitted. The GNU linker extension is to actually discard
801 all but one of the sections. */
802 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
803 && elf_next_in_group (newsect) == NULL)
804 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
806 bed = get_elf_backend_data (abfd);
807 if (bed->elf_backend_section_flags)
808 if (! bed->elf_backend_section_flags (&flags, hdr))
811 if (! bfd_set_section_flags (abfd, newsect, flags))
814 if ((flags & SEC_ALLOC) != 0)
816 Elf_Internal_Phdr *phdr;
819 /* Look through the phdrs to see if we need to adjust the lma.
820 If all the p_paddr fields are zero, we ignore them, since
821 some ELF linkers produce such output. */
822 phdr = elf_tdata (abfd)->phdr;
823 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
825 if (phdr->p_paddr != 0)
828 if (i < elf_elfheader (abfd)->e_phnum)
830 phdr = elf_tdata (abfd)->phdr;
831 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
833 /* This section is part of this segment if its file
834 offset plus size lies within the segment's memory
835 span and, if the section is loaded, the extent of the
836 loaded data lies within the extent of the segment.
838 Note - we used to check the p_paddr field as well, and
839 refuse to set the LMA if it was 0. This is wrong
840 though, as a perfectly valid initialised segment can
841 have a p_paddr of zero. Some architectures, eg ARM,
842 place special significance on the address 0 and
843 executables need to be able to have a segment which
844 covers this address. */
845 if (phdr->p_type == PT_LOAD
846 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
847 && (hdr->sh_offset + hdr->sh_size
848 <= phdr->p_offset + phdr->p_memsz)
849 && ((flags & SEC_LOAD) == 0
850 || (hdr->sh_offset + hdr->sh_size
851 <= phdr->p_offset + phdr->p_filesz)))
853 if ((flags & SEC_LOAD) == 0)
854 newsect->lma = (phdr->p_paddr
855 + hdr->sh_addr - phdr->p_vaddr);
857 /* We used to use the same adjustment for SEC_LOAD
858 sections, but that doesn't work if the segment
859 is packed with code from multiple VMAs.
860 Instead we calculate the section LMA based on
861 the segment LMA. It is assumed that the
862 segment will contain sections with contiguous
863 LMAs, even if the VMAs are not. */
864 newsect->lma = (phdr->p_paddr
865 + hdr->sh_offset - phdr->p_offset);
867 /* With contiguous segments, we can't tell from file
868 offsets whether a section with zero size should
869 be placed at the end of one segment or the
870 beginning of the next. Decide based on vaddr. */
871 if (hdr->sh_addr >= phdr->p_vaddr
872 && (hdr->sh_addr + hdr->sh_size
873 <= phdr->p_vaddr + phdr->p_memsz))
888 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
891 Helper functions for GDB to locate the string tables.
892 Since BFD hides string tables from callers, GDB needs to use an
893 internal hook to find them. Sun's .stabstr, in particular,
894 isn't even pointed to by the .stab section, so ordinary
895 mechanisms wouldn't work to find it, even if we had some.
898 struct elf_internal_shdr *
899 bfd_elf_find_section (bfd *abfd, char *name)
901 Elf_Internal_Shdr **i_shdrp;
906 i_shdrp = elf_elfsections (abfd);
909 shstrtab = bfd_elf_get_str_section (abfd,
910 elf_elfheader (abfd)->e_shstrndx);
911 if (shstrtab != NULL)
913 max = elf_numsections (abfd);
914 for (i = 1; i < max; i++)
915 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
922 const char *const bfd_elf_section_type_names[] = {
923 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
924 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
925 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
928 /* ELF relocs are against symbols. If we are producing relocatable
929 output, and the reloc is against an external symbol, and nothing
930 has given us any additional addend, the resulting reloc will also
931 be against the same symbol. In such a case, we don't want to
932 change anything about the way the reloc is handled, since it will
933 all be done at final link time. Rather than put special case code
934 into bfd_perform_relocation, all the reloc types use this howto
935 function. It just short circuits the reloc if producing
936 relocatable output against an external symbol. */
938 bfd_reloc_status_type
939 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
940 arelent *reloc_entry,
942 void *data ATTRIBUTE_UNUSED,
943 asection *input_section,
945 char **error_message ATTRIBUTE_UNUSED)
947 if (output_bfd != NULL
948 && (symbol->flags & BSF_SECTION_SYM) == 0
949 && (! reloc_entry->howto->partial_inplace
950 || reloc_entry->addend == 0))
952 reloc_entry->address += input_section->output_offset;
956 return bfd_reloc_continue;
959 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
962 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
965 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
966 sec->sec_info_type = ELF_INFO_TYPE_NONE;
969 /* Finish SHF_MERGE section merging. */
972 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
977 if (!is_elf_hash_table (info->hash))
980 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
981 if ((ibfd->flags & DYNAMIC) == 0)
982 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
983 if ((sec->flags & SEC_MERGE) != 0
984 && !bfd_is_abs_section (sec->output_section))
986 struct bfd_elf_section_data *secdata;
988 secdata = elf_section_data (sec);
989 if (! _bfd_add_merge_section (abfd,
990 &elf_hash_table (info)->merge_info,
991 sec, &secdata->sec_info))
993 else if (secdata->sec_info)
994 sec->sec_info_type = ELF_INFO_TYPE_MERGE;
997 if (elf_hash_table (info)->merge_info != NULL)
998 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
999 merge_sections_remove_hook);
1004 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
1006 sec->output_section = bfd_abs_section_ptr;
1007 sec->output_offset = sec->vma;
1008 if (!is_elf_hash_table (info->hash))
1011 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
1014 /* Copy the program header and other data from one object module to
1018 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1020 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1021 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1024 BFD_ASSERT (!elf_flags_init (obfd)
1025 || (elf_elfheader (obfd)->e_flags
1026 == elf_elfheader (ibfd)->e_flags));
1028 elf_gp (obfd) = elf_gp (ibfd);
1029 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1030 elf_flags_init (obfd) = TRUE;
1034 /* Print out the program headers. */
1037 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1040 Elf_Internal_Phdr *p;
1042 bfd_byte *dynbuf = NULL;
1044 p = elf_tdata (abfd)->phdr;
1049 fprintf (f, _("\nProgram Header:\n"));
1050 c = elf_elfheader (abfd)->e_phnum;
1051 for (i = 0; i < c; i++, p++)
1058 case PT_NULL: pt = "NULL"; break;
1059 case PT_LOAD: pt = "LOAD"; break;
1060 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1061 case PT_INTERP: pt = "INTERP"; break;
1062 case PT_NOTE: pt = "NOTE"; break;
1063 case PT_SHLIB: pt = "SHLIB"; break;
1064 case PT_PHDR: pt = "PHDR"; break;
1065 case PT_TLS: pt = "TLS"; break;
1066 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1067 case PT_GNU_STACK: pt = "STACK"; break;
1068 case PT_GNU_RELRO: pt = "RELRO"; break;
1069 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
1071 fprintf (f, "%8s off 0x", pt);
1072 bfd_fprintf_vma (abfd, f, p->p_offset);
1073 fprintf (f, " vaddr 0x");
1074 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1075 fprintf (f, " paddr 0x");
1076 bfd_fprintf_vma (abfd, f, p->p_paddr);
1077 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1078 fprintf (f, " filesz 0x");
1079 bfd_fprintf_vma (abfd, f, p->p_filesz);
1080 fprintf (f, " memsz 0x");
1081 bfd_fprintf_vma (abfd, f, p->p_memsz);
1082 fprintf (f, " flags %c%c%c",
1083 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1084 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1085 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1086 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1087 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1092 s = bfd_get_section_by_name (abfd, ".dynamic");
1096 unsigned long shlink;
1097 bfd_byte *extdyn, *extdynend;
1099 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1101 fprintf (f, _("\nDynamic Section:\n"));
1103 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1106 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1109 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1111 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1112 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1115 extdynend = extdyn + s->size;
1116 for (; extdyn < extdynend; extdyn += extdynsize)
1118 Elf_Internal_Dyn dyn;
1121 bfd_boolean stringp;
1123 (*swap_dyn_in) (abfd, extdyn, &dyn);
1125 if (dyn.d_tag == DT_NULL)
1132 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1136 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1137 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1138 case DT_PLTGOT: name = "PLTGOT"; break;
1139 case DT_HASH: name = "HASH"; break;
1140 case DT_STRTAB: name = "STRTAB"; break;
1141 case DT_SYMTAB: name = "SYMTAB"; break;
1142 case DT_RELA: name = "RELA"; break;
1143 case DT_RELASZ: name = "RELASZ"; break;
1144 case DT_RELAENT: name = "RELAENT"; break;
1145 case DT_STRSZ: name = "STRSZ"; break;
1146 case DT_SYMENT: name = "SYMENT"; break;
1147 case DT_INIT: name = "INIT"; break;
1148 case DT_FINI: name = "FINI"; break;
1149 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1150 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1151 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1152 case DT_REL: name = "REL"; break;
1153 case DT_RELSZ: name = "RELSZ"; break;
1154 case DT_RELENT: name = "RELENT"; break;
1155 case DT_PLTREL: name = "PLTREL"; break;
1156 case DT_DEBUG: name = "DEBUG"; break;
1157 case DT_TEXTREL: name = "TEXTREL"; break;
1158 case DT_JMPREL: name = "JMPREL"; break;
1159 case DT_BIND_NOW: name = "BIND_NOW"; break;
1160 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1161 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1162 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1163 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1164 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1165 case DT_FLAGS: name = "FLAGS"; break;
1166 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1167 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1168 case DT_CHECKSUM: name = "CHECKSUM"; break;
1169 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1170 case DT_MOVEENT: name = "MOVEENT"; break;
1171 case DT_MOVESZ: name = "MOVESZ"; break;
1172 case DT_FEATURE: name = "FEATURE"; break;
1173 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1174 case DT_SYMINSZ: name = "SYMINSZ"; break;
1175 case DT_SYMINENT: name = "SYMINENT"; break;
1176 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1177 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1178 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1179 case DT_PLTPAD: name = "PLTPAD"; break;
1180 case DT_MOVETAB: name = "MOVETAB"; break;
1181 case DT_SYMINFO: name = "SYMINFO"; break;
1182 case DT_RELACOUNT: name = "RELACOUNT"; break;
1183 case DT_RELCOUNT: name = "RELCOUNT"; break;
1184 case DT_FLAGS_1: name = "FLAGS_1"; break;
1185 case DT_VERSYM: name = "VERSYM"; break;
1186 case DT_VERDEF: name = "VERDEF"; break;
1187 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1188 case DT_VERNEED: name = "VERNEED"; break;
1189 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1190 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1191 case DT_USED: name = "USED"; break;
1192 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1195 fprintf (f, " %-11s ", name);
1197 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1201 unsigned int tagv = dyn.d_un.d_val;
1203 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1206 fprintf (f, "%s", string);
1215 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1216 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1218 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1222 if (elf_dynverdef (abfd) != 0)
1224 Elf_Internal_Verdef *t;
1226 fprintf (f, _("\nVersion definitions:\n"));
1227 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1229 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1230 t->vd_flags, t->vd_hash, t->vd_nodename);
1231 if (t->vd_auxptr->vda_nextptr != NULL)
1233 Elf_Internal_Verdaux *a;
1236 for (a = t->vd_auxptr->vda_nextptr;
1239 fprintf (f, "%s ", a->vda_nodename);
1245 if (elf_dynverref (abfd) != 0)
1247 Elf_Internal_Verneed *t;
1249 fprintf (f, _("\nVersion References:\n"));
1250 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1252 Elf_Internal_Vernaux *a;
1254 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1255 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1256 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1257 a->vna_flags, a->vna_other, a->vna_nodename);
1269 /* Display ELF-specific fields of a symbol. */
1272 bfd_elf_print_symbol (bfd *abfd,
1275 bfd_print_symbol_type how)
1280 case bfd_print_symbol_name:
1281 fprintf (file, "%s", symbol->name);
1283 case bfd_print_symbol_more:
1284 fprintf (file, "elf ");
1285 bfd_fprintf_vma (abfd, file, symbol->value);
1286 fprintf (file, " %lx", (long) symbol->flags);
1288 case bfd_print_symbol_all:
1290 const char *section_name;
1291 const char *name = NULL;
1292 const struct elf_backend_data *bed;
1293 unsigned char st_other;
1296 section_name = symbol->section ? symbol->section->name : "(*none*)";
1298 bed = get_elf_backend_data (abfd);
1299 if (bed->elf_backend_print_symbol_all)
1300 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1304 name = symbol->name;
1305 bfd_print_symbol_vandf (abfd, file, symbol);
1308 fprintf (file, " %s\t", section_name);
1309 /* Print the "other" value for a symbol. For common symbols,
1310 we've already printed the size; now print the alignment.
1311 For other symbols, we have no specified alignment, and
1312 we've printed the address; now print the size. */
1313 if (bfd_is_com_section (symbol->section))
1314 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1316 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1317 bfd_fprintf_vma (abfd, file, val);
1319 /* If we have version information, print it. */
1320 if (elf_tdata (abfd)->dynversym_section != 0
1321 && (elf_tdata (abfd)->dynverdef_section != 0
1322 || elf_tdata (abfd)->dynverref_section != 0))
1324 unsigned int vernum;
1325 const char *version_string;
1327 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1330 version_string = "";
1331 else if (vernum == 1)
1332 version_string = "Base";
1333 else if (vernum <= elf_tdata (abfd)->cverdefs)
1335 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1338 Elf_Internal_Verneed *t;
1340 version_string = "";
1341 for (t = elf_tdata (abfd)->verref;
1345 Elf_Internal_Vernaux *a;
1347 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1349 if (a->vna_other == vernum)
1351 version_string = a->vna_nodename;
1358 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1359 fprintf (file, " %-11s", version_string);
1364 fprintf (file, " (%s)", version_string);
1365 for (i = 10 - strlen (version_string); i > 0; --i)
1370 /* If the st_other field is not zero, print it. */
1371 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1376 case STV_INTERNAL: fprintf (file, " .internal"); break;
1377 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1378 case STV_PROTECTED: fprintf (file, " .protected"); break;
1380 /* Some other non-defined flags are also present, so print
1382 fprintf (file, " 0x%02x", (unsigned int) st_other);
1385 fprintf (file, " %s", name);
1391 /* Create an entry in an ELF linker hash table. */
1393 struct bfd_hash_entry *
1394 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1395 struct bfd_hash_table *table,
1398 /* Allocate the structure if it has not already been allocated by a
1402 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1407 /* Call the allocation method of the superclass. */
1408 entry = _bfd_link_hash_newfunc (entry, table, string);
1411 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1412 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1414 /* Set local fields. */
1417 ret->got = htab->init_got_refcount;
1418 ret->plt = htab->init_plt_refcount;
1419 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
1420 - offsetof (struct elf_link_hash_entry, size)));
1421 /* Assume that we have been called by a non-ELF symbol reader.
1422 This flag is then reset by the code which reads an ELF input
1423 file. This ensures that a symbol created by a non-ELF symbol
1424 reader will have the flag set correctly. */
1431 /* Copy data from an indirect symbol to its direct symbol, hiding the
1432 old indirect symbol. Also used for copying flags to a weakdef. */
1435 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data *bed,
1436 struct elf_link_hash_entry *dir,
1437 struct elf_link_hash_entry *ind)
1440 bfd_signed_vma lowest_valid = bed->can_refcount;
1442 /* Copy down any references that we may have already seen to the
1443 symbol which just became indirect. */
1445 dir->ref_dynamic |= ind->ref_dynamic;
1446 dir->ref_regular |= ind->ref_regular;
1447 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1448 dir->non_got_ref |= ind->non_got_ref;
1449 dir->needs_plt |= ind->needs_plt;
1450 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1452 if (ind->root.type != bfd_link_hash_indirect)
1455 /* Copy over the global and procedure linkage table refcount entries.
1456 These may have been already set up by a check_relocs routine. */
1457 tmp = dir->got.refcount;
1458 if (tmp < lowest_valid)
1460 dir->got.refcount = ind->got.refcount;
1461 ind->got.refcount = tmp;
1464 BFD_ASSERT (ind->got.refcount < lowest_valid);
1466 tmp = dir->plt.refcount;
1467 if (tmp < lowest_valid)
1469 dir->plt.refcount = ind->plt.refcount;
1470 ind->plt.refcount = tmp;
1473 BFD_ASSERT (ind->plt.refcount < lowest_valid);
1475 if (dir->dynindx == -1)
1477 dir->dynindx = ind->dynindx;
1478 dir->dynstr_index = ind->dynstr_index;
1480 ind->dynstr_index = 0;
1483 BFD_ASSERT (ind->dynindx == -1);
1487 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
1488 struct elf_link_hash_entry *h,
1489 bfd_boolean force_local)
1491 h->plt = elf_hash_table (info)->init_plt_offset;
1495 h->forced_local = 1;
1496 if (h->dynindx != -1)
1499 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1505 /* Initialize an ELF linker hash table. */
1508 _bfd_elf_link_hash_table_init
1509 (struct elf_link_hash_table *table,
1511 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
1512 struct bfd_hash_table *,
1516 int can_refcount = get_elf_backend_data (abfd)->can_refcount;
1518 table->dynamic_sections_created = FALSE;
1519 table->dynobj = NULL;
1520 table->init_got_refcount.refcount = can_refcount - 1;
1521 table->init_plt_refcount.refcount = can_refcount - 1;
1522 table->init_got_offset.offset = -(bfd_vma) 1;
1523 table->init_plt_offset.offset = -(bfd_vma) 1;
1524 /* The first dynamic symbol is a dummy. */
1525 table->dynsymcount = 1;
1526 table->dynstr = NULL;
1527 table->bucketcount = 0;
1528 table->needed = NULL;
1530 table->merge_info = NULL;
1531 memset (&table->stab_info, 0, sizeof (table->stab_info));
1532 memset (&table->eh_info, 0, sizeof (table->eh_info));
1533 table->dynlocal = NULL;
1534 table->runpath = NULL;
1535 table->tls_sec = NULL;
1536 table->tls_size = 0;
1537 table->loaded = NULL;
1538 table->is_relocatable_executable = FALSE;
1540 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
1541 table->root.type = bfd_link_elf_hash_table;
1546 /* Create an ELF linker hash table. */
1548 struct bfd_link_hash_table *
1549 _bfd_elf_link_hash_table_create (bfd *abfd)
1551 struct elf_link_hash_table *ret;
1552 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1554 ret = bfd_malloc (amt);
1558 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1567 /* This is a hook for the ELF emulation code in the generic linker to
1568 tell the backend linker what file name to use for the DT_NEEDED
1569 entry for a dynamic object. */
1572 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
1574 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1575 && bfd_get_format (abfd) == bfd_object)
1576 elf_dt_name (abfd) = name;
1580 bfd_elf_get_dyn_lib_class (bfd *abfd)
1583 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1584 && bfd_get_format (abfd) == bfd_object)
1585 lib_class = elf_dyn_lib_class (abfd);
1592 bfd_elf_set_dyn_lib_class (bfd *abfd, int lib_class)
1594 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1595 && bfd_get_format (abfd) == bfd_object)
1596 elf_dyn_lib_class (abfd) = lib_class;
1599 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1600 the linker ELF emulation code. */
1602 struct bfd_link_needed_list *
1603 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1604 struct bfd_link_info *info)
1606 if (! is_elf_hash_table (info->hash))
1608 return elf_hash_table (info)->needed;
1611 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1612 hook for the linker ELF emulation code. */
1614 struct bfd_link_needed_list *
1615 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
1616 struct bfd_link_info *info)
1618 if (! is_elf_hash_table (info->hash))
1620 return elf_hash_table (info)->runpath;
1623 /* Get the name actually used for a dynamic object for a link. This
1624 is the SONAME entry if there is one. Otherwise, it is the string
1625 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1628 bfd_elf_get_dt_soname (bfd *abfd)
1630 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1631 && bfd_get_format (abfd) == bfd_object)
1632 return elf_dt_name (abfd);
1636 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1637 the ELF linker emulation code. */
1640 bfd_elf_get_bfd_needed_list (bfd *abfd,
1641 struct bfd_link_needed_list **pneeded)
1644 bfd_byte *dynbuf = NULL;
1646 unsigned long shlink;
1647 bfd_byte *extdyn, *extdynend;
1649 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1653 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1654 || bfd_get_format (abfd) != bfd_object)
1657 s = bfd_get_section_by_name (abfd, ".dynamic");
1658 if (s == NULL || s->size == 0)
1661 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1664 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1668 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1670 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1671 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1674 extdynend = extdyn + s->size;
1675 for (; extdyn < extdynend; extdyn += extdynsize)
1677 Elf_Internal_Dyn dyn;
1679 (*swap_dyn_in) (abfd, extdyn, &dyn);
1681 if (dyn.d_tag == DT_NULL)
1684 if (dyn.d_tag == DT_NEEDED)
1687 struct bfd_link_needed_list *l;
1688 unsigned int tagv = dyn.d_un.d_val;
1691 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1696 l = bfd_alloc (abfd, amt);
1717 /* Allocate an ELF string table--force the first byte to be zero. */
1719 struct bfd_strtab_hash *
1720 _bfd_elf_stringtab_init (void)
1722 struct bfd_strtab_hash *ret;
1724 ret = _bfd_stringtab_init ();
1729 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1730 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1731 if (loc == (bfd_size_type) -1)
1733 _bfd_stringtab_free (ret);
1740 /* ELF .o/exec file reading */
1742 /* Create a new bfd section from an ELF section header. */
1745 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1747 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1748 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1749 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1752 name = bfd_elf_string_from_elf_section (abfd,
1753 elf_elfheader (abfd)->e_shstrndx,
1758 switch (hdr->sh_type)
1761 /* Inactive section. Throw it away. */
1764 case SHT_PROGBITS: /* Normal section with contents. */
1765 case SHT_NOBITS: /* .bss section. */
1766 case SHT_HASH: /* .hash section. */
1767 case SHT_NOTE: /* .note section. */
1768 case SHT_INIT_ARRAY: /* .init_array section. */
1769 case SHT_FINI_ARRAY: /* .fini_array section. */
1770 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1771 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1772 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1774 case SHT_DYNAMIC: /* Dynamic linking information. */
1775 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1777 if (hdr->sh_link > elf_numsections (abfd)
1778 || elf_elfsections (abfd)[hdr->sh_link] == NULL)
1780 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1782 Elf_Internal_Shdr *dynsymhdr;
1784 /* The shared libraries distributed with hpux11 have a bogus
1785 sh_link field for the ".dynamic" section. Find the
1786 string table for the ".dynsym" section instead. */
1787 if (elf_dynsymtab (abfd) != 0)
1789 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1790 hdr->sh_link = dynsymhdr->sh_link;
1794 unsigned int i, num_sec;
1796 num_sec = elf_numsections (abfd);
1797 for (i = 1; i < num_sec; i++)
1799 dynsymhdr = elf_elfsections (abfd)[i];
1800 if (dynsymhdr->sh_type == SHT_DYNSYM)
1802 hdr->sh_link = dynsymhdr->sh_link;
1810 case SHT_SYMTAB: /* A symbol table */
1811 if (elf_onesymtab (abfd) == shindex)
1814 if (hdr->sh_entsize != bed->s->sizeof_sym)
1816 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1817 elf_onesymtab (abfd) = shindex;
1818 elf_tdata (abfd)->symtab_hdr = *hdr;
1819 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1820 abfd->flags |= HAS_SYMS;
1822 /* Sometimes a shared object will map in the symbol table. If
1823 SHF_ALLOC is set, and this is a shared object, then we also
1824 treat this section as a BFD section. We can not base the
1825 decision purely on SHF_ALLOC, because that flag is sometimes
1826 set in a relocatable object file, which would confuse the
1828 if ((hdr->sh_flags & SHF_ALLOC) != 0
1829 && (abfd->flags & DYNAMIC) != 0
1830 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1834 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1835 can't read symbols without that section loaded as well. It
1836 is most likely specified by the next section header. */
1837 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1839 unsigned int i, num_sec;
1841 num_sec = elf_numsections (abfd);
1842 for (i = shindex + 1; i < num_sec; i++)
1844 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1845 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1846 && hdr2->sh_link == shindex)
1850 for (i = 1; i < shindex; i++)
1852 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1853 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1854 && hdr2->sh_link == shindex)
1858 return bfd_section_from_shdr (abfd, i);
1862 case SHT_DYNSYM: /* A dynamic symbol table */
1863 if (elf_dynsymtab (abfd) == shindex)
1866 if (hdr->sh_entsize != bed->s->sizeof_sym)
1868 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1869 elf_dynsymtab (abfd) = shindex;
1870 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1871 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1872 abfd->flags |= HAS_SYMS;
1874 /* Besides being a symbol table, we also treat this as a regular
1875 section, so that objcopy can handle it. */
1876 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1878 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1879 if (elf_symtab_shndx (abfd) == shindex)
1882 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1883 elf_symtab_shndx (abfd) = shindex;
1884 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1885 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1888 case SHT_STRTAB: /* A string table */
1889 if (hdr->bfd_section != NULL)
1891 if (ehdr->e_shstrndx == shindex)
1893 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1894 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1897 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1900 elf_tdata (abfd)->strtab_hdr = *hdr;
1901 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1904 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1907 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1908 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1909 elf_elfsections (abfd)[shindex] = hdr;
1910 /* We also treat this as a regular section, so that objcopy
1912 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1916 /* If the string table isn't one of the above, then treat it as a
1917 regular section. We need to scan all the headers to be sure,
1918 just in case this strtab section appeared before the above. */
1919 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1921 unsigned int i, num_sec;
1923 num_sec = elf_numsections (abfd);
1924 for (i = 1; i < num_sec; i++)
1926 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1927 if (hdr2->sh_link == shindex)
1929 /* Prevent endless recursion on broken objects. */
1932 if (! bfd_section_from_shdr (abfd, i))
1934 if (elf_onesymtab (abfd) == i)
1936 if (elf_dynsymtab (abfd) == i)
1937 goto dynsymtab_strtab;
1941 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1945 /* *These* do a lot of work -- but build no sections! */
1947 asection *target_sect;
1948 Elf_Internal_Shdr *hdr2;
1949 unsigned int num_sec = elf_numsections (abfd);
1952 != (bfd_size_type) (hdr->sh_type == SHT_REL
1953 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1956 /* Check for a bogus link to avoid crashing. */
1957 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1958 || hdr->sh_link >= num_sec)
1960 ((*_bfd_error_handler)
1961 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1962 abfd, hdr->sh_link, name, shindex));
1963 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1967 /* For some incomprehensible reason Oracle distributes
1968 libraries for Solaris in which some of the objects have
1969 bogus sh_link fields. It would be nice if we could just
1970 reject them, but, unfortunately, some people need to use
1971 them. We scan through the section headers; if we find only
1972 one suitable symbol table, we clobber the sh_link to point
1973 to it. I hope this doesn't break anything. */
1974 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1975 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1981 for (scan = 1; scan < num_sec; scan++)
1983 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1984 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1995 hdr->sh_link = found;
1998 /* Get the symbol table. */
1999 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2000 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2001 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2004 /* If this reloc section does not use the main symbol table we
2005 don't treat it as a reloc section. BFD can't adequately
2006 represent such a section, so at least for now, we don't
2007 try. We just present it as a normal section. We also
2008 can't use it as a reloc section if it points to the null
2010 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
2011 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2014 /* Prevent endless recursion on broken objects. */
2015 if (elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2016 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2018 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2020 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2021 if (target_sect == NULL)
2024 if ((target_sect->flags & SEC_RELOC) == 0
2025 || target_sect->reloc_count == 0)
2026 hdr2 = &elf_section_data (target_sect)->rel_hdr;
2030 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
2031 amt = sizeof (*hdr2);
2032 hdr2 = bfd_alloc (abfd, amt);
2033 elf_section_data (target_sect)->rel_hdr2 = hdr2;
2036 elf_elfsections (abfd)[shindex] = hdr2;
2037 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
2038 target_sect->flags |= SEC_RELOC;
2039 target_sect->relocation = NULL;
2040 target_sect->rel_filepos = hdr->sh_offset;
2041 /* In the section to which the relocations apply, mark whether
2042 its relocations are of the REL or RELA variety. */
2043 if (hdr->sh_size != 0)
2044 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
2045 abfd->flags |= HAS_RELOC;
2050 case SHT_GNU_verdef:
2051 elf_dynverdef (abfd) = shindex;
2052 elf_tdata (abfd)->dynverdef_hdr = *hdr;
2053 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2056 case SHT_GNU_versym:
2057 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2059 elf_dynversym (abfd) = shindex;
2060 elf_tdata (abfd)->dynversym_hdr = *hdr;
2061 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2064 case SHT_GNU_verneed:
2065 elf_dynverref (abfd) = shindex;
2066 elf_tdata (abfd)->dynverref_hdr = *hdr;
2067 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2074 /* We need a BFD section for objcopy and relocatable linking,
2075 and it's handy to have the signature available as the section
2077 if (hdr->sh_entsize != GRP_ENTRY_SIZE)
2079 name = group_signature (abfd, hdr);
2082 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2084 if (hdr->contents != NULL)
2086 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2087 unsigned int n_elt = hdr->sh_size / 4;
2090 if (idx->flags & GRP_COMDAT)
2091 hdr->bfd_section->flags
2092 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2094 /* We try to keep the same section order as it comes in. */
2096 while (--n_elt != 0)
2097 if ((s = (--idx)->shdr->bfd_section) != NULL
2098 && elf_next_in_group (s) != NULL)
2100 elf_next_in_group (hdr->bfd_section) = s;
2107 /* Check for any processor-specific section types. */
2108 return bed->elf_backend_section_from_shdr (abfd, hdr, name,
2115 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2116 Return SEC for sections that have no elf section, and NULL on error. */
2119 bfd_section_from_r_symndx (bfd *abfd,
2120 struct sym_sec_cache *cache,
2122 unsigned long r_symndx)
2124 Elf_Internal_Shdr *symtab_hdr;
2125 unsigned char esym[sizeof (Elf64_External_Sym)];
2126 Elf_External_Sym_Shndx eshndx;
2127 Elf_Internal_Sym isym;
2128 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2130 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2131 return cache->sec[ent];
2133 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2134 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2135 &isym, esym, &eshndx) == NULL)
2138 if (cache->abfd != abfd)
2140 memset (cache->indx, -1, sizeof (cache->indx));
2143 cache->indx[ent] = r_symndx;
2144 cache->sec[ent] = sec;
2145 if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2146 || isym.st_shndx > SHN_HIRESERVE)
2149 s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2151 cache->sec[ent] = s;
2153 return cache->sec[ent];
2156 /* Given an ELF section number, retrieve the corresponding BFD
2160 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2162 if (index >= elf_numsections (abfd))
2164 return elf_elfsections (abfd)[index]->bfd_section;
2167 static struct bfd_elf_special_section const special_sections_b[] =
2169 { ".bss", 4, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2170 { NULL, 0, 0, 0, 0 }
2173 static struct bfd_elf_special_section const special_sections_c[] =
2175 { ".comment", 8, 0, SHT_PROGBITS, 0 },
2176 { NULL, 0, 0, 0, 0 }
2179 static struct bfd_elf_special_section const special_sections_d[] =
2181 { ".data", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2182 { ".data1", 6, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2183 { ".debug", 6, 0, SHT_PROGBITS, 0 },
2184 { ".debug_line", 11, 0, SHT_PROGBITS, 0 },
2185 { ".debug_info", 11, 0, SHT_PROGBITS, 0 },
2186 { ".debug_abbrev", 13, 0, SHT_PROGBITS, 0 },
2187 { ".debug_aranges", 14, 0, SHT_PROGBITS, 0 },
2188 { ".dynamic", 8, 0, SHT_DYNAMIC, SHF_ALLOC },
2189 { ".dynstr", 7, 0, SHT_STRTAB, SHF_ALLOC },
2190 { ".dynsym", 7, 0, SHT_DYNSYM, SHF_ALLOC },
2191 { NULL, 0, 0, 0, 0 }
2194 static struct bfd_elf_special_section const special_sections_f[] =
2196 { ".fini", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2197 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2198 { NULL, 0, 0, 0, 0 }
2201 static struct bfd_elf_special_section const special_sections_g[] =
2203 { ".gnu.linkonce.b",15, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2204 { ".got", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2205 { ".gnu.version", 12, 0, SHT_GNU_versym, 0 },
2206 { ".gnu.version_d", 14, 0, SHT_GNU_verdef, 0 },
2207 { ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },
2208 { ".gnu.liblist", 12, 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2209 { ".gnu.conflict", 13, 0, SHT_RELA, SHF_ALLOC },
2210 { NULL, 0, 0, 0, 0 }
2213 static struct bfd_elf_special_section const special_sections_h[] =
2215 { ".hash", 5, 0, SHT_HASH, SHF_ALLOC },
2216 { NULL, 0, 0, 0, 0 }
2219 static struct bfd_elf_special_section const special_sections_i[] =
2221 { ".init", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2222 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2223 { ".interp", 7, 0, SHT_PROGBITS, 0 },
2224 { NULL, 0, 0, 0, 0 }
2227 static struct bfd_elf_special_section const special_sections_l[] =
2229 { ".line", 5, 0, SHT_PROGBITS, 0 },
2230 { NULL, 0, 0, 0, 0 }
2233 static struct bfd_elf_special_section const special_sections_n[] =
2235 { ".note.GNU-stack",15, 0, SHT_PROGBITS, 0 },
2236 { ".note", 5, -1, SHT_NOTE, 0 },
2237 { NULL, 0, 0, 0, 0 }
2240 static struct bfd_elf_special_section const special_sections_p[] =
2242 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2243 { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2244 { NULL, 0, 0, 0, 0 }
2247 static struct bfd_elf_special_section const special_sections_r[] =
2249 { ".rodata", 7, -2, SHT_PROGBITS, SHF_ALLOC },
2250 { ".rodata1", 8, 0, SHT_PROGBITS, SHF_ALLOC },
2251 { ".rela", 5, -1, SHT_RELA, 0 },
2252 { ".rel", 4, -1, SHT_REL, 0 },
2253 { NULL, 0, 0, 0, 0 }
2256 static struct bfd_elf_special_section const special_sections_s[] =
2258 { ".shstrtab", 9, 0, SHT_STRTAB, 0 },
2259 { ".strtab", 7, 0, SHT_STRTAB, 0 },
2260 { ".symtab", 7, 0, SHT_SYMTAB, 0 },
2261 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2262 { NULL, 0, 0, 0, 0 }
2265 static struct bfd_elf_special_section const special_sections_t[] =
2267 { ".text", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2268 { ".tbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2269 { ".tdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2270 { NULL, 0, 0, 0, 0 }
2273 static struct bfd_elf_special_section const *special_sections [27] =
2276 special_sections_b, /* 'b' */
2277 special_sections_c, /* 'b' */
2278 special_sections_d, /* 'd' */
2280 special_sections_f, /* 'f' */
2281 special_sections_g, /* 'g' */
2282 special_sections_h, /* 'h' */
2283 special_sections_i, /* 'i' */
2286 special_sections_l, /* 'l' */
2288 special_sections_n, /* 'n' */
2290 special_sections_p, /* 'p' */
2292 special_sections_r, /* 'r' */
2293 special_sections_s, /* 's' */
2294 special_sections_t, /* 't' */
2304 static const struct bfd_elf_special_section *
2305 get_special_section (const char *name,
2306 const struct bfd_elf_special_section **special_sections_p,
2311 const struct bfd_elf_special_section *special_sections;
2313 if (name [0] == '.')
2316 if (i < 0 || i > 25)
2322 special_sections = special_sections_p [i];
2324 if (!special_sections)
2325 return special_sections;
2329 for (i = 0; special_sections[i].prefix != NULL; i++)
2332 int prefix_len = special_sections[i].prefix_length;
2334 if (len < prefix_len)
2336 if (memcmp (name, special_sections[i].prefix, prefix_len) != 0)
2339 suffix_len = special_sections[i].suffix_length;
2340 if (suffix_len <= 0)
2342 if (name[prefix_len] != 0)
2344 if (suffix_len == 0)
2346 if (name[prefix_len] != '.'
2347 && (suffix_len == -2
2348 || (rela && special_sections[i].type == SHT_REL)))
2354 if (len < prefix_len + suffix_len)
2356 if (memcmp (name + len - suffix_len,
2357 special_sections[i].prefix + prefix_len,
2361 return &special_sections[i];
2367 const struct bfd_elf_special_section *
2368 _bfd_elf_get_sec_type_attr (bfd *abfd, const char *name)
2370 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2371 const struct bfd_elf_special_section *ssect = NULL;
2373 /* See if this is one of the special sections. */
2376 unsigned int rela = bed->default_use_rela_p;
2378 if (bed->special_sections)
2379 ssect = get_special_section (name, bed->special_sections, rela);
2382 ssect = get_special_section (name, special_sections, rela);
2389 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2391 struct bfd_elf_section_data *sdata;
2392 const struct bfd_elf_special_section *ssect;
2394 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2397 sdata = bfd_zalloc (abfd, sizeof (*sdata));
2400 sec->used_by_bfd = sdata;
2403 /* When we read a file, we don't need section type and flags unless
2404 it is a linker created section. They will be overridden in
2405 _bfd_elf_make_section_from_shdr anyway. */
2406 if (abfd->direction != read_direction
2407 || (sec->flags & SEC_LINKER_CREATED) != 0)
2409 ssect = _bfd_elf_get_sec_type_attr (abfd, sec->name);
2412 elf_section_type (sec) = ssect->type;
2413 elf_section_flags (sec) = ssect->attr;
2417 /* Indicate whether or not this section should use RELA relocations. */
2418 sec->use_rela_p = get_elf_backend_data (abfd)->default_use_rela_p;
2423 /* Create a new bfd section from an ELF program header.
2425 Since program segments have no names, we generate a synthetic name
2426 of the form segment<NUM>, where NUM is generally the index in the
2427 program header table. For segments that are split (see below) we
2428 generate the names segment<NUM>a and segment<NUM>b.
2430 Note that some program segments may have a file size that is different than
2431 (less than) the memory size. All this means is that at execution the
2432 system must allocate the amount of memory specified by the memory size,
2433 but only initialize it with the first "file size" bytes read from the
2434 file. This would occur for example, with program segments consisting
2435 of combined data+bss.
2437 To handle the above situation, this routine generates TWO bfd sections
2438 for the single program segment. The first has the length specified by
2439 the file size of the segment, and the second has the length specified
2440 by the difference between the two sizes. In effect, the segment is split
2441 into it's initialized and uninitialized parts.
2446 _bfd_elf_make_section_from_phdr (bfd *abfd,
2447 Elf_Internal_Phdr *hdr,
2449 const char *typename)
2457 split = ((hdr->p_memsz > 0)
2458 && (hdr->p_filesz > 0)
2459 && (hdr->p_memsz > hdr->p_filesz));
2460 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2461 len = strlen (namebuf) + 1;
2462 name = bfd_alloc (abfd, len);
2465 memcpy (name, namebuf, len);
2466 newsect = bfd_make_section (abfd, name);
2467 if (newsect == NULL)
2469 newsect->vma = hdr->p_vaddr;
2470 newsect->lma = hdr->p_paddr;
2471 newsect->size = hdr->p_filesz;
2472 newsect->filepos = hdr->p_offset;
2473 newsect->flags |= SEC_HAS_CONTENTS;
2474 newsect->alignment_power = bfd_log2 (hdr->p_align);
2475 if (hdr->p_type == PT_LOAD)
2477 newsect->flags |= SEC_ALLOC;
2478 newsect->flags |= SEC_LOAD;
2479 if (hdr->p_flags & PF_X)
2481 /* FIXME: all we known is that it has execute PERMISSION,
2483 newsect->flags |= SEC_CODE;
2486 if (!(hdr->p_flags & PF_W))
2488 newsect->flags |= SEC_READONLY;
2493 sprintf (namebuf, "%s%db", typename, index);
2494 len = strlen (namebuf) + 1;
2495 name = bfd_alloc (abfd, len);
2498 memcpy (name, namebuf, len);
2499 newsect = bfd_make_section (abfd, name);
2500 if (newsect == NULL)
2502 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2503 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2504 newsect->size = hdr->p_memsz - hdr->p_filesz;
2505 if (hdr->p_type == PT_LOAD)
2507 newsect->flags |= SEC_ALLOC;
2508 if (hdr->p_flags & PF_X)
2509 newsect->flags |= SEC_CODE;
2511 if (!(hdr->p_flags & PF_W))
2512 newsect->flags |= SEC_READONLY;
2519 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2521 const struct elf_backend_data *bed;
2523 switch (hdr->p_type)
2526 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2529 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2532 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2535 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2538 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2540 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2545 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2548 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2550 case PT_GNU_EH_FRAME:
2551 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2555 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2558 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2561 /* Check for any processor-specific program segment types. */
2562 bed = get_elf_backend_data (abfd);
2563 return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2567 /* Initialize REL_HDR, the section-header for new section, containing
2568 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2569 relocations; otherwise, we use REL relocations. */
2572 _bfd_elf_init_reloc_shdr (bfd *abfd,
2573 Elf_Internal_Shdr *rel_hdr,
2575 bfd_boolean use_rela_p)
2578 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2579 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2581 name = bfd_alloc (abfd, amt);
2584 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2586 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2588 if (rel_hdr->sh_name == (unsigned int) -1)
2590 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2591 rel_hdr->sh_entsize = (use_rela_p
2592 ? bed->s->sizeof_rela
2593 : bed->s->sizeof_rel);
2594 rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2595 rel_hdr->sh_flags = 0;
2596 rel_hdr->sh_addr = 0;
2597 rel_hdr->sh_size = 0;
2598 rel_hdr->sh_offset = 0;
2603 /* Set up an ELF internal section header for a section. */
2606 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2608 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2609 bfd_boolean *failedptr = failedptrarg;
2610 Elf_Internal_Shdr *this_hdr;
2614 /* We already failed; just get out of the bfd_map_over_sections
2619 this_hdr = &elf_section_data (asect)->this_hdr;
2621 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2622 asect->name, FALSE);
2623 if (this_hdr->sh_name == (unsigned int) -1)
2629 this_hdr->sh_flags = 0;
2631 if ((asect->flags & SEC_ALLOC) != 0
2632 || asect->user_set_vma)
2633 this_hdr->sh_addr = asect->vma;
2635 this_hdr->sh_addr = 0;
2637 this_hdr->sh_offset = 0;
2638 this_hdr->sh_size = asect->size;
2639 this_hdr->sh_link = 0;
2640 this_hdr->sh_addralign = 1 << asect->alignment_power;
2641 /* The sh_entsize and sh_info fields may have been set already by
2642 copy_private_section_data. */
2644 this_hdr->bfd_section = asect;
2645 this_hdr->contents = NULL;
2647 /* If the section type is unspecified, we set it based on
2649 if (this_hdr->sh_type == SHT_NULL)
2651 if ((asect->flags & SEC_GROUP) != 0)
2653 /* We also need to mark SHF_GROUP here for relocatable
2655 struct bfd_link_order *l;
2658 for (l = asect->map_head.link_order; l != NULL; l = l->next)
2659 if (l->type == bfd_indirect_link_order
2660 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2663 /* The name is not important. Anything will do. */
2664 elf_group_name (elt->output_section) = "G";
2665 elf_section_flags (elt->output_section) |= SHF_GROUP;
2667 elt = elf_next_in_group (elt);
2668 /* During a relocatable link, the lists are
2671 while (elt != elf_next_in_group (l->u.indirect.section));
2673 this_hdr->sh_type = SHT_GROUP;
2675 else if ((asect->flags & SEC_ALLOC) != 0
2676 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2677 || (asect->flags & SEC_NEVER_LOAD) != 0))
2678 this_hdr->sh_type = SHT_NOBITS;
2680 this_hdr->sh_type = SHT_PROGBITS;
2683 switch (this_hdr->sh_type)
2689 case SHT_INIT_ARRAY:
2690 case SHT_FINI_ARRAY:
2691 case SHT_PREINIT_ARRAY:
2698 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2702 this_hdr->sh_entsize = bed->s->sizeof_sym;
2706 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2710 if (get_elf_backend_data (abfd)->may_use_rela_p)
2711 this_hdr->sh_entsize = bed->s->sizeof_rela;
2715 if (get_elf_backend_data (abfd)->may_use_rel_p)
2716 this_hdr->sh_entsize = bed->s->sizeof_rel;
2719 case SHT_GNU_versym:
2720 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2723 case SHT_GNU_verdef:
2724 this_hdr->sh_entsize = 0;
2725 /* objcopy or strip will copy over sh_info, but may not set
2726 cverdefs. The linker will set cverdefs, but sh_info will be
2728 if (this_hdr->sh_info == 0)
2729 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2731 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2732 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2735 case SHT_GNU_verneed:
2736 this_hdr->sh_entsize = 0;
2737 /* objcopy or strip will copy over sh_info, but may not set
2738 cverrefs. The linker will set cverrefs, but sh_info will be
2740 if (this_hdr->sh_info == 0)
2741 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2743 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2744 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2748 this_hdr->sh_entsize = 4;
2752 if ((asect->flags & SEC_ALLOC) != 0)
2753 this_hdr->sh_flags |= SHF_ALLOC;
2754 if ((asect->flags & SEC_READONLY) == 0)
2755 this_hdr->sh_flags |= SHF_WRITE;
2756 if ((asect->flags & SEC_CODE) != 0)
2757 this_hdr->sh_flags |= SHF_EXECINSTR;
2758 if ((asect->flags & SEC_MERGE) != 0)
2760 this_hdr->sh_flags |= SHF_MERGE;
2761 this_hdr->sh_entsize = asect->entsize;
2762 if ((asect->flags & SEC_STRINGS) != 0)
2763 this_hdr->sh_flags |= SHF_STRINGS;
2765 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2766 this_hdr->sh_flags |= SHF_GROUP;
2767 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2769 this_hdr->sh_flags |= SHF_TLS;
2770 if (asect->size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2772 struct bfd_link_order *o;
2774 this_hdr->sh_size = 0;
2775 for (o = asect->map_head.link_order; o != NULL; o = o->next)
2776 if (this_hdr->sh_size < o->offset + o->size)
2777 this_hdr->sh_size = o->offset + o->size;
2778 if (this_hdr->sh_size)
2779 this_hdr->sh_type = SHT_NOBITS;
2783 /* Check for processor-specific section types. */
2784 if (bed->elf_backend_fake_sections
2785 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2788 /* If the section has relocs, set up a section header for the
2789 SHT_REL[A] section. If two relocation sections are required for
2790 this section, it is up to the processor-specific back-end to
2791 create the other. */
2792 if ((asect->flags & SEC_RELOC) != 0
2793 && !_bfd_elf_init_reloc_shdr (abfd,
2794 &elf_section_data (asect)->rel_hdr,
2800 /* Fill in the contents of a SHT_GROUP section. */
2803 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2805 bfd_boolean *failedptr = failedptrarg;
2806 unsigned long symindx;
2807 asection *elt, *first;
2809 struct bfd_link_order *l;
2812 /* Ignore linker created group section. See elfNN_ia64_object_p in
2814 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2819 if (elf_group_id (sec) != NULL)
2820 symindx = elf_group_id (sec)->udata.i;
2824 /* If called from the assembler, swap_out_syms will have set up
2825 elf_section_syms; If called for "ld -r", use target_index. */
2826 if (elf_section_syms (abfd) != NULL)
2827 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2829 symindx = sec->target_index;
2831 elf_section_data (sec)->this_hdr.sh_info = symindx;
2833 /* The contents won't be allocated for "ld -r" or objcopy. */
2835 if (sec->contents == NULL)
2838 sec->contents = bfd_alloc (abfd, sec->size);
2840 /* Arrange for the section to be written out. */
2841 elf_section_data (sec)->this_hdr.contents = sec->contents;
2842 if (sec->contents == NULL)
2849 loc = sec->contents + sec->size;
2851 /* Get the pointer to the first section in the group that gas
2852 squirreled away here. objcopy arranges for this to be set to the
2853 start of the input section group. */
2854 first = elt = elf_next_in_group (sec);
2856 /* First element is a flag word. Rest of section is elf section
2857 indices for all the sections of the group. Write them backwards
2858 just to keep the group in the same order as given in .section
2859 directives, not that it matters. */
2868 s = s->output_section;
2871 idx = elf_section_data (s)->this_idx;
2872 H_PUT_32 (abfd, idx, loc);
2873 elt = elf_next_in_group (elt);
2878 /* If this is a relocatable link, then the above did nothing because
2879 SEC is the output section. Look through the input sections
2881 for (l = sec->map_head.link_order; l != NULL; l = l->next)
2882 if (l->type == bfd_indirect_link_order
2883 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2888 elf_section_data (elt->output_section)->this_idx, loc);
2889 elt = elf_next_in_group (elt);
2890 /* During a relocatable link, the lists are circular. */
2892 while (elt != elf_next_in_group (l->u.indirect.section));
2894 if ((loc -= 4) != sec->contents)
2897 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2900 /* Assign all ELF section numbers. The dummy first section is handled here
2901 too. The link/info pointers for the standard section types are filled
2902 in here too, while we're at it. */
2905 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2907 struct elf_obj_tdata *t = elf_tdata (abfd);
2909 unsigned int section_number, secn;
2910 Elf_Internal_Shdr **i_shdrp;
2912 struct bfd_elf_section_data *d;
2916 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2918 /* SHT_GROUP sections are in relocatable files only. */
2919 if (link_info == NULL || link_info->relocatable)
2921 /* Put SHT_GROUP sections first. */
2922 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2924 d = elf_section_data (sec);
2926 if (d->this_hdr.sh_type == SHT_GROUP)
2928 if (sec->flags & SEC_LINKER_CREATED)
2930 /* Remove the linker created SHT_GROUP sections. */
2931 bfd_section_list_remove (abfd, sec);
2932 abfd->section_count--;
2936 if (section_number == SHN_LORESERVE)
2937 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2938 d->this_idx = section_number++;
2944 for (sec = abfd->sections; sec; sec = sec->next)
2946 d = elf_section_data (sec);
2948 if (d->this_hdr.sh_type != SHT_GROUP)
2950 if (section_number == SHN_LORESERVE)
2951 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2952 d->this_idx = section_number++;
2954 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2955 if ((sec->flags & SEC_RELOC) == 0)
2959 if (section_number == SHN_LORESERVE)
2960 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2961 d->rel_idx = section_number++;
2962 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2967 if (section_number == SHN_LORESERVE)
2968 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2969 d->rel_idx2 = section_number++;
2970 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2976 if (section_number == SHN_LORESERVE)
2977 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2978 t->shstrtab_section = section_number++;
2979 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2980 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2982 if (bfd_get_symcount (abfd) > 0)
2984 if (section_number == SHN_LORESERVE)
2985 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2986 t->symtab_section = section_number++;
2987 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2988 if (section_number > SHN_LORESERVE - 2)
2990 if (section_number == SHN_LORESERVE)
2991 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2992 t->symtab_shndx_section = section_number++;
2993 t->symtab_shndx_hdr.sh_name
2994 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2995 ".symtab_shndx", FALSE);
2996 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2999 if (section_number == SHN_LORESERVE)
3000 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3001 t->strtab_section = section_number++;
3002 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
3005 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3006 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3008 elf_numsections (abfd) = section_number;
3009 elf_elfheader (abfd)->e_shnum = section_number;
3010 if (section_number > SHN_LORESERVE)
3011 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
3013 /* Set up the list of section header pointers, in agreement with the
3015 amt = section_number * sizeof (Elf_Internal_Shdr *);
3016 i_shdrp = bfd_zalloc (abfd, amt);
3017 if (i_shdrp == NULL)
3020 amt = sizeof (Elf_Internal_Shdr);
3021 i_shdrp[0] = bfd_zalloc (abfd, amt);
3022 if (i_shdrp[0] == NULL)
3024 bfd_release (abfd, i_shdrp);
3028 elf_elfsections (abfd) = i_shdrp;
3030 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3031 if (bfd_get_symcount (abfd) > 0)
3033 i_shdrp[t->symtab_section] = &t->symtab_hdr;
3034 if (elf_numsections (abfd) > SHN_LORESERVE)
3036 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3037 t->symtab_shndx_hdr.sh_link = t->symtab_section;
3039 i_shdrp[t->strtab_section] = &t->strtab_hdr;
3040 t->symtab_hdr.sh_link = t->strtab_section;
3043 for (sec = abfd->sections; sec; sec = sec->next)
3045 struct bfd_elf_section_data *d = elf_section_data (sec);
3049 i_shdrp[d->this_idx] = &d->this_hdr;
3050 if (d->rel_idx != 0)
3051 i_shdrp[d->rel_idx] = &d->rel_hdr;
3052 if (d->rel_idx2 != 0)
3053 i_shdrp[d->rel_idx2] = d->rel_hdr2;
3055 /* Fill in the sh_link and sh_info fields while we're at it. */
3057 /* sh_link of a reloc section is the section index of the symbol
3058 table. sh_info is the section index of the section to which
3059 the relocation entries apply. */
3060 if (d->rel_idx != 0)
3062 d->rel_hdr.sh_link = t->symtab_section;
3063 d->rel_hdr.sh_info = d->this_idx;
3065 if (d->rel_idx2 != 0)
3067 d->rel_hdr2->sh_link = t->symtab_section;
3068 d->rel_hdr2->sh_info = d->this_idx;
3071 /* We need to set up sh_link for SHF_LINK_ORDER. */
3072 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3074 s = elf_linked_to_section (sec);
3076 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3079 struct bfd_link_order *p;
3081 /* Find out what the corresponding section in output
3083 for (p = sec->map_head.link_order; p != NULL; p = p->next)
3085 s = p->u.indirect.section;
3086 if (p->type == bfd_indirect_link_order
3087 && (bfd_get_flavour (s->owner)
3088 == bfd_target_elf_flavour))
3090 Elf_Internal_Shdr ** const elf_shdrp
3091 = elf_elfsections (s->owner);
3093 = _bfd_elf_section_from_bfd_section (s->owner, s);
3094 elfsec = elf_shdrp[elfsec]->sh_link;
3096 The Intel C compiler generates SHT_IA_64_UNWIND with
3097 SHF_LINK_ORDER. But it doesn't set the sh_link or
3098 sh_info fields. Hence we could get the situation
3099 where elfsec is 0. */
3102 const struct elf_backend_data *bed
3103 = get_elf_backend_data (abfd);
3104 if (bed->link_order_error_handler)
3105 bed->link_order_error_handler
3106 (_("%B: warning: sh_link not set for section `%A'"),
3111 s = elf_shdrp[elfsec]->bfd_section;
3112 if (elf_discarded_section (s))
3115 (*_bfd_error_handler)
3116 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3117 abfd, d->this_hdr.bfd_section,
3119 /* Point to the kept section if it has
3120 the same size as the discarded
3122 kept = _bfd_elf_check_kept_section (s);
3125 bfd_set_error (bfd_error_bad_value);
3130 s = s->output_section;
3131 BFD_ASSERT (s != NULL);
3132 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3140 switch (d->this_hdr.sh_type)
3144 /* A reloc section which we are treating as a normal BFD
3145 section. sh_link is the section index of the symbol
3146 table. sh_info is the section index of the section to
3147 which the relocation entries apply. We assume that an
3148 allocated reloc section uses the dynamic symbol table.
3149 FIXME: How can we be sure? */
3150 s = bfd_get_section_by_name (abfd, ".dynsym");
3152 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3154 /* We look up the section the relocs apply to by name. */
3156 if (d->this_hdr.sh_type == SHT_REL)
3160 s = bfd_get_section_by_name (abfd, name);
3162 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3166 /* We assume that a section named .stab*str is a stabs
3167 string section. We look for a section with the same name
3168 but without the trailing ``str'', and set its sh_link
3169 field to point to this section. */
3170 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
3171 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3176 len = strlen (sec->name);
3177 alc = bfd_malloc (len - 2);
3180 memcpy (alc, sec->name, len - 3);
3181 alc[len - 3] = '\0';
3182 s = bfd_get_section_by_name (abfd, alc);
3186 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3188 /* This is a .stab section. */
3189 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3190 elf_section_data (s)->this_hdr.sh_entsize
3191 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3198 case SHT_GNU_verneed:
3199 case SHT_GNU_verdef:
3200 /* sh_link is the section header index of the string table
3201 used for the dynamic entries, or the symbol table, or the
3203 s = bfd_get_section_by_name (abfd, ".dynstr");
3205 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3208 case SHT_GNU_LIBLIST:
3209 /* sh_link is the section header index of the prelink library
3211 used for the dynamic entries, or the symbol table, or the
3213 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3214 ? ".dynstr" : ".gnu.libstr");
3216 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3220 case SHT_GNU_versym:
3221 /* sh_link is the section header index of the symbol table
3222 this hash table or version table is for. */
3223 s = bfd_get_section_by_name (abfd, ".dynsym");
3225 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3229 d->this_hdr.sh_link = t->symtab_section;
3233 for (secn = 1; secn < section_number; ++secn)
3234 if (i_shdrp[secn] == NULL)
3235 i_shdrp[secn] = i_shdrp[0];
3237 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3238 i_shdrp[secn]->sh_name);
3242 /* Map symbol from it's internal number to the external number, moving
3243 all local symbols to be at the head of the list. */
3246 sym_is_global (bfd *abfd, asymbol *sym)
3248 /* If the backend has a special mapping, use it. */
3249 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3250 if (bed->elf_backend_sym_is_global)
3251 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3253 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3254 || bfd_is_und_section (bfd_get_section (sym))
3255 || bfd_is_com_section (bfd_get_section (sym)));
3259 elf_map_symbols (bfd *abfd)
3261 unsigned int symcount = bfd_get_symcount (abfd);
3262 asymbol **syms = bfd_get_outsymbols (abfd);
3263 asymbol **sect_syms;
3264 unsigned int num_locals = 0;
3265 unsigned int num_globals = 0;
3266 unsigned int num_locals2 = 0;
3267 unsigned int num_globals2 = 0;
3275 fprintf (stderr, "elf_map_symbols\n");
3279 for (asect = abfd->sections; asect; asect = asect->next)
3281 if (max_index < asect->index)
3282 max_index = asect->index;
3286 amt = max_index * sizeof (asymbol *);
3287 sect_syms = bfd_zalloc (abfd, amt);
3288 if (sect_syms == NULL)
3290 elf_section_syms (abfd) = sect_syms;
3291 elf_num_section_syms (abfd) = max_index;
3293 /* Init sect_syms entries for any section symbols we have already
3294 decided to output. */
3295 for (idx = 0; idx < symcount; idx++)
3297 asymbol *sym = syms[idx];
3299 if ((sym->flags & BSF_SECTION_SYM) != 0
3306 if (sec->owner != NULL)
3308 if (sec->owner != abfd)
3310 if (sec->output_offset != 0)
3313 sec = sec->output_section;
3315 /* Empty sections in the input files may have had a
3316 section symbol created for them. (See the comment
3317 near the end of _bfd_generic_link_output_symbols in
3318 linker.c). If the linker script discards such
3319 sections then we will reach this point. Since we know
3320 that we cannot avoid this case, we detect it and skip
3321 the abort and the assignment to the sect_syms array.
3322 To reproduce this particular case try running the
3323 linker testsuite test ld-scripts/weak.exp for an ELF
3324 port that uses the generic linker. */
3325 if (sec->owner == NULL)
3328 BFD_ASSERT (sec->owner == abfd);
3330 sect_syms[sec->index] = syms[idx];
3335 /* Classify all of the symbols. */
3336 for (idx = 0; idx < symcount; idx++)
3338 if (!sym_is_global (abfd, syms[idx]))
3344 /* We will be adding a section symbol for each BFD section. Most normal
3345 sections will already have a section symbol in outsymbols, but
3346 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3347 at least in that case. */
3348 for (asect = abfd->sections; asect; asect = asect->next)
3350 if (sect_syms[asect->index] == NULL)
3352 if (!sym_is_global (abfd, asect->symbol))
3359 /* Now sort the symbols so the local symbols are first. */
3360 amt = (num_locals + num_globals) * sizeof (asymbol *);
3361 new_syms = bfd_alloc (abfd, amt);
3363 if (new_syms == NULL)
3366 for (idx = 0; idx < symcount; idx++)
3368 asymbol *sym = syms[idx];
3371 if (!sym_is_global (abfd, sym))
3374 i = num_locals + num_globals2++;
3376 sym->udata.i = i + 1;
3378 for (asect = abfd->sections; asect; asect = asect->next)
3380 if (sect_syms[asect->index] == NULL)
3382 asymbol *sym = asect->symbol;
3385 sect_syms[asect->index] = sym;
3386 if (!sym_is_global (abfd, sym))
3389 i = num_locals + num_globals2++;
3391 sym->udata.i = i + 1;
3395 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3397 elf_num_locals (abfd) = num_locals;
3398 elf_num_globals (abfd) = num_globals;
3402 /* Align to the maximum file alignment that could be required for any
3403 ELF data structure. */
3405 static inline file_ptr
3406 align_file_position (file_ptr off, int align)
3408 return (off + align - 1) & ~(align - 1);
3411 /* Assign a file position to a section, optionally aligning to the
3412 required section alignment. */
3415 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3423 al = i_shdrp->sh_addralign;
3425 offset = BFD_ALIGN (offset, al);
3427 i_shdrp->sh_offset = offset;
3428 if (i_shdrp->bfd_section != NULL)
3429 i_shdrp->bfd_section->filepos = offset;
3430 if (i_shdrp->sh_type != SHT_NOBITS)
3431 offset += i_shdrp->sh_size;
3435 /* Compute the file positions we are going to put the sections at, and
3436 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3437 is not NULL, this is being called by the ELF backend linker. */
3440 _bfd_elf_compute_section_file_positions (bfd *abfd,
3441 struct bfd_link_info *link_info)
3443 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3445 struct bfd_strtab_hash *strtab = NULL;
3446 Elf_Internal_Shdr *shstrtab_hdr;
3448 if (abfd->output_has_begun)
3451 /* Do any elf backend specific processing first. */
3452 if (bed->elf_backend_begin_write_processing)
3453 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3455 if (! prep_headers (abfd))
3458 /* Post process the headers if necessary. */
3459 if (bed->elf_backend_post_process_headers)
3460 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3463 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3467 if (!assign_section_numbers (abfd, link_info))
3470 /* The backend linker builds symbol table information itself. */
3471 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3473 /* Non-zero if doing a relocatable link. */
3474 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3476 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3480 if (link_info == NULL)
3482 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3487 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3488 /* sh_name was set in prep_headers. */
3489 shstrtab_hdr->sh_type = SHT_STRTAB;
3490 shstrtab_hdr->sh_flags = 0;
3491 shstrtab_hdr->sh_addr = 0;
3492 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3493 shstrtab_hdr->sh_entsize = 0;
3494 shstrtab_hdr->sh_link = 0;
3495 shstrtab_hdr->sh_info = 0;
3496 /* sh_offset is set in assign_file_positions_except_relocs. */
3497 shstrtab_hdr->sh_addralign = 1;
3499 if (!assign_file_positions_except_relocs (abfd, link_info))
3502 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3505 Elf_Internal_Shdr *hdr;
3507 off = elf_tdata (abfd)->next_file_pos;
3509 hdr = &elf_tdata (abfd)->symtab_hdr;
3510 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3512 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3513 if (hdr->sh_size != 0)
3514 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3516 hdr = &elf_tdata (abfd)->strtab_hdr;
3517 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3519 elf_tdata (abfd)->next_file_pos = off;
3521 /* Now that we know where the .strtab section goes, write it
3523 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3524 || ! _bfd_stringtab_emit (abfd, strtab))
3526 _bfd_stringtab_free (strtab);
3529 abfd->output_has_begun = TRUE;
3534 /* Create a mapping from a set of sections to a program segment. */
3536 static struct elf_segment_map *
3537 make_mapping (bfd *abfd,
3538 asection **sections,
3543 struct elf_segment_map *m;
3548 amt = sizeof (struct elf_segment_map);
3549 amt += (to - from - 1) * sizeof (asection *);
3550 m = bfd_zalloc (abfd, amt);
3554 m->p_type = PT_LOAD;
3555 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3556 m->sections[i - from] = *hdrpp;
3557 m->count = to - from;
3559 if (from == 0 && phdr)
3561 /* Include the headers in the first PT_LOAD segment. */
3562 m->includes_filehdr = 1;
3563 m->includes_phdrs = 1;
3569 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3572 struct elf_segment_map *
3573 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3575 struct elf_segment_map *m;
3577 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3581 m->p_type = PT_DYNAMIC;
3583 m->sections[0] = dynsec;
3588 /* Set up a mapping from BFD sections to program segments. */
3591 map_sections_to_segments (bfd *abfd)
3593 asection **sections = NULL;
3597 struct elf_segment_map *mfirst;
3598 struct elf_segment_map **pm;
3599 struct elf_segment_map *m;
3602 unsigned int phdr_index;
3603 bfd_vma maxpagesize;
3605 bfd_boolean phdr_in_segment = TRUE;
3606 bfd_boolean writable;
3608 asection *first_tls = NULL;
3609 asection *dynsec, *eh_frame_hdr;
3612 if (elf_tdata (abfd)->segment_map != NULL)
3615 if (bfd_count_sections (abfd) == 0)
3618 /* Select the allocated sections, and sort them. */
3620 amt = bfd_count_sections (abfd) * sizeof (asection *);
3621 sections = bfd_malloc (amt);
3622 if (sections == NULL)
3626 for (s = abfd->sections; s != NULL; s = s->next)
3628 if ((s->flags & SEC_ALLOC) != 0)
3634 BFD_ASSERT (i <= bfd_count_sections (abfd));
3637 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3639 /* Build the mapping. */
3644 /* If we have a .interp section, then create a PT_PHDR segment for
3645 the program headers and a PT_INTERP segment for the .interp
3647 s = bfd_get_section_by_name (abfd, ".interp");
3648 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3650 amt = sizeof (struct elf_segment_map);
3651 m = bfd_zalloc (abfd, amt);
3655 m->p_type = PT_PHDR;
3656 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3657 m->p_flags = PF_R | PF_X;
3658 m->p_flags_valid = 1;
3659 m->includes_phdrs = 1;
3664 amt = sizeof (struct elf_segment_map);
3665 m = bfd_zalloc (abfd, amt);
3669 m->p_type = PT_INTERP;
3677 /* Look through the sections. We put sections in the same program
3678 segment when the start of the second section can be placed within
3679 a few bytes of the end of the first section. */
3683 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3685 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3687 && (dynsec->flags & SEC_LOAD) == 0)
3690 /* Deal with -Ttext or something similar such that the first section
3691 is not adjacent to the program headers. This is an
3692 approximation, since at this point we don't know exactly how many
3693 program headers we will need. */
3696 bfd_size_type phdr_size;
3698 phdr_size = elf_tdata (abfd)->program_header_size;
3700 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3701 if ((abfd->flags & D_PAGED) == 0
3702 || sections[0]->lma < phdr_size
3703 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3704 phdr_in_segment = FALSE;
3707 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3710 bfd_boolean new_segment;
3714 /* See if this section and the last one will fit in the same
3717 if (last_hdr == NULL)
3719 /* If we don't have a segment yet, then we don't need a new
3720 one (we build the last one after this loop). */
3721 new_segment = FALSE;
3723 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3725 /* If this section has a different relation between the
3726 virtual address and the load address, then we need a new
3730 else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3731 < BFD_ALIGN (hdr->lma, maxpagesize))
3733 /* If putting this section in this segment would force us to
3734 skip a page in the segment, then we need a new segment. */
3737 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3738 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3740 /* We don't want to put a loadable section after a
3741 nonloadable section in the same segment.
3742 Consider .tbss sections as loadable for this purpose. */
3745 else if ((abfd->flags & D_PAGED) == 0)
3747 /* If the file is not demand paged, which means that we
3748 don't require the sections to be correctly aligned in the
3749 file, then there is no other reason for a new segment. */
3750 new_segment = FALSE;
3753 && (hdr->flags & SEC_READONLY) == 0
3754 && (((last_hdr->lma + last_size - 1)
3755 & ~(maxpagesize - 1))
3756 != (hdr->lma & ~(maxpagesize - 1))))
3758 /* We don't want to put a writable section in a read only
3759 segment, unless they are on the same page in memory
3760 anyhow. We already know that the last section does not
3761 bring us past the current section on the page, so the
3762 only case in which the new section is not on the same
3763 page as the previous section is when the previous section
3764 ends precisely on a page boundary. */
3769 /* Otherwise, we can use the same segment. */
3770 new_segment = FALSE;
3775 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;
3786 /* We need a new program segment. We must create a new program
3787 header holding all the sections from phdr_index until hdr. */
3789 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3796 if ((hdr->flags & SEC_READONLY) == 0)
3802 /* .tbss sections effectively have zero size. */
3803 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3804 last_size = hdr->size;
3808 phdr_in_segment = FALSE;
3811 /* Create a final PT_LOAD program segment. */
3812 if (last_hdr != NULL)
3814 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3822 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3825 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3832 /* For each loadable .note section, add a PT_NOTE segment. We don't
3833 use bfd_get_section_by_name, because if we link together
3834 nonloadable .note sections and loadable .note sections, we will
3835 generate two .note sections in the output file. FIXME: Using
3836 names for section types is bogus anyhow. */
3837 for (s = abfd->sections; s != NULL; s = s->next)
3839 if ((s->flags & SEC_LOAD) != 0
3840 && strncmp (s->name, ".note", 5) == 0)
3842 amt = sizeof (struct elf_segment_map);
3843 m = bfd_zalloc (abfd, amt);
3847 m->p_type = PT_NOTE;
3854 if (s->flags & SEC_THREAD_LOCAL)
3862 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3867 amt = sizeof (struct elf_segment_map);
3868 amt += (tls_count - 1) * sizeof (asection *);
3869 m = bfd_zalloc (abfd, amt);
3874 m->count = tls_count;
3875 /* Mandated PF_R. */
3877 m->p_flags_valid = 1;
3878 for (i = 0; i < tls_count; ++i)
3880 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3881 m->sections[i] = first_tls;
3882 first_tls = first_tls->next;
3889 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3891 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3892 if (eh_frame_hdr != NULL
3893 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3895 amt = sizeof (struct elf_segment_map);
3896 m = bfd_zalloc (abfd, amt);
3900 m->p_type = PT_GNU_EH_FRAME;
3902 m->sections[0] = eh_frame_hdr->output_section;
3908 if (elf_tdata (abfd)->stack_flags)
3910 amt = sizeof (struct elf_segment_map);
3911 m = bfd_zalloc (abfd, amt);
3915 m->p_type = PT_GNU_STACK;
3916 m->p_flags = elf_tdata (abfd)->stack_flags;
3917 m->p_flags_valid = 1;
3923 if (elf_tdata (abfd)->relro)
3925 amt = sizeof (struct elf_segment_map);
3926 m = bfd_zalloc (abfd, amt);
3930 m->p_type = PT_GNU_RELRO;
3932 m->p_flags_valid = 1;
3941 elf_tdata (abfd)->segment_map = mfirst;
3945 if (sections != NULL)
3950 /* Sort sections by address. */
3953 elf_sort_sections (const void *arg1, const void *arg2)
3955 const asection *sec1 = *(const asection **) arg1;
3956 const asection *sec2 = *(const asection **) arg2;
3957 bfd_size_type size1, size2;
3959 /* Sort by LMA first, since this is the address used to
3960 place the section into a segment. */
3961 if (sec1->lma < sec2->lma)
3963 else if (sec1->lma > sec2->lma)
3966 /* Then sort by VMA. Normally the LMA and the VMA will be
3967 the same, and this will do nothing. */
3968 if (sec1->vma < sec2->vma)
3970 else if (sec1->vma > sec2->vma)
3973 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3975 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3981 /* If the indicies are the same, do not return 0
3982 here, but continue to try the next comparison. */
3983 if (sec1->target_index - sec2->target_index != 0)
3984 return sec1->target_index - sec2->target_index;
3989 else if (TOEND (sec2))
3994 /* Sort by size, to put zero sized sections
3995 before others at the same address. */
3997 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
3998 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4005 return sec1->target_index - sec2->target_index;
4008 /* Ian Lance Taylor writes:
4010 We shouldn't be using % with a negative signed number. That's just
4011 not good. We have to make sure either that the number is not
4012 negative, or that the number has an unsigned type. When the types
4013 are all the same size they wind up as unsigned. When file_ptr is a
4014 larger signed type, the arithmetic winds up as signed long long,
4017 What we're trying to say here is something like ``increase OFF by
4018 the least amount that will cause it to be equal to the VMA modulo
4020 /* In other words, something like:
4022 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4023 off_offset = off % bed->maxpagesize;
4024 if (vma_offset < off_offset)
4025 adjustment = vma_offset + bed->maxpagesize - off_offset;
4027 adjustment = vma_offset - off_offset;
4029 which can can be collapsed into the expression below. */
4032 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4034 return ((vma - off) % maxpagesize);
4037 /* Assign file positions to the sections based on the mapping from
4038 sections to segments. This function also sets up some fields in
4039 the file header, and writes out the program headers. */
4042 assign_file_positions_for_segments (bfd *abfd, struct bfd_link_info *link_info)
4044 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4046 struct elf_segment_map *m;
4048 Elf_Internal_Phdr *phdrs;
4050 bfd_vma filehdr_vaddr, filehdr_paddr;
4051 bfd_vma phdrs_vaddr, phdrs_paddr;
4052 Elf_Internal_Phdr *p;
4055 if (elf_tdata (abfd)->segment_map == NULL)
4057 if (! map_sections_to_segments (abfd))
4062 /* The placement algorithm assumes that non allocated sections are
4063 not in PT_LOAD segments. We ensure this here by removing such
4064 sections from the segment map. */
4065 for (m = elf_tdata (abfd)->segment_map;
4069 unsigned int new_count;
4072 if (m->p_type != PT_LOAD)
4076 for (i = 0; i < m->count; i ++)
4078 if ((m->sections[i]->flags & SEC_ALLOC) != 0)
4081 m->sections[new_count] = m->sections[i];
4087 if (new_count != m->count)
4088 m->count = new_count;
4092 if (bed->elf_backend_modify_segment_map)
4094 if (! (*bed->elf_backend_modify_segment_map) (abfd, link_info))
4099 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4102 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4103 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4104 elf_elfheader (abfd)->e_phnum = count;
4108 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4112 /* If we already counted the number of program segments, make sure
4113 that we allocated enough space. This happens when SIZEOF_HEADERS
4114 is used in a linker script. */
4115 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
4116 if (alloc != 0 && count > alloc)
4118 ((*_bfd_error_handler)
4119 (_("%B: Not enough room for program headers (allocated %u, need %u)"),
4120 abfd, alloc, count));
4121 bfd_set_error (bfd_error_bad_value);
4128 amt = alloc * sizeof (Elf_Internal_Phdr);
4129 phdrs = bfd_alloc (abfd, amt);
4133 off = bed->s->sizeof_ehdr;
4134 off += alloc * bed->s->sizeof_phdr;
4141 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4148 /* If elf_segment_map is not from map_sections_to_segments, the
4149 sections may not be correctly ordered. NOTE: sorting should
4150 not be done to the PT_NOTE section of a corefile, which may
4151 contain several pseudo-sections artificially created by bfd.
4152 Sorting these pseudo-sections breaks things badly. */
4154 && !(elf_elfheader (abfd)->e_type == ET_CORE
4155 && m->p_type == PT_NOTE))
4156 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4159 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4160 number of sections with contents contributing to both p_filesz
4161 and p_memsz, followed by a number of sections with no contents
4162 that just contribute to p_memsz. In this loop, OFF tracks next
4163 available file offset for PT_LOAD and PT_NOTE segments. VOFF is
4164 an adjustment we use for segments that have no file contents
4165 but need zero filled memory allocation. */
4167 p->p_type = m->p_type;
4168 p->p_flags = m->p_flags;
4170 if (p->p_type == PT_LOAD
4173 bfd_size_type align;
4175 unsigned int align_power = 0;
4177 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4179 unsigned int secalign;
4181 secalign = bfd_get_section_alignment (abfd, *secpp);
4182 if (secalign > align_power)
4183 align_power = secalign;
4185 align = (bfd_size_type) 1 << align_power;
4187 if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > align)
4188 align = bed->maxpagesize;
4190 adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4193 && !m->includes_filehdr
4194 && !m->includes_phdrs
4195 && (ufile_ptr) off >= align)
4197 /* If the first section isn't loadable, the same holds for
4198 any other sections. Since the segment won't need file
4199 space, we can make p_offset overlap some prior segment.
4200 However, .tbss is special. If a segment starts with
4201 .tbss, we need to look at the next section to decide
4202 whether the segment has any loadable sections. */
4204 while ((m->sections[i]->flags & SEC_LOAD) == 0)
4206 if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
4210 voff = adjust - align;
4216 /* Make sure the .dynamic section is the first section in the
4217 PT_DYNAMIC segment. */
4218 else if (p->p_type == PT_DYNAMIC
4220 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4223 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4225 bfd_set_error (bfd_error_bad_value);
4232 p->p_vaddr = m->sections[0]->vma;
4234 if (m->p_paddr_valid)
4235 p->p_paddr = m->p_paddr;
4236 else if (m->count == 0)
4239 p->p_paddr = m->sections[0]->lma;
4241 if (p->p_type == PT_LOAD
4242 && (abfd->flags & D_PAGED) != 0)
4243 p->p_align = bed->maxpagesize;
4244 else if (m->count == 0)
4245 p->p_align = 1 << bed->s->log_file_align;
4253 if (m->includes_filehdr)
4255 if (! m->p_flags_valid)
4258 p->p_filesz = bed->s->sizeof_ehdr;
4259 p->p_memsz = bed->s->sizeof_ehdr;
4262 BFD_ASSERT (p->p_type == PT_LOAD);
4264 if (p->p_vaddr < (bfd_vma) off)
4266 (*_bfd_error_handler)
4267 (_("%B: Not enough room for program headers, try linking with -N"),
4269 bfd_set_error (bfd_error_bad_value);
4274 if (! m->p_paddr_valid)
4277 if (p->p_type == PT_LOAD)
4279 filehdr_vaddr = p->p_vaddr;
4280 filehdr_paddr = p->p_paddr;
4284 if (m->includes_phdrs)
4286 if (! m->p_flags_valid)
4289 if (m->includes_filehdr)
4291 if (p->p_type == PT_LOAD)
4293 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4294 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4299 p->p_offset = bed->s->sizeof_ehdr;
4303 BFD_ASSERT (p->p_type == PT_LOAD);
4304 p->p_vaddr -= off - p->p_offset;
4305 if (! m->p_paddr_valid)
4306 p->p_paddr -= off - p->p_offset;
4309 if (p->p_type == PT_LOAD)
4311 phdrs_vaddr = p->p_vaddr;
4312 phdrs_paddr = p->p_paddr;
4315 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4318 p->p_filesz += alloc * bed->s->sizeof_phdr;
4319 p->p_memsz += alloc * bed->s->sizeof_phdr;
4322 if (p->p_type == PT_LOAD
4323 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4325 if (! m->includes_filehdr && ! m->includes_phdrs)
4326 p->p_offset = off + voff;
4331 adjust = off - (p->p_offset + p->p_filesz);
4332 p->p_filesz += adjust;
4333 p->p_memsz += adjust;
4337 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4341 bfd_size_type align;
4345 align = 1 << bfd_get_section_alignment (abfd, sec);
4347 if (p->p_type == PT_LOAD
4348 || p->p_type == PT_TLS)
4350 bfd_signed_vma adjust;
4352 if ((flags & SEC_LOAD) != 0)
4354 adjust = sec->lma - (p->p_paddr + p->p_filesz);
4357 (*_bfd_error_handler)
4358 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4359 abfd, sec, (unsigned long) sec->lma);
4363 p->p_filesz += adjust;
4364 p->p_memsz += adjust;
4366 /* .tbss is special. It doesn't contribute to p_memsz of
4368 else if ((flags & SEC_THREAD_LOCAL) == 0
4369 || p->p_type == PT_TLS)
4371 /* The section VMA must equal the file position
4372 modulo the page size. */
4373 bfd_size_type page = align;
4374 if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > page)
4375 page = bed->maxpagesize;
4376 adjust = vma_page_aligned_bias (sec->vma,
4377 p->p_vaddr + p->p_memsz,
4379 p->p_memsz += adjust;
4383 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4385 /* The section at i == 0 is the one that actually contains
4391 p->p_filesz = sec->size;
4397 /* The rest are fake sections that shouldn't be written. */
4406 if (p->p_type == PT_LOAD)
4409 /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4410 1997, and the exact reason for it isn't clear. One
4411 plausible explanation is that it is to work around
4412 a problem we have with linker scripts using data
4413 statements in NOLOAD sections. I don't think it
4414 makes a great deal of sense to have such a section
4415 assigned to a PT_LOAD segment, but apparently
4416 people do this. The data statement results in a
4417 bfd_data_link_order being built, and these need
4418 section contents to write into. Eventually, we get
4419 to _bfd_elf_write_object_contents which writes any
4420 section with contents to the output. Make room
4421 here for the write, so that following segments are
4423 if ((flags & SEC_LOAD) != 0
4424 || (flags & SEC_HAS_CONTENTS) != 0)
4428 if ((flags & SEC_LOAD) != 0)
4430 p->p_filesz += sec->size;
4431 p->p_memsz += sec->size;
4433 /* PR ld/594: Sections in note segments which are not loaded
4434 contribute to the file size but not the in-memory size. */
4435 else if (p->p_type == PT_NOTE
4436 && (flags & SEC_HAS_CONTENTS) != 0)
4437 p->p_filesz += sec->size;
4439 /* .tbss is special. It doesn't contribute to p_memsz of
4441 else if ((flags & SEC_THREAD_LOCAL) == 0
4442 || p->p_type == PT_TLS)
4443 p->p_memsz += sec->size;
4445 if (p->p_type == PT_TLS
4447 && (sec->flags & SEC_HAS_CONTENTS) == 0)
4449 struct bfd_link_order *o;
4450 bfd_vma tbss_size = 0;
4452 for (o = sec->map_head.link_order; o != NULL; o = o->next)
4453 if (tbss_size < o->offset + o->size)
4454 tbss_size = o->offset + o->size;
4456 p->p_memsz += tbss_size;
4459 if (align > p->p_align
4460 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
4464 if (! m->p_flags_valid)
4467 if ((flags & SEC_CODE) != 0)
4469 if ((flags & SEC_READONLY) == 0)
4475 /* Now that we have set the section file positions, we can set up
4476 the file positions for the non PT_LOAD segments. */
4477 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4481 if (p->p_type != PT_LOAD && m->count > 0)
4483 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
4484 /* If the section has not yet been assigned a file position,
4485 do so now. The ARM BPABI requires that .dynamic section
4486 not be marked SEC_ALLOC because it is not part of any
4487 PT_LOAD segment, so it will not be processed above. */
4488 if (p->p_type == PT_DYNAMIC && m->sections[0]->filepos == 0)
4491 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4494 while (i_shdrpp[i]->bfd_section != m->sections[0])
4496 off = (_bfd_elf_assign_file_position_for_section
4497 (i_shdrpp[i], off, TRUE));
4498 p->p_filesz = m->sections[0]->size;
4500 p->p_offset = m->sections[0]->filepos;
4504 if (m->includes_filehdr)
4506 p->p_vaddr = filehdr_vaddr;
4507 if (! m->p_paddr_valid)
4508 p->p_paddr = filehdr_paddr;
4510 else if (m->includes_phdrs)
4512 p->p_vaddr = phdrs_vaddr;
4513 if (! m->p_paddr_valid)
4514 p->p_paddr = phdrs_paddr;
4516 else if (p->p_type == PT_GNU_RELRO)
4518 Elf_Internal_Phdr *lp;
4520 for (lp = phdrs; lp < phdrs + count; ++lp)
4522 if (lp->p_type == PT_LOAD
4523 && lp->p_vaddr <= link_info->relro_end
4524 && lp->p_vaddr >= link_info->relro_start
4525 && lp->p_vaddr + lp->p_filesz
4526 >= link_info->relro_end)
4530 if (lp < phdrs + count
4531 && link_info->relro_end > lp->p_vaddr)
4533 p->p_vaddr = lp->p_vaddr;
4534 p->p_paddr = lp->p_paddr;
4535 p->p_offset = lp->p_offset;
4536 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4537 p->p_memsz = p->p_filesz;
4539 p->p_flags = (lp->p_flags & ~PF_W);
4543 memset (p, 0, sizeof *p);
4544 p->p_type = PT_NULL;
4550 /* Clear out any program headers we allocated but did not use. */
4551 for (; count < alloc; count++, p++)
4553 memset (p, 0, sizeof *p);
4554 p->p_type = PT_NULL;
4557 elf_tdata (abfd)->phdr = phdrs;
4559 elf_tdata (abfd)->next_file_pos = off;
4561 /* Write out the program headers. */
4562 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4563 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4569 /* Get the size of the program header.
4571 If this is called by the linker before any of the section VMA's are set, it
4572 can't calculate the correct value for a strange memory layout. This only
4573 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4574 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4575 data segment (exclusive of .interp and .dynamic).
4577 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4578 will be two segments. */
4580 static bfd_size_type
4581 get_program_header_size (bfd *abfd)
4585 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4587 /* We can't return a different result each time we're called. */
4588 if (elf_tdata (abfd)->program_header_size != 0)
4589 return elf_tdata (abfd)->program_header_size;
4591 if (elf_tdata (abfd)->segment_map != NULL)
4593 struct elf_segment_map *m;
4596 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4598 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4599 return elf_tdata (abfd)->program_header_size;
4602 /* Assume we will need exactly two PT_LOAD segments: one for text
4603 and one for data. */
4606 s = bfd_get_section_by_name (abfd, ".interp");
4607 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4609 /* If we have a loadable interpreter section, we need a
4610 PT_INTERP segment. In this case, assume we also need a
4611 PT_PHDR segment, although that may not be true for all
4616 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4618 /* We need a PT_DYNAMIC segment. */
4622 if (elf_tdata (abfd)->eh_frame_hdr)
4624 /* We need a PT_GNU_EH_FRAME segment. */
4628 if (elf_tdata (abfd)->stack_flags)
4630 /* We need a PT_GNU_STACK segment. */
4634 if (elf_tdata (abfd)->relro)
4636 /* We need a PT_GNU_RELRO segment. */
4640 for (s = abfd->sections; s != NULL; s = s->next)
4642 if ((s->flags & SEC_LOAD) != 0
4643 && strncmp (s->name, ".note", 5) == 0)
4645 /* We need a PT_NOTE segment. */
4650 for (s = abfd->sections; s != NULL; s = s->next)
4652 if (s->flags & SEC_THREAD_LOCAL)
4654 /* We need a PT_TLS segment. */
4660 /* Let the backend count up any program headers it might need. */
4661 if (bed->elf_backend_additional_program_headers)
4665 a = (*bed->elf_backend_additional_program_headers) (abfd);
4671 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4672 return elf_tdata (abfd)->program_header_size;
4675 /* Work out the file positions of all the sections. This is called by
4676 _bfd_elf_compute_section_file_positions. All the section sizes and
4677 VMAs must be known before this is called.
4679 Reloc sections come in two flavours: Those processed specially as
4680 "side-channel" data attached to a section to which they apply, and
4681 those that bfd doesn't process as relocations. The latter sort are
4682 stored in a normal bfd section by bfd_section_from_shdr. We don't
4683 consider the former sort here, unless they form part of the loadable
4684 image. Reloc sections not assigned here will be handled later by
4685 assign_file_positions_for_relocs.
4687 We also don't set the positions of the .symtab and .strtab here. */
4690 assign_file_positions_except_relocs (bfd *abfd,
4691 struct bfd_link_info *link_info)
4693 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4694 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4695 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4696 unsigned int num_sec = elf_numsections (abfd);
4698 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4700 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4701 && bfd_get_format (abfd) != bfd_core)
4703 Elf_Internal_Shdr **hdrpp;
4706 /* Start after the ELF header. */
4707 off = i_ehdrp->e_ehsize;
4709 /* We are not creating an executable, which means that we are
4710 not creating a program header, and that the actual order of
4711 the sections in the file is unimportant. */
4712 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4714 Elf_Internal_Shdr *hdr;
4717 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4718 && hdr->bfd_section == NULL)
4719 || i == tdata->symtab_section
4720 || i == tdata->symtab_shndx_section
4721 || i == tdata->strtab_section)
4723 hdr->sh_offset = -1;
4726 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4728 if (i == SHN_LORESERVE - 1)
4730 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4731 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4738 Elf_Internal_Shdr **hdrpp;
4740 /* Assign file positions for the loaded sections based on the
4741 assignment of sections to segments. */
4742 if (! assign_file_positions_for_segments (abfd, link_info))
4745 /* Assign file positions for the other sections. */
4747 off = elf_tdata (abfd)->next_file_pos;
4748 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4750 Elf_Internal_Shdr *hdr;
4753 if (hdr->bfd_section != NULL
4754 && hdr->bfd_section->filepos != 0)
4755 hdr->sh_offset = hdr->bfd_section->filepos;
4756 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4758 ((*_bfd_error_handler)
4759 (_("%B: warning: allocated section `%s' not in segment"),
4761 (hdr->bfd_section == NULL
4763 : hdr->bfd_section->name)));
4764 if ((abfd->flags & D_PAGED) != 0)
4765 off += vma_page_aligned_bias (hdr->sh_addr, off,
4768 off += vma_page_aligned_bias (hdr->sh_addr, off,
4770 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4773 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4774 && hdr->bfd_section == NULL)
4775 || hdr == i_shdrpp[tdata->symtab_section]
4776 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4777 || hdr == i_shdrpp[tdata->strtab_section])
4778 hdr->sh_offset = -1;
4780 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4782 if (i == SHN_LORESERVE - 1)
4784 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4785 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4790 /* Place the section headers. */
4791 off = align_file_position (off, 1 << bed->s->log_file_align);
4792 i_ehdrp->e_shoff = off;
4793 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4795 elf_tdata (abfd)->next_file_pos = off;
4801 prep_headers (bfd *abfd)
4803 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4804 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4805 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
4806 struct elf_strtab_hash *shstrtab;
4807 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4809 i_ehdrp = elf_elfheader (abfd);
4810 i_shdrp = elf_elfsections (abfd);
4812 shstrtab = _bfd_elf_strtab_init ();
4813 if (shstrtab == NULL)
4816 elf_shstrtab (abfd) = shstrtab;
4818 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4819 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4820 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4821 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4823 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4824 i_ehdrp->e_ident[EI_DATA] =
4825 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4826 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4828 if ((abfd->flags & DYNAMIC) != 0)
4829 i_ehdrp->e_type = ET_DYN;
4830 else if ((abfd->flags & EXEC_P) != 0)
4831 i_ehdrp->e_type = ET_EXEC;
4832 else if (bfd_get_format (abfd) == bfd_core)
4833 i_ehdrp->e_type = ET_CORE;
4835 i_ehdrp->e_type = ET_REL;
4837 switch (bfd_get_arch (abfd))
4839 case bfd_arch_unknown:
4840 i_ehdrp->e_machine = EM_NONE;
4843 /* There used to be a long list of cases here, each one setting
4844 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4845 in the corresponding bfd definition. To avoid duplication,
4846 the switch was removed. Machines that need special handling
4847 can generally do it in elf_backend_final_write_processing(),
4848 unless they need the information earlier than the final write.
4849 Such need can generally be supplied by replacing the tests for
4850 e_machine with the conditions used to determine it. */
4852 i_ehdrp->e_machine = bed->elf_machine_code;
4855 i_ehdrp->e_version = bed->s->ev_current;
4856 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4858 /* No program header, for now. */
4859 i_ehdrp->e_phoff = 0;
4860 i_ehdrp->e_phentsize = 0;
4861 i_ehdrp->e_phnum = 0;
4863 /* Each bfd section is section header entry. */
4864 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4865 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4867 /* If we're building an executable, we'll need a program header table. */
4868 if (abfd->flags & EXEC_P)
4869 /* It all happens later. */
4873 i_ehdrp->e_phentsize = 0;
4875 i_ehdrp->e_phoff = 0;
4878 elf_tdata (abfd)->symtab_hdr.sh_name =
4879 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4880 elf_tdata (abfd)->strtab_hdr.sh_name =
4881 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4882 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4883 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4884 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4885 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4886 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4892 /* Assign file positions for all the reloc sections which are not part
4893 of the loadable file image. */
4896 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4899 unsigned int i, num_sec;
4900 Elf_Internal_Shdr **shdrpp;
4902 off = elf_tdata (abfd)->next_file_pos;
4904 num_sec = elf_numsections (abfd);
4905 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4907 Elf_Internal_Shdr *shdrp;
4910 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4911 && shdrp->sh_offset == -1)
4912 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4915 elf_tdata (abfd)->next_file_pos = off;
4919 _bfd_elf_write_object_contents (bfd *abfd)
4921 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4922 Elf_Internal_Ehdr *i_ehdrp;
4923 Elf_Internal_Shdr **i_shdrp;
4925 unsigned int count, num_sec;
4927 if (! abfd->output_has_begun
4928 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4931 i_shdrp = elf_elfsections (abfd);
4932 i_ehdrp = elf_elfheader (abfd);
4935 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4939 _bfd_elf_assign_file_positions_for_relocs (abfd);
4941 /* After writing the headers, we need to write the sections too... */
4942 num_sec = elf_numsections (abfd);
4943 for (count = 1; count < num_sec; count++)
4945 if (bed->elf_backend_section_processing)
4946 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4947 if (i_shdrp[count]->contents)
4949 bfd_size_type amt = i_shdrp[count]->sh_size;
4951 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4952 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4955 if (count == SHN_LORESERVE - 1)
4956 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4959 /* Write out the section header names. */
4960 if (elf_shstrtab (abfd) != NULL
4961 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4962 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4965 if (bed->elf_backend_final_write_processing)
4966 (*bed->elf_backend_final_write_processing) (abfd,
4967 elf_tdata (abfd)->linker);
4969 return bed->s->write_shdrs_and_ehdr (abfd);
4973 _bfd_elf_write_corefile_contents (bfd *abfd)
4975 /* Hopefully this can be done just like an object file. */
4976 return _bfd_elf_write_object_contents (abfd);
4979 /* Given a section, search the header to find them. */
4982 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4984 const struct elf_backend_data *bed;
4987 if (elf_section_data (asect) != NULL
4988 && elf_section_data (asect)->this_idx != 0)
4989 return elf_section_data (asect)->this_idx;
4991 if (bfd_is_abs_section (asect))
4993 else if (bfd_is_com_section (asect))
4995 else if (bfd_is_und_section (asect))
5000 bed = get_elf_backend_data (abfd);
5001 if (bed->elf_backend_section_from_bfd_section)
5005 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5010 bfd_set_error (bfd_error_nonrepresentable_section);
5015 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5019 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5021 asymbol *asym_ptr = *asym_ptr_ptr;
5023 flagword flags = asym_ptr->flags;
5025 /* When gas creates relocations against local labels, it creates its
5026 own symbol for the section, but does put the symbol into the
5027 symbol chain, so udata is 0. When the linker is generating
5028 relocatable output, this section symbol may be for one of the
5029 input sections rather than the output section. */
5030 if (asym_ptr->udata.i == 0
5031 && (flags & BSF_SECTION_SYM)
5032 && asym_ptr->section)
5036 if (asym_ptr->section->output_section != NULL)
5037 indx = asym_ptr->section->output_section->index;
5039 indx = asym_ptr->section->index;
5040 if (indx < elf_num_section_syms (abfd)
5041 && elf_section_syms (abfd)[indx] != NULL)
5042 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5045 idx = asym_ptr->udata.i;
5049 /* This case can occur when using --strip-symbol on a symbol
5050 which is used in a relocation entry. */
5051 (*_bfd_error_handler)
5052 (_("%B: symbol `%s' required but not present"),
5053 abfd, bfd_asymbol_name (asym_ptr));
5054 bfd_set_error (bfd_error_no_symbols);
5061 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5062 (long) asym_ptr, asym_ptr->name, idx, flags,
5063 elf_symbol_flags (flags));
5071 /* Copy private BFD data. This copies any program header information. */
5074 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5076 Elf_Internal_Ehdr *iehdr;
5077 struct elf_segment_map *map;
5078 struct elf_segment_map *map_first;
5079 struct elf_segment_map **pointer_to_map;
5080 Elf_Internal_Phdr *segment;
5083 unsigned int num_segments;
5084 bfd_boolean phdr_included = FALSE;
5085 bfd_vma maxpagesize;
5086 struct elf_segment_map *phdr_adjust_seg = NULL;
5087 unsigned int phdr_adjust_num = 0;
5088 const struct elf_backend_data *bed;
5090 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5091 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5094 if (elf_tdata (ibfd)->phdr == NULL)
5097 bed = get_elf_backend_data (ibfd);
5098 iehdr = elf_elfheader (ibfd);
5101 pointer_to_map = &map_first;
5103 num_segments = elf_elfheader (ibfd)->e_phnum;
5104 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5106 /* Returns the end address of the segment + 1. */
5107 #define SEGMENT_END(segment, start) \
5108 (start + (segment->p_memsz > segment->p_filesz \
5109 ? segment->p_memsz : segment->p_filesz))
5111 #define SECTION_SIZE(section, segment) \
5112 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5113 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5114 ? section->size : 0)
5116 /* Returns TRUE if the given section is contained within
5117 the given segment. VMA addresses are compared. */
5118 #define IS_CONTAINED_BY_VMA(section, segment) \
5119 (section->vma >= segment->p_vaddr \
5120 && (section->vma + SECTION_SIZE (section, segment) \
5121 <= (SEGMENT_END (segment, segment->p_vaddr))))
5123 /* Returns TRUE if the given section is contained within
5124 the given segment. LMA addresses are compared. */
5125 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5126 (section->lma >= base \
5127 && (section->lma + SECTION_SIZE (section, segment) \
5128 <= SEGMENT_END (segment, base)))
5130 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
5131 #define IS_COREFILE_NOTE(p, s) \
5132 (p->p_type == PT_NOTE \
5133 && bfd_get_format (ibfd) == bfd_core \
5134 && s->vma == 0 && s->lma == 0 \
5135 && (bfd_vma) s->filepos >= p->p_offset \
5136 && ((bfd_vma) s->filepos + s->size \
5137 <= p->p_offset + p->p_filesz))
5139 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5140 linker, which generates a PT_INTERP section with p_vaddr and
5141 p_memsz set to 0. */
5142 #define IS_SOLARIS_PT_INTERP(p, s) \
5144 && p->p_paddr == 0 \
5145 && p->p_memsz == 0 \
5146 && p->p_filesz > 0 \
5147 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5149 && (bfd_vma) s->filepos >= p->p_offset \
5150 && ((bfd_vma) s->filepos + s->size \
5151 <= p->p_offset + p->p_filesz))
5153 /* Decide if the given section should be included in the given segment.
5154 A section will be included if:
5155 1. It is within the address space of the segment -- we use the LMA
5156 if that is set for the segment and the VMA otherwise,
5157 2. It is an allocated segment,
5158 3. There is an output section associated with it,
5159 4. The section has not already been allocated to a previous segment.
5160 5. PT_GNU_STACK segments do not include any sections.
5161 6. PT_TLS segment includes only SHF_TLS sections.
5162 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5163 8. PT_DYNAMIC should not contain empty sections at the beginning
5164 (with the possible exception of .dynamic). */
5165 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5166 ((((segment->p_paddr \
5167 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5168 : IS_CONTAINED_BY_VMA (section, segment)) \
5169 && (section->flags & SEC_ALLOC) != 0) \
5170 || IS_COREFILE_NOTE (segment, section)) \
5171 && section->output_section != NULL \
5172 && segment->p_type != PT_GNU_STACK \
5173 && (segment->p_type != PT_TLS \
5174 || (section->flags & SEC_THREAD_LOCAL)) \
5175 && (segment->p_type == PT_LOAD \
5176 || segment->p_type == PT_TLS \
5177 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5178 && (segment->p_type != PT_DYNAMIC \
5179 || SECTION_SIZE (section, segment) > 0 \
5180 || (segment->p_paddr \
5181 ? segment->p_paddr != section->lma \
5182 : segment->p_vaddr != section->vma) \
5183 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5185 && ! section->segment_mark)
5187 /* Returns TRUE iff seg1 starts after the end of seg2. */
5188 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5189 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5191 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5192 their VMA address ranges and their LMA address ranges overlap.
5193 It is possible to have overlapping VMA ranges without overlapping LMA
5194 ranges. RedBoot images for example can have both .data and .bss mapped
5195 to the same VMA range, but with the .data section mapped to a different
5197 #define SEGMENT_OVERLAPS(seg1, seg2) \
5198 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5199 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5200 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5201 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5203 /* Initialise the segment mark field. */
5204 for (section = ibfd->sections; section != NULL; section = section->next)
5205 section->segment_mark = FALSE;
5207 /* Scan through the segments specified in the program header
5208 of the input BFD. For this first scan we look for overlaps
5209 in the loadable segments. These can be created by weird
5210 parameters to objcopy. Also, fix some solaris weirdness. */
5211 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5216 Elf_Internal_Phdr *segment2;
5218 if (segment->p_type == PT_INTERP)
5219 for (section = ibfd->sections; section; section = section->next)
5220 if (IS_SOLARIS_PT_INTERP (segment, section))
5222 /* Mininal change so that the normal section to segment
5223 assignment code will work. */
5224 segment->p_vaddr = section->vma;
5228 if (segment->p_type != PT_LOAD)
5231 /* Determine if this segment overlaps any previous segments. */
5232 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5234 bfd_signed_vma extra_length;
5236 if (segment2->p_type != PT_LOAD
5237 || ! SEGMENT_OVERLAPS (segment, segment2))
5240 /* Merge the two segments together. */
5241 if (segment2->p_vaddr < segment->p_vaddr)
5243 /* Extend SEGMENT2 to include SEGMENT and then delete
5246 SEGMENT_END (segment, segment->p_vaddr)
5247 - SEGMENT_END (segment2, segment2->p_vaddr);
5249 if (extra_length > 0)
5251 segment2->p_memsz += extra_length;
5252 segment2->p_filesz += extra_length;
5255 segment->p_type = PT_NULL;
5257 /* Since we have deleted P we must restart the outer loop. */
5259 segment = elf_tdata (ibfd)->phdr;
5264 /* Extend SEGMENT to include SEGMENT2 and then delete
5267 SEGMENT_END (segment2, segment2->p_vaddr)
5268 - SEGMENT_END (segment, segment->p_vaddr);
5270 if (extra_length > 0)
5272 segment->p_memsz += extra_length;
5273 segment->p_filesz += extra_length;
5276 segment2->p_type = PT_NULL;
5281 /* The second scan attempts to assign sections to segments. */
5282 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5286 unsigned int section_count;
5287 asection ** sections;
5288 asection * output_section;
5290 bfd_vma matching_lma;
5291 bfd_vma suggested_lma;
5295 if (segment->p_type == PT_NULL)
5298 /* Compute how many sections might be placed into this segment. */
5299 for (section = ibfd->sections, section_count = 0;
5301 section = section->next)
5302 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5305 /* Allocate a segment map big enough to contain
5306 all of the sections we have selected. */
5307 amt = sizeof (struct elf_segment_map);
5308 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5309 map = bfd_alloc (obfd, amt);
5313 /* Initialise the fields of the segment map. Default to
5314 using the physical address of the segment in the input BFD. */
5316 map->p_type = segment->p_type;
5317 map->p_flags = segment->p_flags;
5318 map->p_flags_valid = 1;
5319 map->p_paddr = segment->p_paddr;
5320 map->p_paddr_valid = 1;
5322 /* Determine if this segment contains the ELF file header
5323 and if it contains the program headers themselves. */
5324 map->includes_filehdr = (segment->p_offset == 0
5325 && segment->p_filesz >= iehdr->e_ehsize);
5327 map->includes_phdrs = 0;
5329 if (! phdr_included || segment->p_type != PT_LOAD)
5331 map->includes_phdrs =
5332 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5333 && (segment->p_offset + segment->p_filesz
5334 >= ((bfd_vma) iehdr->e_phoff
5335 + iehdr->e_phnum * iehdr->e_phentsize)));
5337 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5338 phdr_included = TRUE;
5341 if (section_count == 0)
5343 /* Special segments, such as the PT_PHDR segment, may contain
5344 no sections, but ordinary, loadable segments should contain
5345 something. They are allowed by the ELF spec however, so only
5346 a warning is produced. */
5347 if (segment->p_type == PT_LOAD)
5348 (*_bfd_error_handler)
5349 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5353 *pointer_to_map = map;
5354 pointer_to_map = &map->next;
5359 /* Now scan the sections in the input BFD again and attempt
5360 to add their corresponding output sections to the segment map.
5361 The problem here is how to handle an output section which has
5362 been moved (ie had its LMA changed). There are four possibilities:
5364 1. None of the sections have been moved.
5365 In this case we can continue to use the segment LMA from the
5368 2. All of the sections have been moved by the same amount.
5369 In this case we can change the segment's LMA to match the LMA
5370 of the first section.
5372 3. Some of the sections have been moved, others have not.
5373 In this case those sections which have not been moved can be
5374 placed in the current segment which will have to have its size,
5375 and possibly its LMA changed, and a new segment or segments will
5376 have to be created to contain the other sections.
5378 4. The sections have been moved, but not by the same amount.
5379 In this case we can change the segment's LMA to match the LMA
5380 of the first section and we will have to create a new segment
5381 or segments to contain the other sections.
5383 In order to save time, we allocate an array to hold the section
5384 pointers that we are interested in. As these sections get assigned
5385 to a segment, they are removed from this array. */
5387 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5388 to work around this long long bug. */
5389 amt = section_count * sizeof (asection *);
5390 sections = bfd_malloc (amt);
5391 if (sections == NULL)
5394 /* Step One: Scan for segment vs section LMA conflicts.
5395 Also add the sections to the section array allocated above.
5396 Also add the sections to the current segment. In the common
5397 case, where the sections have not been moved, this means that
5398 we have completely filled the segment, and there is nothing
5404 for (j = 0, section = ibfd->sections;
5406 section = section->next)
5408 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5410 output_section = section->output_section;
5412 sections[j ++] = section;
5414 /* The Solaris native linker always sets p_paddr to 0.
5415 We try to catch that case here, and set it to the
5416 correct value. Note - some backends require that
5417 p_paddr be left as zero. */
5418 if (segment->p_paddr == 0
5419 && segment->p_vaddr != 0
5420 && (! bed->want_p_paddr_set_to_zero)
5422 && output_section->lma != 0
5423 && (output_section->vma == (segment->p_vaddr
5424 + (map->includes_filehdr
5427 + (map->includes_phdrs
5429 * iehdr->e_phentsize)
5431 map->p_paddr = segment->p_vaddr;
5433 /* Match up the physical address of the segment with the
5434 LMA address of the output section. */
5435 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5436 || IS_COREFILE_NOTE (segment, section)
5437 || (bed->want_p_paddr_set_to_zero &&
5438 IS_CONTAINED_BY_VMA (output_section, segment))
5441 if (matching_lma == 0)
5442 matching_lma = output_section->lma;
5444 /* We assume that if the section fits within the segment
5445 then it does not overlap any other section within that
5447 map->sections[isec ++] = output_section;
5449 else if (suggested_lma == 0)
5450 suggested_lma = output_section->lma;
5454 BFD_ASSERT (j == section_count);
5456 /* Step Two: Adjust the physical address of the current segment,
5458 if (isec == section_count)
5460 /* All of the sections fitted within the segment as currently
5461 specified. This is the default case. Add the segment to
5462 the list of built segments and carry on to process the next
5463 program header in the input BFD. */
5464 map->count = section_count;
5465 *pointer_to_map = map;
5466 pointer_to_map = &map->next;
5473 if (matching_lma != 0)
5475 /* At least one section fits inside the current segment.
5476 Keep it, but modify its physical address to match the
5477 LMA of the first section that fitted. */
5478 map->p_paddr = matching_lma;
5482 /* None of the sections fitted inside the current segment.
5483 Change the current segment's physical address to match
5484 the LMA of the first section. */
5485 map->p_paddr = suggested_lma;
5488 /* Offset the segment physical address from the lma
5489 to allow for space taken up by elf headers. */
5490 if (map->includes_filehdr)
5491 map->p_paddr -= iehdr->e_ehsize;
5493 if (map->includes_phdrs)
5495 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5497 /* iehdr->e_phnum is just an estimate of the number
5498 of program headers that we will need. Make a note
5499 here of the number we used and the segment we chose
5500 to hold these headers, so that we can adjust the
5501 offset when we know the correct value. */
5502 phdr_adjust_num = iehdr->e_phnum;
5503 phdr_adjust_seg = map;
5507 /* Step Three: Loop over the sections again, this time assigning
5508 those that fit to the current segment and removing them from the
5509 sections array; but making sure not to leave large gaps. Once all
5510 possible sections have been assigned to the current segment it is
5511 added to the list of built segments and if sections still remain
5512 to be assigned, a new segment is constructed before repeating
5520 /* Fill the current segment with sections that fit. */
5521 for (j = 0; j < section_count; j++)
5523 section = sections[j];
5525 if (section == NULL)
5528 output_section = section->output_section;
5530 BFD_ASSERT (output_section != NULL);
5532 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5533 || IS_COREFILE_NOTE (segment, section))
5535 if (map->count == 0)
5537 /* If the first section in a segment does not start at
5538 the beginning of the segment, then something is
5540 if (output_section->lma !=
5542 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5543 + (map->includes_phdrs
5544 ? iehdr->e_phnum * iehdr->e_phentsize
5550 asection * prev_sec;
5552 prev_sec = map->sections[map->count - 1];
5554 /* If the gap between the end of the previous section
5555 and the start of this section is more than
5556 maxpagesize then we need to start a new segment. */
5557 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5559 < BFD_ALIGN (output_section->lma, maxpagesize))
5560 || ((prev_sec->lma + prev_sec->size)
5561 > output_section->lma))
5563 if (suggested_lma == 0)
5564 suggested_lma = output_section->lma;
5570 map->sections[map->count++] = output_section;
5573 section->segment_mark = TRUE;
5575 else if (suggested_lma == 0)
5576 suggested_lma = output_section->lma;
5579 BFD_ASSERT (map->count > 0);
5581 /* Add the current segment to the list of built segments. */
5582 *pointer_to_map = map;
5583 pointer_to_map = &map->next;
5585 if (isec < section_count)
5587 /* We still have not allocated all of the sections to
5588 segments. Create a new segment here, initialise it
5589 and carry on looping. */
5590 amt = sizeof (struct elf_segment_map);
5591 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5592 map = bfd_alloc (obfd, amt);
5599 /* Initialise the fields of the segment map. Set the physical
5600 physical address to the LMA of the first section that has
5601 not yet been assigned. */
5603 map->p_type = segment->p_type;
5604 map->p_flags = segment->p_flags;
5605 map->p_flags_valid = 1;
5606 map->p_paddr = suggested_lma;
5607 map->p_paddr_valid = 1;
5608 map->includes_filehdr = 0;
5609 map->includes_phdrs = 0;
5612 while (isec < section_count);
5617 /* The Solaris linker creates program headers in which all the
5618 p_paddr fields are zero. When we try to objcopy or strip such a
5619 file, we get confused. Check for this case, and if we find it
5620 reset the p_paddr_valid fields. */
5621 for (map = map_first; map != NULL; map = map->next)
5622 if (map->p_paddr != 0)
5625 for (map = map_first; map != NULL; map = map->next)
5626 map->p_paddr_valid = 0;
5628 elf_tdata (obfd)->segment_map = map_first;
5630 /* If we had to estimate the number of program headers that were
5631 going to be needed, then check our estimate now and adjust
5632 the offset if necessary. */
5633 if (phdr_adjust_seg != NULL)
5637 for (count = 0, map = map_first; map != NULL; map = map->next)
5640 if (count > phdr_adjust_num)
5641 phdr_adjust_seg->p_paddr
5642 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5647 #undef IS_CONTAINED_BY_VMA
5648 #undef IS_CONTAINED_BY_LMA
5649 #undef IS_COREFILE_NOTE
5650 #undef IS_SOLARIS_PT_INTERP
5651 #undef INCLUDE_SECTION_IN_SEGMENT
5652 #undef SEGMENT_AFTER_SEGMENT
5653 #undef SEGMENT_OVERLAPS
5657 /* Copy private section information. This copies over the entsize
5658 field, and sometimes the info field. */
5661 _bfd_elf_copy_private_section_data (bfd *ibfd,
5666 Elf_Internal_Shdr *ihdr, *ohdr;
5668 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5669 || obfd->xvec->flavour != bfd_target_elf_flavour)
5672 ihdr = &elf_section_data (isec)->this_hdr;
5673 ohdr = &elf_section_data (osec)->this_hdr;
5675 ohdr->sh_entsize = ihdr->sh_entsize;
5677 if (ihdr->sh_type == SHT_SYMTAB
5678 || ihdr->sh_type == SHT_DYNSYM
5679 || ihdr->sh_type == SHT_GNU_verneed
5680 || ihdr->sh_type == SHT_GNU_verdef)
5681 ohdr->sh_info = ihdr->sh_info;
5683 /* Set things up for objcopy. The output SHT_GROUP section will
5684 have its elf_next_in_group pointing back to the input group
5685 members. Ignore linker created group section. See
5686 elfNN_ia64_object_p in elfxx-ia64.c. */
5687 if (elf_sec_group (isec) == NULL
5688 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5690 elf_next_in_group (osec) = elf_next_in_group (isec);
5691 elf_group_name (osec) = elf_group_name (isec);
5694 osec->use_rela_p = isec->use_rela_p;
5699 /* Copy private header information. */
5702 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5704 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5705 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5708 /* Copy over private BFD data if it has not already been copied.
5709 This must be done here, rather than in the copy_private_bfd_data
5710 entry point, because the latter is called after the section
5711 contents have been set, which means that the program headers have
5712 already been worked out. */
5713 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5715 if (! copy_private_bfd_data (ibfd, obfd))
5722 /* Copy private symbol information. If this symbol is in a section
5723 which we did not map into a BFD section, try to map the section
5724 index correctly. We use special macro definitions for the mapped
5725 section indices; these definitions are interpreted by the
5726 swap_out_syms function. */
5728 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5729 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5730 #define MAP_STRTAB (SHN_HIOS + 3)
5731 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5732 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5735 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5740 elf_symbol_type *isym, *osym;
5742 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5743 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5746 isym = elf_symbol_from (ibfd, isymarg);
5747 osym = elf_symbol_from (obfd, osymarg);
5751 && bfd_is_abs_section (isym->symbol.section))
5755 shndx = isym->internal_elf_sym.st_shndx;
5756 if (shndx == elf_onesymtab (ibfd))
5757 shndx = MAP_ONESYMTAB;
5758 else if (shndx == elf_dynsymtab (ibfd))
5759 shndx = MAP_DYNSYMTAB;
5760 else if (shndx == elf_tdata (ibfd)->strtab_section)
5762 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5763 shndx = MAP_SHSTRTAB;
5764 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5765 shndx = MAP_SYM_SHNDX;
5766 osym->internal_elf_sym.st_shndx = shndx;
5772 /* Swap out the symbols. */
5775 swap_out_syms (bfd *abfd,
5776 struct bfd_strtab_hash **sttp,
5779 const struct elf_backend_data *bed;
5782 struct bfd_strtab_hash *stt;
5783 Elf_Internal_Shdr *symtab_hdr;
5784 Elf_Internal_Shdr *symtab_shndx_hdr;
5785 Elf_Internal_Shdr *symstrtab_hdr;
5786 bfd_byte *outbound_syms;
5787 bfd_byte *outbound_shndx;
5790 bfd_boolean name_local_sections;
5792 if (!elf_map_symbols (abfd))
5795 /* Dump out the symtabs. */
5796 stt = _bfd_elf_stringtab_init ();
5800 bed = get_elf_backend_data (abfd);
5801 symcount = bfd_get_symcount (abfd);
5802 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5803 symtab_hdr->sh_type = SHT_SYMTAB;
5804 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5805 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5806 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5807 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5809 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5810 symstrtab_hdr->sh_type = SHT_STRTAB;
5812 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5813 outbound_syms = bfd_alloc (abfd, amt);
5814 if (outbound_syms == NULL)
5816 _bfd_stringtab_free (stt);
5819 symtab_hdr->contents = outbound_syms;
5821 outbound_shndx = NULL;
5822 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5823 if (symtab_shndx_hdr->sh_name != 0)
5825 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5826 outbound_shndx = bfd_zalloc (abfd, amt);
5827 if (outbound_shndx == NULL)
5829 _bfd_stringtab_free (stt);
5833 symtab_shndx_hdr->contents = outbound_shndx;
5834 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5835 symtab_shndx_hdr->sh_size = amt;
5836 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5837 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5840 /* Now generate the data (for "contents"). */
5842 /* Fill in zeroth symbol and swap it out. */
5843 Elf_Internal_Sym sym;
5849 sym.st_shndx = SHN_UNDEF;
5850 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5851 outbound_syms += bed->s->sizeof_sym;
5852 if (outbound_shndx != NULL)
5853 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5857 = (bed->elf_backend_name_local_section_symbols
5858 && bed->elf_backend_name_local_section_symbols (abfd));
5860 syms = bfd_get_outsymbols (abfd);
5861 for (idx = 0; idx < symcount; idx++)
5863 Elf_Internal_Sym sym;
5864 bfd_vma value = syms[idx]->value;
5865 elf_symbol_type *type_ptr;
5866 flagword flags = syms[idx]->flags;
5869 if (!name_local_sections
5870 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5872 /* Local section symbols have no name. */
5877 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5880 if (sym.st_name == (unsigned long) -1)
5882 _bfd_stringtab_free (stt);
5887 type_ptr = elf_symbol_from (abfd, syms[idx]);
5889 if ((flags & BSF_SECTION_SYM) == 0
5890 && bfd_is_com_section (syms[idx]->section))
5892 /* ELF common symbols put the alignment into the `value' field,
5893 and the size into the `size' field. This is backwards from
5894 how BFD handles it, so reverse it here. */
5895 sym.st_size = value;
5896 if (type_ptr == NULL
5897 || type_ptr->internal_elf_sym.st_value == 0)
5898 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5900 sym.st_value = type_ptr->internal_elf_sym.st_value;
5901 sym.st_shndx = _bfd_elf_section_from_bfd_section
5902 (abfd, syms[idx]->section);
5906 asection *sec = syms[idx]->section;
5909 if (sec->output_section)
5911 value += sec->output_offset;
5912 sec = sec->output_section;
5915 /* Don't add in the section vma for relocatable output. */
5916 if (! relocatable_p)
5918 sym.st_value = value;
5919 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5921 if (bfd_is_abs_section (sec)
5923 && type_ptr->internal_elf_sym.st_shndx != 0)
5925 /* This symbol is in a real ELF section which we did
5926 not create as a BFD section. Undo the mapping done
5927 by copy_private_symbol_data. */
5928 shndx = type_ptr->internal_elf_sym.st_shndx;
5932 shndx = elf_onesymtab (abfd);
5935 shndx = elf_dynsymtab (abfd);
5938 shndx = elf_tdata (abfd)->strtab_section;
5941 shndx = elf_tdata (abfd)->shstrtab_section;
5944 shndx = elf_tdata (abfd)->symtab_shndx_section;
5952 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5958 /* Writing this would be a hell of a lot easier if
5959 we had some decent documentation on bfd, and
5960 knew what to expect of the library, and what to
5961 demand of applications. For example, it
5962 appears that `objcopy' might not set the
5963 section of a symbol to be a section that is
5964 actually in the output file. */
5965 sec2 = bfd_get_section_by_name (abfd, sec->name);
5968 _bfd_error_handler (_("\
5969 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5970 syms[idx]->name ? syms[idx]->name : "<Local sym>",
5972 bfd_set_error (bfd_error_invalid_operation);
5973 _bfd_stringtab_free (stt);
5977 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5978 BFD_ASSERT (shndx != -1);
5982 sym.st_shndx = shndx;
5985 if ((flags & BSF_THREAD_LOCAL) != 0)
5987 else if ((flags & BSF_FUNCTION) != 0)
5989 else if ((flags & BSF_OBJECT) != 0)
5994 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5997 /* Processor-specific types. */
5998 if (type_ptr != NULL
5999 && bed->elf_backend_get_symbol_type)
6000 type = ((*bed->elf_backend_get_symbol_type)
6001 (&type_ptr->internal_elf_sym, type));
6003 if (flags & BSF_SECTION_SYM)
6005 if (flags & BSF_GLOBAL)
6006 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6008 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6010 else if (bfd_is_com_section (syms[idx]->section))
6011 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6012 else if (bfd_is_und_section (syms[idx]->section))
6013 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6017 else if (flags & BSF_FILE)
6018 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6021 int bind = STB_LOCAL;
6023 if (flags & BSF_LOCAL)
6025 else if (flags & BSF_WEAK)
6027 else if (flags & BSF_GLOBAL)
6030 sym.st_info = ELF_ST_INFO (bind, type);
6033 if (type_ptr != NULL)
6034 sym.st_other = type_ptr->internal_elf_sym.st_other;
6038 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6039 outbound_syms += bed->s->sizeof_sym;
6040 if (outbound_shndx != NULL)
6041 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6045 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6046 symstrtab_hdr->sh_type = SHT_STRTAB;
6048 symstrtab_hdr->sh_flags = 0;
6049 symstrtab_hdr->sh_addr = 0;
6050 symstrtab_hdr->sh_entsize = 0;
6051 symstrtab_hdr->sh_link = 0;
6052 symstrtab_hdr->sh_info = 0;
6053 symstrtab_hdr->sh_addralign = 1;
6058 /* Return the number of bytes required to hold the symtab vector.
6060 Note that we base it on the count plus 1, since we will null terminate
6061 the vector allocated based on this size. However, the ELF symbol table
6062 always has a dummy entry as symbol #0, so it ends up even. */
6065 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6069 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6071 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6072 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6074 symtab_size -= sizeof (asymbol *);
6080 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6084 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6086 if (elf_dynsymtab (abfd) == 0)
6088 bfd_set_error (bfd_error_invalid_operation);
6092 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6093 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6095 symtab_size -= sizeof (asymbol *);
6101 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6104 return (asect->reloc_count + 1) * sizeof (arelent *);
6107 /* Canonicalize the relocs. */
6110 _bfd_elf_canonicalize_reloc (bfd *abfd,
6117 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6119 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6122 tblptr = section->relocation;
6123 for (i = 0; i < section->reloc_count; i++)
6124 *relptr++ = tblptr++;
6128 return section->reloc_count;
6132 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6134 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6135 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6138 bfd_get_symcount (abfd) = symcount;
6143 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6144 asymbol **allocation)
6146 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6147 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6150 bfd_get_dynamic_symcount (abfd) = symcount;
6154 /* Return the size required for the dynamic reloc entries. Any loadable
6155 section that was actually installed in the BFD, and has type SHT_REL
6156 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6157 dynamic reloc section. */
6160 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6165 if (elf_dynsymtab (abfd) == 0)
6167 bfd_set_error (bfd_error_invalid_operation);
6171 ret = sizeof (arelent *);
6172 for (s = abfd->sections; s != NULL; s = s->next)
6173 if ((s->flags & SEC_LOAD) != 0
6174 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6175 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6176 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6177 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6178 * sizeof (arelent *));
6183 /* Canonicalize the dynamic relocation entries. Note that we return the
6184 dynamic relocations as a single block, although they are actually
6185 associated with particular sections; the interface, which was
6186 designed for SunOS style shared libraries, expects that there is only
6187 one set of dynamic relocs. Any loadable section that was actually
6188 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6189 dynamic symbol table, is considered to be a dynamic reloc section. */
6192 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6196 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6200 if (elf_dynsymtab (abfd) == 0)
6202 bfd_set_error (bfd_error_invalid_operation);
6206 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6208 for (s = abfd->sections; s != NULL; s = s->next)
6210 if ((s->flags & SEC_LOAD) != 0
6211 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6212 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6213 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6218 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6220 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6222 for (i = 0; i < count; i++)
6233 /* Read in the version information. */
6236 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6238 bfd_byte *contents = NULL;
6240 unsigned int freeidx = 0;
6242 if (elf_dynverref (abfd) != 0)
6244 Elf_Internal_Shdr *hdr;
6245 Elf_External_Verneed *everneed;
6246 Elf_Internal_Verneed *iverneed;
6249 hdr = &elf_tdata (abfd)->dynverref_hdr;
6251 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
6252 elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
6253 if (elf_tdata (abfd)->verref == NULL)
6256 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6258 contents = bfd_malloc (hdr->sh_size);
6259 if (contents == NULL)
6261 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6262 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6265 everneed = (Elf_External_Verneed *) contents;
6266 iverneed = elf_tdata (abfd)->verref;
6267 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6269 Elf_External_Vernaux *evernaux;
6270 Elf_Internal_Vernaux *ivernaux;
6273 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6275 iverneed->vn_bfd = abfd;
6277 iverneed->vn_filename =
6278 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6280 if (iverneed->vn_filename == NULL)
6283 amt = iverneed->vn_cnt;
6284 amt *= sizeof (Elf_Internal_Vernaux);
6285 iverneed->vn_auxptr = bfd_alloc (abfd, amt);
6287 evernaux = ((Elf_External_Vernaux *)
6288 ((bfd_byte *) everneed + iverneed->vn_aux));
6289 ivernaux = iverneed->vn_auxptr;
6290 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6292 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6294 ivernaux->vna_nodename =
6295 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6296 ivernaux->vna_name);
6297 if (ivernaux->vna_nodename == NULL)
6300 if (j + 1 < iverneed->vn_cnt)
6301 ivernaux->vna_nextptr = ivernaux + 1;
6303 ivernaux->vna_nextptr = NULL;
6305 evernaux = ((Elf_External_Vernaux *)
6306 ((bfd_byte *) evernaux + ivernaux->vna_next));
6308 if (ivernaux->vna_other > freeidx)
6309 freeidx = ivernaux->vna_other;
6312 if (i + 1 < hdr->sh_info)
6313 iverneed->vn_nextref = iverneed + 1;
6315 iverneed->vn_nextref = NULL;
6317 everneed = ((Elf_External_Verneed *)
6318 ((bfd_byte *) everneed + iverneed->vn_next));
6325 if (elf_dynverdef (abfd) != 0)
6327 Elf_Internal_Shdr *hdr;
6328 Elf_External_Verdef *everdef;
6329 Elf_Internal_Verdef *iverdef;
6330 Elf_Internal_Verdef *iverdefarr;
6331 Elf_Internal_Verdef iverdefmem;
6333 unsigned int maxidx;
6335 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6337 contents = bfd_malloc (hdr->sh_size);
6338 if (contents == NULL)
6340 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6341 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6344 /* We know the number of entries in the section but not the maximum
6345 index. Therefore we have to run through all entries and find
6347 everdef = (Elf_External_Verdef *) contents;
6349 for (i = 0; i < hdr->sh_info; ++i)
6351 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6353 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6354 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6356 everdef = ((Elf_External_Verdef *)
6357 ((bfd_byte *) everdef + iverdefmem.vd_next));
6360 if (default_imported_symver)
6362 if (freeidx > maxidx)
6367 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
6368 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6369 if (elf_tdata (abfd)->verdef == NULL)
6372 elf_tdata (abfd)->cverdefs = maxidx;
6374 everdef = (Elf_External_Verdef *) contents;
6375 iverdefarr = elf_tdata (abfd)->verdef;
6376 for (i = 0; i < hdr->sh_info; i++)
6378 Elf_External_Verdaux *everdaux;
6379 Elf_Internal_Verdaux *iverdaux;
6382 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6384 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6385 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6387 iverdef->vd_bfd = abfd;
6389 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
6390 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6391 if (iverdef->vd_auxptr == NULL)
6394 everdaux = ((Elf_External_Verdaux *)
6395 ((bfd_byte *) everdef + iverdef->vd_aux));
6396 iverdaux = iverdef->vd_auxptr;
6397 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6399 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6401 iverdaux->vda_nodename =
6402 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6403 iverdaux->vda_name);
6404 if (iverdaux->vda_nodename == NULL)
6407 if (j + 1 < iverdef->vd_cnt)
6408 iverdaux->vda_nextptr = iverdaux + 1;
6410 iverdaux->vda_nextptr = NULL;
6412 everdaux = ((Elf_External_Verdaux *)
6413 ((bfd_byte *) everdaux + iverdaux->vda_next));
6416 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6418 if (i + 1 < hdr->sh_info)
6419 iverdef->vd_nextdef = iverdef + 1;
6421 iverdef->vd_nextdef = NULL;
6423 everdef = ((Elf_External_Verdef *)
6424 ((bfd_byte *) everdef + iverdef->vd_next));
6430 else if (default_imported_symver)
6437 amt = (bfd_size_type) freeidx * sizeof (Elf_Internal_Verdef);
6438 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6439 if (elf_tdata (abfd)->verdef == NULL)
6442 elf_tdata (abfd)->cverdefs = freeidx;
6445 /* Create a default version based on the soname. */
6446 if (default_imported_symver)
6448 Elf_Internal_Verdef *iverdef;
6449 Elf_Internal_Verdaux *iverdaux;
6451 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6453 iverdef->vd_version = VER_DEF_CURRENT;
6454 iverdef->vd_flags = 0;
6455 iverdef->vd_ndx = freeidx;
6456 iverdef->vd_cnt = 1;
6458 iverdef->vd_bfd = abfd;
6460 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6461 if (iverdef->vd_nodename == NULL)
6463 iverdef->vd_nextdef = NULL;
6464 amt = (bfd_size_type) sizeof (Elf_Internal_Verdaux);
6465 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6467 iverdaux = iverdef->vd_auxptr;
6468 iverdaux->vda_nodename = iverdef->vd_nodename;
6469 iverdaux->vda_nextptr = NULL;
6475 if (contents != NULL)
6481 _bfd_elf_make_empty_symbol (bfd *abfd)
6483 elf_symbol_type *newsym;
6484 bfd_size_type amt = sizeof (elf_symbol_type);
6486 newsym = bfd_zalloc (abfd, amt);
6491 newsym->symbol.the_bfd = abfd;
6492 return &newsym->symbol;
6497 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6501 bfd_symbol_info (symbol, ret);
6504 /* Return whether a symbol name implies a local symbol. Most targets
6505 use this function for the is_local_label_name entry point, but some
6509 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6512 /* Normal local symbols start with ``.L''. */
6513 if (name[0] == '.' && name[1] == 'L')
6516 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6517 DWARF debugging symbols starting with ``..''. */
6518 if (name[0] == '.' && name[1] == '.')
6521 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6522 emitting DWARF debugging output. I suspect this is actually a
6523 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6524 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6525 underscore to be emitted on some ELF targets). For ease of use,
6526 we treat such symbols as local. */
6527 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6534 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6535 asymbol *symbol ATTRIBUTE_UNUSED)
6542 _bfd_elf_set_arch_mach (bfd *abfd,
6543 enum bfd_architecture arch,
6544 unsigned long machine)
6546 /* If this isn't the right architecture for this backend, and this
6547 isn't the generic backend, fail. */
6548 if (arch != get_elf_backend_data (abfd)->arch
6549 && arch != bfd_arch_unknown
6550 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6553 return bfd_default_set_arch_mach (abfd, arch, machine);
6556 /* Find the function to a particular section and offset,
6557 for error reporting. */
6560 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6564 const char **filename_ptr,
6565 const char **functionname_ptr)
6567 const char *filename;
6568 asymbol *func, *file;
6571 /* ??? Given multiple file symbols, it is impossible to reliably
6572 choose the right file name for global symbols. File symbols are
6573 local symbols, and thus all file symbols must sort before any
6574 global symbols. The ELF spec may be interpreted to say that a
6575 file symbol must sort before other local symbols, but currently
6576 ld -r doesn't do this. So, for ld -r output, it is possible to
6577 make a better choice of file name for local symbols by ignoring
6578 file symbols appearing after a given local symbol. */
6579 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6585 state = nothing_seen;
6587 for (p = symbols; *p != NULL; p++)
6591 q = (elf_symbol_type *) *p;
6593 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6599 if (state == symbol_seen)
6600 state = file_after_symbol_seen;
6606 if (bfd_get_section (&q->symbol) == section
6607 && q->symbol.value >= low_func
6608 && q->symbol.value <= offset)
6610 func = (asymbol *) q;
6611 low_func = q->symbol.value;
6614 else if (ELF_ST_BIND (q->internal_elf_sym.st_info) != STB_LOCAL
6615 && state == file_after_symbol_seen)
6618 filename = bfd_asymbol_name (file);
6622 if (state == nothing_seen)
6623 state = symbol_seen;
6630 *filename_ptr = filename;
6631 if (functionname_ptr)
6632 *functionname_ptr = bfd_asymbol_name (func);
6637 /* Find the nearest line to a particular section and offset,
6638 for error reporting. */
6641 _bfd_elf_find_nearest_line (bfd *abfd,
6645 const char **filename_ptr,
6646 const char **functionname_ptr,
6647 unsigned int *line_ptr)
6651 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6652 filename_ptr, functionname_ptr,
6655 if (!*functionname_ptr)
6656 elf_find_function (abfd, section, symbols, offset,
6657 *filename_ptr ? NULL : filename_ptr,
6663 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6664 filename_ptr, functionname_ptr,
6666 &elf_tdata (abfd)->dwarf2_find_line_info))
6668 if (!*functionname_ptr)
6669 elf_find_function (abfd, section, symbols, offset,
6670 *filename_ptr ? NULL : filename_ptr,
6676 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6677 &found, filename_ptr,
6678 functionname_ptr, line_ptr,
6679 &elf_tdata (abfd)->line_info))
6681 if (found && (*functionname_ptr || *line_ptr))
6684 if (symbols == NULL)
6687 if (! elf_find_function (abfd, section, symbols, offset,
6688 filename_ptr, functionname_ptr))
6695 /* Find the line for a symbol. */
6698 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
6699 const char **filename_ptr, unsigned int *line_ptr)
6701 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
6702 filename_ptr, line_ptr, 0,
6703 &elf_tdata (abfd)->dwarf2_find_line_info);
6706 /* After a call to bfd_find_nearest_line, successive calls to
6707 bfd_find_inliner_info can be used to get source information about
6708 each level of function inlining that terminated at the address
6709 passed to bfd_find_nearest_line. Currently this is only supported
6710 for DWARF2 with appropriate DWARF3 extensions. */
6713 _bfd_elf_find_inliner_info (bfd *abfd,
6714 const char **filename_ptr,
6715 const char **functionname_ptr,
6716 unsigned int *line_ptr)
6719 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6720 functionname_ptr, line_ptr,
6721 & elf_tdata (abfd)->dwarf2_find_line_info);
6726 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
6730 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6732 ret += get_program_header_size (abfd);
6737 _bfd_elf_set_section_contents (bfd *abfd,
6739 const void *location,
6741 bfd_size_type count)
6743 Elf_Internal_Shdr *hdr;
6746 if (! abfd->output_has_begun
6747 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6750 hdr = &elf_section_data (section)->this_hdr;
6751 pos = hdr->sh_offset + offset;
6752 if (bfd_seek (abfd, pos, SEEK_SET) != 0
6753 || bfd_bwrite (location, count, abfd) != count)
6760 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6761 arelent *cache_ptr ATTRIBUTE_UNUSED,
6762 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6767 /* Try to convert a non-ELF reloc into an ELF one. */
6770 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6772 /* Check whether we really have an ELF howto. */
6774 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6776 bfd_reloc_code_real_type code;
6777 reloc_howto_type *howto;
6779 /* Alien reloc: Try to determine its type to replace it with an
6780 equivalent ELF reloc. */
6782 if (areloc->howto->pc_relative)
6784 switch (areloc->howto->bitsize)
6787 code = BFD_RELOC_8_PCREL;
6790 code = BFD_RELOC_12_PCREL;
6793 code = BFD_RELOC_16_PCREL;
6796 code = BFD_RELOC_24_PCREL;
6799 code = BFD_RELOC_32_PCREL;
6802 code = BFD_RELOC_64_PCREL;
6808 howto = bfd_reloc_type_lookup (abfd, code);
6810 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6812 if (howto->pcrel_offset)
6813 areloc->addend += areloc->address;
6815 areloc->addend -= areloc->address; /* addend is unsigned!! */
6820 switch (areloc->howto->bitsize)
6826 code = BFD_RELOC_14;
6829 code = BFD_RELOC_16;
6832 code = BFD_RELOC_26;
6835 code = BFD_RELOC_32;
6838 code = BFD_RELOC_64;
6844 howto = bfd_reloc_type_lookup (abfd, code);
6848 areloc->howto = howto;
6856 (*_bfd_error_handler)
6857 (_("%B: unsupported relocation type %s"),
6858 abfd, areloc->howto->name);
6859 bfd_set_error (bfd_error_bad_value);
6864 _bfd_elf_close_and_cleanup (bfd *abfd)
6866 if (bfd_get_format (abfd) == bfd_object)
6868 if (elf_shstrtab (abfd) != NULL)
6869 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6870 _bfd_dwarf2_cleanup_debug_info (abfd);
6873 return _bfd_generic_close_and_cleanup (abfd);
6876 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6877 in the relocation's offset. Thus we cannot allow any sort of sanity
6878 range-checking to interfere. There is nothing else to do in processing
6881 bfd_reloc_status_type
6882 _bfd_elf_rel_vtable_reloc_fn
6883 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
6884 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
6885 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6886 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
6888 return bfd_reloc_ok;
6891 /* Elf core file support. Much of this only works on native
6892 toolchains, since we rely on knowing the
6893 machine-dependent procfs structure in order to pick
6894 out details about the corefile. */
6896 #ifdef HAVE_SYS_PROCFS_H
6897 # include <sys/procfs.h>
6900 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6903 elfcore_make_pid (bfd *abfd)
6905 return ((elf_tdata (abfd)->core_lwpid << 16)
6906 + (elf_tdata (abfd)->core_pid));
6909 /* If there isn't a section called NAME, make one, using
6910 data from SECT. Note, this function will generate a
6911 reference to NAME, so you shouldn't deallocate or
6915 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
6919 if (bfd_get_section_by_name (abfd, name) != NULL)
6922 sect2 = bfd_make_section (abfd, name);
6926 sect2->size = sect->size;
6927 sect2->filepos = sect->filepos;
6928 sect2->flags = sect->flags;
6929 sect2->alignment_power = sect->alignment_power;
6933 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6934 actually creates up to two pseudosections:
6935 - For the single-threaded case, a section named NAME, unless
6936 such a section already exists.
6937 - For the multi-threaded case, a section named "NAME/PID", where
6938 PID is elfcore_make_pid (abfd).
6939 Both pseudosections have identical contents. */
6941 _bfd_elfcore_make_pseudosection (bfd *abfd,
6947 char *threaded_name;
6951 /* Build the section name. */
6953 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6954 len = strlen (buf) + 1;
6955 threaded_name = bfd_alloc (abfd, len);
6956 if (threaded_name == NULL)
6958 memcpy (threaded_name, buf, len);
6960 sect = bfd_make_section_anyway (abfd, threaded_name);
6964 sect->filepos = filepos;
6965 sect->flags = SEC_HAS_CONTENTS;
6966 sect->alignment_power = 2;
6968 return elfcore_maybe_make_sect (abfd, name, sect);
6971 /* prstatus_t exists on:
6973 linux 2.[01] + glibc
6977 #if defined (HAVE_PRSTATUS_T)
6980 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6985 if (note->descsz == sizeof (prstatus_t))
6989 size = sizeof (prstat.pr_reg);
6990 offset = offsetof (prstatus_t, pr_reg);
6991 memcpy (&prstat, note->descdata, sizeof (prstat));
6993 /* Do not overwrite the core signal if it
6994 has already been set by another thread. */
6995 if (elf_tdata (abfd)->core_signal == 0)
6996 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6997 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6999 /* pr_who exists on:
7002 pr_who doesn't exist on:
7005 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7006 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7009 #if defined (HAVE_PRSTATUS32_T)
7010 else if (note->descsz == sizeof (prstatus32_t))
7012 /* 64-bit host, 32-bit corefile */
7013 prstatus32_t prstat;
7015 size = sizeof (prstat.pr_reg);
7016 offset = offsetof (prstatus32_t, pr_reg);
7017 memcpy (&prstat, note->descdata, sizeof (prstat));
7019 /* Do not overwrite the core signal if it
7020 has already been set by another thread. */
7021 if (elf_tdata (abfd)->core_signal == 0)
7022 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7023 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7025 /* pr_who exists on:
7028 pr_who doesn't exist on:
7031 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7032 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7035 #endif /* HAVE_PRSTATUS32_T */
7038 /* Fail - we don't know how to handle any other
7039 note size (ie. data object type). */
7043 /* Make a ".reg/999" section and a ".reg" section. */
7044 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7045 size, note->descpos + offset);
7047 #endif /* defined (HAVE_PRSTATUS_T) */
7049 /* Create a pseudosection containing the exact contents of NOTE. */
7051 elfcore_make_note_pseudosection (bfd *abfd,
7053 Elf_Internal_Note *note)
7055 return _bfd_elfcore_make_pseudosection (abfd, name,
7056 note->descsz, note->descpos);
7059 /* There isn't a consistent prfpregset_t across platforms,
7060 but it doesn't matter, because we don't have to pick this
7061 data structure apart. */
7064 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7066 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7069 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7070 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7074 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7076 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7079 #if defined (HAVE_PRPSINFO_T)
7080 typedef prpsinfo_t elfcore_psinfo_t;
7081 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7082 typedef prpsinfo32_t elfcore_psinfo32_t;
7086 #if defined (HAVE_PSINFO_T)
7087 typedef psinfo_t elfcore_psinfo_t;
7088 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7089 typedef psinfo32_t elfcore_psinfo32_t;
7093 /* return a malloc'ed copy of a string at START which is at
7094 most MAX bytes long, possibly without a terminating '\0'.
7095 the copy will always have a terminating '\0'. */
7098 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7101 char *end = memchr (start, '\0', max);
7109 dups = bfd_alloc (abfd, len + 1);
7113 memcpy (dups, start, len);
7119 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7121 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7123 if (note->descsz == sizeof (elfcore_psinfo_t))
7125 elfcore_psinfo_t psinfo;
7127 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7129 elf_tdata (abfd)->core_program
7130 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7131 sizeof (psinfo.pr_fname));
7133 elf_tdata (abfd)->core_command
7134 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7135 sizeof (psinfo.pr_psargs));
7137 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7138 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7140 /* 64-bit host, 32-bit corefile */
7141 elfcore_psinfo32_t psinfo;
7143 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7145 elf_tdata (abfd)->core_program
7146 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7147 sizeof (psinfo.pr_fname));
7149 elf_tdata (abfd)->core_command
7150 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7151 sizeof (psinfo.pr_psargs));
7157 /* Fail - we don't know how to handle any other
7158 note size (ie. data object type). */
7162 /* Note that for some reason, a spurious space is tacked
7163 onto the end of the args in some (at least one anyway)
7164 implementations, so strip it off if it exists. */
7167 char *command = elf_tdata (abfd)->core_command;
7168 int n = strlen (command);
7170 if (0 < n && command[n - 1] == ' ')
7171 command[n - 1] = '\0';
7176 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7178 #if defined (HAVE_PSTATUS_T)
7180 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7182 if (note->descsz == sizeof (pstatus_t)
7183 #if defined (HAVE_PXSTATUS_T)
7184 || note->descsz == sizeof (pxstatus_t)
7190 memcpy (&pstat, note->descdata, sizeof (pstat));
7192 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7194 #if defined (HAVE_PSTATUS32_T)
7195 else if (note->descsz == sizeof (pstatus32_t))
7197 /* 64-bit host, 32-bit corefile */
7200 memcpy (&pstat, note->descdata, sizeof (pstat));
7202 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7205 /* Could grab some more details from the "representative"
7206 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7207 NT_LWPSTATUS note, presumably. */
7211 #endif /* defined (HAVE_PSTATUS_T) */
7213 #if defined (HAVE_LWPSTATUS_T)
7215 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7217 lwpstatus_t lwpstat;
7223 if (note->descsz != sizeof (lwpstat)
7224 #if defined (HAVE_LWPXSTATUS_T)
7225 && note->descsz != sizeof (lwpxstatus_t)
7230 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7232 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7233 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7235 /* Make a ".reg/999" section. */
7237 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7238 len = strlen (buf) + 1;
7239 name = bfd_alloc (abfd, len);
7242 memcpy (name, buf, len);
7244 sect = bfd_make_section_anyway (abfd, name);
7248 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7249 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7250 sect->filepos = note->descpos
7251 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7254 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7255 sect->size = sizeof (lwpstat.pr_reg);
7256 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7259 sect->flags = SEC_HAS_CONTENTS;
7260 sect->alignment_power = 2;
7262 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7265 /* Make a ".reg2/999" section */
7267 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7268 len = strlen (buf) + 1;
7269 name = bfd_alloc (abfd, len);
7272 memcpy (name, buf, len);
7274 sect = bfd_make_section_anyway (abfd, name);
7278 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7279 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7280 sect->filepos = note->descpos
7281 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7284 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7285 sect->size = sizeof (lwpstat.pr_fpreg);
7286 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7289 sect->flags = SEC_HAS_CONTENTS;
7290 sect->alignment_power = 2;
7292 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7294 #endif /* defined (HAVE_LWPSTATUS_T) */
7296 #if defined (HAVE_WIN32_PSTATUS_T)
7298 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7304 win32_pstatus_t pstatus;
7306 if (note->descsz < sizeof (pstatus))
7309 memcpy (&pstatus, note->descdata, sizeof (pstatus));
7311 switch (pstatus.data_type)
7313 case NOTE_INFO_PROCESS:
7314 /* FIXME: need to add ->core_command. */
7315 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7316 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7319 case NOTE_INFO_THREAD:
7320 /* Make a ".reg/999" section. */
7321 sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
7323 len = strlen (buf) + 1;
7324 name = bfd_alloc (abfd, len);
7328 memcpy (name, buf, len);
7330 sect = bfd_make_section_anyway (abfd, name);
7334 sect->size = sizeof (pstatus.data.thread_info.thread_context);
7335 sect->filepos = (note->descpos
7336 + offsetof (struct win32_pstatus,
7337 data.thread_info.thread_context));
7338 sect->flags = SEC_HAS_CONTENTS;
7339 sect->alignment_power = 2;
7341 if (pstatus.data.thread_info.is_active_thread)
7342 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7346 case NOTE_INFO_MODULE:
7347 /* Make a ".module/xxxxxxxx" section. */
7348 sprintf (buf, ".module/%08lx",
7349 (long) pstatus.data.module_info.base_address);
7351 len = strlen (buf) + 1;
7352 name = bfd_alloc (abfd, len);
7356 memcpy (name, buf, len);
7358 sect = bfd_make_section_anyway (abfd, name);
7363 sect->size = note->descsz;
7364 sect->filepos = note->descpos;
7365 sect->flags = SEC_HAS_CONTENTS;
7366 sect->alignment_power = 2;
7375 #endif /* HAVE_WIN32_PSTATUS_T */
7378 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7380 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7388 if (bed->elf_backend_grok_prstatus)
7389 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7391 #if defined (HAVE_PRSTATUS_T)
7392 return elfcore_grok_prstatus (abfd, note);
7397 #if defined (HAVE_PSTATUS_T)
7399 return elfcore_grok_pstatus (abfd, note);
7402 #if defined (HAVE_LWPSTATUS_T)
7404 return elfcore_grok_lwpstatus (abfd, note);
7407 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7408 return elfcore_grok_prfpreg (abfd, note);
7410 #if defined (HAVE_WIN32_PSTATUS_T)
7411 case NT_WIN32PSTATUS:
7412 return elfcore_grok_win32pstatus (abfd, note);
7415 case NT_PRXFPREG: /* Linux SSE extension */
7416 if (note->namesz == 6
7417 && strcmp (note->namedata, "LINUX") == 0)
7418 return elfcore_grok_prxfpreg (abfd, note);
7424 if (bed->elf_backend_grok_psinfo)
7425 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7427 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7428 return elfcore_grok_psinfo (abfd, note);
7435 asection *sect = bfd_make_section_anyway (abfd, ".auxv");
7439 sect->size = note->descsz;
7440 sect->filepos = note->descpos;
7441 sect->flags = SEC_HAS_CONTENTS;
7442 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7450 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7454 cp = strchr (note->namedata, '@');
7457 *lwpidp = atoi(cp + 1);
7464 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7467 /* Signal number at offset 0x08. */
7468 elf_tdata (abfd)->core_signal
7469 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7471 /* Process ID at offset 0x50. */
7472 elf_tdata (abfd)->core_pid
7473 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7475 /* Command name at 0x7c (max 32 bytes, including nul). */
7476 elf_tdata (abfd)->core_command
7477 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7479 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7484 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7488 if (elfcore_netbsd_get_lwpid (note, &lwp))
7489 elf_tdata (abfd)->core_lwpid = lwp;
7491 if (note->type == NT_NETBSDCORE_PROCINFO)
7493 /* NetBSD-specific core "procinfo". Note that we expect to
7494 find this note before any of the others, which is fine,
7495 since the kernel writes this note out first when it
7496 creates a core file. */
7498 return elfcore_grok_netbsd_procinfo (abfd, note);
7501 /* As of Jan 2002 there are no other machine-independent notes
7502 defined for NetBSD core files. If the note type is less
7503 than the start of the machine-dependent note types, we don't
7506 if (note->type < NT_NETBSDCORE_FIRSTMACH)
7510 switch (bfd_get_arch (abfd))
7512 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7513 PT_GETFPREGS == mach+2. */
7515 case bfd_arch_alpha:
7516 case bfd_arch_sparc:
7519 case NT_NETBSDCORE_FIRSTMACH+0:
7520 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7522 case NT_NETBSDCORE_FIRSTMACH+2:
7523 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7529 /* On all other arch's, PT_GETREGS == mach+1 and
7530 PT_GETFPREGS == mach+3. */
7535 case NT_NETBSDCORE_FIRSTMACH+1:
7536 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7538 case NT_NETBSDCORE_FIRSTMACH+3:
7539 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7549 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
7551 void *ddata = note->descdata;
7558 /* nto_procfs_status 'pid' field is at offset 0. */
7559 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7561 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7562 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7564 /* nto_procfs_status 'flags' field is at offset 8. */
7565 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7567 /* nto_procfs_status 'what' field is at offset 14. */
7568 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7570 elf_tdata (abfd)->core_signal = sig;
7571 elf_tdata (abfd)->core_lwpid = *tid;
7574 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7575 do not come from signals so we make sure we set the current
7576 thread just in case. */
7577 if (flags & 0x00000080)
7578 elf_tdata (abfd)->core_lwpid = *tid;
7580 /* Make a ".qnx_core_status/%d" section. */
7581 sprintf (buf, ".qnx_core_status/%ld", (long) *tid);
7583 name = bfd_alloc (abfd, strlen (buf) + 1);
7588 sect = bfd_make_section_anyway (abfd, name);
7592 sect->size = note->descsz;
7593 sect->filepos = note->descpos;
7594 sect->flags = SEC_HAS_CONTENTS;
7595 sect->alignment_power = 2;
7597 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7601 elfcore_grok_nto_regs (bfd *abfd,
7602 Elf_Internal_Note *note,
7610 /* Make a "(base)/%d" section. */
7611 sprintf (buf, "%s/%ld", base, (long) tid);
7613 name = bfd_alloc (abfd, strlen (buf) + 1);
7618 sect = bfd_make_section_anyway (abfd, name);
7622 sect->size = note->descsz;
7623 sect->filepos = note->descpos;
7624 sect->flags = SEC_HAS_CONTENTS;
7625 sect->alignment_power = 2;
7627 /* This is the current thread. */
7628 if (elf_tdata (abfd)->core_lwpid == tid)
7629 return elfcore_maybe_make_sect (abfd, base, sect);
7634 #define BFD_QNT_CORE_INFO 7
7635 #define BFD_QNT_CORE_STATUS 8
7636 #define BFD_QNT_CORE_GREG 9
7637 #define BFD_QNT_CORE_FPREG 10
7640 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
7642 /* Every GREG section has a STATUS section before it. Store the
7643 tid from the previous call to pass down to the next gregs
7645 static pid_t tid = 1;
7649 case BFD_QNT_CORE_INFO:
7650 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7651 case BFD_QNT_CORE_STATUS:
7652 return elfcore_grok_nto_status (abfd, note, &tid);
7653 case BFD_QNT_CORE_GREG:
7654 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
7655 case BFD_QNT_CORE_FPREG:
7656 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
7662 /* Function: elfcore_write_note
7669 size of data for note
7672 End of buffer containing note. */
7675 elfcore_write_note (bfd *abfd,
7683 Elf_External_Note *xnp;
7693 const struct elf_backend_data *bed;
7695 namesz = strlen (name) + 1;
7696 bed = get_elf_backend_data (abfd);
7697 pad = -namesz & ((1 << bed->s->log_file_align) - 1);
7700 newspace = 12 + namesz + pad + size;
7702 p = realloc (buf, *bufsiz + newspace);
7704 *bufsiz += newspace;
7705 xnp = (Elf_External_Note *) dest;
7706 H_PUT_32 (abfd, namesz, xnp->namesz);
7707 H_PUT_32 (abfd, size, xnp->descsz);
7708 H_PUT_32 (abfd, type, xnp->type);
7712 memcpy (dest, name, namesz);
7720 memcpy (dest, input, size);
7724 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7726 elfcore_write_prpsinfo (bfd *abfd,
7733 char *note_name = "CORE";
7735 #if defined (HAVE_PSINFO_T)
7737 note_type = NT_PSINFO;
7740 note_type = NT_PRPSINFO;
7743 memset (&data, 0, sizeof (data));
7744 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7745 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7746 return elfcore_write_note (abfd, buf, bufsiz,
7747 note_name, note_type, &data, sizeof (data));
7749 #endif /* PSINFO_T or PRPSINFO_T */
7751 #if defined (HAVE_PRSTATUS_T)
7753 elfcore_write_prstatus (bfd *abfd,
7761 char *note_name = "CORE";
7763 memset (&prstat, 0, sizeof (prstat));
7764 prstat.pr_pid = pid;
7765 prstat.pr_cursig = cursig;
7766 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7767 return elfcore_write_note (abfd, buf, bufsiz,
7768 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7770 #endif /* HAVE_PRSTATUS_T */
7772 #if defined (HAVE_LWPSTATUS_T)
7774 elfcore_write_lwpstatus (bfd *abfd,
7781 lwpstatus_t lwpstat;
7782 char *note_name = "CORE";
7784 memset (&lwpstat, 0, sizeof (lwpstat));
7785 lwpstat.pr_lwpid = pid >> 16;
7786 lwpstat.pr_cursig = cursig;
7787 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7788 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7789 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7791 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7792 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7794 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7795 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7798 return elfcore_write_note (abfd, buf, bufsiz, note_name,
7799 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7801 #endif /* HAVE_LWPSTATUS_T */
7803 #if defined (HAVE_PSTATUS_T)
7805 elfcore_write_pstatus (bfd *abfd,
7813 char *note_name = "CORE";
7815 memset (&pstat, 0, sizeof (pstat));
7816 pstat.pr_pid = pid & 0xffff;
7817 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7818 NT_PSTATUS, &pstat, sizeof (pstat));
7821 #endif /* HAVE_PSTATUS_T */
7824 elfcore_write_prfpreg (bfd *abfd,
7830 char *note_name = "CORE";
7831 return elfcore_write_note (abfd, buf, bufsiz,
7832 note_name, NT_FPREGSET, fpregs, size);
7836 elfcore_write_prxfpreg (bfd *abfd,
7839 const void *xfpregs,
7842 char *note_name = "LINUX";
7843 return elfcore_write_note (abfd, buf, bufsiz,
7844 note_name, NT_PRXFPREG, xfpregs, size);
7848 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
7856 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7859 buf = bfd_malloc (size);
7863 if (bfd_bread (buf, size, abfd) != size)
7871 while (p < buf + size)
7873 /* FIXME: bad alignment assumption. */
7874 Elf_External_Note *xnp = (Elf_External_Note *) p;
7875 Elf_Internal_Note in;
7877 in.type = H_GET_32 (abfd, xnp->type);
7879 in.namesz = H_GET_32 (abfd, xnp->namesz);
7880 in.namedata = xnp->name;
7882 in.descsz = H_GET_32 (abfd, xnp->descsz);
7883 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7884 in.descpos = offset + (in.descdata - buf);
7886 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7888 if (! elfcore_grok_netbsd_note (abfd, &in))
7891 else if (strncmp (in.namedata, "QNX", 3) == 0)
7893 if (! elfcore_grok_nto_note (abfd, &in))
7898 if (! elfcore_grok_note (abfd, &in))
7902 p = in.descdata + BFD_ALIGN (in.descsz, 4);
7909 /* Providing external access to the ELF program header table. */
7911 /* Return an upper bound on the number of bytes required to store a
7912 copy of ABFD's program header table entries. Return -1 if an error
7913 occurs; bfd_get_error will return an appropriate code. */
7916 bfd_get_elf_phdr_upper_bound (bfd *abfd)
7918 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7920 bfd_set_error (bfd_error_wrong_format);
7924 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7927 /* Copy ABFD's program header table entries to *PHDRS. The entries
7928 will be stored as an array of Elf_Internal_Phdr structures, as
7929 defined in include/elf/internal.h. To find out how large the
7930 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7932 Return the number of program header table entries read, or -1 if an
7933 error occurs; bfd_get_error will return an appropriate code. */
7936 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
7940 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7942 bfd_set_error (bfd_error_wrong_format);
7946 num_phdrs = elf_elfheader (abfd)->e_phnum;
7947 memcpy (phdrs, elf_tdata (abfd)->phdr,
7948 num_phdrs * sizeof (Elf_Internal_Phdr));
7954 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
7957 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7959 i_ehdrp = elf_elfheader (abfd);
7960 if (i_ehdrp == NULL)
7961 sprintf_vma (buf, value);
7964 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7966 #if BFD_HOST_64BIT_LONG
7967 sprintf (buf, "%016lx", value);
7969 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7970 _bfd_int64_low (value));
7974 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7977 sprintf_vma (buf, value);
7982 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
7985 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7987 i_ehdrp = elf_elfheader (abfd);
7988 if (i_ehdrp == NULL)
7989 fprintf_vma ((FILE *) stream, value);
7992 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7994 #if BFD_HOST_64BIT_LONG
7995 fprintf ((FILE *) stream, "%016lx", value);
7997 fprintf ((FILE *) stream, "%08lx%08lx",
7998 _bfd_int64_high (value), _bfd_int64_low (value));
8002 fprintf ((FILE *) stream, "%08lx",
8003 (unsigned long) (value & 0xffffffff));
8006 fprintf_vma ((FILE *) stream, value);
8010 enum elf_reloc_type_class
8011 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8013 return reloc_class_normal;
8016 /* For RELA architectures, return the relocation value for a
8017 relocation against a local symbol. */
8020 _bfd_elf_rela_local_sym (bfd *abfd,
8021 Elf_Internal_Sym *sym,
8023 Elf_Internal_Rela *rel)
8025 asection *sec = *psec;
8028 relocation = (sec->output_section->vma
8029 + sec->output_offset
8031 if ((sec->flags & SEC_MERGE)
8032 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8033 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8036 _bfd_merged_section_offset (abfd, psec,
8037 elf_section_data (sec)->sec_info,
8038 sym->st_value + rel->r_addend);
8041 /* If we have changed the section, and our original section is
8042 marked with SEC_EXCLUDE, it means that the original
8043 SEC_MERGE section has been completely subsumed in some
8044 other SEC_MERGE section. In this case, we need to leave
8045 some info around for --emit-relocs. */
8046 if ((sec->flags & SEC_EXCLUDE) != 0)
8047 sec->kept_section = *psec;
8050 rel->r_addend -= relocation;
8051 rel->r_addend += sec->output_section->vma + sec->output_offset;
8057 _bfd_elf_rel_local_sym (bfd *abfd,
8058 Elf_Internal_Sym *sym,
8062 asection *sec = *psec;
8064 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8065 return sym->st_value + addend;
8067 return _bfd_merged_section_offset (abfd, psec,
8068 elf_section_data (sec)->sec_info,
8069 sym->st_value + addend);
8073 _bfd_elf_section_offset (bfd *abfd,
8074 struct bfd_link_info *info,
8078 switch (sec->sec_info_type)
8080 case ELF_INFO_TYPE_STABS:
8081 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8083 case ELF_INFO_TYPE_EH_FRAME:
8084 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8090 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8091 reconstruct an ELF file by reading the segments out of remote memory
8092 based on the ELF file header at EHDR_VMA and the ELF program headers it
8093 points to. If not null, *LOADBASEP is filled in with the difference
8094 between the VMAs from which the segments were read, and the VMAs the
8095 file headers (and hence BFD's idea of each section's VMA) put them at.
8097 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8098 remote memory at target address VMA into the local buffer at MYADDR; it
8099 should return zero on success or an `errno' code on failure. TEMPL must
8100 be a BFD for an ELF target with the word size and byte order found in
8101 the remote memory. */
8104 bfd_elf_bfd_from_remote_memory
8108 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8110 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8111 (templ, ehdr_vma, loadbasep, target_read_memory);
8115 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8116 long symcount ATTRIBUTE_UNUSED,
8117 asymbol **syms ATTRIBUTE_UNUSED,
8122 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8125 const char *relplt_name;
8126 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8130 Elf_Internal_Shdr *hdr;
8136 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8139 if (dynsymcount <= 0)
8142 if (!bed->plt_sym_val)
8145 relplt_name = bed->relplt_name;
8146 if (relplt_name == NULL)
8147 relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8148 relplt = bfd_get_section_by_name (abfd, relplt_name);
8152 hdr = &elf_section_data (relplt)->this_hdr;
8153 if (hdr->sh_link != elf_dynsymtab (abfd)
8154 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8157 plt = bfd_get_section_by_name (abfd, ".plt");
8161 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8162 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8165 count = relplt->size / hdr->sh_entsize;
8166 size = count * sizeof (asymbol);
8167 p = relplt->relocation;
8168 for (i = 0; i < count; i++, s++, p++)
8169 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8171 s = *ret = bfd_malloc (size);
8175 names = (char *) (s + count);
8176 p = relplt->relocation;
8178 for (i = 0; i < count; i++, s++, p++)
8183 addr = bed->plt_sym_val (i, plt, p);
8184 if (addr == (bfd_vma) -1)
8187 *s = **p->sym_ptr_ptr;
8189 s->value = addr - plt->vma;
8191 len = strlen ((*p->sym_ptr_ptr)->name);
8192 memcpy (names, (*p->sym_ptr_ptr)->name, len);
8194 memcpy (names, "@plt", sizeof ("@plt"));
8195 names += sizeof ("@plt");
8202 /* Sort symbol by binding and section. We want to put definitions
8203 sorted by section at the beginning. */
8206 elf_sort_elf_symbol (const void *arg1, const void *arg2)
8208 const Elf_Internal_Sym *s1;
8209 const Elf_Internal_Sym *s2;
8212 /* Make sure that undefined symbols are at the end. */
8213 s1 = (const Elf_Internal_Sym *) arg1;
8214 if (s1->st_shndx == SHN_UNDEF)
8216 s2 = (const Elf_Internal_Sym *) arg2;
8217 if (s2->st_shndx == SHN_UNDEF)
8220 /* Sorted by section index. */
8221 shndx = s1->st_shndx - s2->st_shndx;
8225 /* Sorted by binding. */
8226 return ELF_ST_BIND (s1->st_info) - ELF_ST_BIND (s2->st_info);
8231 Elf_Internal_Sym *sym;
8236 elf_sym_name_compare (const void *arg1, const void *arg2)
8238 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
8239 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
8240 return strcmp (s1->name, s2->name);
8243 /* Check if 2 sections define the same set of local and global
8247 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2)
8250 const struct elf_backend_data *bed1, *bed2;
8251 Elf_Internal_Shdr *hdr1, *hdr2;
8252 bfd_size_type symcount1, symcount2;
8253 Elf_Internal_Sym *isymbuf1, *isymbuf2;
8254 Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
8255 Elf_Internal_Sym *isymend;
8256 struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
8257 bfd_size_type count1, count2, i;
8264 /* If both are .gnu.linkonce sections, they have to have the same
8266 if (strncmp (sec1->name, ".gnu.linkonce",
8267 sizeof ".gnu.linkonce" - 1) == 0
8268 && strncmp (sec2->name, ".gnu.linkonce",
8269 sizeof ".gnu.linkonce" - 1) == 0)
8270 return strcmp (sec1->name + sizeof ".gnu.linkonce",
8271 sec2->name + sizeof ".gnu.linkonce") == 0;
8273 /* Both sections have to be in ELF. */
8274 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8275 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8278 if (elf_section_type (sec1) != elf_section_type (sec2))
8281 if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8282 && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8284 /* If both are members of section groups, they have to have the
8286 if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8290 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8291 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8292 if (shndx1 == -1 || shndx2 == -1)
8295 bed1 = get_elf_backend_data (bfd1);
8296 bed2 = get_elf_backend_data (bfd2);
8297 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8298 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8299 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8300 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8302 if (symcount1 == 0 || symcount2 == 0)
8305 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8307 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
8311 if (isymbuf1 == NULL || isymbuf2 == NULL)
8314 /* Sort symbols by binding and section. Global definitions are at
8316 qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
8317 elf_sort_elf_symbol);
8318 qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
8319 elf_sort_elf_symbol);
8321 /* Count definitions in the section. */
8323 for (isym = isymbuf1, isymend = isym + symcount1;
8324 isym < isymend; isym++)
8326 if (isym->st_shndx == (unsigned int) shndx1)
8333 if (count1 && isym->st_shndx != (unsigned int) shndx1)
8338 for (isym = isymbuf2, isymend = isym + symcount2;
8339 isym < isymend; isym++)
8341 if (isym->st_shndx == (unsigned int) shndx2)
8348 if (count2 && isym->st_shndx != (unsigned int) shndx2)
8352 if (count1 == 0 || count2 == 0 || count1 != count2)
8355 symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8356 symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8358 if (symtable1 == NULL || symtable2 == NULL)
8362 for (isym = isymstart1, isymend = isym + count1;
8363 isym < isymend; isym++)
8366 symp->name = bfd_elf_string_from_elf_section (bfd1,
8373 for (isym = isymstart2, isymend = isym + count1;
8374 isym < isymend; isym++)
8377 symp->name = bfd_elf_string_from_elf_section (bfd2,
8383 /* Sort symbol by name. */
8384 qsort (symtable1, count1, sizeof (struct elf_symbol),
8385 elf_sym_name_compare);
8386 qsort (symtable2, count1, sizeof (struct elf_symbol),
8387 elf_sym_name_compare);
8389 for (i = 0; i < count1; i++)
8390 /* Two symbols must have the same binding, type and name. */
8391 if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8392 || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8393 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)