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;
210 bfd_elf_mkobject (bfd *abfd)
212 /* This just does initialization. */
213 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
214 elf_tdata (abfd) = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
215 if (elf_tdata (abfd) == 0)
217 /* Since everything is done at close time, do we need any
224 bfd_elf_mkcorefile (bfd *abfd)
226 /* I think this can be done just like an object file. */
227 return bfd_elf_mkobject (abfd);
231 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
233 Elf_Internal_Shdr **i_shdrp;
234 bfd_byte *shstrtab = NULL;
236 bfd_size_type shstrtabsize;
238 i_shdrp = elf_elfsections (abfd);
239 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
242 shstrtab = i_shdrp[shindex]->contents;
243 if (shstrtab == NULL)
245 /* No cached one, attempt to read, and cache what we read. */
246 offset = i_shdrp[shindex]->sh_offset;
247 shstrtabsize = i_shdrp[shindex]->sh_size;
249 /* Allocate and clear an extra byte at the end, to prevent crashes
250 in case the string table is not terminated. */
251 if (shstrtabsize + 1 == 0
252 || (shstrtab = bfd_alloc (abfd, shstrtabsize + 1)) == NULL
253 || bfd_seek (abfd, offset, SEEK_SET) != 0)
255 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
257 if (bfd_get_error () != bfd_error_system_call)
258 bfd_set_error (bfd_error_file_truncated);
262 shstrtab[shstrtabsize] = '\0';
263 i_shdrp[shindex]->contents = shstrtab;
265 return (char *) shstrtab;
269 bfd_elf_string_from_elf_section (bfd *abfd,
270 unsigned int shindex,
271 unsigned int strindex)
273 Elf_Internal_Shdr *hdr;
278 hdr = elf_elfsections (abfd)[shindex];
280 if (hdr->contents == NULL
281 && bfd_elf_get_str_section (abfd, shindex) == NULL)
284 if (strindex >= hdr->sh_size)
286 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
287 (*_bfd_error_handler)
288 (_("%B: invalid string offset %u >= %lu for section `%s'"),
289 abfd, strindex, (unsigned long) hdr->sh_size,
290 (shindex == shstrndx && strindex == hdr->sh_name
292 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
296 return ((char *) hdr->contents) + strindex;
299 /* Read and convert symbols to internal format.
300 SYMCOUNT specifies the number of symbols to read, starting from
301 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
302 are non-NULL, they are used to store the internal symbols, external
303 symbols, and symbol section index extensions, respectively. */
306 bfd_elf_get_elf_syms (bfd *ibfd,
307 Elf_Internal_Shdr *symtab_hdr,
310 Elf_Internal_Sym *intsym_buf,
312 Elf_External_Sym_Shndx *extshndx_buf)
314 Elf_Internal_Shdr *shndx_hdr;
316 const bfd_byte *esym;
317 Elf_External_Sym_Shndx *alloc_extshndx;
318 Elf_External_Sym_Shndx *shndx;
319 Elf_Internal_Sym *isym;
320 Elf_Internal_Sym *isymend;
321 const struct elf_backend_data *bed;
329 /* Normal syms might have section extension entries. */
331 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
332 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
334 /* Read the symbols. */
336 alloc_extshndx = NULL;
337 bed = get_elf_backend_data (ibfd);
338 extsym_size = bed->s->sizeof_sym;
339 amt = symcount * extsym_size;
340 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
341 if (extsym_buf == NULL)
343 alloc_ext = bfd_malloc (amt);
344 extsym_buf = alloc_ext;
346 if (extsym_buf == NULL
347 || bfd_seek (ibfd, pos, SEEK_SET) != 0
348 || bfd_bread (extsym_buf, amt, ibfd) != amt)
354 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
358 amt = symcount * sizeof (Elf_External_Sym_Shndx);
359 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
360 if (extshndx_buf == NULL)
362 alloc_extshndx = bfd_malloc (amt);
363 extshndx_buf = alloc_extshndx;
365 if (extshndx_buf == NULL
366 || bfd_seek (ibfd, pos, SEEK_SET) != 0
367 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
374 if (intsym_buf == NULL)
376 bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
377 intsym_buf = bfd_malloc (amt);
378 if (intsym_buf == NULL)
382 /* Convert the symbols to internal form. */
383 isymend = intsym_buf + symcount;
384 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
386 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
387 (*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym);
390 if (alloc_ext != NULL)
392 if (alloc_extshndx != NULL)
393 free (alloc_extshndx);
398 /* Look up a symbol name. */
400 bfd_elf_sym_name (bfd *abfd,
401 Elf_Internal_Shdr *symtab_hdr,
402 Elf_Internal_Sym *isym,
406 unsigned int iname = isym->st_name;
407 unsigned int shindex = symtab_hdr->sh_link;
409 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
410 /* Check for a bogus st_shndx to avoid crashing. */
411 && isym->st_shndx < elf_numsections (abfd)
412 && !(isym->st_shndx >= SHN_LORESERVE && isym->st_shndx <= SHN_HIRESERVE))
414 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
415 shindex = elf_elfheader (abfd)->e_shstrndx;
418 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
421 else if (sym_sec && *name == '\0')
422 name = bfd_section_name (abfd, sym_sec);
427 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
428 sections. The first element is the flags, the rest are section
431 typedef union elf_internal_group {
432 Elf_Internal_Shdr *shdr;
434 } Elf_Internal_Group;
436 /* Return the name of the group signature symbol. Why isn't the
437 signature just a string? */
440 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
442 Elf_Internal_Shdr *hdr;
443 unsigned char esym[sizeof (Elf64_External_Sym)];
444 Elf_External_Sym_Shndx eshndx;
445 Elf_Internal_Sym isym;
447 /* First we need to ensure the symbol table is available. Make sure
448 that it is a symbol table section. */
449 hdr = elf_elfsections (abfd) [ghdr->sh_link];
450 if (hdr->sh_type != SHT_SYMTAB
451 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
454 /* Go read the symbol. */
455 hdr = &elf_tdata (abfd)->symtab_hdr;
456 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
457 &isym, esym, &eshndx) == NULL)
460 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
463 /* Set next_in_group list pointer, and group name for NEWSECT. */
466 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
468 unsigned int num_group = elf_tdata (abfd)->num_group;
470 /* If num_group is zero, read in all SHT_GROUP sections. The count
471 is set to -1 if there are no SHT_GROUP sections. */
474 unsigned int i, shnum;
476 /* First count the number of groups. If we have a SHT_GROUP
477 section with just a flag word (ie. sh_size is 4), ignore it. */
478 shnum = elf_numsections (abfd);
480 for (i = 0; i < shnum; i++)
482 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
483 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
489 num_group = (unsigned) -1;
490 elf_tdata (abfd)->num_group = num_group;
494 /* We keep a list of elf section headers for group sections,
495 so we can find them quickly. */
498 elf_tdata (abfd)->num_group = num_group;
499 amt = num_group * sizeof (Elf_Internal_Shdr *);
500 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
501 if (elf_tdata (abfd)->group_sect_ptr == NULL)
505 for (i = 0; i < shnum; i++)
507 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
508 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
511 Elf_Internal_Group *dest;
513 /* Add to list of sections. */
514 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
517 /* Read the raw contents. */
518 BFD_ASSERT (sizeof (*dest) >= 4);
519 amt = shdr->sh_size * sizeof (*dest) / 4;
520 shdr->contents = bfd_alloc (abfd, amt);
521 if (shdr->contents == NULL
522 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
523 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
527 /* Translate raw contents, a flag word followed by an
528 array of elf section indices all in target byte order,
529 to the flag word followed by an array of elf section
531 src = shdr->contents + shdr->sh_size;
532 dest = (Elf_Internal_Group *) (shdr->contents + amt);
539 idx = H_GET_32 (abfd, src);
540 if (src == shdr->contents)
543 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
544 shdr->bfd_section->flags
545 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
550 ((*_bfd_error_handler)
551 (_("%B: invalid SHT_GROUP entry"), abfd));
554 dest->shdr = elf_elfsections (abfd)[idx];
561 if (num_group != (unsigned) -1)
565 for (i = 0; i < num_group; i++)
567 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
568 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
569 unsigned int n_elt = shdr->sh_size / 4;
571 /* Look through this group's sections to see if current
572 section is a member. */
574 if ((++idx)->shdr == hdr)
578 /* We are a member of this group. Go looking through
579 other members to see if any others are linked via
581 idx = (Elf_Internal_Group *) shdr->contents;
582 n_elt = shdr->sh_size / 4;
584 if ((s = (++idx)->shdr->bfd_section) != NULL
585 && elf_next_in_group (s) != NULL)
589 /* Snarf the group name from other member, and
590 insert current section in circular list. */
591 elf_group_name (newsect) = elf_group_name (s);
592 elf_next_in_group (newsect) = elf_next_in_group (s);
593 elf_next_in_group (s) = newsect;
599 gname = group_signature (abfd, shdr);
602 elf_group_name (newsect) = gname;
604 /* Start a circular list with one element. */
605 elf_next_in_group (newsect) = newsect;
608 /* If the group section has been created, point to the
610 if (shdr->bfd_section != NULL)
611 elf_next_in_group (shdr->bfd_section) = newsect;
619 if (elf_group_name (newsect) == NULL)
621 (*_bfd_error_handler) (_("%B: no group info for section %A"),
628 _bfd_elf_setup_group_pointers (bfd *abfd)
631 unsigned int num_group = elf_tdata (abfd)->num_group;
632 bfd_boolean result = TRUE;
634 if (num_group == (unsigned) -1)
637 for (i = 0; i < num_group; i++)
639 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
640 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
641 unsigned int n_elt = shdr->sh_size / 4;
644 if ((++idx)->shdr->bfd_section)
645 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
646 else if (idx->shdr->sh_type == SHT_RELA
647 || idx->shdr->sh_type == SHT_REL)
648 /* We won't include relocation sections in section groups in
649 output object files. We adjust the group section size here
650 so that relocatable link will work correctly when
651 relocation sections are in section group in input object
653 shdr->bfd_section->size -= 4;
656 /* There are some unknown sections in the group. */
657 (*_bfd_error_handler)
658 (_("%B: unknown [%d] section `%s' in group [%s]"),
660 (unsigned int) idx->shdr->sh_type,
661 bfd_elf_string_from_elf_section (abfd,
662 (elf_elfheader (abfd)
665 shdr->bfd_section->name);
673 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
675 return elf_next_in_group (sec) != NULL;
678 /* Make a BFD section from an ELF section. We store a pointer to the
679 BFD section in the bfd_section field of the header. */
682 _bfd_elf_make_section_from_shdr (bfd *abfd,
683 Elf_Internal_Shdr *hdr,
689 const struct elf_backend_data *bed;
691 if (hdr->bfd_section != NULL)
693 BFD_ASSERT (strcmp (name,
694 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
698 newsect = bfd_make_section_anyway (abfd, name);
702 hdr->bfd_section = newsect;
703 elf_section_data (newsect)->this_hdr = *hdr;
704 elf_section_data (newsect)->this_idx = shindex;
706 /* Always use the real type/flags. */
707 elf_section_type (newsect) = hdr->sh_type;
708 elf_section_flags (newsect) = hdr->sh_flags;
710 newsect->filepos = hdr->sh_offset;
712 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
713 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
714 || ! bfd_set_section_alignment (abfd, newsect,
715 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
718 flags = SEC_NO_FLAGS;
719 if (hdr->sh_type != SHT_NOBITS)
720 flags |= SEC_HAS_CONTENTS;
721 if (hdr->sh_type == SHT_GROUP)
722 flags |= SEC_GROUP | SEC_EXCLUDE;
723 if ((hdr->sh_flags & SHF_ALLOC) != 0)
726 if (hdr->sh_type != SHT_NOBITS)
729 if ((hdr->sh_flags & SHF_WRITE) == 0)
730 flags |= SEC_READONLY;
731 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
733 else if ((flags & SEC_LOAD) != 0)
735 if ((hdr->sh_flags & SHF_MERGE) != 0)
738 newsect->entsize = hdr->sh_entsize;
739 if ((hdr->sh_flags & SHF_STRINGS) != 0)
740 flags |= SEC_STRINGS;
742 if (hdr->sh_flags & SHF_GROUP)
743 if (!setup_group (abfd, hdr, newsect))
745 if ((hdr->sh_flags & SHF_TLS) != 0)
746 flags |= SEC_THREAD_LOCAL;
748 if ((flags & SEC_ALLOC) == 0)
750 /* The debugging sections appear to be recognized only by name,
751 not any sort of flag. Their SEC_ALLOC bits are cleared. */
756 } debug_sections [] =
758 { "debug", 5 }, /* 'd' */
759 { NULL, 0 }, /* 'e' */
760 { NULL, 0 }, /* 'f' */
761 { "gnu.linkonce.wi.", 17 }, /* 'g' */
762 { NULL, 0 }, /* 'h' */
763 { NULL, 0 }, /* 'i' */
764 { NULL, 0 }, /* 'j' */
765 { NULL, 0 }, /* 'k' */
766 { "line", 4 }, /* 'l' */
767 { NULL, 0 }, /* 'm' */
768 { NULL, 0 }, /* 'n' */
769 { NULL, 0 }, /* 'o' */
770 { NULL, 0 }, /* 'p' */
771 { NULL, 0 }, /* 'q' */
772 { NULL, 0 }, /* 'r' */
773 { "stab", 4 } /* 's' */
778 int i = name [1] - 'd';
780 && i < (int) ARRAY_SIZE (debug_sections)
781 && debug_sections [i].name != NULL
782 && strncmp (&name [1], debug_sections [i].name,
783 debug_sections [i].len) == 0)
784 flags |= SEC_DEBUGGING;
788 /* As a GNU extension, if the name begins with .gnu.linkonce, we
789 only link a single copy of the section. This is used to support
790 g++. g++ will emit each template expansion in its own section.
791 The symbols will be defined as weak, so that multiple definitions
792 are permitted. The GNU linker extension is to actually discard
793 all but one of the sections. */
794 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
795 && elf_next_in_group (newsect) == NULL)
796 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
798 bed = get_elf_backend_data (abfd);
799 if (bed->elf_backend_section_flags)
800 if (! bed->elf_backend_section_flags (&flags, hdr))
803 if (! bfd_set_section_flags (abfd, newsect, flags))
806 if ((flags & SEC_ALLOC) != 0)
808 Elf_Internal_Phdr *phdr;
811 /* Look through the phdrs to see if we need to adjust the lma.
812 If all the p_paddr fields are zero, we ignore them, since
813 some ELF linkers produce such output. */
814 phdr = elf_tdata (abfd)->phdr;
815 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
817 if (phdr->p_paddr != 0)
820 if (i < elf_elfheader (abfd)->e_phnum)
822 phdr = elf_tdata (abfd)->phdr;
823 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
825 /* This section is part of this segment if its file
826 offset plus size lies within the segment's memory
827 span and, if the section is loaded, the extent of the
828 loaded data lies within the extent of the segment.
830 Note - we used to check the p_paddr field as well, and
831 refuse to set the LMA if it was 0. This is wrong
832 though, as a perfectly valid initialised segment can
833 have a p_paddr of zero. Some architectures, eg ARM,
834 place special significance on the address 0 and
835 executables need to be able to have a segment which
836 covers this address. */
837 if (phdr->p_type == PT_LOAD
838 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
839 && (hdr->sh_offset + hdr->sh_size
840 <= phdr->p_offset + phdr->p_memsz)
841 && ((flags & SEC_LOAD) == 0
842 || (hdr->sh_offset + hdr->sh_size
843 <= phdr->p_offset + phdr->p_filesz)))
845 if ((flags & SEC_LOAD) == 0)
846 newsect->lma = (phdr->p_paddr
847 + hdr->sh_addr - phdr->p_vaddr);
849 /* We used to use the same adjustment for SEC_LOAD
850 sections, but that doesn't work if the segment
851 is packed with code from multiple VMAs.
852 Instead we calculate the section LMA based on
853 the segment LMA. It is assumed that the
854 segment will contain sections with contiguous
855 LMAs, even if the VMAs are not. */
856 newsect->lma = (phdr->p_paddr
857 + hdr->sh_offset - phdr->p_offset);
859 /* With contiguous segments, we can't tell from file
860 offsets whether a section with zero size should
861 be placed at the end of one segment or the
862 beginning of the next. Decide based on vaddr. */
863 if (hdr->sh_addr >= phdr->p_vaddr
864 && (hdr->sh_addr + hdr->sh_size
865 <= phdr->p_vaddr + phdr->p_memsz))
880 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
883 Helper functions for GDB to locate the string tables.
884 Since BFD hides string tables from callers, GDB needs to use an
885 internal hook to find them. Sun's .stabstr, in particular,
886 isn't even pointed to by the .stab section, so ordinary
887 mechanisms wouldn't work to find it, even if we had some.
890 struct elf_internal_shdr *
891 bfd_elf_find_section (bfd *abfd, char *name)
893 Elf_Internal_Shdr **i_shdrp;
898 i_shdrp = elf_elfsections (abfd);
901 shstrtab = bfd_elf_get_str_section (abfd,
902 elf_elfheader (abfd)->e_shstrndx);
903 if (shstrtab != NULL)
905 max = elf_numsections (abfd);
906 for (i = 1; i < max; i++)
907 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
914 const char *const bfd_elf_section_type_names[] = {
915 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
916 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
917 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
920 /* ELF relocs are against symbols. If we are producing relocatable
921 output, and the reloc is against an external symbol, and nothing
922 has given us any additional addend, the resulting reloc will also
923 be against the same symbol. In such a case, we don't want to
924 change anything about the way the reloc is handled, since it will
925 all be done at final link time. Rather than put special case code
926 into bfd_perform_relocation, all the reloc types use this howto
927 function. It just short circuits the reloc if producing
928 relocatable output against an external symbol. */
930 bfd_reloc_status_type
931 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
932 arelent *reloc_entry,
934 void *data ATTRIBUTE_UNUSED,
935 asection *input_section,
937 char **error_message ATTRIBUTE_UNUSED)
939 if (output_bfd != NULL
940 && (symbol->flags & BSF_SECTION_SYM) == 0
941 && (! reloc_entry->howto->partial_inplace
942 || reloc_entry->addend == 0))
944 reloc_entry->address += input_section->output_offset;
948 return bfd_reloc_continue;
951 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
954 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
957 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
958 sec->sec_info_type = ELF_INFO_TYPE_NONE;
961 /* Finish SHF_MERGE section merging. */
964 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
969 if (!is_elf_hash_table (info->hash))
972 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
973 if ((ibfd->flags & DYNAMIC) == 0)
974 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
975 if ((sec->flags & SEC_MERGE) != 0
976 && !bfd_is_abs_section (sec->output_section))
978 struct bfd_elf_section_data *secdata;
980 secdata = elf_section_data (sec);
981 if (! _bfd_add_merge_section (abfd,
982 &elf_hash_table (info)->merge_info,
983 sec, &secdata->sec_info))
985 else if (secdata->sec_info)
986 sec->sec_info_type = ELF_INFO_TYPE_MERGE;
989 if (elf_hash_table (info)->merge_info != NULL)
990 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
991 merge_sections_remove_hook);
996 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
998 sec->output_section = bfd_abs_section_ptr;
999 sec->output_offset = sec->vma;
1000 if (!is_elf_hash_table (info->hash))
1003 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
1006 /* Copy the program header and other data from one object module to
1010 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1012 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1013 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1016 BFD_ASSERT (!elf_flags_init (obfd)
1017 || (elf_elfheader (obfd)->e_flags
1018 == elf_elfheader (ibfd)->e_flags));
1020 elf_gp (obfd) = elf_gp (ibfd);
1021 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1022 elf_flags_init (obfd) = TRUE;
1026 /* Print out the program headers. */
1029 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1032 Elf_Internal_Phdr *p;
1034 bfd_byte *dynbuf = NULL;
1036 p = elf_tdata (abfd)->phdr;
1041 fprintf (f, _("\nProgram Header:\n"));
1042 c = elf_elfheader (abfd)->e_phnum;
1043 for (i = 0; i < c; i++, p++)
1050 case PT_NULL: pt = "NULL"; break;
1051 case PT_LOAD: pt = "LOAD"; break;
1052 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1053 case PT_INTERP: pt = "INTERP"; break;
1054 case PT_NOTE: pt = "NOTE"; break;
1055 case PT_SHLIB: pt = "SHLIB"; break;
1056 case PT_PHDR: pt = "PHDR"; break;
1057 case PT_TLS: pt = "TLS"; break;
1058 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1059 case PT_GNU_STACK: pt = "STACK"; break;
1060 case PT_GNU_RELRO: pt = "RELRO"; break;
1061 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
1063 fprintf (f, "%8s off 0x", pt);
1064 bfd_fprintf_vma (abfd, f, p->p_offset);
1065 fprintf (f, " vaddr 0x");
1066 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1067 fprintf (f, " paddr 0x");
1068 bfd_fprintf_vma (abfd, f, p->p_paddr);
1069 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1070 fprintf (f, " filesz 0x");
1071 bfd_fprintf_vma (abfd, f, p->p_filesz);
1072 fprintf (f, " memsz 0x");
1073 bfd_fprintf_vma (abfd, f, p->p_memsz);
1074 fprintf (f, " flags %c%c%c",
1075 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1076 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1077 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1078 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1079 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1084 s = bfd_get_section_by_name (abfd, ".dynamic");
1088 unsigned long shlink;
1089 bfd_byte *extdyn, *extdynend;
1091 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1093 fprintf (f, _("\nDynamic Section:\n"));
1095 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1098 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1101 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1103 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1104 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1107 extdynend = extdyn + s->size;
1108 for (; extdyn < extdynend; extdyn += extdynsize)
1110 Elf_Internal_Dyn dyn;
1113 bfd_boolean stringp;
1115 (*swap_dyn_in) (abfd, extdyn, &dyn);
1117 if (dyn.d_tag == DT_NULL)
1124 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1128 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1129 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1130 case DT_PLTGOT: name = "PLTGOT"; break;
1131 case DT_HASH: name = "HASH"; break;
1132 case DT_STRTAB: name = "STRTAB"; break;
1133 case DT_SYMTAB: name = "SYMTAB"; break;
1134 case DT_RELA: name = "RELA"; break;
1135 case DT_RELASZ: name = "RELASZ"; break;
1136 case DT_RELAENT: name = "RELAENT"; break;
1137 case DT_STRSZ: name = "STRSZ"; break;
1138 case DT_SYMENT: name = "SYMENT"; break;
1139 case DT_INIT: name = "INIT"; break;
1140 case DT_FINI: name = "FINI"; break;
1141 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1142 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1143 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1144 case DT_REL: name = "REL"; break;
1145 case DT_RELSZ: name = "RELSZ"; break;
1146 case DT_RELENT: name = "RELENT"; break;
1147 case DT_PLTREL: name = "PLTREL"; break;
1148 case DT_DEBUG: name = "DEBUG"; break;
1149 case DT_TEXTREL: name = "TEXTREL"; break;
1150 case DT_JMPREL: name = "JMPREL"; break;
1151 case DT_BIND_NOW: name = "BIND_NOW"; break;
1152 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1153 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1154 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1155 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1156 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1157 case DT_FLAGS: name = "FLAGS"; break;
1158 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1159 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1160 case DT_CHECKSUM: name = "CHECKSUM"; break;
1161 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1162 case DT_MOVEENT: name = "MOVEENT"; break;
1163 case DT_MOVESZ: name = "MOVESZ"; break;
1164 case DT_FEATURE: name = "FEATURE"; break;
1165 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1166 case DT_SYMINSZ: name = "SYMINSZ"; break;
1167 case DT_SYMINENT: name = "SYMINENT"; break;
1168 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1169 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1170 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1171 case DT_PLTPAD: name = "PLTPAD"; break;
1172 case DT_MOVETAB: name = "MOVETAB"; break;
1173 case DT_SYMINFO: name = "SYMINFO"; break;
1174 case DT_RELACOUNT: name = "RELACOUNT"; break;
1175 case DT_RELCOUNT: name = "RELCOUNT"; break;
1176 case DT_FLAGS_1: name = "FLAGS_1"; break;
1177 case DT_VERSYM: name = "VERSYM"; break;
1178 case DT_VERDEF: name = "VERDEF"; break;
1179 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1180 case DT_VERNEED: name = "VERNEED"; break;
1181 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1182 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1183 case DT_USED: name = "USED"; break;
1184 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1187 fprintf (f, " %-11s ", name);
1189 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1193 unsigned int tagv = dyn.d_un.d_val;
1195 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1198 fprintf (f, "%s", string);
1207 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1208 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1210 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1214 if (elf_dynverdef (abfd) != 0)
1216 Elf_Internal_Verdef *t;
1218 fprintf (f, _("\nVersion definitions:\n"));
1219 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1221 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1222 t->vd_flags, t->vd_hash, t->vd_nodename);
1223 if (t->vd_auxptr->vda_nextptr != NULL)
1225 Elf_Internal_Verdaux *a;
1228 for (a = t->vd_auxptr->vda_nextptr;
1231 fprintf (f, "%s ", a->vda_nodename);
1237 if (elf_dynverref (abfd) != 0)
1239 Elf_Internal_Verneed *t;
1241 fprintf (f, _("\nVersion References:\n"));
1242 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1244 Elf_Internal_Vernaux *a;
1246 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1247 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1248 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1249 a->vna_flags, a->vna_other, a->vna_nodename);
1261 /* Display ELF-specific fields of a symbol. */
1264 bfd_elf_print_symbol (bfd *abfd,
1267 bfd_print_symbol_type how)
1272 case bfd_print_symbol_name:
1273 fprintf (file, "%s", symbol->name);
1275 case bfd_print_symbol_more:
1276 fprintf (file, "elf ");
1277 bfd_fprintf_vma (abfd, file, symbol->value);
1278 fprintf (file, " %lx", (long) symbol->flags);
1280 case bfd_print_symbol_all:
1282 const char *section_name;
1283 const char *name = NULL;
1284 const struct elf_backend_data *bed;
1285 unsigned char st_other;
1288 section_name = symbol->section ? symbol->section->name : "(*none*)";
1290 bed = get_elf_backend_data (abfd);
1291 if (bed->elf_backend_print_symbol_all)
1292 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1296 name = symbol->name;
1297 bfd_print_symbol_vandf (abfd, file, symbol);
1300 fprintf (file, " %s\t", section_name);
1301 /* Print the "other" value for a symbol. For common symbols,
1302 we've already printed the size; now print the alignment.
1303 For other symbols, we have no specified alignment, and
1304 we've printed the address; now print the size. */
1305 if (bfd_is_com_section (symbol->section))
1306 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1308 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1309 bfd_fprintf_vma (abfd, file, val);
1311 /* If we have version information, print it. */
1312 if (elf_tdata (abfd)->dynversym_section != 0
1313 && (elf_tdata (abfd)->dynverdef_section != 0
1314 || elf_tdata (abfd)->dynverref_section != 0))
1316 unsigned int vernum;
1317 const char *version_string;
1319 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1322 version_string = "";
1323 else if (vernum == 1)
1324 version_string = "Base";
1325 else if (vernum <= elf_tdata (abfd)->cverdefs)
1327 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1330 Elf_Internal_Verneed *t;
1332 version_string = "";
1333 for (t = elf_tdata (abfd)->verref;
1337 Elf_Internal_Vernaux *a;
1339 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1341 if (a->vna_other == vernum)
1343 version_string = a->vna_nodename;
1350 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1351 fprintf (file, " %-11s", version_string);
1356 fprintf (file, " (%s)", version_string);
1357 for (i = 10 - strlen (version_string); i > 0; --i)
1362 /* If the st_other field is not zero, print it. */
1363 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1368 case STV_INTERNAL: fprintf (file, " .internal"); break;
1369 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1370 case STV_PROTECTED: fprintf (file, " .protected"); break;
1372 /* Some other non-defined flags are also present, so print
1374 fprintf (file, " 0x%02x", (unsigned int) st_other);
1377 fprintf (file, " %s", name);
1383 /* Create an entry in an ELF linker hash table. */
1385 struct bfd_hash_entry *
1386 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1387 struct bfd_hash_table *table,
1390 /* Allocate the structure if it has not already been allocated by a
1394 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1399 /* Call the allocation method of the superclass. */
1400 entry = _bfd_link_hash_newfunc (entry, table, string);
1403 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1404 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1406 /* Set local fields. */
1409 ret->got = htab->init_got_refcount;
1410 ret->plt = htab->init_plt_refcount;
1411 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
1412 - offsetof (struct elf_link_hash_entry, size)));
1413 /* Assume that we have been called by a non-ELF symbol reader.
1414 This flag is then reset by the code which reads an ELF input
1415 file. This ensures that a symbol created by a non-ELF symbol
1416 reader will have the flag set correctly. */
1423 /* Copy data from an indirect symbol to its direct symbol, hiding the
1424 old indirect symbol. Also used for copying flags to a weakdef. */
1427 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data *bed,
1428 struct elf_link_hash_entry *dir,
1429 struct elf_link_hash_entry *ind)
1432 bfd_signed_vma lowest_valid = bed->can_refcount;
1434 /* Copy down any references that we may have already seen to the
1435 symbol which just became indirect. */
1437 dir->ref_dynamic |= ind->ref_dynamic;
1438 dir->ref_regular |= ind->ref_regular;
1439 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1440 dir->non_got_ref |= ind->non_got_ref;
1441 dir->needs_plt |= ind->needs_plt;
1442 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1444 if (ind->root.type != bfd_link_hash_indirect)
1447 /* Copy over the global and procedure linkage table refcount entries.
1448 These may have been already set up by a check_relocs routine. */
1449 tmp = dir->got.refcount;
1450 if (tmp < lowest_valid)
1452 dir->got.refcount = ind->got.refcount;
1453 ind->got.refcount = tmp;
1456 BFD_ASSERT (ind->got.refcount < lowest_valid);
1458 tmp = dir->plt.refcount;
1459 if (tmp < lowest_valid)
1461 dir->plt.refcount = ind->plt.refcount;
1462 ind->plt.refcount = tmp;
1465 BFD_ASSERT (ind->plt.refcount < lowest_valid);
1467 if (dir->dynindx == -1)
1469 dir->dynindx = ind->dynindx;
1470 dir->dynstr_index = ind->dynstr_index;
1472 ind->dynstr_index = 0;
1475 BFD_ASSERT (ind->dynindx == -1);
1479 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
1480 struct elf_link_hash_entry *h,
1481 bfd_boolean force_local)
1483 h->plt = elf_hash_table (info)->init_plt_offset;
1487 h->forced_local = 1;
1488 if (h->dynindx != -1)
1491 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1497 /* Initialize an ELF linker hash table. */
1500 _bfd_elf_link_hash_table_init
1501 (struct elf_link_hash_table *table,
1503 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
1504 struct bfd_hash_table *,
1508 int can_refcount = get_elf_backend_data (abfd)->can_refcount;
1510 table->dynamic_sections_created = FALSE;
1511 table->dynobj = NULL;
1512 table->init_got_refcount.refcount = can_refcount - 1;
1513 table->init_plt_refcount.refcount = can_refcount - 1;
1514 table->init_got_offset.offset = -(bfd_vma) 1;
1515 table->init_plt_offset.offset = -(bfd_vma) 1;
1516 /* The first dynamic symbol is a dummy. */
1517 table->dynsymcount = 1;
1518 table->dynstr = NULL;
1519 table->bucketcount = 0;
1520 table->needed = NULL;
1522 table->merge_info = NULL;
1523 memset (&table->stab_info, 0, sizeof (table->stab_info));
1524 memset (&table->eh_info, 0, sizeof (table->eh_info));
1525 table->dynlocal = NULL;
1526 table->runpath = NULL;
1527 table->tls_sec = NULL;
1528 table->tls_size = 0;
1529 table->loaded = NULL;
1530 table->is_relocatable_executable = FALSE;
1532 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
1533 table->root.type = bfd_link_elf_hash_table;
1538 /* Create an ELF linker hash table. */
1540 struct bfd_link_hash_table *
1541 _bfd_elf_link_hash_table_create (bfd *abfd)
1543 struct elf_link_hash_table *ret;
1544 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1546 ret = bfd_malloc (amt);
1550 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1559 /* This is a hook for the ELF emulation code in the generic linker to
1560 tell the backend linker what file name to use for the DT_NEEDED
1561 entry for a dynamic object. */
1564 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
1566 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1567 && bfd_get_format (abfd) == bfd_object)
1568 elf_dt_name (abfd) = name;
1572 bfd_elf_get_dyn_lib_class (bfd *abfd)
1575 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1576 && bfd_get_format (abfd) == bfd_object)
1577 lib_class = elf_dyn_lib_class (abfd);
1584 bfd_elf_set_dyn_lib_class (bfd *abfd, int lib_class)
1586 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1587 && bfd_get_format (abfd) == bfd_object)
1588 elf_dyn_lib_class (abfd) = lib_class;
1591 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1592 the linker ELF emulation code. */
1594 struct bfd_link_needed_list *
1595 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1596 struct bfd_link_info *info)
1598 if (! is_elf_hash_table (info->hash))
1600 return elf_hash_table (info)->needed;
1603 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1604 hook for the linker ELF emulation code. */
1606 struct bfd_link_needed_list *
1607 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
1608 struct bfd_link_info *info)
1610 if (! is_elf_hash_table (info->hash))
1612 return elf_hash_table (info)->runpath;
1615 /* Get the name actually used for a dynamic object for a link. This
1616 is the SONAME entry if there is one. Otherwise, it is the string
1617 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1620 bfd_elf_get_dt_soname (bfd *abfd)
1622 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1623 && bfd_get_format (abfd) == bfd_object)
1624 return elf_dt_name (abfd);
1628 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1629 the ELF linker emulation code. */
1632 bfd_elf_get_bfd_needed_list (bfd *abfd,
1633 struct bfd_link_needed_list **pneeded)
1636 bfd_byte *dynbuf = NULL;
1638 unsigned long shlink;
1639 bfd_byte *extdyn, *extdynend;
1641 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1645 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1646 || bfd_get_format (abfd) != bfd_object)
1649 s = bfd_get_section_by_name (abfd, ".dynamic");
1650 if (s == NULL || s->size == 0)
1653 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1656 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1660 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1662 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1663 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1666 extdynend = extdyn + s->size;
1667 for (; extdyn < extdynend; extdyn += extdynsize)
1669 Elf_Internal_Dyn dyn;
1671 (*swap_dyn_in) (abfd, extdyn, &dyn);
1673 if (dyn.d_tag == DT_NULL)
1676 if (dyn.d_tag == DT_NEEDED)
1679 struct bfd_link_needed_list *l;
1680 unsigned int tagv = dyn.d_un.d_val;
1683 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1688 l = bfd_alloc (abfd, amt);
1709 /* Allocate an ELF string table--force the first byte to be zero. */
1711 struct bfd_strtab_hash *
1712 _bfd_elf_stringtab_init (void)
1714 struct bfd_strtab_hash *ret;
1716 ret = _bfd_stringtab_init ();
1721 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1722 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1723 if (loc == (bfd_size_type) -1)
1725 _bfd_stringtab_free (ret);
1732 /* ELF .o/exec file reading */
1734 /* Create a new bfd section from an ELF section header. */
1737 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1739 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1740 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1741 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1744 name = bfd_elf_string_from_elf_section (abfd,
1745 elf_elfheader (abfd)->e_shstrndx,
1750 switch (hdr->sh_type)
1753 /* Inactive section. Throw it away. */
1756 case SHT_PROGBITS: /* Normal section with contents. */
1757 case SHT_NOBITS: /* .bss section. */
1758 case SHT_HASH: /* .hash section. */
1759 case SHT_NOTE: /* .note section. */
1760 case SHT_INIT_ARRAY: /* .init_array section. */
1761 case SHT_FINI_ARRAY: /* .fini_array section. */
1762 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1763 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1764 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1766 case SHT_DYNAMIC: /* Dynamic linking information. */
1767 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1769 if (hdr->sh_link > elf_numsections (abfd)
1770 || elf_elfsections (abfd)[hdr->sh_link] == NULL)
1772 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1774 Elf_Internal_Shdr *dynsymhdr;
1776 /* The shared libraries distributed with hpux11 have a bogus
1777 sh_link field for the ".dynamic" section. Find the
1778 string table for the ".dynsym" section instead. */
1779 if (elf_dynsymtab (abfd) != 0)
1781 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1782 hdr->sh_link = dynsymhdr->sh_link;
1786 unsigned int i, num_sec;
1788 num_sec = elf_numsections (abfd);
1789 for (i = 1; i < num_sec; i++)
1791 dynsymhdr = elf_elfsections (abfd)[i];
1792 if (dynsymhdr->sh_type == SHT_DYNSYM)
1794 hdr->sh_link = dynsymhdr->sh_link;
1802 case SHT_SYMTAB: /* A symbol table */
1803 if (elf_onesymtab (abfd) == shindex)
1806 if (hdr->sh_entsize != bed->s->sizeof_sym)
1808 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1809 elf_onesymtab (abfd) = shindex;
1810 elf_tdata (abfd)->symtab_hdr = *hdr;
1811 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1812 abfd->flags |= HAS_SYMS;
1814 /* Sometimes a shared object will map in the symbol table. If
1815 SHF_ALLOC is set, and this is a shared object, then we also
1816 treat this section as a BFD section. We can not base the
1817 decision purely on SHF_ALLOC, because that flag is sometimes
1818 set in a relocatable object file, which would confuse the
1820 if ((hdr->sh_flags & SHF_ALLOC) != 0
1821 && (abfd->flags & DYNAMIC) != 0
1822 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1826 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1827 can't read symbols without that section loaded as well. It
1828 is most likely specified by the next section header. */
1829 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1831 unsigned int i, num_sec;
1833 num_sec = elf_numsections (abfd);
1834 for (i = shindex + 1; i < num_sec; i++)
1836 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1837 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1838 && hdr2->sh_link == shindex)
1842 for (i = 1; i < shindex; i++)
1844 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1845 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1846 && hdr2->sh_link == shindex)
1850 return bfd_section_from_shdr (abfd, i);
1854 case SHT_DYNSYM: /* A dynamic symbol table */
1855 if (elf_dynsymtab (abfd) == shindex)
1858 if (hdr->sh_entsize != bed->s->sizeof_sym)
1860 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1861 elf_dynsymtab (abfd) = shindex;
1862 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1863 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1864 abfd->flags |= HAS_SYMS;
1866 /* Besides being a symbol table, we also treat this as a regular
1867 section, so that objcopy can handle it. */
1868 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1870 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1871 if (elf_symtab_shndx (abfd) == shindex)
1874 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1875 elf_symtab_shndx (abfd) = shindex;
1876 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1877 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1880 case SHT_STRTAB: /* A string table */
1881 if (hdr->bfd_section != NULL)
1883 if (ehdr->e_shstrndx == shindex)
1885 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1886 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1889 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1892 elf_tdata (abfd)->strtab_hdr = *hdr;
1893 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1896 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1899 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1900 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1901 elf_elfsections (abfd)[shindex] = hdr;
1902 /* We also treat this as a regular section, so that objcopy
1904 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1908 /* If the string table isn't one of the above, then treat it as a
1909 regular section. We need to scan all the headers to be sure,
1910 just in case this strtab section appeared before the above. */
1911 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1913 unsigned int i, num_sec;
1915 num_sec = elf_numsections (abfd);
1916 for (i = 1; i < num_sec; i++)
1918 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1919 if (hdr2->sh_link == shindex)
1921 /* Prevent endless recursion on broken objects. */
1924 if (! bfd_section_from_shdr (abfd, i))
1926 if (elf_onesymtab (abfd) == i)
1928 if (elf_dynsymtab (abfd) == i)
1929 goto dynsymtab_strtab;
1933 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1937 /* *These* do a lot of work -- but build no sections! */
1939 asection *target_sect;
1940 Elf_Internal_Shdr *hdr2;
1941 unsigned int num_sec = elf_numsections (abfd);
1944 != (bfd_size_type) (hdr->sh_type == SHT_REL
1945 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1948 /* Check for a bogus link to avoid crashing. */
1949 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1950 || hdr->sh_link >= num_sec)
1952 ((*_bfd_error_handler)
1953 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1954 abfd, hdr->sh_link, name, shindex));
1955 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1959 /* For some incomprehensible reason Oracle distributes
1960 libraries for Solaris in which some of the objects have
1961 bogus sh_link fields. It would be nice if we could just
1962 reject them, but, unfortunately, some people need to use
1963 them. We scan through the section headers; if we find only
1964 one suitable symbol table, we clobber the sh_link to point
1965 to it. I hope this doesn't break anything. */
1966 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1967 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1973 for (scan = 1; scan < num_sec; scan++)
1975 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1976 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1987 hdr->sh_link = found;
1990 /* Get the symbol table. */
1991 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1992 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1993 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1996 /* If this reloc section does not use the main symbol table we
1997 don't treat it as a reloc section. BFD can't adequately
1998 represent such a section, so at least for now, we don't
1999 try. We just present it as a normal section. We also
2000 can't use it as a reloc section if it points to the null
2002 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
2003 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2006 /* Prevent endless recursion on broken objects. */
2007 if (elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2008 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2010 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2012 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2013 if (target_sect == NULL)
2016 if ((target_sect->flags & SEC_RELOC) == 0
2017 || target_sect->reloc_count == 0)
2018 hdr2 = &elf_section_data (target_sect)->rel_hdr;
2022 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
2023 amt = sizeof (*hdr2);
2024 hdr2 = bfd_alloc (abfd, amt);
2025 elf_section_data (target_sect)->rel_hdr2 = hdr2;
2028 elf_elfsections (abfd)[shindex] = hdr2;
2029 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
2030 target_sect->flags |= SEC_RELOC;
2031 target_sect->relocation = NULL;
2032 target_sect->rel_filepos = hdr->sh_offset;
2033 /* In the section to which the relocations apply, mark whether
2034 its relocations are of the REL or RELA variety. */
2035 if (hdr->sh_size != 0)
2036 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
2037 abfd->flags |= HAS_RELOC;
2042 case SHT_GNU_verdef:
2043 elf_dynverdef (abfd) = shindex;
2044 elf_tdata (abfd)->dynverdef_hdr = *hdr;
2045 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2048 case SHT_GNU_versym:
2049 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2051 elf_dynversym (abfd) = shindex;
2052 elf_tdata (abfd)->dynversym_hdr = *hdr;
2053 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2056 case SHT_GNU_verneed:
2057 elf_dynverref (abfd) = shindex;
2058 elf_tdata (abfd)->dynverref_hdr = *hdr;
2059 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2066 /* We need a BFD section for objcopy and relocatable linking,
2067 and it's handy to have the signature available as the section
2069 if (hdr->sh_entsize != GRP_ENTRY_SIZE)
2071 name = group_signature (abfd, hdr);
2074 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2076 if (hdr->contents != NULL)
2078 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2079 unsigned int n_elt = hdr->sh_size / 4;
2082 if (idx->flags & GRP_COMDAT)
2083 hdr->bfd_section->flags
2084 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2086 /* We try to keep the same section order as it comes in. */
2088 while (--n_elt != 0)
2089 if ((s = (--idx)->shdr->bfd_section) != NULL
2090 && elf_next_in_group (s) != NULL)
2092 elf_next_in_group (hdr->bfd_section) = s;
2099 /* Check for any processor-specific section types. */
2100 return bed->elf_backend_section_from_shdr (abfd, hdr, name,
2107 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2108 Return SEC for sections that have no elf section, and NULL on error. */
2111 bfd_section_from_r_symndx (bfd *abfd,
2112 struct sym_sec_cache *cache,
2114 unsigned long r_symndx)
2116 Elf_Internal_Shdr *symtab_hdr;
2117 unsigned char esym[sizeof (Elf64_External_Sym)];
2118 Elf_External_Sym_Shndx eshndx;
2119 Elf_Internal_Sym isym;
2120 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2122 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2123 return cache->sec[ent];
2125 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2126 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2127 &isym, esym, &eshndx) == NULL)
2130 if (cache->abfd != abfd)
2132 memset (cache->indx, -1, sizeof (cache->indx));
2135 cache->indx[ent] = r_symndx;
2136 cache->sec[ent] = sec;
2137 if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2138 || isym.st_shndx > SHN_HIRESERVE)
2141 s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2143 cache->sec[ent] = s;
2145 return cache->sec[ent];
2148 /* Given an ELF section number, retrieve the corresponding BFD
2152 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2154 if (index >= elf_numsections (abfd))
2156 return elf_elfsections (abfd)[index]->bfd_section;
2159 static const struct bfd_elf_special_section special_sections_b[] =
2161 { ".bss", 4, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2162 { NULL, 0, 0, 0, 0 }
2165 static const struct bfd_elf_special_section special_sections_c[] =
2167 { ".comment", 8, 0, SHT_PROGBITS, 0 },
2168 { NULL, 0, 0, 0, 0 }
2171 static const struct bfd_elf_special_section special_sections_d[] =
2173 { ".data", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2174 { ".data1", 6, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2175 { ".debug", 6, 0, SHT_PROGBITS, 0 },
2176 { ".debug_line", 11, 0, SHT_PROGBITS, 0 },
2177 { ".debug_info", 11, 0, SHT_PROGBITS, 0 },
2178 { ".debug_abbrev", 13, 0, SHT_PROGBITS, 0 },
2179 { ".debug_aranges", 14, 0, SHT_PROGBITS, 0 },
2180 { ".dynamic", 8, 0, SHT_DYNAMIC, SHF_ALLOC },
2181 { ".dynstr", 7, 0, SHT_STRTAB, SHF_ALLOC },
2182 { ".dynsym", 7, 0, SHT_DYNSYM, SHF_ALLOC },
2183 { NULL, 0, 0, 0, 0 }
2186 static const struct bfd_elf_special_section special_sections_f[] =
2188 { ".fini", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2189 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2190 { NULL, 0, 0, 0, 0 }
2193 static const struct bfd_elf_special_section special_sections_g[] =
2195 { ".gnu.linkonce.b",15, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2196 { ".got", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2197 { ".gnu.version", 12, 0, SHT_GNU_versym, 0 },
2198 { ".gnu.version_d", 14, 0, SHT_GNU_verdef, 0 },
2199 { ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },
2200 { ".gnu.liblist", 12, 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2201 { ".gnu.conflict", 13, 0, SHT_RELA, SHF_ALLOC },
2202 { NULL, 0, 0, 0, 0 }
2205 static const struct bfd_elf_special_section special_sections_h[] =
2207 { ".hash", 5, 0, SHT_HASH, SHF_ALLOC },
2208 { NULL, 0, 0, 0, 0 }
2211 static const struct bfd_elf_special_section special_sections_i[] =
2213 { ".init", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2214 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2215 { ".interp", 7, 0, SHT_PROGBITS, 0 },
2216 { NULL, 0, 0, 0, 0 }
2219 static const struct bfd_elf_special_section special_sections_l[] =
2221 { ".line", 5, 0, SHT_PROGBITS, 0 },
2222 { NULL, 0, 0, 0, 0 }
2225 static const struct bfd_elf_special_section special_sections_n[] =
2227 { ".note.GNU-stack",15, 0, SHT_PROGBITS, 0 },
2228 { ".note", 5, -1, SHT_NOTE, 0 },
2229 { NULL, 0, 0, 0, 0 }
2232 static const struct bfd_elf_special_section special_sections_p[] =
2234 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2235 { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2236 { NULL, 0, 0, 0, 0 }
2239 static const struct bfd_elf_special_section special_sections_r[] =
2241 { ".rodata", 7, -2, SHT_PROGBITS, SHF_ALLOC },
2242 { ".rodata1", 8, 0, SHT_PROGBITS, SHF_ALLOC },
2243 { ".rela", 5, -1, SHT_RELA, 0 },
2244 { ".rel", 4, -1, SHT_REL, 0 },
2245 { NULL, 0, 0, 0, 0 }
2248 static const struct bfd_elf_special_section special_sections_s[] =
2250 { ".shstrtab", 9, 0, SHT_STRTAB, 0 },
2251 { ".strtab", 7, 0, SHT_STRTAB, 0 },
2252 { ".symtab", 7, 0, SHT_SYMTAB, 0 },
2253 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2254 { NULL, 0, 0, 0, 0 }
2257 static const struct bfd_elf_special_section special_sections_t[] =
2259 { ".text", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2260 { ".tbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2261 { ".tdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2262 { NULL, 0, 0, 0, 0 }
2265 static const struct bfd_elf_special_section *special_sections[] =
2267 special_sections_b, /* 'b' */
2268 special_sections_c, /* 'b' */
2269 special_sections_d, /* 'd' */
2271 special_sections_f, /* 'f' */
2272 special_sections_g, /* 'g' */
2273 special_sections_h, /* 'h' */
2274 special_sections_i, /* 'i' */
2277 special_sections_l, /* 'l' */
2279 special_sections_n, /* 'n' */
2281 special_sections_p, /* 'p' */
2283 special_sections_r, /* 'r' */
2284 special_sections_s, /* 's' */
2285 special_sections_t, /* 't' */
2288 const struct bfd_elf_special_section *
2289 _bfd_elf_get_special_section (const char *name,
2290 const struct bfd_elf_special_section *spec,
2296 len = strlen (name);
2298 for (i = 0; spec[i].prefix != NULL; i++)
2301 int prefix_len = spec[i].prefix_length;
2303 if (len < prefix_len)
2305 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2308 suffix_len = spec[i].suffix_length;
2309 if (suffix_len <= 0)
2311 if (name[prefix_len] != 0)
2313 if (suffix_len == 0)
2315 if (name[prefix_len] != '.'
2316 && (suffix_len == -2
2317 || (rela && spec[i].type == SHT_REL)))
2323 if (len < prefix_len + suffix_len)
2325 if (memcmp (name + len - suffix_len,
2326 spec[i].prefix + prefix_len,
2336 const struct bfd_elf_special_section *
2337 _bfd_elf_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
2340 const struct bfd_elf_special_section *spec;
2342 /* See if this is one of the special sections. */
2343 if (sec->name == NULL)
2346 if (sec->name[0] != '.')
2349 i = sec->name[1] - 'b';
2350 if (i < 0 || i > 't' - 'b')
2353 spec = special_sections[i];
2358 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2362 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2364 struct bfd_elf_section_data *sdata;
2365 const struct elf_backend_data *bed;
2366 const struct bfd_elf_special_section *ssect;
2368 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2371 sdata = bfd_zalloc (abfd, sizeof (*sdata));
2374 sec->used_by_bfd = sdata;
2377 /* Indicate whether or not this section should use RELA relocations. */
2378 bed = get_elf_backend_data (abfd);
2379 sec->use_rela_p = bed->default_use_rela_p;
2381 /* When we read a file, we don't need section type and flags unless
2382 it is a linker created section. They will be overridden in
2383 _bfd_elf_make_section_from_shdr anyway. */
2384 if (abfd->direction != read_direction
2385 || (sec->flags & SEC_LINKER_CREATED) != 0)
2387 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2390 elf_section_type (sec) = ssect->type;
2391 elf_section_flags (sec) = ssect->attr;
2398 /* Create a new bfd section from an ELF program header.
2400 Since program segments have no names, we generate a synthetic name
2401 of the form segment<NUM>, where NUM is generally the index in the
2402 program header table. For segments that are split (see below) we
2403 generate the names segment<NUM>a and segment<NUM>b.
2405 Note that some program segments may have a file size that is different than
2406 (less than) the memory size. All this means is that at execution the
2407 system must allocate the amount of memory specified by the memory size,
2408 but only initialize it with the first "file size" bytes read from the
2409 file. This would occur for example, with program segments consisting
2410 of combined data+bss.
2412 To handle the above situation, this routine generates TWO bfd sections
2413 for the single program segment. The first has the length specified by
2414 the file size of the segment, and the second has the length specified
2415 by the difference between the two sizes. In effect, the segment is split
2416 into it's initialized and uninitialized parts.
2421 _bfd_elf_make_section_from_phdr (bfd *abfd,
2422 Elf_Internal_Phdr *hdr,
2424 const char *typename)
2432 split = ((hdr->p_memsz > 0)
2433 && (hdr->p_filesz > 0)
2434 && (hdr->p_memsz > hdr->p_filesz));
2435 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2436 len = strlen (namebuf) + 1;
2437 name = bfd_alloc (abfd, len);
2440 memcpy (name, namebuf, len);
2441 newsect = bfd_make_section (abfd, name);
2442 if (newsect == NULL)
2444 newsect->vma = hdr->p_vaddr;
2445 newsect->lma = hdr->p_paddr;
2446 newsect->size = hdr->p_filesz;
2447 newsect->filepos = hdr->p_offset;
2448 newsect->flags |= SEC_HAS_CONTENTS;
2449 newsect->alignment_power = bfd_log2 (hdr->p_align);
2450 if (hdr->p_type == PT_LOAD)
2452 newsect->flags |= SEC_ALLOC;
2453 newsect->flags |= SEC_LOAD;
2454 if (hdr->p_flags & PF_X)
2456 /* FIXME: all we known is that it has execute PERMISSION,
2458 newsect->flags |= SEC_CODE;
2461 if (!(hdr->p_flags & PF_W))
2463 newsect->flags |= SEC_READONLY;
2468 sprintf (namebuf, "%s%db", typename, index);
2469 len = strlen (namebuf) + 1;
2470 name = bfd_alloc (abfd, len);
2473 memcpy (name, namebuf, len);
2474 newsect = bfd_make_section (abfd, name);
2475 if (newsect == NULL)
2477 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2478 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2479 newsect->size = hdr->p_memsz - hdr->p_filesz;
2480 if (hdr->p_type == PT_LOAD)
2482 newsect->flags |= SEC_ALLOC;
2483 if (hdr->p_flags & PF_X)
2484 newsect->flags |= SEC_CODE;
2486 if (!(hdr->p_flags & PF_W))
2487 newsect->flags |= SEC_READONLY;
2494 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2496 const struct elf_backend_data *bed;
2498 switch (hdr->p_type)
2501 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2504 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2507 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2510 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2513 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2515 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2520 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2523 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2525 case PT_GNU_EH_FRAME:
2526 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2530 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2533 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2536 /* Check for any processor-specific program segment types. */
2537 bed = get_elf_backend_data (abfd);
2538 return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2542 /* Initialize REL_HDR, the section-header for new section, containing
2543 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2544 relocations; otherwise, we use REL relocations. */
2547 _bfd_elf_init_reloc_shdr (bfd *abfd,
2548 Elf_Internal_Shdr *rel_hdr,
2550 bfd_boolean use_rela_p)
2553 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2554 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2556 name = bfd_alloc (abfd, amt);
2559 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2561 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2563 if (rel_hdr->sh_name == (unsigned int) -1)
2565 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2566 rel_hdr->sh_entsize = (use_rela_p
2567 ? bed->s->sizeof_rela
2568 : bed->s->sizeof_rel);
2569 rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2570 rel_hdr->sh_flags = 0;
2571 rel_hdr->sh_addr = 0;
2572 rel_hdr->sh_size = 0;
2573 rel_hdr->sh_offset = 0;
2578 /* Set up an ELF internal section header for a section. */
2581 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2583 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2584 bfd_boolean *failedptr = failedptrarg;
2585 Elf_Internal_Shdr *this_hdr;
2589 /* We already failed; just get out of the bfd_map_over_sections
2594 this_hdr = &elf_section_data (asect)->this_hdr;
2596 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2597 asect->name, FALSE);
2598 if (this_hdr->sh_name == (unsigned int) -1)
2604 this_hdr->sh_flags = 0;
2606 if ((asect->flags & SEC_ALLOC) != 0
2607 || asect->user_set_vma)
2608 this_hdr->sh_addr = asect->vma;
2610 this_hdr->sh_addr = 0;
2612 this_hdr->sh_offset = 0;
2613 this_hdr->sh_size = asect->size;
2614 this_hdr->sh_link = 0;
2615 this_hdr->sh_addralign = 1 << asect->alignment_power;
2616 /* The sh_entsize and sh_info fields may have been set already by
2617 copy_private_section_data. */
2619 this_hdr->bfd_section = asect;
2620 this_hdr->contents = NULL;
2622 /* If the section type is unspecified, we set it based on
2624 if (this_hdr->sh_type == SHT_NULL)
2626 if ((asect->flags & SEC_GROUP) != 0)
2628 /* We also need to mark SHF_GROUP here for relocatable
2630 struct bfd_link_order *l;
2633 for (l = asect->map_head.link_order; l != NULL; l = l->next)
2634 if (l->type == bfd_indirect_link_order
2635 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2638 /* The name is not important. Anything will do. */
2639 elf_group_name (elt->output_section) = "G";
2640 elf_section_flags (elt->output_section) |= SHF_GROUP;
2642 elt = elf_next_in_group (elt);
2643 /* During a relocatable link, the lists are
2646 while (elt != elf_next_in_group (l->u.indirect.section));
2648 this_hdr->sh_type = SHT_GROUP;
2650 else if ((asect->flags & SEC_ALLOC) != 0
2651 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2652 || (asect->flags & SEC_NEVER_LOAD) != 0))
2653 this_hdr->sh_type = SHT_NOBITS;
2655 this_hdr->sh_type = SHT_PROGBITS;
2658 switch (this_hdr->sh_type)
2664 case SHT_INIT_ARRAY:
2665 case SHT_FINI_ARRAY:
2666 case SHT_PREINIT_ARRAY:
2673 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2677 this_hdr->sh_entsize = bed->s->sizeof_sym;
2681 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2685 if (get_elf_backend_data (abfd)->may_use_rela_p)
2686 this_hdr->sh_entsize = bed->s->sizeof_rela;
2690 if (get_elf_backend_data (abfd)->may_use_rel_p)
2691 this_hdr->sh_entsize = bed->s->sizeof_rel;
2694 case SHT_GNU_versym:
2695 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2698 case SHT_GNU_verdef:
2699 this_hdr->sh_entsize = 0;
2700 /* objcopy or strip will copy over sh_info, but may not set
2701 cverdefs. The linker will set cverdefs, but sh_info will be
2703 if (this_hdr->sh_info == 0)
2704 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2706 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2707 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2710 case SHT_GNU_verneed:
2711 this_hdr->sh_entsize = 0;
2712 /* objcopy or strip will copy over sh_info, but may not set
2713 cverrefs. The linker will set cverrefs, but sh_info will be
2715 if (this_hdr->sh_info == 0)
2716 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2718 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2719 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2723 this_hdr->sh_entsize = 4;
2727 if ((asect->flags & SEC_ALLOC) != 0)
2728 this_hdr->sh_flags |= SHF_ALLOC;
2729 if ((asect->flags & SEC_READONLY) == 0)
2730 this_hdr->sh_flags |= SHF_WRITE;
2731 if ((asect->flags & SEC_CODE) != 0)
2732 this_hdr->sh_flags |= SHF_EXECINSTR;
2733 if ((asect->flags & SEC_MERGE) != 0)
2735 this_hdr->sh_flags |= SHF_MERGE;
2736 this_hdr->sh_entsize = asect->entsize;
2737 if ((asect->flags & SEC_STRINGS) != 0)
2738 this_hdr->sh_flags |= SHF_STRINGS;
2740 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2741 this_hdr->sh_flags |= SHF_GROUP;
2742 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2744 this_hdr->sh_flags |= SHF_TLS;
2745 if (asect->size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2747 struct bfd_link_order *o;
2749 this_hdr->sh_size = 0;
2750 for (o = asect->map_head.link_order; o != NULL; o = o->next)
2751 if (this_hdr->sh_size < o->offset + o->size)
2752 this_hdr->sh_size = o->offset + o->size;
2753 if (this_hdr->sh_size)
2754 this_hdr->sh_type = SHT_NOBITS;
2758 /* Check for processor-specific section types. */
2759 if (bed->elf_backend_fake_sections
2760 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2763 /* If the section has relocs, set up a section header for the
2764 SHT_REL[A] section. If two relocation sections are required for
2765 this section, it is up to the processor-specific back-end to
2766 create the other. */
2767 if ((asect->flags & SEC_RELOC) != 0
2768 && !_bfd_elf_init_reloc_shdr (abfd,
2769 &elf_section_data (asect)->rel_hdr,
2775 /* Fill in the contents of a SHT_GROUP section. */
2778 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2780 bfd_boolean *failedptr = failedptrarg;
2781 unsigned long symindx;
2782 asection *elt, *first;
2784 struct bfd_link_order *l;
2787 /* Ignore linker created group section. See elfNN_ia64_object_p in
2789 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2794 if (elf_group_id (sec) != NULL)
2795 symindx = elf_group_id (sec)->udata.i;
2799 /* If called from the assembler, swap_out_syms will have set up
2800 elf_section_syms; If called for "ld -r", use target_index. */
2801 if (elf_section_syms (abfd) != NULL)
2802 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2804 symindx = sec->target_index;
2806 elf_section_data (sec)->this_hdr.sh_info = symindx;
2808 /* The contents won't be allocated for "ld -r" or objcopy. */
2810 if (sec->contents == NULL)
2813 sec->contents = bfd_alloc (abfd, sec->size);
2815 /* Arrange for the section to be written out. */
2816 elf_section_data (sec)->this_hdr.contents = sec->contents;
2817 if (sec->contents == NULL)
2824 loc = sec->contents + sec->size;
2826 /* Get the pointer to the first section in the group that gas
2827 squirreled away here. objcopy arranges for this to be set to the
2828 start of the input section group. */
2829 first = elt = elf_next_in_group (sec);
2831 /* First element is a flag word. Rest of section is elf section
2832 indices for all the sections of the group. Write them backwards
2833 just to keep the group in the same order as given in .section
2834 directives, not that it matters. */
2843 s = s->output_section;
2846 idx = elf_section_data (s)->this_idx;
2847 H_PUT_32 (abfd, idx, loc);
2848 elt = elf_next_in_group (elt);
2853 /* If this is a relocatable link, then the above did nothing because
2854 SEC is the output section. Look through the input sections
2856 for (l = sec->map_head.link_order; l != NULL; l = l->next)
2857 if (l->type == bfd_indirect_link_order
2858 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2863 elf_section_data (elt->output_section)->this_idx, loc);
2864 elt = elf_next_in_group (elt);
2865 /* During a relocatable link, the lists are circular. */
2867 while (elt != elf_next_in_group (l->u.indirect.section));
2869 if ((loc -= 4) != sec->contents)
2872 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2875 /* Assign all ELF section numbers. The dummy first section is handled here
2876 too. The link/info pointers for the standard section types are filled
2877 in here too, while we're at it. */
2880 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2882 struct elf_obj_tdata *t = elf_tdata (abfd);
2884 unsigned int section_number, secn;
2885 Elf_Internal_Shdr **i_shdrp;
2887 struct bfd_elf_section_data *d;
2891 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2893 /* SHT_GROUP sections are in relocatable files only. */
2894 if (link_info == NULL || link_info->relocatable)
2896 /* Put SHT_GROUP sections first. */
2897 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2899 d = elf_section_data (sec);
2901 if (d->this_hdr.sh_type == SHT_GROUP)
2903 if (sec->flags & SEC_LINKER_CREATED)
2905 /* Remove the linker created SHT_GROUP sections. */
2906 bfd_section_list_remove (abfd, sec);
2907 abfd->section_count--;
2911 if (section_number == SHN_LORESERVE)
2912 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2913 d->this_idx = section_number++;
2919 for (sec = abfd->sections; sec; sec = sec->next)
2921 d = elf_section_data (sec);
2923 if (d->this_hdr.sh_type != SHT_GROUP)
2925 if (section_number == SHN_LORESERVE)
2926 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2927 d->this_idx = section_number++;
2929 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2930 if ((sec->flags & SEC_RELOC) == 0)
2934 if (section_number == SHN_LORESERVE)
2935 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2936 d->rel_idx = section_number++;
2937 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2942 if (section_number == SHN_LORESERVE)
2943 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2944 d->rel_idx2 = section_number++;
2945 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2951 if (section_number == SHN_LORESERVE)
2952 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2953 t->shstrtab_section = section_number++;
2954 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2955 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2957 if (bfd_get_symcount (abfd) > 0)
2959 if (section_number == SHN_LORESERVE)
2960 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2961 t->symtab_section = section_number++;
2962 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2963 if (section_number > SHN_LORESERVE - 2)
2965 if (section_number == SHN_LORESERVE)
2966 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2967 t->symtab_shndx_section = section_number++;
2968 t->symtab_shndx_hdr.sh_name
2969 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2970 ".symtab_shndx", FALSE);
2971 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2974 if (section_number == SHN_LORESERVE)
2975 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2976 t->strtab_section = section_number++;
2977 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2980 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2981 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2983 elf_numsections (abfd) = section_number;
2984 elf_elfheader (abfd)->e_shnum = section_number;
2985 if (section_number > SHN_LORESERVE)
2986 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2988 /* Set up the list of section header pointers, in agreement with the
2990 amt = section_number * sizeof (Elf_Internal_Shdr *);
2991 i_shdrp = bfd_zalloc (abfd, amt);
2992 if (i_shdrp == NULL)
2995 amt = sizeof (Elf_Internal_Shdr);
2996 i_shdrp[0] = bfd_zalloc (abfd, amt);
2997 if (i_shdrp[0] == NULL)
2999 bfd_release (abfd, i_shdrp);
3003 elf_elfsections (abfd) = i_shdrp;
3005 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3006 if (bfd_get_symcount (abfd) > 0)
3008 i_shdrp[t->symtab_section] = &t->symtab_hdr;
3009 if (elf_numsections (abfd) > SHN_LORESERVE)
3011 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3012 t->symtab_shndx_hdr.sh_link = t->symtab_section;
3014 i_shdrp[t->strtab_section] = &t->strtab_hdr;
3015 t->symtab_hdr.sh_link = t->strtab_section;
3018 for (sec = abfd->sections; sec; sec = sec->next)
3020 struct bfd_elf_section_data *d = elf_section_data (sec);
3024 i_shdrp[d->this_idx] = &d->this_hdr;
3025 if (d->rel_idx != 0)
3026 i_shdrp[d->rel_idx] = &d->rel_hdr;
3027 if (d->rel_idx2 != 0)
3028 i_shdrp[d->rel_idx2] = d->rel_hdr2;
3030 /* Fill in the sh_link and sh_info fields while we're at it. */
3032 /* sh_link of a reloc section is the section index of the symbol
3033 table. sh_info is the section index of the section to which
3034 the relocation entries apply. */
3035 if (d->rel_idx != 0)
3037 d->rel_hdr.sh_link = t->symtab_section;
3038 d->rel_hdr.sh_info = d->this_idx;
3040 if (d->rel_idx2 != 0)
3042 d->rel_hdr2->sh_link = t->symtab_section;
3043 d->rel_hdr2->sh_info = d->this_idx;
3046 /* We need to set up sh_link for SHF_LINK_ORDER. */
3047 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3049 s = elf_linked_to_section (sec);
3051 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3054 struct bfd_link_order *p;
3056 /* Find out what the corresponding section in output
3058 for (p = sec->map_head.link_order; p != NULL; p = p->next)
3060 s = p->u.indirect.section;
3061 if (p->type == bfd_indirect_link_order
3062 && (bfd_get_flavour (s->owner)
3063 == bfd_target_elf_flavour))
3065 Elf_Internal_Shdr ** const elf_shdrp
3066 = elf_elfsections (s->owner);
3068 = _bfd_elf_section_from_bfd_section (s->owner, s);
3069 elfsec = elf_shdrp[elfsec]->sh_link;
3071 The Intel C compiler generates SHT_IA_64_UNWIND with
3072 SHF_LINK_ORDER. But it doesn't set the sh_link or
3073 sh_info fields. Hence we could get the situation
3074 where elfsec is 0. */
3077 const struct elf_backend_data *bed
3078 = get_elf_backend_data (abfd);
3079 if (bed->link_order_error_handler)
3080 bed->link_order_error_handler
3081 (_("%B: warning: sh_link not set for section `%A'"),
3086 s = elf_shdrp[elfsec]->bfd_section;
3087 if (elf_discarded_section (s))
3090 (*_bfd_error_handler)
3091 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3092 abfd, d->this_hdr.bfd_section,
3094 /* Point to the kept section if it has
3095 the same size as the discarded
3097 kept = _bfd_elf_check_kept_section (s);
3100 bfd_set_error (bfd_error_bad_value);
3105 s = s->output_section;
3106 BFD_ASSERT (s != NULL);
3107 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3115 switch (d->this_hdr.sh_type)
3119 /* A reloc section which we are treating as a normal BFD
3120 section. sh_link is the section index of the symbol
3121 table. sh_info is the section index of the section to
3122 which the relocation entries apply. We assume that an
3123 allocated reloc section uses the dynamic symbol table.
3124 FIXME: How can we be sure? */
3125 s = bfd_get_section_by_name (abfd, ".dynsym");
3127 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3129 /* We look up the section the relocs apply to by name. */
3131 if (d->this_hdr.sh_type == SHT_REL)
3135 s = bfd_get_section_by_name (abfd, name);
3137 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3141 /* We assume that a section named .stab*str is a stabs
3142 string section. We look for a section with the same name
3143 but without the trailing ``str'', and set its sh_link
3144 field to point to this section. */
3145 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
3146 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3151 len = strlen (sec->name);
3152 alc = bfd_malloc (len - 2);
3155 memcpy (alc, sec->name, len - 3);
3156 alc[len - 3] = '\0';
3157 s = bfd_get_section_by_name (abfd, alc);
3161 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3163 /* This is a .stab section. */
3164 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3165 elf_section_data (s)->this_hdr.sh_entsize
3166 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3173 case SHT_GNU_verneed:
3174 case SHT_GNU_verdef:
3175 /* sh_link is the section header index of the string table
3176 used for the dynamic entries, or the symbol table, or the
3178 s = bfd_get_section_by_name (abfd, ".dynstr");
3180 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3183 case SHT_GNU_LIBLIST:
3184 /* sh_link is the section header index of the prelink library
3186 used for the dynamic entries, or the symbol table, or the
3188 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3189 ? ".dynstr" : ".gnu.libstr");
3191 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3195 case SHT_GNU_versym:
3196 /* sh_link is the section header index of the symbol table
3197 this hash table or version table is for. */
3198 s = bfd_get_section_by_name (abfd, ".dynsym");
3200 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3204 d->this_hdr.sh_link = t->symtab_section;
3208 for (secn = 1; secn < section_number; ++secn)
3209 if (i_shdrp[secn] == NULL)
3210 i_shdrp[secn] = i_shdrp[0];
3212 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3213 i_shdrp[secn]->sh_name);
3217 /* Map symbol from it's internal number to the external number, moving
3218 all local symbols to be at the head of the list. */
3221 sym_is_global (bfd *abfd, asymbol *sym)
3223 /* If the backend has a special mapping, use it. */
3224 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3225 if (bed->elf_backend_sym_is_global)
3226 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3228 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3229 || bfd_is_und_section (bfd_get_section (sym))
3230 || bfd_is_com_section (bfd_get_section (sym)));
3234 elf_map_symbols (bfd *abfd)
3236 unsigned int symcount = bfd_get_symcount (abfd);
3237 asymbol **syms = bfd_get_outsymbols (abfd);
3238 asymbol **sect_syms;
3239 unsigned int num_locals = 0;
3240 unsigned int num_globals = 0;
3241 unsigned int num_locals2 = 0;
3242 unsigned int num_globals2 = 0;
3250 fprintf (stderr, "elf_map_symbols\n");
3254 for (asect = abfd->sections; asect; asect = asect->next)
3256 if (max_index < asect->index)
3257 max_index = asect->index;
3261 amt = max_index * sizeof (asymbol *);
3262 sect_syms = bfd_zalloc (abfd, amt);
3263 if (sect_syms == NULL)
3265 elf_section_syms (abfd) = sect_syms;
3266 elf_num_section_syms (abfd) = max_index;
3268 /* Init sect_syms entries for any section symbols we have already
3269 decided to output. */
3270 for (idx = 0; idx < symcount; idx++)
3272 asymbol *sym = syms[idx];
3274 if ((sym->flags & BSF_SECTION_SYM) != 0
3281 if (sec->owner != NULL)
3283 if (sec->owner != abfd)
3285 if (sec->output_offset != 0)
3288 sec = sec->output_section;
3290 /* Empty sections in the input files may have had a
3291 section symbol created for them. (See the comment
3292 near the end of _bfd_generic_link_output_symbols in
3293 linker.c). If the linker script discards such
3294 sections then we will reach this point. Since we know
3295 that we cannot avoid this case, we detect it and skip
3296 the abort and the assignment to the sect_syms array.
3297 To reproduce this particular case try running the
3298 linker testsuite test ld-scripts/weak.exp for an ELF
3299 port that uses the generic linker. */
3300 if (sec->owner == NULL)
3303 BFD_ASSERT (sec->owner == abfd);
3305 sect_syms[sec->index] = syms[idx];
3310 /* Classify all of the symbols. */
3311 for (idx = 0; idx < symcount; idx++)
3313 if (!sym_is_global (abfd, syms[idx]))
3319 /* We will be adding a section symbol for each BFD section. Most normal
3320 sections will already have a section symbol in outsymbols, but
3321 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3322 at least in that case. */
3323 for (asect = abfd->sections; asect; asect = asect->next)
3325 if (sect_syms[asect->index] == NULL)
3327 if (!sym_is_global (abfd, asect->symbol))
3334 /* Now sort the symbols so the local symbols are first. */
3335 amt = (num_locals + num_globals) * sizeof (asymbol *);
3336 new_syms = bfd_alloc (abfd, amt);
3338 if (new_syms == NULL)
3341 for (idx = 0; idx < symcount; idx++)
3343 asymbol *sym = syms[idx];
3346 if (!sym_is_global (abfd, sym))
3349 i = num_locals + num_globals2++;
3351 sym->udata.i = i + 1;
3353 for (asect = abfd->sections; asect; asect = asect->next)
3355 if (sect_syms[asect->index] == NULL)
3357 asymbol *sym = asect->symbol;
3360 sect_syms[asect->index] = sym;
3361 if (!sym_is_global (abfd, sym))
3364 i = num_locals + num_globals2++;
3366 sym->udata.i = i + 1;
3370 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3372 elf_num_locals (abfd) = num_locals;
3373 elf_num_globals (abfd) = num_globals;
3377 /* Align to the maximum file alignment that could be required for any
3378 ELF data structure. */
3380 static inline file_ptr
3381 align_file_position (file_ptr off, int align)
3383 return (off + align - 1) & ~(align - 1);
3386 /* Assign a file position to a section, optionally aligning to the
3387 required section alignment. */
3390 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3398 al = i_shdrp->sh_addralign;
3400 offset = BFD_ALIGN (offset, al);
3402 i_shdrp->sh_offset = offset;
3403 if (i_shdrp->bfd_section != NULL)
3404 i_shdrp->bfd_section->filepos = offset;
3405 if (i_shdrp->sh_type != SHT_NOBITS)
3406 offset += i_shdrp->sh_size;
3410 /* Compute the file positions we are going to put the sections at, and
3411 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3412 is not NULL, this is being called by the ELF backend linker. */
3415 _bfd_elf_compute_section_file_positions (bfd *abfd,
3416 struct bfd_link_info *link_info)
3418 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3420 struct bfd_strtab_hash *strtab = NULL;
3421 Elf_Internal_Shdr *shstrtab_hdr;
3423 if (abfd->output_has_begun)
3426 /* Do any elf backend specific processing first. */
3427 if (bed->elf_backend_begin_write_processing)
3428 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3430 if (! prep_headers (abfd))
3433 /* Post process the headers if necessary. */
3434 if (bed->elf_backend_post_process_headers)
3435 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3438 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3442 if (!assign_section_numbers (abfd, link_info))
3445 /* The backend linker builds symbol table information itself. */
3446 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3448 /* Non-zero if doing a relocatable link. */
3449 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3451 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3455 if (link_info == NULL)
3457 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3462 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3463 /* sh_name was set in prep_headers. */
3464 shstrtab_hdr->sh_type = SHT_STRTAB;
3465 shstrtab_hdr->sh_flags = 0;
3466 shstrtab_hdr->sh_addr = 0;
3467 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3468 shstrtab_hdr->sh_entsize = 0;
3469 shstrtab_hdr->sh_link = 0;
3470 shstrtab_hdr->sh_info = 0;
3471 /* sh_offset is set in assign_file_positions_except_relocs. */
3472 shstrtab_hdr->sh_addralign = 1;
3474 if (!assign_file_positions_except_relocs (abfd, link_info))
3477 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3480 Elf_Internal_Shdr *hdr;
3482 off = elf_tdata (abfd)->next_file_pos;
3484 hdr = &elf_tdata (abfd)->symtab_hdr;
3485 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3487 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3488 if (hdr->sh_size != 0)
3489 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3491 hdr = &elf_tdata (abfd)->strtab_hdr;
3492 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3494 elf_tdata (abfd)->next_file_pos = off;
3496 /* Now that we know where the .strtab section goes, write it
3498 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3499 || ! _bfd_stringtab_emit (abfd, strtab))
3501 _bfd_stringtab_free (strtab);
3504 abfd->output_has_begun = TRUE;
3509 /* Create a mapping from a set of sections to a program segment. */
3511 static struct elf_segment_map *
3512 make_mapping (bfd *abfd,
3513 asection **sections,
3518 struct elf_segment_map *m;
3523 amt = sizeof (struct elf_segment_map);
3524 amt += (to - from - 1) * sizeof (asection *);
3525 m = bfd_zalloc (abfd, amt);
3529 m->p_type = PT_LOAD;
3530 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3531 m->sections[i - from] = *hdrpp;
3532 m->count = to - from;
3534 if (from == 0 && phdr)
3536 /* Include the headers in the first PT_LOAD segment. */
3537 m->includes_filehdr = 1;
3538 m->includes_phdrs = 1;
3544 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3547 struct elf_segment_map *
3548 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3550 struct elf_segment_map *m;
3552 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3556 m->p_type = PT_DYNAMIC;
3558 m->sections[0] = dynsec;
3563 /* Set up a mapping from BFD sections to program segments. */
3566 map_sections_to_segments (bfd *abfd)
3568 asection **sections = NULL;
3572 struct elf_segment_map *mfirst;
3573 struct elf_segment_map **pm;
3574 struct elf_segment_map *m;
3577 unsigned int phdr_index;
3578 bfd_vma maxpagesize;
3580 bfd_boolean phdr_in_segment = TRUE;
3581 bfd_boolean writable;
3583 asection *first_tls = NULL;
3584 asection *dynsec, *eh_frame_hdr;
3587 if (elf_tdata (abfd)->segment_map != NULL)
3590 if (bfd_count_sections (abfd) == 0)
3593 /* Select the allocated sections, and sort them. */
3595 amt = bfd_count_sections (abfd) * sizeof (asection *);
3596 sections = bfd_malloc (amt);
3597 if (sections == NULL)
3601 for (s = abfd->sections; s != NULL; s = s->next)
3603 if ((s->flags & SEC_ALLOC) != 0)
3609 BFD_ASSERT (i <= bfd_count_sections (abfd));
3612 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3614 /* Build the mapping. */
3619 /* If we have a .interp section, then create a PT_PHDR segment for
3620 the program headers and a PT_INTERP segment for the .interp
3622 s = bfd_get_section_by_name (abfd, ".interp");
3623 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3625 amt = sizeof (struct elf_segment_map);
3626 m = bfd_zalloc (abfd, amt);
3630 m->p_type = PT_PHDR;
3631 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3632 m->p_flags = PF_R | PF_X;
3633 m->p_flags_valid = 1;
3634 m->includes_phdrs = 1;
3639 amt = sizeof (struct elf_segment_map);
3640 m = bfd_zalloc (abfd, amt);
3644 m->p_type = PT_INTERP;
3652 /* Look through the sections. We put sections in the same program
3653 segment when the start of the second section can be placed within
3654 a few bytes of the end of the first section. */
3658 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3660 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3662 && (dynsec->flags & SEC_LOAD) == 0)
3665 /* Deal with -Ttext or something similar such that the first section
3666 is not adjacent to the program headers. This is an
3667 approximation, since at this point we don't know exactly how many
3668 program headers we will need. */
3671 bfd_size_type phdr_size;
3673 phdr_size = elf_tdata (abfd)->program_header_size;
3675 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3676 if ((abfd->flags & D_PAGED) == 0
3677 || sections[0]->lma < phdr_size
3678 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3679 phdr_in_segment = FALSE;
3682 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3685 bfd_boolean new_segment;
3689 /* See if this section and the last one will fit in the same
3692 if (last_hdr == NULL)
3694 /* If we don't have a segment yet, then we don't need a new
3695 one (we build the last one after this loop). */
3696 new_segment = FALSE;
3698 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3700 /* If this section has a different relation between the
3701 virtual address and the load address, then we need a new
3705 else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3706 < BFD_ALIGN (hdr->lma, maxpagesize))
3708 /* If putting this section in this segment would force us to
3709 skip a page in the segment, then we need a new segment. */
3712 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3713 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3715 /* We don't want to put a loadable section after a
3716 nonloadable section in the same segment.
3717 Consider .tbss sections as loadable for this purpose. */
3720 else if ((abfd->flags & D_PAGED) == 0)
3722 /* If the file is not demand paged, which means that we
3723 don't require the sections to be correctly aligned in the
3724 file, then there is no other reason for a new segment. */
3725 new_segment = FALSE;
3728 && (hdr->flags & SEC_READONLY) == 0
3729 && (((last_hdr->lma + last_size - 1)
3730 & ~(maxpagesize - 1))
3731 != (hdr->lma & ~(maxpagesize - 1))))
3733 /* We don't want to put a writable section in a read only
3734 segment, unless they are on the same page in memory
3735 anyhow. We already know that the last section does not
3736 bring us past the current section on the page, so the
3737 only case in which the new section is not on the same
3738 page as the previous section is when the previous section
3739 ends precisely on a page boundary. */
3744 /* Otherwise, we can use the same segment. */
3745 new_segment = FALSE;
3750 if ((hdr->flags & SEC_READONLY) == 0)
3753 /* .tbss sections effectively have zero size. */
3754 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3755 last_size = hdr->size;
3761 /* We need a new program segment. We must create a new program
3762 header holding all the sections from phdr_index until hdr. */
3764 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3771 if ((hdr->flags & SEC_READONLY) == 0)
3777 /* .tbss sections effectively have zero size. */
3778 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3779 last_size = hdr->size;
3783 phdr_in_segment = FALSE;
3786 /* Create a final PT_LOAD program segment. */
3787 if (last_hdr != NULL)
3789 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3797 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3800 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3807 /* For each loadable .note section, add a PT_NOTE segment. We don't
3808 use bfd_get_section_by_name, because if we link together
3809 nonloadable .note sections and loadable .note sections, we will
3810 generate two .note sections in the output file. FIXME: Using
3811 names for section types is bogus anyhow. */
3812 for (s = abfd->sections; s != NULL; s = s->next)
3814 if ((s->flags & SEC_LOAD) != 0
3815 && strncmp (s->name, ".note", 5) == 0)
3817 amt = sizeof (struct elf_segment_map);
3818 m = bfd_zalloc (abfd, amt);
3822 m->p_type = PT_NOTE;
3829 if (s->flags & SEC_THREAD_LOCAL)
3837 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3842 amt = sizeof (struct elf_segment_map);
3843 amt += (tls_count - 1) * sizeof (asection *);
3844 m = bfd_zalloc (abfd, amt);
3849 m->count = tls_count;
3850 /* Mandated PF_R. */
3852 m->p_flags_valid = 1;
3853 for (i = 0; i < tls_count; ++i)
3855 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3856 m->sections[i] = first_tls;
3857 first_tls = first_tls->next;
3864 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3866 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3867 if (eh_frame_hdr != NULL
3868 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3870 amt = sizeof (struct elf_segment_map);
3871 m = bfd_zalloc (abfd, amt);
3875 m->p_type = PT_GNU_EH_FRAME;
3877 m->sections[0] = eh_frame_hdr->output_section;
3883 if (elf_tdata (abfd)->stack_flags)
3885 amt = sizeof (struct elf_segment_map);
3886 m = bfd_zalloc (abfd, amt);
3890 m->p_type = PT_GNU_STACK;
3891 m->p_flags = elf_tdata (abfd)->stack_flags;
3892 m->p_flags_valid = 1;
3898 if (elf_tdata (abfd)->relro)
3900 amt = sizeof (struct elf_segment_map);
3901 m = bfd_zalloc (abfd, amt);
3905 m->p_type = PT_GNU_RELRO;
3907 m->p_flags_valid = 1;
3916 elf_tdata (abfd)->segment_map = mfirst;
3920 if (sections != NULL)
3925 /* Sort sections by address. */
3928 elf_sort_sections (const void *arg1, const void *arg2)
3930 const asection *sec1 = *(const asection **) arg1;
3931 const asection *sec2 = *(const asection **) arg2;
3932 bfd_size_type size1, size2;
3934 /* Sort by LMA first, since this is the address used to
3935 place the section into a segment. */
3936 if (sec1->lma < sec2->lma)
3938 else if (sec1->lma > sec2->lma)
3941 /* Then sort by VMA. Normally the LMA and the VMA will be
3942 the same, and this will do nothing. */
3943 if (sec1->vma < sec2->vma)
3945 else if (sec1->vma > sec2->vma)
3948 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3950 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3956 /* If the indicies are the same, do not return 0
3957 here, but continue to try the next comparison. */
3958 if (sec1->target_index - sec2->target_index != 0)
3959 return sec1->target_index - sec2->target_index;
3964 else if (TOEND (sec2))
3969 /* Sort by size, to put zero sized sections
3970 before others at the same address. */
3972 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
3973 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
3980 return sec1->target_index - sec2->target_index;
3983 /* Ian Lance Taylor writes:
3985 We shouldn't be using % with a negative signed number. That's just
3986 not good. We have to make sure either that the number is not
3987 negative, or that the number has an unsigned type. When the types
3988 are all the same size they wind up as unsigned. When file_ptr is a
3989 larger signed type, the arithmetic winds up as signed long long,
3992 What we're trying to say here is something like ``increase OFF by
3993 the least amount that will cause it to be equal to the VMA modulo
3995 /* In other words, something like:
3997 vma_offset = m->sections[0]->vma % bed->maxpagesize;
3998 off_offset = off % bed->maxpagesize;
3999 if (vma_offset < off_offset)
4000 adjustment = vma_offset + bed->maxpagesize - off_offset;
4002 adjustment = vma_offset - off_offset;
4004 which can can be collapsed into the expression below. */
4007 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4009 return ((vma - off) % maxpagesize);
4012 /* Assign file positions to the sections based on the mapping from
4013 sections to segments. This function also sets up some fields in
4014 the file header, and writes out the program headers. */
4017 assign_file_positions_for_segments (bfd *abfd, struct bfd_link_info *link_info)
4019 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4021 struct elf_segment_map *m;
4023 Elf_Internal_Phdr *phdrs;
4025 bfd_vma filehdr_vaddr, filehdr_paddr;
4026 bfd_vma phdrs_vaddr, phdrs_paddr;
4027 Elf_Internal_Phdr *p;
4030 if (elf_tdata (abfd)->segment_map == NULL)
4032 if (! map_sections_to_segments (abfd))
4037 /* The placement algorithm assumes that non allocated sections are
4038 not in PT_LOAD segments. We ensure this here by removing such
4039 sections from the segment map. We also remove excluded
4041 for (m = elf_tdata (abfd)->segment_map;
4045 unsigned int new_count;
4049 for (i = 0; i < m->count; i ++)
4051 if ((m->sections[i]->flags & SEC_EXCLUDE) == 0
4052 && ((m->sections[i]->flags & SEC_ALLOC) != 0
4053 || m->p_type != PT_LOAD))
4056 m->sections[new_count] = m->sections[i];
4062 if (new_count != m->count)
4063 m->count = new_count;
4067 if (bed->elf_backend_modify_segment_map)
4069 if (! (*bed->elf_backend_modify_segment_map) (abfd, link_info))
4074 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4077 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4078 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4079 elf_elfheader (abfd)->e_phnum = count;
4083 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4087 /* If we already counted the number of program segments, make sure
4088 that we allocated enough space. This happens when SIZEOF_HEADERS
4089 is used in a linker script. */
4090 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
4091 if (alloc != 0 && count > alloc)
4093 ((*_bfd_error_handler)
4094 (_("%B: Not enough room for program headers (allocated %u, need %u)"),
4095 abfd, alloc, count));
4096 bfd_set_error (bfd_error_bad_value);
4103 amt = alloc * sizeof (Elf_Internal_Phdr);
4104 phdrs = bfd_alloc (abfd, amt);
4108 off = bed->s->sizeof_ehdr;
4109 off += alloc * bed->s->sizeof_phdr;
4116 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4123 /* If elf_segment_map is not from map_sections_to_segments, the
4124 sections may not be correctly ordered. NOTE: sorting should
4125 not be done to the PT_NOTE section of a corefile, which may
4126 contain several pseudo-sections artificially created by bfd.
4127 Sorting these pseudo-sections breaks things badly. */
4129 && !(elf_elfheader (abfd)->e_type == ET_CORE
4130 && m->p_type == PT_NOTE))
4131 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4134 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4135 number of sections with contents contributing to both p_filesz
4136 and p_memsz, followed by a number of sections with no contents
4137 that just contribute to p_memsz. In this loop, OFF tracks next
4138 available file offset for PT_LOAD and PT_NOTE segments. VOFF is
4139 an adjustment we use for segments that have no file contents
4140 but need zero filled memory allocation. */
4142 p->p_type = m->p_type;
4143 p->p_flags = m->p_flags;
4145 if (p->p_type == PT_LOAD
4148 bfd_size_type align;
4150 unsigned int align_power = 0;
4152 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4154 unsigned int secalign;
4156 secalign = bfd_get_section_alignment (abfd, *secpp);
4157 if (secalign > align_power)
4158 align_power = secalign;
4160 align = (bfd_size_type) 1 << align_power;
4162 if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > align)
4163 align = bed->maxpagesize;
4165 adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4168 && !m->includes_filehdr
4169 && !m->includes_phdrs
4170 && (ufile_ptr) off >= align)
4172 /* If the first section isn't loadable, the same holds for
4173 any other sections. Since the segment won't need file
4174 space, we can make p_offset overlap some prior segment.
4175 However, .tbss is special. If a segment starts with
4176 .tbss, we need to look at the next section to decide
4177 whether the segment has any loadable sections. */
4179 while ((m->sections[i]->flags & SEC_LOAD) == 0)
4181 if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
4185 voff = adjust - align;
4191 /* Make sure the .dynamic section is the first section in the
4192 PT_DYNAMIC segment. */
4193 else if (p->p_type == PT_DYNAMIC
4195 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4198 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4200 bfd_set_error (bfd_error_bad_value);
4207 p->p_vaddr = m->sections[0]->vma;
4209 if (m->p_paddr_valid)
4210 p->p_paddr = m->p_paddr;
4211 else if (m->count == 0)
4214 p->p_paddr = m->sections[0]->lma;
4216 if (p->p_type == PT_LOAD
4217 && (abfd->flags & D_PAGED) != 0)
4218 p->p_align = bed->maxpagesize;
4219 else if (m->count == 0)
4220 p->p_align = 1 << bed->s->log_file_align;
4228 if (m->includes_filehdr)
4230 if (! m->p_flags_valid)
4233 p->p_filesz = bed->s->sizeof_ehdr;
4234 p->p_memsz = bed->s->sizeof_ehdr;
4237 BFD_ASSERT (p->p_type == PT_LOAD);
4239 if (p->p_vaddr < (bfd_vma) off)
4241 (*_bfd_error_handler)
4242 (_("%B: Not enough room for program headers, try linking with -N"),
4244 bfd_set_error (bfd_error_bad_value);
4249 if (! m->p_paddr_valid)
4252 if (p->p_type == PT_LOAD)
4254 filehdr_vaddr = p->p_vaddr;
4255 filehdr_paddr = p->p_paddr;
4259 if (m->includes_phdrs)
4261 if (! m->p_flags_valid)
4264 if (m->includes_filehdr)
4266 if (p->p_type == PT_LOAD)
4268 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4269 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4274 p->p_offset = bed->s->sizeof_ehdr;
4278 BFD_ASSERT (p->p_type == PT_LOAD);
4279 p->p_vaddr -= off - p->p_offset;
4280 if (! m->p_paddr_valid)
4281 p->p_paddr -= off - p->p_offset;
4284 if (p->p_type == PT_LOAD)
4286 phdrs_vaddr = p->p_vaddr;
4287 phdrs_paddr = p->p_paddr;
4290 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4293 p->p_filesz += alloc * bed->s->sizeof_phdr;
4294 p->p_memsz += alloc * bed->s->sizeof_phdr;
4297 if (p->p_type == PT_LOAD
4298 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4300 if (! m->includes_filehdr && ! m->includes_phdrs)
4301 p->p_offset = off + voff;
4306 adjust = off - (p->p_offset + p->p_filesz);
4307 p->p_filesz += adjust;
4308 p->p_memsz += adjust;
4312 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4316 bfd_size_type align;
4320 align = 1 << bfd_get_section_alignment (abfd, sec);
4322 if (p->p_type == PT_LOAD
4323 || p->p_type == PT_TLS)
4325 bfd_signed_vma adjust;
4327 if ((flags & SEC_LOAD) != 0)
4329 adjust = sec->lma - (p->p_paddr + p->p_filesz);
4332 (*_bfd_error_handler)
4333 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4334 abfd, sec, (unsigned long) sec->lma);
4338 p->p_filesz += adjust;
4339 p->p_memsz += adjust;
4341 /* .tbss is special. It doesn't contribute to p_memsz of
4343 else if ((flags & SEC_THREAD_LOCAL) == 0
4344 || p->p_type == PT_TLS)
4346 /* The section VMA must equal the file position
4347 modulo the page size. */
4348 bfd_size_type page = align;
4349 if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > page)
4350 page = bed->maxpagesize;
4351 adjust = vma_page_aligned_bias (sec->vma,
4352 p->p_vaddr + p->p_memsz,
4354 p->p_memsz += adjust;
4358 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4360 /* The section at i == 0 is the one that actually contains
4366 p->p_filesz = sec->size;
4372 /* The rest are fake sections that shouldn't be written. */
4381 if (p->p_type == PT_LOAD)
4384 /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4385 1997, and the exact reason for it isn't clear. One
4386 plausible explanation is that it is to work around
4387 a problem we have with linker scripts using data
4388 statements in NOLOAD sections. I don't think it
4389 makes a great deal of sense to have such a section
4390 assigned to a PT_LOAD segment, but apparently
4391 people do this. The data statement results in a
4392 bfd_data_link_order being built, and these need
4393 section contents to write into. Eventually, we get
4394 to _bfd_elf_write_object_contents which writes any
4395 section with contents to the output. Make room
4396 here for the write, so that following segments are
4398 if ((flags & SEC_LOAD) != 0
4399 || (flags & SEC_HAS_CONTENTS) != 0)
4403 if ((flags & SEC_LOAD) != 0)
4405 p->p_filesz += sec->size;
4406 p->p_memsz += sec->size;
4408 /* PR ld/594: Sections in note segments which are not loaded
4409 contribute to the file size but not the in-memory size. */
4410 else if (p->p_type == PT_NOTE
4411 && (flags & SEC_HAS_CONTENTS) != 0)
4412 p->p_filesz += sec->size;
4414 /* .tbss is special. It doesn't contribute to p_memsz of
4416 else if ((flags & SEC_THREAD_LOCAL) == 0
4417 || p->p_type == PT_TLS)
4418 p->p_memsz += sec->size;
4420 if (p->p_type == PT_TLS
4422 && (sec->flags & SEC_HAS_CONTENTS) == 0)
4424 struct bfd_link_order *o;
4425 bfd_vma tbss_size = 0;
4427 for (o = sec->map_head.link_order; o != NULL; o = o->next)
4428 if (tbss_size < o->offset + o->size)
4429 tbss_size = o->offset + o->size;
4431 p->p_memsz += tbss_size;
4434 if (align > p->p_align
4435 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
4439 if (! m->p_flags_valid)
4442 if ((flags & SEC_CODE) != 0)
4444 if ((flags & SEC_READONLY) == 0)
4450 /* Now that we have set the section file positions, we can set up
4451 the file positions for the non PT_LOAD segments. */
4452 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4456 if (p->p_type != PT_LOAD && m->count > 0)
4458 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
4459 /* If the section has not yet been assigned a file position,
4460 do so now. The ARM BPABI requires that .dynamic section
4461 not be marked SEC_ALLOC because it is not part of any
4462 PT_LOAD segment, so it will not be processed above. */
4463 if (p->p_type == PT_DYNAMIC && m->sections[0]->filepos == 0)
4466 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4469 while (i_shdrpp[i]->bfd_section != m->sections[0])
4471 off = (_bfd_elf_assign_file_position_for_section
4472 (i_shdrpp[i], off, TRUE));
4473 p->p_filesz = m->sections[0]->size;
4475 p->p_offset = m->sections[0]->filepos;
4479 if (m->includes_filehdr)
4481 p->p_vaddr = filehdr_vaddr;
4482 if (! m->p_paddr_valid)
4483 p->p_paddr = filehdr_paddr;
4485 else if (m->includes_phdrs)
4487 p->p_vaddr = phdrs_vaddr;
4488 if (! m->p_paddr_valid)
4489 p->p_paddr = phdrs_paddr;
4491 else if (p->p_type == PT_GNU_RELRO)
4493 Elf_Internal_Phdr *lp;
4495 for (lp = phdrs; lp < phdrs + count; ++lp)
4497 if (lp->p_type == PT_LOAD
4498 && lp->p_vaddr <= link_info->relro_end
4499 && lp->p_vaddr >= link_info->relro_start
4500 && lp->p_vaddr + lp->p_filesz
4501 >= link_info->relro_end)
4505 if (lp < phdrs + count
4506 && link_info->relro_end > lp->p_vaddr)
4508 p->p_vaddr = lp->p_vaddr;
4509 p->p_paddr = lp->p_paddr;
4510 p->p_offset = lp->p_offset;
4511 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4512 p->p_memsz = p->p_filesz;
4514 p->p_flags = (lp->p_flags & ~PF_W);
4518 memset (p, 0, sizeof *p);
4519 p->p_type = PT_NULL;
4525 /* Clear out any program headers we allocated but did not use. */
4526 for (; count < alloc; count++, p++)
4528 memset (p, 0, sizeof *p);
4529 p->p_type = PT_NULL;
4532 elf_tdata (abfd)->phdr = phdrs;
4534 elf_tdata (abfd)->next_file_pos = off;
4536 /* Write out the program headers. */
4537 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4538 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4544 /* Get the size of the program header.
4546 If this is called by the linker before any of the section VMA's are set, it
4547 can't calculate the correct value for a strange memory layout. This only
4548 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4549 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4550 data segment (exclusive of .interp and .dynamic).
4552 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4553 will be two segments. */
4555 static bfd_size_type
4556 get_program_header_size (bfd *abfd)
4560 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4562 /* We can't return a different result each time we're called. */
4563 if (elf_tdata (abfd)->program_header_size != 0)
4564 return elf_tdata (abfd)->program_header_size;
4566 if (elf_tdata (abfd)->segment_map != NULL)
4568 struct elf_segment_map *m;
4571 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4573 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4574 return elf_tdata (abfd)->program_header_size;
4577 /* Assume we will need exactly two PT_LOAD segments: one for text
4578 and one for data. */
4581 s = bfd_get_section_by_name (abfd, ".interp");
4582 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4584 /* If we have a loadable interpreter section, we need a
4585 PT_INTERP segment. In this case, assume we also need a
4586 PT_PHDR segment, although that may not be true for all
4591 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4593 /* We need a PT_DYNAMIC segment. */
4597 if (elf_tdata (abfd)->eh_frame_hdr)
4599 /* We need a PT_GNU_EH_FRAME segment. */
4603 if (elf_tdata (abfd)->stack_flags)
4605 /* We need a PT_GNU_STACK segment. */
4609 if (elf_tdata (abfd)->relro)
4611 /* We need a PT_GNU_RELRO segment. */
4615 for (s = abfd->sections; s != NULL; s = s->next)
4617 if ((s->flags & SEC_LOAD) != 0
4618 && strncmp (s->name, ".note", 5) == 0)
4620 /* We need a PT_NOTE segment. */
4625 for (s = abfd->sections; s != NULL; s = s->next)
4627 if (s->flags & SEC_THREAD_LOCAL)
4629 /* We need a PT_TLS segment. */
4635 /* Let the backend count up any program headers it might need. */
4636 if (bed->elf_backend_additional_program_headers)
4640 a = (*bed->elf_backend_additional_program_headers) (abfd);
4646 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4647 return elf_tdata (abfd)->program_header_size;
4650 /* Work out the file positions of all the sections. This is called by
4651 _bfd_elf_compute_section_file_positions. All the section sizes and
4652 VMAs must be known before this is called.
4654 Reloc sections come in two flavours: Those processed specially as
4655 "side-channel" data attached to a section to which they apply, and
4656 those that bfd doesn't process as relocations. The latter sort are
4657 stored in a normal bfd section by bfd_section_from_shdr. We don't
4658 consider the former sort here, unless they form part of the loadable
4659 image. Reloc sections not assigned here will be handled later by
4660 assign_file_positions_for_relocs.
4662 We also don't set the positions of the .symtab and .strtab here. */
4665 assign_file_positions_except_relocs (bfd *abfd,
4666 struct bfd_link_info *link_info)
4668 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4669 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4670 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4671 unsigned int num_sec = elf_numsections (abfd);
4673 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4675 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4676 && bfd_get_format (abfd) != bfd_core)
4678 Elf_Internal_Shdr **hdrpp;
4681 /* Start after the ELF header. */
4682 off = i_ehdrp->e_ehsize;
4684 /* We are not creating an executable, which means that we are
4685 not creating a program header, and that the actual order of
4686 the sections in the file is unimportant. */
4687 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4689 Elf_Internal_Shdr *hdr;
4692 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4693 && hdr->bfd_section == NULL)
4694 || i == tdata->symtab_section
4695 || i == tdata->symtab_shndx_section
4696 || i == tdata->strtab_section)
4698 hdr->sh_offset = -1;
4701 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4703 if (i == SHN_LORESERVE - 1)
4705 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4706 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4713 Elf_Internal_Shdr **hdrpp;
4715 /* Assign file positions for the loaded sections based on the
4716 assignment of sections to segments. */
4717 if (! assign_file_positions_for_segments (abfd, link_info))
4720 /* Assign file positions for the other sections. */
4722 off = elf_tdata (abfd)->next_file_pos;
4723 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4725 Elf_Internal_Shdr *hdr;
4728 if (hdr->bfd_section != NULL
4729 && hdr->bfd_section->filepos != 0)
4730 hdr->sh_offset = hdr->bfd_section->filepos;
4731 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4733 ((*_bfd_error_handler)
4734 (_("%B: warning: allocated section `%s' not in segment"),
4736 (hdr->bfd_section == NULL
4738 : hdr->bfd_section->name)));
4739 if ((abfd->flags & D_PAGED) != 0)
4740 off += vma_page_aligned_bias (hdr->sh_addr, off,
4743 off += vma_page_aligned_bias (hdr->sh_addr, off,
4745 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4748 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4749 && hdr->bfd_section == NULL)
4750 || hdr == i_shdrpp[tdata->symtab_section]
4751 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4752 || hdr == i_shdrpp[tdata->strtab_section])
4753 hdr->sh_offset = -1;
4755 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4757 if (i == SHN_LORESERVE - 1)
4759 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4760 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4765 /* Place the section headers. */
4766 off = align_file_position (off, 1 << bed->s->log_file_align);
4767 i_ehdrp->e_shoff = off;
4768 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4770 elf_tdata (abfd)->next_file_pos = off;
4776 prep_headers (bfd *abfd)
4778 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4779 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4780 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
4781 struct elf_strtab_hash *shstrtab;
4782 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4784 i_ehdrp = elf_elfheader (abfd);
4785 i_shdrp = elf_elfsections (abfd);
4787 shstrtab = _bfd_elf_strtab_init ();
4788 if (shstrtab == NULL)
4791 elf_shstrtab (abfd) = shstrtab;
4793 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4794 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4795 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4796 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4798 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4799 i_ehdrp->e_ident[EI_DATA] =
4800 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4801 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4803 if ((abfd->flags & DYNAMIC) != 0)
4804 i_ehdrp->e_type = ET_DYN;
4805 else if ((abfd->flags & EXEC_P) != 0)
4806 i_ehdrp->e_type = ET_EXEC;
4807 else if (bfd_get_format (abfd) == bfd_core)
4808 i_ehdrp->e_type = ET_CORE;
4810 i_ehdrp->e_type = ET_REL;
4812 switch (bfd_get_arch (abfd))
4814 case bfd_arch_unknown:
4815 i_ehdrp->e_machine = EM_NONE;
4818 /* There used to be a long list of cases here, each one setting
4819 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4820 in the corresponding bfd definition. To avoid duplication,
4821 the switch was removed. Machines that need special handling
4822 can generally do it in elf_backend_final_write_processing(),
4823 unless they need the information earlier than the final write.
4824 Such need can generally be supplied by replacing the tests for
4825 e_machine with the conditions used to determine it. */
4827 i_ehdrp->e_machine = bed->elf_machine_code;
4830 i_ehdrp->e_version = bed->s->ev_current;
4831 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4833 /* No program header, for now. */
4834 i_ehdrp->e_phoff = 0;
4835 i_ehdrp->e_phentsize = 0;
4836 i_ehdrp->e_phnum = 0;
4838 /* Each bfd section is section header entry. */
4839 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4840 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4842 /* If we're building an executable, we'll need a program header table. */
4843 if (abfd->flags & EXEC_P)
4844 /* It all happens later. */
4848 i_ehdrp->e_phentsize = 0;
4850 i_ehdrp->e_phoff = 0;
4853 elf_tdata (abfd)->symtab_hdr.sh_name =
4854 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4855 elf_tdata (abfd)->strtab_hdr.sh_name =
4856 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4857 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4858 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4859 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4860 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4861 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4867 /* Assign file positions for all the reloc sections which are not part
4868 of the loadable file image. */
4871 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4874 unsigned int i, num_sec;
4875 Elf_Internal_Shdr **shdrpp;
4877 off = elf_tdata (abfd)->next_file_pos;
4879 num_sec = elf_numsections (abfd);
4880 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4882 Elf_Internal_Shdr *shdrp;
4885 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4886 && shdrp->sh_offset == -1)
4887 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4890 elf_tdata (abfd)->next_file_pos = off;
4894 _bfd_elf_write_object_contents (bfd *abfd)
4896 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4897 Elf_Internal_Ehdr *i_ehdrp;
4898 Elf_Internal_Shdr **i_shdrp;
4900 unsigned int count, num_sec;
4902 if (! abfd->output_has_begun
4903 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4906 i_shdrp = elf_elfsections (abfd);
4907 i_ehdrp = elf_elfheader (abfd);
4910 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4914 _bfd_elf_assign_file_positions_for_relocs (abfd);
4916 /* After writing the headers, we need to write the sections too... */
4917 num_sec = elf_numsections (abfd);
4918 for (count = 1; count < num_sec; count++)
4920 if (bed->elf_backend_section_processing)
4921 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4922 if (i_shdrp[count]->contents)
4924 bfd_size_type amt = i_shdrp[count]->sh_size;
4926 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4927 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4930 if (count == SHN_LORESERVE - 1)
4931 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4934 /* Write out the section header names. */
4935 if (elf_shstrtab (abfd) != NULL
4936 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4937 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4940 if (bed->elf_backend_final_write_processing)
4941 (*bed->elf_backend_final_write_processing) (abfd,
4942 elf_tdata (abfd)->linker);
4944 return bed->s->write_shdrs_and_ehdr (abfd);
4948 _bfd_elf_write_corefile_contents (bfd *abfd)
4950 /* Hopefully this can be done just like an object file. */
4951 return _bfd_elf_write_object_contents (abfd);
4954 /* Given a section, search the header to find them. */
4957 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4959 const struct elf_backend_data *bed;
4962 if (elf_section_data (asect) != NULL
4963 && elf_section_data (asect)->this_idx != 0)
4964 return elf_section_data (asect)->this_idx;
4966 if (bfd_is_abs_section (asect))
4968 else if (bfd_is_com_section (asect))
4970 else if (bfd_is_und_section (asect))
4975 bed = get_elf_backend_data (abfd);
4976 if (bed->elf_backend_section_from_bfd_section)
4980 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4985 bfd_set_error (bfd_error_nonrepresentable_section);
4990 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4994 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4996 asymbol *asym_ptr = *asym_ptr_ptr;
4998 flagword flags = asym_ptr->flags;
5000 /* When gas creates relocations against local labels, it creates its
5001 own symbol for the section, but does put the symbol into the
5002 symbol chain, so udata is 0. When the linker is generating
5003 relocatable output, this section symbol may be for one of the
5004 input sections rather than the output section. */
5005 if (asym_ptr->udata.i == 0
5006 && (flags & BSF_SECTION_SYM)
5007 && asym_ptr->section)
5011 if (asym_ptr->section->output_section != NULL)
5012 indx = asym_ptr->section->output_section->index;
5014 indx = asym_ptr->section->index;
5015 if (indx < elf_num_section_syms (abfd)
5016 && elf_section_syms (abfd)[indx] != NULL)
5017 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5020 idx = asym_ptr->udata.i;
5024 /* This case can occur when using --strip-symbol on a symbol
5025 which is used in a relocation entry. */
5026 (*_bfd_error_handler)
5027 (_("%B: symbol `%s' required but not present"),
5028 abfd, bfd_asymbol_name (asym_ptr));
5029 bfd_set_error (bfd_error_no_symbols);
5036 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5037 (long) asym_ptr, asym_ptr->name, idx, flags,
5038 elf_symbol_flags (flags));
5046 /* Copy private BFD data. This copies any program header information. */
5049 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5051 Elf_Internal_Ehdr *iehdr;
5052 struct elf_segment_map *map;
5053 struct elf_segment_map *map_first;
5054 struct elf_segment_map **pointer_to_map;
5055 Elf_Internal_Phdr *segment;
5058 unsigned int num_segments;
5059 bfd_boolean phdr_included = FALSE;
5060 bfd_vma maxpagesize;
5061 struct elf_segment_map *phdr_adjust_seg = NULL;
5062 unsigned int phdr_adjust_num = 0;
5063 const struct elf_backend_data *bed;
5065 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5066 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5069 if (elf_tdata (ibfd)->phdr == NULL)
5072 bed = get_elf_backend_data (ibfd);
5073 iehdr = elf_elfheader (ibfd);
5076 pointer_to_map = &map_first;
5078 num_segments = elf_elfheader (ibfd)->e_phnum;
5079 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5081 /* Returns the end address of the segment + 1. */
5082 #define SEGMENT_END(segment, start) \
5083 (start + (segment->p_memsz > segment->p_filesz \
5084 ? segment->p_memsz : segment->p_filesz))
5086 #define SECTION_SIZE(section, segment) \
5087 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5088 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5089 ? section->size : 0)
5091 /* Returns TRUE if the given section is contained within
5092 the given segment. VMA addresses are compared. */
5093 #define IS_CONTAINED_BY_VMA(section, segment) \
5094 (section->vma >= segment->p_vaddr \
5095 && (section->vma + SECTION_SIZE (section, segment) \
5096 <= (SEGMENT_END (segment, segment->p_vaddr))))
5098 /* Returns TRUE if the given section is contained within
5099 the given segment. LMA addresses are compared. */
5100 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5101 (section->lma >= base \
5102 && (section->lma + SECTION_SIZE (section, segment) \
5103 <= SEGMENT_END (segment, base)))
5105 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
5106 #define IS_COREFILE_NOTE(p, s) \
5107 (p->p_type == PT_NOTE \
5108 && bfd_get_format (ibfd) == bfd_core \
5109 && s->vma == 0 && s->lma == 0 \
5110 && (bfd_vma) s->filepos >= p->p_offset \
5111 && ((bfd_vma) s->filepos + s->size \
5112 <= p->p_offset + p->p_filesz))
5114 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5115 linker, which generates a PT_INTERP section with p_vaddr and
5116 p_memsz set to 0. */
5117 #define IS_SOLARIS_PT_INTERP(p, s) \
5119 && p->p_paddr == 0 \
5120 && p->p_memsz == 0 \
5121 && p->p_filesz > 0 \
5122 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5124 && (bfd_vma) s->filepos >= p->p_offset \
5125 && ((bfd_vma) s->filepos + s->size \
5126 <= p->p_offset + p->p_filesz))
5128 /* Decide if the given section should be included in the given segment.
5129 A section will be included if:
5130 1. It is within the address space of the segment -- we use the LMA
5131 if that is set for the segment and the VMA otherwise,
5132 2. It is an allocated segment,
5133 3. There is an output section associated with it,
5134 4. The section has not already been allocated to a previous segment.
5135 5. PT_GNU_STACK segments do not include any sections.
5136 6. PT_TLS segment includes only SHF_TLS sections.
5137 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5138 8. PT_DYNAMIC should not contain empty sections at the beginning
5139 (with the possible exception of .dynamic). */
5140 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5141 ((((segment->p_paddr \
5142 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5143 : IS_CONTAINED_BY_VMA (section, segment)) \
5144 && (section->flags & SEC_ALLOC) != 0) \
5145 || IS_COREFILE_NOTE (segment, section)) \
5146 && section->output_section != NULL \
5147 && segment->p_type != PT_GNU_STACK \
5148 && (segment->p_type != PT_TLS \
5149 || (section->flags & SEC_THREAD_LOCAL)) \
5150 && (segment->p_type == PT_LOAD \
5151 || segment->p_type == PT_TLS \
5152 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5153 && (segment->p_type != PT_DYNAMIC \
5154 || SECTION_SIZE (section, segment) > 0 \
5155 || (segment->p_paddr \
5156 ? segment->p_paddr != section->lma \
5157 : segment->p_vaddr != section->vma) \
5158 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5160 && ! section->segment_mark)
5162 /* Returns TRUE iff seg1 starts after the end of seg2. */
5163 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5164 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5166 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5167 their VMA address ranges and their LMA address ranges overlap.
5168 It is possible to have overlapping VMA ranges without overlapping LMA
5169 ranges. RedBoot images for example can have both .data and .bss mapped
5170 to the same VMA range, but with the .data section mapped to a different
5172 #define SEGMENT_OVERLAPS(seg1, seg2) \
5173 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5174 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5175 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5176 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5178 /* Initialise the segment mark field. */
5179 for (section = ibfd->sections; section != NULL; section = section->next)
5180 section->segment_mark = FALSE;
5182 /* Scan through the segments specified in the program header
5183 of the input BFD. For this first scan we look for overlaps
5184 in the loadable segments. These can be created by weird
5185 parameters to objcopy. Also, fix some solaris weirdness. */
5186 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5191 Elf_Internal_Phdr *segment2;
5193 if (segment->p_type == PT_INTERP)
5194 for (section = ibfd->sections; section; section = section->next)
5195 if (IS_SOLARIS_PT_INTERP (segment, section))
5197 /* Mininal change so that the normal section to segment
5198 assignment code will work. */
5199 segment->p_vaddr = section->vma;
5203 if (segment->p_type != PT_LOAD)
5206 /* Determine if this segment overlaps any previous segments. */
5207 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5209 bfd_signed_vma extra_length;
5211 if (segment2->p_type != PT_LOAD
5212 || ! SEGMENT_OVERLAPS (segment, segment2))
5215 /* Merge the two segments together. */
5216 if (segment2->p_vaddr < segment->p_vaddr)
5218 /* Extend SEGMENT2 to include SEGMENT and then delete
5221 SEGMENT_END (segment, segment->p_vaddr)
5222 - SEGMENT_END (segment2, segment2->p_vaddr);
5224 if (extra_length > 0)
5226 segment2->p_memsz += extra_length;
5227 segment2->p_filesz += extra_length;
5230 segment->p_type = PT_NULL;
5232 /* Since we have deleted P we must restart the outer loop. */
5234 segment = elf_tdata (ibfd)->phdr;
5239 /* Extend SEGMENT to include SEGMENT2 and then delete
5242 SEGMENT_END (segment2, segment2->p_vaddr)
5243 - SEGMENT_END (segment, segment->p_vaddr);
5245 if (extra_length > 0)
5247 segment->p_memsz += extra_length;
5248 segment->p_filesz += extra_length;
5251 segment2->p_type = PT_NULL;
5256 /* The second scan attempts to assign sections to segments. */
5257 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5261 unsigned int section_count;
5262 asection ** sections;
5263 asection * output_section;
5265 bfd_vma matching_lma;
5266 bfd_vma suggested_lma;
5270 if (segment->p_type == PT_NULL)
5273 /* Compute how many sections might be placed into this segment. */
5274 for (section = ibfd->sections, section_count = 0;
5276 section = section->next)
5277 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5280 /* Allocate a segment map big enough to contain
5281 all of the sections we have selected. */
5282 amt = sizeof (struct elf_segment_map);
5283 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5284 map = bfd_alloc (obfd, amt);
5288 /* Initialise the fields of the segment map. Default to
5289 using the physical address of the segment in the input BFD. */
5291 map->p_type = segment->p_type;
5292 map->p_flags = segment->p_flags;
5293 map->p_flags_valid = 1;
5294 map->p_paddr = segment->p_paddr;
5295 map->p_paddr_valid = 1;
5297 /* Determine if this segment contains the ELF file header
5298 and if it contains the program headers themselves. */
5299 map->includes_filehdr = (segment->p_offset == 0
5300 && segment->p_filesz >= iehdr->e_ehsize);
5302 map->includes_phdrs = 0;
5304 if (! phdr_included || segment->p_type != PT_LOAD)
5306 map->includes_phdrs =
5307 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5308 && (segment->p_offset + segment->p_filesz
5309 >= ((bfd_vma) iehdr->e_phoff
5310 + iehdr->e_phnum * iehdr->e_phentsize)));
5312 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5313 phdr_included = TRUE;
5316 if (section_count == 0)
5318 /* Special segments, such as the PT_PHDR segment, may contain
5319 no sections, but ordinary, loadable segments should contain
5320 something. They are allowed by the ELF spec however, so only
5321 a warning is produced. */
5322 if (segment->p_type == PT_LOAD)
5323 (*_bfd_error_handler)
5324 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5328 *pointer_to_map = map;
5329 pointer_to_map = &map->next;
5334 /* Now scan the sections in the input BFD again and attempt
5335 to add their corresponding output sections to the segment map.
5336 The problem here is how to handle an output section which has
5337 been moved (ie had its LMA changed). There are four possibilities:
5339 1. None of the sections have been moved.
5340 In this case we can continue to use the segment LMA from the
5343 2. All of the sections have been moved by the same amount.
5344 In this case we can change the segment's LMA to match the LMA
5345 of the first section.
5347 3. Some of the sections have been moved, others have not.
5348 In this case those sections which have not been moved can be
5349 placed in the current segment which will have to have its size,
5350 and possibly its LMA changed, and a new segment or segments will
5351 have to be created to contain the other sections.
5353 4. The sections have been moved, but not by the same amount.
5354 In this case we can change the segment's LMA to match the LMA
5355 of the first section and we will have to create a new segment
5356 or segments to contain the other sections.
5358 In order to save time, we allocate an array to hold the section
5359 pointers that we are interested in. As these sections get assigned
5360 to a segment, they are removed from this array. */
5362 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5363 to work around this long long bug. */
5364 amt = section_count * sizeof (asection *);
5365 sections = bfd_malloc (amt);
5366 if (sections == NULL)
5369 /* Step One: Scan for segment vs section LMA conflicts.
5370 Also add the sections to the section array allocated above.
5371 Also add the sections to the current segment. In the common
5372 case, where the sections have not been moved, this means that
5373 we have completely filled the segment, and there is nothing
5379 for (j = 0, section = ibfd->sections;
5381 section = section->next)
5383 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5385 output_section = section->output_section;
5387 sections[j ++] = section;
5389 /* The Solaris native linker always sets p_paddr to 0.
5390 We try to catch that case here, and set it to the
5391 correct value. Note - some backends require that
5392 p_paddr be left as zero. */
5393 if (segment->p_paddr == 0
5394 && segment->p_vaddr != 0
5395 && (! bed->want_p_paddr_set_to_zero)
5397 && output_section->lma != 0
5398 && (output_section->vma == (segment->p_vaddr
5399 + (map->includes_filehdr
5402 + (map->includes_phdrs
5404 * iehdr->e_phentsize)
5406 map->p_paddr = segment->p_vaddr;
5408 /* Match up the physical address of the segment with the
5409 LMA address of the output section. */
5410 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5411 || IS_COREFILE_NOTE (segment, section)
5412 || (bed->want_p_paddr_set_to_zero &&
5413 IS_CONTAINED_BY_VMA (output_section, segment))
5416 if (matching_lma == 0)
5417 matching_lma = output_section->lma;
5419 /* We assume that if the section fits within the segment
5420 then it does not overlap any other section within that
5422 map->sections[isec ++] = output_section;
5424 else if (suggested_lma == 0)
5425 suggested_lma = output_section->lma;
5429 BFD_ASSERT (j == section_count);
5431 /* Step Two: Adjust the physical address of the current segment,
5433 if (isec == section_count)
5435 /* All of the sections fitted within the segment as currently
5436 specified. This is the default case. Add the segment to
5437 the list of built segments and carry on to process the next
5438 program header in the input BFD. */
5439 map->count = section_count;
5440 *pointer_to_map = map;
5441 pointer_to_map = &map->next;
5448 if (matching_lma != 0)
5450 /* At least one section fits inside the current segment.
5451 Keep it, but modify its physical address to match the
5452 LMA of the first section that fitted. */
5453 map->p_paddr = matching_lma;
5457 /* None of the sections fitted inside the current segment.
5458 Change the current segment's physical address to match
5459 the LMA of the first section. */
5460 map->p_paddr = suggested_lma;
5463 /* Offset the segment physical address from the lma
5464 to allow for space taken up by elf headers. */
5465 if (map->includes_filehdr)
5466 map->p_paddr -= iehdr->e_ehsize;
5468 if (map->includes_phdrs)
5470 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5472 /* iehdr->e_phnum is just an estimate of the number
5473 of program headers that we will need. Make a note
5474 here of the number we used and the segment we chose
5475 to hold these headers, so that we can adjust the
5476 offset when we know the correct value. */
5477 phdr_adjust_num = iehdr->e_phnum;
5478 phdr_adjust_seg = map;
5482 /* Step Three: Loop over the sections again, this time assigning
5483 those that fit to the current segment and removing them from the
5484 sections array; but making sure not to leave large gaps. Once all
5485 possible sections have been assigned to the current segment it is
5486 added to the list of built segments and if sections still remain
5487 to be assigned, a new segment is constructed before repeating
5495 /* Fill the current segment with sections that fit. */
5496 for (j = 0; j < section_count; j++)
5498 section = sections[j];
5500 if (section == NULL)
5503 output_section = section->output_section;
5505 BFD_ASSERT (output_section != NULL);
5507 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5508 || IS_COREFILE_NOTE (segment, section))
5510 if (map->count == 0)
5512 /* If the first section in a segment does not start at
5513 the beginning of the segment, then something is
5515 if (output_section->lma !=
5517 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5518 + (map->includes_phdrs
5519 ? iehdr->e_phnum * iehdr->e_phentsize
5525 asection * prev_sec;
5527 prev_sec = map->sections[map->count - 1];
5529 /* If the gap between the end of the previous section
5530 and the start of this section is more than
5531 maxpagesize then we need to start a new segment. */
5532 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5534 < BFD_ALIGN (output_section->lma, maxpagesize))
5535 || ((prev_sec->lma + prev_sec->size)
5536 > output_section->lma))
5538 if (suggested_lma == 0)
5539 suggested_lma = output_section->lma;
5545 map->sections[map->count++] = output_section;
5548 section->segment_mark = TRUE;
5550 else if (suggested_lma == 0)
5551 suggested_lma = output_section->lma;
5554 BFD_ASSERT (map->count > 0);
5556 /* Add the current segment to the list of built segments. */
5557 *pointer_to_map = map;
5558 pointer_to_map = &map->next;
5560 if (isec < section_count)
5562 /* We still have not allocated all of the sections to
5563 segments. Create a new segment here, initialise it
5564 and carry on looping. */
5565 amt = sizeof (struct elf_segment_map);
5566 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5567 map = bfd_alloc (obfd, amt);
5574 /* Initialise the fields of the segment map. Set the physical
5575 physical address to the LMA of the first section that has
5576 not yet been assigned. */
5578 map->p_type = segment->p_type;
5579 map->p_flags = segment->p_flags;
5580 map->p_flags_valid = 1;
5581 map->p_paddr = suggested_lma;
5582 map->p_paddr_valid = 1;
5583 map->includes_filehdr = 0;
5584 map->includes_phdrs = 0;
5587 while (isec < section_count);
5592 /* The Solaris linker creates program headers in which all the
5593 p_paddr fields are zero. When we try to objcopy or strip such a
5594 file, we get confused. Check for this case, and if we find it
5595 reset the p_paddr_valid fields. */
5596 for (map = map_first; map != NULL; map = map->next)
5597 if (map->p_paddr != 0)
5600 for (map = map_first; map != NULL; map = map->next)
5601 map->p_paddr_valid = 0;
5603 elf_tdata (obfd)->segment_map = map_first;
5605 /* If we had to estimate the number of program headers that were
5606 going to be needed, then check our estimate now and adjust
5607 the offset if necessary. */
5608 if (phdr_adjust_seg != NULL)
5612 for (count = 0, map = map_first; map != NULL; map = map->next)
5615 if (count > phdr_adjust_num)
5616 phdr_adjust_seg->p_paddr
5617 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5622 #undef IS_CONTAINED_BY_VMA
5623 #undef IS_CONTAINED_BY_LMA
5624 #undef IS_COREFILE_NOTE
5625 #undef IS_SOLARIS_PT_INTERP
5626 #undef INCLUDE_SECTION_IN_SEGMENT
5627 #undef SEGMENT_AFTER_SEGMENT
5628 #undef SEGMENT_OVERLAPS
5632 /* Copy private section information. This copies over the entsize
5633 field, and sometimes the info field. */
5636 _bfd_elf_copy_private_section_data (bfd *ibfd,
5641 Elf_Internal_Shdr *ihdr, *ohdr;
5643 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5644 || obfd->xvec->flavour != bfd_target_elf_flavour)
5647 ihdr = &elf_section_data (isec)->this_hdr;
5648 ohdr = &elf_section_data (osec)->this_hdr;
5650 ohdr->sh_entsize = ihdr->sh_entsize;
5652 if (ihdr->sh_type == SHT_SYMTAB
5653 || ihdr->sh_type == SHT_DYNSYM
5654 || ihdr->sh_type == SHT_GNU_verneed
5655 || ihdr->sh_type == SHT_GNU_verdef)
5656 ohdr->sh_info = ihdr->sh_info;
5658 /* Set things up for objcopy. The output SHT_GROUP section will
5659 have its elf_next_in_group pointing back to the input group
5660 members. Ignore linker created group section. See
5661 elfNN_ia64_object_p in elfxx-ia64.c. */
5662 if (elf_sec_group (isec) == NULL
5663 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5665 elf_next_in_group (osec) = elf_next_in_group (isec);
5666 elf_group_name (osec) = elf_group_name (isec);
5669 osec->use_rela_p = isec->use_rela_p;
5674 /* Copy private header information. */
5677 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5679 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5680 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5683 /* Copy over private BFD data if it has not already been copied.
5684 This must be done here, rather than in the copy_private_bfd_data
5685 entry point, because the latter is called after the section
5686 contents have been set, which means that the program headers have
5687 already been worked out. */
5688 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5690 if (! copy_private_bfd_data (ibfd, obfd))
5697 /* Copy private symbol information. If this symbol is in a section
5698 which we did not map into a BFD section, try to map the section
5699 index correctly. We use special macro definitions for the mapped
5700 section indices; these definitions are interpreted by the
5701 swap_out_syms function. */
5703 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5704 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5705 #define MAP_STRTAB (SHN_HIOS + 3)
5706 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5707 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5710 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5715 elf_symbol_type *isym, *osym;
5717 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5718 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5721 isym = elf_symbol_from (ibfd, isymarg);
5722 osym = elf_symbol_from (obfd, osymarg);
5726 && bfd_is_abs_section (isym->symbol.section))
5730 shndx = isym->internal_elf_sym.st_shndx;
5731 if (shndx == elf_onesymtab (ibfd))
5732 shndx = MAP_ONESYMTAB;
5733 else if (shndx == elf_dynsymtab (ibfd))
5734 shndx = MAP_DYNSYMTAB;
5735 else if (shndx == elf_tdata (ibfd)->strtab_section)
5737 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5738 shndx = MAP_SHSTRTAB;
5739 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5740 shndx = MAP_SYM_SHNDX;
5741 osym->internal_elf_sym.st_shndx = shndx;
5747 /* Swap out the symbols. */
5750 swap_out_syms (bfd *abfd,
5751 struct bfd_strtab_hash **sttp,
5754 const struct elf_backend_data *bed;
5757 struct bfd_strtab_hash *stt;
5758 Elf_Internal_Shdr *symtab_hdr;
5759 Elf_Internal_Shdr *symtab_shndx_hdr;
5760 Elf_Internal_Shdr *symstrtab_hdr;
5761 bfd_byte *outbound_syms;
5762 bfd_byte *outbound_shndx;
5765 bfd_boolean name_local_sections;
5767 if (!elf_map_symbols (abfd))
5770 /* Dump out the symtabs. */
5771 stt = _bfd_elf_stringtab_init ();
5775 bed = get_elf_backend_data (abfd);
5776 symcount = bfd_get_symcount (abfd);
5777 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5778 symtab_hdr->sh_type = SHT_SYMTAB;
5779 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5780 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5781 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5782 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5784 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5785 symstrtab_hdr->sh_type = SHT_STRTAB;
5787 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5788 outbound_syms = bfd_alloc (abfd, amt);
5789 if (outbound_syms == NULL)
5791 _bfd_stringtab_free (stt);
5794 symtab_hdr->contents = outbound_syms;
5796 outbound_shndx = NULL;
5797 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5798 if (symtab_shndx_hdr->sh_name != 0)
5800 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5801 outbound_shndx = bfd_zalloc (abfd, amt);
5802 if (outbound_shndx == NULL)
5804 _bfd_stringtab_free (stt);
5808 symtab_shndx_hdr->contents = outbound_shndx;
5809 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5810 symtab_shndx_hdr->sh_size = amt;
5811 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5812 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5815 /* Now generate the data (for "contents"). */
5817 /* Fill in zeroth symbol and swap it out. */
5818 Elf_Internal_Sym sym;
5824 sym.st_shndx = SHN_UNDEF;
5825 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5826 outbound_syms += bed->s->sizeof_sym;
5827 if (outbound_shndx != NULL)
5828 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5832 = (bed->elf_backend_name_local_section_symbols
5833 && bed->elf_backend_name_local_section_symbols (abfd));
5835 syms = bfd_get_outsymbols (abfd);
5836 for (idx = 0; idx < symcount; idx++)
5838 Elf_Internal_Sym sym;
5839 bfd_vma value = syms[idx]->value;
5840 elf_symbol_type *type_ptr;
5841 flagword flags = syms[idx]->flags;
5844 if (!name_local_sections
5845 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5847 /* Local section symbols have no name. */
5852 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5855 if (sym.st_name == (unsigned long) -1)
5857 _bfd_stringtab_free (stt);
5862 type_ptr = elf_symbol_from (abfd, syms[idx]);
5864 if ((flags & BSF_SECTION_SYM) == 0
5865 && bfd_is_com_section (syms[idx]->section))
5867 /* ELF common symbols put the alignment into the `value' field,
5868 and the size into the `size' field. This is backwards from
5869 how BFD handles it, so reverse it here. */
5870 sym.st_size = value;
5871 if (type_ptr == NULL
5872 || type_ptr->internal_elf_sym.st_value == 0)
5873 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5875 sym.st_value = type_ptr->internal_elf_sym.st_value;
5876 sym.st_shndx = _bfd_elf_section_from_bfd_section
5877 (abfd, syms[idx]->section);
5881 asection *sec = syms[idx]->section;
5884 if (sec->output_section)
5886 value += sec->output_offset;
5887 sec = sec->output_section;
5890 /* Don't add in the section vma for relocatable output. */
5891 if (! relocatable_p)
5893 sym.st_value = value;
5894 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5896 if (bfd_is_abs_section (sec)
5898 && type_ptr->internal_elf_sym.st_shndx != 0)
5900 /* This symbol is in a real ELF section which we did
5901 not create as a BFD section. Undo the mapping done
5902 by copy_private_symbol_data. */
5903 shndx = type_ptr->internal_elf_sym.st_shndx;
5907 shndx = elf_onesymtab (abfd);
5910 shndx = elf_dynsymtab (abfd);
5913 shndx = elf_tdata (abfd)->strtab_section;
5916 shndx = elf_tdata (abfd)->shstrtab_section;
5919 shndx = elf_tdata (abfd)->symtab_shndx_section;
5927 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5933 /* Writing this would be a hell of a lot easier if
5934 we had some decent documentation on bfd, and
5935 knew what to expect of the library, and what to
5936 demand of applications. For example, it
5937 appears that `objcopy' might not set the
5938 section of a symbol to be a section that is
5939 actually in the output file. */
5940 sec2 = bfd_get_section_by_name (abfd, sec->name);
5943 _bfd_error_handler (_("\
5944 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5945 syms[idx]->name ? syms[idx]->name : "<Local sym>",
5947 bfd_set_error (bfd_error_invalid_operation);
5948 _bfd_stringtab_free (stt);
5952 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5953 BFD_ASSERT (shndx != -1);
5957 sym.st_shndx = shndx;
5960 if ((flags & BSF_THREAD_LOCAL) != 0)
5962 else if ((flags & BSF_FUNCTION) != 0)
5964 else if ((flags & BSF_OBJECT) != 0)
5969 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5972 /* Processor-specific types. */
5973 if (type_ptr != NULL
5974 && bed->elf_backend_get_symbol_type)
5975 type = ((*bed->elf_backend_get_symbol_type)
5976 (&type_ptr->internal_elf_sym, type));
5978 if (flags & BSF_SECTION_SYM)
5980 if (flags & BSF_GLOBAL)
5981 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5983 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5985 else if (bfd_is_com_section (syms[idx]->section))
5986 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5987 else if (bfd_is_und_section (syms[idx]->section))
5988 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5992 else if (flags & BSF_FILE)
5993 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5996 int bind = STB_LOCAL;
5998 if (flags & BSF_LOCAL)
6000 else if (flags & BSF_WEAK)
6002 else if (flags & BSF_GLOBAL)
6005 sym.st_info = ELF_ST_INFO (bind, type);
6008 if (type_ptr != NULL)
6009 sym.st_other = type_ptr->internal_elf_sym.st_other;
6013 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6014 outbound_syms += bed->s->sizeof_sym;
6015 if (outbound_shndx != NULL)
6016 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6020 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6021 symstrtab_hdr->sh_type = SHT_STRTAB;
6023 symstrtab_hdr->sh_flags = 0;
6024 symstrtab_hdr->sh_addr = 0;
6025 symstrtab_hdr->sh_entsize = 0;
6026 symstrtab_hdr->sh_link = 0;
6027 symstrtab_hdr->sh_info = 0;
6028 symstrtab_hdr->sh_addralign = 1;
6033 /* Return the number of bytes required to hold the symtab vector.
6035 Note that we base it on the count plus 1, since we will null terminate
6036 the vector allocated based on this size. However, the ELF symbol table
6037 always has a dummy entry as symbol #0, so it ends up even. */
6040 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6044 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6046 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6047 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6049 symtab_size -= sizeof (asymbol *);
6055 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6059 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6061 if (elf_dynsymtab (abfd) == 0)
6063 bfd_set_error (bfd_error_invalid_operation);
6067 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6068 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6070 symtab_size -= sizeof (asymbol *);
6076 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6079 return (asect->reloc_count + 1) * sizeof (arelent *);
6082 /* Canonicalize the relocs. */
6085 _bfd_elf_canonicalize_reloc (bfd *abfd,
6092 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6094 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6097 tblptr = section->relocation;
6098 for (i = 0; i < section->reloc_count; i++)
6099 *relptr++ = tblptr++;
6103 return section->reloc_count;
6107 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6109 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6110 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6113 bfd_get_symcount (abfd) = symcount;
6118 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6119 asymbol **allocation)
6121 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6122 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6125 bfd_get_dynamic_symcount (abfd) = symcount;
6129 /* Return the size required for the dynamic reloc entries. Any loadable
6130 section that was actually installed in the BFD, and has type SHT_REL
6131 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6132 dynamic reloc section. */
6135 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6140 if (elf_dynsymtab (abfd) == 0)
6142 bfd_set_error (bfd_error_invalid_operation);
6146 ret = sizeof (arelent *);
6147 for (s = abfd->sections; s != NULL; s = s->next)
6148 if ((s->flags & SEC_LOAD) != 0
6149 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6150 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6151 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6152 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6153 * sizeof (arelent *));
6158 /* Canonicalize the dynamic relocation entries. Note that we return the
6159 dynamic relocations as a single block, although they are actually
6160 associated with particular sections; the interface, which was
6161 designed for SunOS style shared libraries, expects that there is only
6162 one set of dynamic relocs. Any loadable section that was actually
6163 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6164 dynamic symbol table, is considered to be a dynamic reloc section. */
6167 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6171 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6175 if (elf_dynsymtab (abfd) == 0)
6177 bfd_set_error (bfd_error_invalid_operation);
6181 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6183 for (s = abfd->sections; s != NULL; s = s->next)
6185 if ((s->flags & SEC_LOAD) != 0
6186 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6187 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6188 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6193 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6195 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6197 for (i = 0; i < count; i++)
6208 /* Read in the version information. */
6211 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6213 bfd_byte *contents = NULL;
6215 unsigned int freeidx = 0;
6217 if (elf_dynverref (abfd) != 0)
6219 Elf_Internal_Shdr *hdr;
6220 Elf_External_Verneed *everneed;
6221 Elf_Internal_Verneed *iverneed;
6224 hdr = &elf_tdata (abfd)->dynverref_hdr;
6226 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
6227 elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
6228 if (elf_tdata (abfd)->verref == NULL)
6231 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6233 contents = bfd_malloc (hdr->sh_size);
6234 if (contents == NULL)
6236 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6237 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6240 everneed = (Elf_External_Verneed *) contents;
6241 iverneed = elf_tdata (abfd)->verref;
6242 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6244 Elf_External_Vernaux *evernaux;
6245 Elf_Internal_Vernaux *ivernaux;
6248 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6250 iverneed->vn_bfd = abfd;
6252 iverneed->vn_filename =
6253 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6255 if (iverneed->vn_filename == NULL)
6258 amt = iverneed->vn_cnt;
6259 amt *= sizeof (Elf_Internal_Vernaux);
6260 iverneed->vn_auxptr = bfd_alloc (abfd, amt);
6262 evernaux = ((Elf_External_Vernaux *)
6263 ((bfd_byte *) everneed + iverneed->vn_aux));
6264 ivernaux = iverneed->vn_auxptr;
6265 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6267 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6269 ivernaux->vna_nodename =
6270 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6271 ivernaux->vna_name);
6272 if (ivernaux->vna_nodename == NULL)
6275 if (j + 1 < iverneed->vn_cnt)
6276 ivernaux->vna_nextptr = ivernaux + 1;
6278 ivernaux->vna_nextptr = NULL;
6280 evernaux = ((Elf_External_Vernaux *)
6281 ((bfd_byte *) evernaux + ivernaux->vna_next));
6283 if (ivernaux->vna_other > freeidx)
6284 freeidx = ivernaux->vna_other;
6287 if (i + 1 < hdr->sh_info)
6288 iverneed->vn_nextref = iverneed + 1;
6290 iverneed->vn_nextref = NULL;
6292 everneed = ((Elf_External_Verneed *)
6293 ((bfd_byte *) everneed + iverneed->vn_next));
6300 if (elf_dynverdef (abfd) != 0)
6302 Elf_Internal_Shdr *hdr;
6303 Elf_External_Verdef *everdef;
6304 Elf_Internal_Verdef *iverdef;
6305 Elf_Internal_Verdef *iverdefarr;
6306 Elf_Internal_Verdef iverdefmem;
6308 unsigned int maxidx;
6310 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6312 contents = bfd_malloc (hdr->sh_size);
6313 if (contents == NULL)
6315 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6316 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6319 /* We know the number of entries in the section but not the maximum
6320 index. Therefore we have to run through all entries and find
6322 everdef = (Elf_External_Verdef *) contents;
6324 for (i = 0; i < hdr->sh_info; ++i)
6326 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6328 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6329 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6331 everdef = ((Elf_External_Verdef *)
6332 ((bfd_byte *) everdef + iverdefmem.vd_next));
6335 if (default_imported_symver)
6337 if (freeidx > maxidx)
6342 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
6343 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6344 if (elf_tdata (abfd)->verdef == NULL)
6347 elf_tdata (abfd)->cverdefs = maxidx;
6349 everdef = (Elf_External_Verdef *) contents;
6350 iverdefarr = elf_tdata (abfd)->verdef;
6351 for (i = 0; i < hdr->sh_info; i++)
6353 Elf_External_Verdaux *everdaux;
6354 Elf_Internal_Verdaux *iverdaux;
6357 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6359 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6360 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6362 iverdef->vd_bfd = abfd;
6364 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
6365 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6366 if (iverdef->vd_auxptr == NULL)
6369 everdaux = ((Elf_External_Verdaux *)
6370 ((bfd_byte *) everdef + iverdef->vd_aux));
6371 iverdaux = iverdef->vd_auxptr;
6372 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6374 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6376 iverdaux->vda_nodename =
6377 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6378 iverdaux->vda_name);
6379 if (iverdaux->vda_nodename == NULL)
6382 if (j + 1 < iverdef->vd_cnt)
6383 iverdaux->vda_nextptr = iverdaux + 1;
6385 iverdaux->vda_nextptr = NULL;
6387 everdaux = ((Elf_External_Verdaux *)
6388 ((bfd_byte *) everdaux + iverdaux->vda_next));
6391 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6393 if (i + 1 < hdr->sh_info)
6394 iverdef->vd_nextdef = iverdef + 1;
6396 iverdef->vd_nextdef = NULL;
6398 everdef = ((Elf_External_Verdef *)
6399 ((bfd_byte *) everdef + iverdef->vd_next));
6405 else if (default_imported_symver)
6412 amt = (bfd_size_type) freeidx * sizeof (Elf_Internal_Verdef);
6413 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6414 if (elf_tdata (abfd)->verdef == NULL)
6417 elf_tdata (abfd)->cverdefs = freeidx;
6420 /* Create a default version based on the soname. */
6421 if (default_imported_symver)
6423 Elf_Internal_Verdef *iverdef;
6424 Elf_Internal_Verdaux *iverdaux;
6426 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6428 iverdef->vd_version = VER_DEF_CURRENT;
6429 iverdef->vd_flags = 0;
6430 iverdef->vd_ndx = freeidx;
6431 iverdef->vd_cnt = 1;
6433 iverdef->vd_bfd = abfd;
6435 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6436 if (iverdef->vd_nodename == NULL)
6438 iverdef->vd_nextdef = NULL;
6439 amt = (bfd_size_type) sizeof (Elf_Internal_Verdaux);
6440 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6442 iverdaux = iverdef->vd_auxptr;
6443 iverdaux->vda_nodename = iverdef->vd_nodename;
6444 iverdaux->vda_nextptr = NULL;
6450 if (contents != NULL)
6456 _bfd_elf_make_empty_symbol (bfd *abfd)
6458 elf_symbol_type *newsym;
6459 bfd_size_type amt = sizeof (elf_symbol_type);
6461 newsym = bfd_zalloc (abfd, amt);
6466 newsym->symbol.the_bfd = abfd;
6467 return &newsym->symbol;
6472 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6476 bfd_symbol_info (symbol, ret);
6479 /* Return whether a symbol name implies a local symbol. Most targets
6480 use this function for the is_local_label_name entry point, but some
6484 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6487 /* Normal local symbols start with ``.L''. */
6488 if (name[0] == '.' && name[1] == 'L')
6491 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6492 DWARF debugging symbols starting with ``..''. */
6493 if (name[0] == '.' && name[1] == '.')
6496 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6497 emitting DWARF debugging output. I suspect this is actually a
6498 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6499 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6500 underscore to be emitted on some ELF targets). For ease of use,
6501 we treat such symbols as local. */
6502 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6509 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6510 asymbol *symbol ATTRIBUTE_UNUSED)
6517 _bfd_elf_set_arch_mach (bfd *abfd,
6518 enum bfd_architecture arch,
6519 unsigned long machine)
6521 /* If this isn't the right architecture for this backend, and this
6522 isn't the generic backend, fail. */
6523 if (arch != get_elf_backend_data (abfd)->arch
6524 && arch != bfd_arch_unknown
6525 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6528 return bfd_default_set_arch_mach (abfd, arch, machine);
6531 /* Find the function to a particular section and offset,
6532 for error reporting. */
6535 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6539 const char **filename_ptr,
6540 const char **functionname_ptr)
6542 const char *filename;
6543 asymbol *func, *file;
6546 /* ??? Given multiple file symbols, it is impossible to reliably
6547 choose the right file name for global symbols. File symbols are
6548 local symbols, and thus all file symbols must sort before any
6549 global symbols. The ELF spec may be interpreted to say that a
6550 file symbol must sort before other local symbols, but currently
6551 ld -r doesn't do this. So, for ld -r output, it is possible to
6552 make a better choice of file name for local symbols by ignoring
6553 file symbols appearing after a given local symbol. */
6554 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6560 state = nothing_seen;
6562 for (p = symbols; *p != NULL; p++)
6566 q = (elf_symbol_type *) *p;
6568 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6574 if (state == symbol_seen)
6575 state = file_after_symbol_seen;
6581 if (bfd_get_section (&q->symbol) == section
6582 && q->symbol.value >= low_func
6583 && q->symbol.value <= offset)
6585 func = (asymbol *) q;
6586 low_func = q->symbol.value;
6589 else if (ELF_ST_BIND (q->internal_elf_sym.st_info) != STB_LOCAL
6590 && state == file_after_symbol_seen)
6593 filename = bfd_asymbol_name (file);
6597 if (state == nothing_seen)
6598 state = symbol_seen;
6605 *filename_ptr = filename;
6606 if (functionname_ptr)
6607 *functionname_ptr = bfd_asymbol_name (func);
6612 /* Find the nearest line to a particular section and offset,
6613 for error reporting. */
6616 _bfd_elf_find_nearest_line (bfd *abfd,
6620 const char **filename_ptr,
6621 const char **functionname_ptr,
6622 unsigned int *line_ptr)
6626 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6627 filename_ptr, functionname_ptr,
6630 if (!*functionname_ptr)
6631 elf_find_function (abfd, section, symbols, offset,
6632 *filename_ptr ? NULL : filename_ptr,
6638 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6639 filename_ptr, functionname_ptr,
6641 &elf_tdata (abfd)->dwarf2_find_line_info))
6643 if (!*functionname_ptr)
6644 elf_find_function (abfd, section, symbols, offset,
6645 *filename_ptr ? NULL : filename_ptr,
6651 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6652 &found, filename_ptr,
6653 functionname_ptr, line_ptr,
6654 &elf_tdata (abfd)->line_info))
6656 if (found && (*functionname_ptr || *line_ptr))
6659 if (symbols == NULL)
6662 if (! elf_find_function (abfd, section, symbols, offset,
6663 filename_ptr, functionname_ptr))
6670 /* Find the line for a symbol. */
6673 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
6674 const char **filename_ptr, unsigned int *line_ptr)
6676 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
6677 filename_ptr, line_ptr, 0,
6678 &elf_tdata (abfd)->dwarf2_find_line_info);
6681 /* After a call to bfd_find_nearest_line, successive calls to
6682 bfd_find_inliner_info can be used to get source information about
6683 each level of function inlining that terminated at the address
6684 passed to bfd_find_nearest_line. Currently this is only supported
6685 for DWARF2 with appropriate DWARF3 extensions. */
6688 _bfd_elf_find_inliner_info (bfd *abfd,
6689 const char **filename_ptr,
6690 const char **functionname_ptr,
6691 unsigned int *line_ptr)
6694 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6695 functionname_ptr, line_ptr,
6696 & elf_tdata (abfd)->dwarf2_find_line_info);
6701 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
6705 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6707 ret += get_program_header_size (abfd);
6712 _bfd_elf_set_section_contents (bfd *abfd,
6714 const void *location,
6716 bfd_size_type count)
6718 Elf_Internal_Shdr *hdr;
6721 if (! abfd->output_has_begun
6722 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6725 hdr = &elf_section_data (section)->this_hdr;
6726 pos = hdr->sh_offset + offset;
6727 if (bfd_seek (abfd, pos, SEEK_SET) != 0
6728 || bfd_bwrite (location, count, abfd) != count)
6735 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6736 arelent *cache_ptr ATTRIBUTE_UNUSED,
6737 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6742 /* Try to convert a non-ELF reloc into an ELF one. */
6745 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6747 /* Check whether we really have an ELF howto. */
6749 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6751 bfd_reloc_code_real_type code;
6752 reloc_howto_type *howto;
6754 /* Alien reloc: Try to determine its type to replace it with an
6755 equivalent ELF reloc. */
6757 if (areloc->howto->pc_relative)
6759 switch (areloc->howto->bitsize)
6762 code = BFD_RELOC_8_PCREL;
6765 code = BFD_RELOC_12_PCREL;
6768 code = BFD_RELOC_16_PCREL;
6771 code = BFD_RELOC_24_PCREL;
6774 code = BFD_RELOC_32_PCREL;
6777 code = BFD_RELOC_64_PCREL;
6783 howto = bfd_reloc_type_lookup (abfd, code);
6785 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6787 if (howto->pcrel_offset)
6788 areloc->addend += areloc->address;
6790 areloc->addend -= areloc->address; /* addend is unsigned!! */
6795 switch (areloc->howto->bitsize)
6801 code = BFD_RELOC_14;
6804 code = BFD_RELOC_16;
6807 code = BFD_RELOC_26;
6810 code = BFD_RELOC_32;
6813 code = BFD_RELOC_64;
6819 howto = bfd_reloc_type_lookup (abfd, code);
6823 areloc->howto = howto;
6831 (*_bfd_error_handler)
6832 (_("%B: unsupported relocation type %s"),
6833 abfd, areloc->howto->name);
6834 bfd_set_error (bfd_error_bad_value);
6839 _bfd_elf_close_and_cleanup (bfd *abfd)
6841 if (bfd_get_format (abfd) == bfd_object)
6843 if (elf_shstrtab (abfd) != NULL)
6844 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6845 _bfd_dwarf2_cleanup_debug_info (abfd);
6848 return _bfd_generic_close_and_cleanup (abfd);
6851 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6852 in the relocation's offset. Thus we cannot allow any sort of sanity
6853 range-checking to interfere. There is nothing else to do in processing
6856 bfd_reloc_status_type
6857 _bfd_elf_rel_vtable_reloc_fn
6858 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
6859 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
6860 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6861 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
6863 return bfd_reloc_ok;
6866 /* Elf core file support. Much of this only works on native
6867 toolchains, since we rely on knowing the
6868 machine-dependent procfs structure in order to pick
6869 out details about the corefile. */
6871 #ifdef HAVE_SYS_PROCFS_H
6872 # include <sys/procfs.h>
6875 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6878 elfcore_make_pid (bfd *abfd)
6880 return ((elf_tdata (abfd)->core_lwpid << 16)
6881 + (elf_tdata (abfd)->core_pid));
6884 /* If there isn't a section called NAME, make one, using
6885 data from SECT. Note, this function will generate a
6886 reference to NAME, so you shouldn't deallocate or
6890 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
6894 if (bfd_get_section_by_name (abfd, name) != NULL)
6897 sect2 = bfd_make_section (abfd, name);
6901 sect2->size = sect->size;
6902 sect2->filepos = sect->filepos;
6903 sect2->flags = sect->flags;
6904 sect2->alignment_power = sect->alignment_power;
6908 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6909 actually creates up to two pseudosections:
6910 - For the single-threaded case, a section named NAME, unless
6911 such a section already exists.
6912 - For the multi-threaded case, a section named "NAME/PID", where
6913 PID is elfcore_make_pid (abfd).
6914 Both pseudosections have identical contents. */
6916 _bfd_elfcore_make_pseudosection (bfd *abfd,
6922 char *threaded_name;
6926 /* Build the section name. */
6928 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6929 len = strlen (buf) + 1;
6930 threaded_name = bfd_alloc (abfd, len);
6931 if (threaded_name == NULL)
6933 memcpy (threaded_name, buf, len);
6935 sect = bfd_make_section_anyway (abfd, threaded_name);
6939 sect->filepos = filepos;
6940 sect->flags = SEC_HAS_CONTENTS;
6941 sect->alignment_power = 2;
6943 return elfcore_maybe_make_sect (abfd, name, sect);
6946 /* prstatus_t exists on:
6948 linux 2.[01] + glibc
6952 #if defined (HAVE_PRSTATUS_T)
6955 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6960 if (note->descsz == sizeof (prstatus_t))
6964 size = sizeof (prstat.pr_reg);
6965 offset = offsetof (prstatus_t, pr_reg);
6966 memcpy (&prstat, note->descdata, sizeof (prstat));
6968 /* Do not overwrite the core signal if it
6969 has already been set by another thread. */
6970 if (elf_tdata (abfd)->core_signal == 0)
6971 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6972 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6974 /* pr_who exists on:
6977 pr_who doesn't exist on:
6980 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6981 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6984 #if defined (HAVE_PRSTATUS32_T)
6985 else if (note->descsz == sizeof (prstatus32_t))
6987 /* 64-bit host, 32-bit corefile */
6988 prstatus32_t prstat;
6990 size = sizeof (prstat.pr_reg);
6991 offset = offsetof (prstatus32_t, pr_reg);
6992 memcpy (&prstat, note->descdata, sizeof (prstat));
6994 /* Do not overwrite the core signal if it
6995 has already been set by another thread. */
6996 if (elf_tdata (abfd)->core_signal == 0)
6997 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6998 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7000 /* pr_who exists on:
7003 pr_who doesn't exist on:
7006 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7007 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7010 #endif /* HAVE_PRSTATUS32_T */
7013 /* Fail - we don't know how to handle any other
7014 note size (ie. data object type). */
7018 /* Make a ".reg/999" section and a ".reg" section. */
7019 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7020 size, note->descpos + offset);
7022 #endif /* defined (HAVE_PRSTATUS_T) */
7024 /* Create a pseudosection containing the exact contents of NOTE. */
7026 elfcore_make_note_pseudosection (bfd *abfd,
7028 Elf_Internal_Note *note)
7030 return _bfd_elfcore_make_pseudosection (abfd, name,
7031 note->descsz, note->descpos);
7034 /* There isn't a consistent prfpregset_t across platforms,
7035 but it doesn't matter, because we don't have to pick this
7036 data structure apart. */
7039 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7041 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7044 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7045 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7049 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7051 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7054 #if defined (HAVE_PRPSINFO_T)
7055 typedef prpsinfo_t elfcore_psinfo_t;
7056 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7057 typedef prpsinfo32_t elfcore_psinfo32_t;
7061 #if defined (HAVE_PSINFO_T)
7062 typedef psinfo_t elfcore_psinfo_t;
7063 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7064 typedef psinfo32_t elfcore_psinfo32_t;
7068 /* return a malloc'ed copy of a string at START which is at
7069 most MAX bytes long, possibly without a terminating '\0'.
7070 the copy will always have a terminating '\0'. */
7073 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7076 char *end = memchr (start, '\0', max);
7084 dups = bfd_alloc (abfd, len + 1);
7088 memcpy (dups, start, len);
7094 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7096 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7098 if (note->descsz == sizeof (elfcore_psinfo_t))
7100 elfcore_psinfo_t psinfo;
7102 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7104 elf_tdata (abfd)->core_program
7105 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7106 sizeof (psinfo.pr_fname));
7108 elf_tdata (abfd)->core_command
7109 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7110 sizeof (psinfo.pr_psargs));
7112 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7113 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7115 /* 64-bit host, 32-bit corefile */
7116 elfcore_psinfo32_t psinfo;
7118 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7120 elf_tdata (abfd)->core_program
7121 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7122 sizeof (psinfo.pr_fname));
7124 elf_tdata (abfd)->core_command
7125 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7126 sizeof (psinfo.pr_psargs));
7132 /* Fail - we don't know how to handle any other
7133 note size (ie. data object type). */
7137 /* Note that for some reason, a spurious space is tacked
7138 onto the end of the args in some (at least one anyway)
7139 implementations, so strip it off if it exists. */
7142 char *command = elf_tdata (abfd)->core_command;
7143 int n = strlen (command);
7145 if (0 < n && command[n - 1] == ' ')
7146 command[n - 1] = '\0';
7151 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7153 #if defined (HAVE_PSTATUS_T)
7155 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7157 if (note->descsz == sizeof (pstatus_t)
7158 #if defined (HAVE_PXSTATUS_T)
7159 || note->descsz == sizeof (pxstatus_t)
7165 memcpy (&pstat, note->descdata, sizeof (pstat));
7167 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7169 #if defined (HAVE_PSTATUS32_T)
7170 else if (note->descsz == sizeof (pstatus32_t))
7172 /* 64-bit host, 32-bit corefile */
7175 memcpy (&pstat, note->descdata, sizeof (pstat));
7177 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7180 /* Could grab some more details from the "representative"
7181 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7182 NT_LWPSTATUS note, presumably. */
7186 #endif /* defined (HAVE_PSTATUS_T) */
7188 #if defined (HAVE_LWPSTATUS_T)
7190 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7192 lwpstatus_t lwpstat;
7198 if (note->descsz != sizeof (lwpstat)
7199 #if defined (HAVE_LWPXSTATUS_T)
7200 && note->descsz != sizeof (lwpxstatus_t)
7205 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7207 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7208 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7210 /* Make a ".reg/999" section. */
7212 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7213 len = strlen (buf) + 1;
7214 name = bfd_alloc (abfd, len);
7217 memcpy (name, buf, len);
7219 sect = bfd_make_section_anyway (abfd, name);
7223 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7224 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7225 sect->filepos = note->descpos
7226 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7229 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7230 sect->size = sizeof (lwpstat.pr_reg);
7231 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7234 sect->flags = SEC_HAS_CONTENTS;
7235 sect->alignment_power = 2;
7237 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7240 /* Make a ".reg2/999" section */
7242 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7243 len = strlen (buf) + 1;
7244 name = bfd_alloc (abfd, len);
7247 memcpy (name, buf, len);
7249 sect = bfd_make_section_anyway (abfd, name);
7253 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7254 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7255 sect->filepos = note->descpos
7256 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7259 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7260 sect->size = sizeof (lwpstat.pr_fpreg);
7261 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7264 sect->flags = SEC_HAS_CONTENTS;
7265 sect->alignment_power = 2;
7267 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7269 #endif /* defined (HAVE_LWPSTATUS_T) */
7271 #if defined (HAVE_WIN32_PSTATUS_T)
7273 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7279 win32_pstatus_t pstatus;
7281 if (note->descsz < sizeof (pstatus))
7284 memcpy (&pstatus, note->descdata, sizeof (pstatus));
7286 switch (pstatus.data_type)
7288 case NOTE_INFO_PROCESS:
7289 /* FIXME: need to add ->core_command. */
7290 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7291 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7294 case NOTE_INFO_THREAD:
7295 /* Make a ".reg/999" section. */
7296 sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
7298 len = strlen (buf) + 1;
7299 name = bfd_alloc (abfd, len);
7303 memcpy (name, buf, len);
7305 sect = bfd_make_section_anyway (abfd, name);
7309 sect->size = sizeof (pstatus.data.thread_info.thread_context);
7310 sect->filepos = (note->descpos
7311 + offsetof (struct win32_pstatus,
7312 data.thread_info.thread_context));
7313 sect->flags = SEC_HAS_CONTENTS;
7314 sect->alignment_power = 2;
7316 if (pstatus.data.thread_info.is_active_thread)
7317 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7321 case NOTE_INFO_MODULE:
7322 /* Make a ".module/xxxxxxxx" section. */
7323 sprintf (buf, ".module/%08lx",
7324 (long) pstatus.data.module_info.base_address);
7326 len = strlen (buf) + 1;
7327 name = bfd_alloc (abfd, len);
7331 memcpy (name, buf, len);
7333 sect = bfd_make_section_anyway (abfd, name);
7338 sect->size = note->descsz;
7339 sect->filepos = note->descpos;
7340 sect->flags = SEC_HAS_CONTENTS;
7341 sect->alignment_power = 2;
7350 #endif /* HAVE_WIN32_PSTATUS_T */
7353 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7355 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7363 if (bed->elf_backend_grok_prstatus)
7364 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7366 #if defined (HAVE_PRSTATUS_T)
7367 return elfcore_grok_prstatus (abfd, note);
7372 #if defined (HAVE_PSTATUS_T)
7374 return elfcore_grok_pstatus (abfd, note);
7377 #if defined (HAVE_LWPSTATUS_T)
7379 return elfcore_grok_lwpstatus (abfd, note);
7382 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7383 return elfcore_grok_prfpreg (abfd, note);
7385 #if defined (HAVE_WIN32_PSTATUS_T)
7386 case NT_WIN32PSTATUS:
7387 return elfcore_grok_win32pstatus (abfd, note);
7390 case NT_PRXFPREG: /* Linux SSE extension */
7391 if (note->namesz == 6
7392 && strcmp (note->namedata, "LINUX") == 0)
7393 return elfcore_grok_prxfpreg (abfd, note);
7399 if (bed->elf_backend_grok_psinfo)
7400 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7402 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7403 return elfcore_grok_psinfo (abfd, note);
7410 asection *sect = bfd_make_section_anyway (abfd, ".auxv");
7414 sect->size = note->descsz;
7415 sect->filepos = note->descpos;
7416 sect->flags = SEC_HAS_CONTENTS;
7417 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7425 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7429 cp = strchr (note->namedata, '@');
7432 *lwpidp = atoi(cp + 1);
7439 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7442 /* Signal number at offset 0x08. */
7443 elf_tdata (abfd)->core_signal
7444 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7446 /* Process ID at offset 0x50. */
7447 elf_tdata (abfd)->core_pid
7448 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7450 /* Command name at 0x7c (max 32 bytes, including nul). */
7451 elf_tdata (abfd)->core_command
7452 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7454 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7459 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7463 if (elfcore_netbsd_get_lwpid (note, &lwp))
7464 elf_tdata (abfd)->core_lwpid = lwp;
7466 if (note->type == NT_NETBSDCORE_PROCINFO)
7468 /* NetBSD-specific core "procinfo". Note that we expect to
7469 find this note before any of the others, which is fine,
7470 since the kernel writes this note out first when it
7471 creates a core file. */
7473 return elfcore_grok_netbsd_procinfo (abfd, note);
7476 /* As of Jan 2002 there are no other machine-independent notes
7477 defined for NetBSD core files. If the note type is less
7478 than the start of the machine-dependent note types, we don't
7481 if (note->type < NT_NETBSDCORE_FIRSTMACH)
7485 switch (bfd_get_arch (abfd))
7487 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7488 PT_GETFPREGS == mach+2. */
7490 case bfd_arch_alpha:
7491 case bfd_arch_sparc:
7494 case NT_NETBSDCORE_FIRSTMACH+0:
7495 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7497 case NT_NETBSDCORE_FIRSTMACH+2:
7498 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7504 /* On all other arch's, PT_GETREGS == mach+1 and
7505 PT_GETFPREGS == mach+3. */
7510 case NT_NETBSDCORE_FIRSTMACH+1:
7511 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7513 case NT_NETBSDCORE_FIRSTMACH+3:
7514 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7524 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
7526 void *ddata = note->descdata;
7533 /* nto_procfs_status 'pid' field is at offset 0. */
7534 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7536 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7537 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7539 /* nto_procfs_status 'flags' field is at offset 8. */
7540 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7542 /* nto_procfs_status 'what' field is at offset 14. */
7543 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7545 elf_tdata (abfd)->core_signal = sig;
7546 elf_tdata (abfd)->core_lwpid = *tid;
7549 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7550 do not come from signals so we make sure we set the current
7551 thread just in case. */
7552 if (flags & 0x00000080)
7553 elf_tdata (abfd)->core_lwpid = *tid;
7555 /* Make a ".qnx_core_status/%d" section. */
7556 sprintf (buf, ".qnx_core_status/%ld", (long) *tid);
7558 name = bfd_alloc (abfd, strlen (buf) + 1);
7563 sect = bfd_make_section_anyway (abfd, name);
7567 sect->size = note->descsz;
7568 sect->filepos = note->descpos;
7569 sect->flags = SEC_HAS_CONTENTS;
7570 sect->alignment_power = 2;
7572 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7576 elfcore_grok_nto_regs (bfd *abfd,
7577 Elf_Internal_Note *note,
7585 /* Make a "(base)/%d" section. */
7586 sprintf (buf, "%s/%ld", base, (long) tid);
7588 name = bfd_alloc (abfd, strlen (buf) + 1);
7593 sect = bfd_make_section_anyway (abfd, name);
7597 sect->size = note->descsz;
7598 sect->filepos = note->descpos;
7599 sect->flags = SEC_HAS_CONTENTS;
7600 sect->alignment_power = 2;
7602 /* This is the current thread. */
7603 if (elf_tdata (abfd)->core_lwpid == tid)
7604 return elfcore_maybe_make_sect (abfd, base, sect);
7609 #define BFD_QNT_CORE_INFO 7
7610 #define BFD_QNT_CORE_STATUS 8
7611 #define BFD_QNT_CORE_GREG 9
7612 #define BFD_QNT_CORE_FPREG 10
7615 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
7617 /* Every GREG section has a STATUS section before it. Store the
7618 tid from the previous call to pass down to the next gregs
7620 static pid_t tid = 1;
7624 case BFD_QNT_CORE_INFO:
7625 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7626 case BFD_QNT_CORE_STATUS:
7627 return elfcore_grok_nto_status (abfd, note, &tid);
7628 case BFD_QNT_CORE_GREG:
7629 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
7630 case BFD_QNT_CORE_FPREG:
7631 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
7637 /* Function: elfcore_write_note
7644 size of data for note
7647 End of buffer containing note. */
7650 elfcore_write_note (bfd *abfd,
7658 Elf_External_Note *xnp;
7668 const struct elf_backend_data *bed;
7670 namesz = strlen (name) + 1;
7671 bed = get_elf_backend_data (abfd);
7672 pad = -namesz & ((1 << bed->s->log_file_align) - 1);
7675 newspace = 12 + namesz + pad + size;
7677 p = realloc (buf, *bufsiz + newspace);
7679 *bufsiz += newspace;
7680 xnp = (Elf_External_Note *) dest;
7681 H_PUT_32 (abfd, namesz, xnp->namesz);
7682 H_PUT_32 (abfd, size, xnp->descsz);
7683 H_PUT_32 (abfd, type, xnp->type);
7687 memcpy (dest, name, namesz);
7695 memcpy (dest, input, size);
7699 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7701 elfcore_write_prpsinfo (bfd *abfd,
7708 char *note_name = "CORE";
7710 #if defined (HAVE_PSINFO_T)
7712 note_type = NT_PSINFO;
7715 note_type = NT_PRPSINFO;
7718 memset (&data, 0, sizeof (data));
7719 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7720 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7721 return elfcore_write_note (abfd, buf, bufsiz,
7722 note_name, note_type, &data, sizeof (data));
7724 #endif /* PSINFO_T or PRPSINFO_T */
7726 #if defined (HAVE_PRSTATUS_T)
7728 elfcore_write_prstatus (bfd *abfd,
7736 char *note_name = "CORE";
7738 memset (&prstat, 0, sizeof (prstat));
7739 prstat.pr_pid = pid;
7740 prstat.pr_cursig = cursig;
7741 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7742 return elfcore_write_note (abfd, buf, bufsiz,
7743 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7745 #endif /* HAVE_PRSTATUS_T */
7747 #if defined (HAVE_LWPSTATUS_T)
7749 elfcore_write_lwpstatus (bfd *abfd,
7756 lwpstatus_t lwpstat;
7757 char *note_name = "CORE";
7759 memset (&lwpstat, 0, sizeof (lwpstat));
7760 lwpstat.pr_lwpid = pid >> 16;
7761 lwpstat.pr_cursig = cursig;
7762 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7763 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7764 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7766 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7767 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7769 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7770 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7773 return elfcore_write_note (abfd, buf, bufsiz, note_name,
7774 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7776 #endif /* HAVE_LWPSTATUS_T */
7778 #if defined (HAVE_PSTATUS_T)
7780 elfcore_write_pstatus (bfd *abfd,
7788 char *note_name = "CORE";
7790 memset (&pstat, 0, sizeof (pstat));
7791 pstat.pr_pid = pid & 0xffff;
7792 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7793 NT_PSTATUS, &pstat, sizeof (pstat));
7796 #endif /* HAVE_PSTATUS_T */
7799 elfcore_write_prfpreg (bfd *abfd,
7805 char *note_name = "CORE";
7806 return elfcore_write_note (abfd, buf, bufsiz,
7807 note_name, NT_FPREGSET, fpregs, size);
7811 elfcore_write_prxfpreg (bfd *abfd,
7814 const void *xfpregs,
7817 char *note_name = "LINUX";
7818 return elfcore_write_note (abfd, buf, bufsiz,
7819 note_name, NT_PRXFPREG, xfpregs, size);
7823 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
7831 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7834 buf = bfd_malloc (size);
7838 if (bfd_bread (buf, size, abfd) != size)
7846 while (p < buf + size)
7848 /* FIXME: bad alignment assumption. */
7849 Elf_External_Note *xnp = (Elf_External_Note *) p;
7850 Elf_Internal_Note in;
7852 in.type = H_GET_32 (abfd, xnp->type);
7854 in.namesz = H_GET_32 (abfd, xnp->namesz);
7855 in.namedata = xnp->name;
7857 in.descsz = H_GET_32 (abfd, xnp->descsz);
7858 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7859 in.descpos = offset + (in.descdata - buf);
7861 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7863 if (! elfcore_grok_netbsd_note (abfd, &in))
7866 else if (strncmp (in.namedata, "QNX", 3) == 0)
7868 if (! elfcore_grok_nto_note (abfd, &in))
7873 if (! elfcore_grok_note (abfd, &in))
7877 p = in.descdata + BFD_ALIGN (in.descsz, 4);
7884 /* Providing external access to the ELF program header table. */
7886 /* Return an upper bound on the number of bytes required to store a
7887 copy of ABFD's program header table entries. Return -1 if an error
7888 occurs; bfd_get_error will return an appropriate code. */
7891 bfd_get_elf_phdr_upper_bound (bfd *abfd)
7893 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7895 bfd_set_error (bfd_error_wrong_format);
7899 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7902 /* Copy ABFD's program header table entries to *PHDRS. The entries
7903 will be stored as an array of Elf_Internal_Phdr structures, as
7904 defined in include/elf/internal.h. To find out how large the
7905 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7907 Return the number of program header table entries read, or -1 if an
7908 error occurs; bfd_get_error will return an appropriate code. */
7911 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
7915 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7917 bfd_set_error (bfd_error_wrong_format);
7921 num_phdrs = elf_elfheader (abfd)->e_phnum;
7922 memcpy (phdrs, elf_tdata (abfd)->phdr,
7923 num_phdrs * sizeof (Elf_Internal_Phdr));
7929 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
7932 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7934 i_ehdrp = elf_elfheader (abfd);
7935 if (i_ehdrp == NULL)
7936 sprintf_vma (buf, value);
7939 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7941 #if BFD_HOST_64BIT_LONG
7942 sprintf (buf, "%016lx", value);
7944 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7945 _bfd_int64_low (value));
7949 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7952 sprintf_vma (buf, value);
7957 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
7960 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7962 i_ehdrp = elf_elfheader (abfd);
7963 if (i_ehdrp == NULL)
7964 fprintf_vma ((FILE *) stream, value);
7967 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7969 #if BFD_HOST_64BIT_LONG
7970 fprintf ((FILE *) stream, "%016lx", value);
7972 fprintf ((FILE *) stream, "%08lx%08lx",
7973 _bfd_int64_high (value), _bfd_int64_low (value));
7977 fprintf ((FILE *) stream, "%08lx",
7978 (unsigned long) (value & 0xffffffff));
7981 fprintf_vma ((FILE *) stream, value);
7985 enum elf_reloc_type_class
7986 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
7988 return reloc_class_normal;
7991 /* For RELA architectures, return the relocation value for a
7992 relocation against a local symbol. */
7995 _bfd_elf_rela_local_sym (bfd *abfd,
7996 Elf_Internal_Sym *sym,
7998 Elf_Internal_Rela *rel)
8000 asection *sec = *psec;
8003 relocation = (sec->output_section->vma
8004 + sec->output_offset
8006 if ((sec->flags & SEC_MERGE)
8007 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8008 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8011 _bfd_merged_section_offset (abfd, psec,
8012 elf_section_data (sec)->sec_info,
8013 sym->st_value + rel->r_addend);
8016 /* If we have changed the section, and our original section is
8017 marked with SEC_EXCLUDE, it means that the original
8018 SEC_MERGE section has been completely subsumed in some
8019 other SEC_MERGE section. In this case, we need to leave
8020 some info around for --emit-relocs. */
8021 if ((sec->flags & SEC_EXCLUDE) != 0)
8022 sec->kept_section = *psec;
8025 rel->r_addend -= relocation;
8026 rel->r_addend += sec->output_section->vma + sec->output_offset;
8032 _bfd_elf_rel_local_sym (bfd *abfd,
8033 Elf_Internal_Sym *sym,
8037 asection *sec = *psec;
8039 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8040 return sym->st_value + addend;
8042 return _bfd_merged_section_offset (abfd, psec,
8043 elf_section_data (sec)->sec_info,
8044 sym->st_value + addend);
8048 _bfd_elf_section_offset (bfd *abfd,
8049 struct bfd_link_info *info,
8053 switch (sec->sec_info_type)
8055 case ELF_INFO_TYPE_STABS:
8056 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8058 case ELF_INFO_TYPE_EH_FRAME:
8059 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8065 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8066 reconstruct an ELF file by reading the segments out of remote memory
8067 based on the ELF file header at EHDR_VMA and the ELF program headers it
8068 points to. If not null, *LOADBASEP is filled in with the difference
8069 between the VMAs from which the segments were read, and the VMAs the
8070 file headers (and hence BFD's idea of each section's VMA) put them at.
8072 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8073 remote memory at target address VMA into the local buffer at MYADDR; it
8074 should return zero on success or an `errno' code on failure. TEMPL must
8075 be a BFD for an ELF target with the word size and byte order found in
8076 the remote memory. */
8079 bfd_elf_bfd_from_remote_memory
8083 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8085 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8086 (templ, ehdr_vma, loadbasep, target_read_memory);
8090 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8091 long symcount ATTRIBUTE_UNUSED,
8092 asymbol **syms ATTRIBUTE_UNUSED,
8097 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8100 const char *relplt_name;
8101 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8105 Elf_Internal_Shdr *hdr;
8111 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8114 if (dynsymcount <= 0)
8117 if (!bed->plt_sym_val)
8120 relplt_name = bed->relplt_name;
8121 if (relplt_name == NULL)
8122 relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8123 relplt = bfd_get_section_by_name (abfd, relplt_name);
8127 hdr = &elf_section_data (relplt)->this_hdr;
8128 if (hdr->sh_link != elf_dynsymtab (abfd)
8129 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8132 plt = bfd_get_section_by_name (abfd, ".plt");
8136 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8137 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8140 count = relplt->size / hdr->sh_entsize;
8141 size = count * sizeof (asymbol);
8142 p = relplt->relocation;
8143 for (i = 0; i < count; i++, s++, p++)
8144 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8146 s = *ret = bfd_malloc (size);
8150 names = (char *) (s + count);
8151 p = relplt->relocation;
8153 for (i = 0; i < count; i++, s++, p++)
8158 addr = bed->plt_sym_val (i, plt, p);
8159 if (addr == (bfd_vma) -1)
8162 *s = **p->sym_ptr_ptr;
8164 s->value = addr - plt->vma;
8166 len = strlen ((*p->sym_ptr_ptr)->name);
8167 memcpy (names, (*p->sym_ptr_ptr)->name, len);
8169 memcpy (names, "@plt", sizeof ("@plt"));
8170 names += sizeof ("@plt");
8177 /* Sort symbol by binding and section. We want to put definitions
8178 sorted by section at the beginning. */
8181 elf_sort_elf_symbol (const void *arg1, const void *arg2)
8183 const Elf_Internal_Sym *s1;
8184 const Elf_Internal_Sym *s2;
8187 /* Make sure that undefined symbols are at the end. */
8188 s1 = (const Elf_Internal_Sym *) arg1;
8189 if (s1->st_shndx == SHN_UNDEF)
8191 s2 = (const Elf_Internal_Sym *) arg2;
8192 if (s2->st_shndx == SHN_UNDEF)
8195 /* Sorted by section index. */
8196 shndx = s1->st_shndx - s2->st_shndx;
8200 /* Sorted by binding. */
8201 return ELF_ST_BIND (s1->st_info) - ELF_ST_BIND (s2->st_info);
8206 Elf_Internal_Sym *sym;
8211 elf_sym_name_compare (const void *arg1, const void *arg2)
8213 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
8214 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
8215 return strcmp (s1->name, s2->name);
8218 /* Check if 2 sections define the same set of local and global
8222 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2)
8225 const struct elf_backend_data *bed1, *bed2;
8226 Elf_Internal_Shdr *hdr1, *hdr2;
8227 bfd_size_type symcount1, symcount2;
8228 Elf_Internal_Sym *isymbuf1, *isymbuf2;
8229 Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
8230 Elf_Internal_Sym *isymend;
8231 struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
8232 bfd_size_type count1, count2, i;
8239 /* If both are .gnu.linkonce sections, they have to have the same
8241 if (strncmp (sec1->name, ".gnu.linkonce",
8242 sizeof ".gnu.linkonce" - 1) == 0
8243 && strncmp (sec2->name, ".gnu.linkonce",
8244 sizeof ".gnu.linkonce" - 1) == 0)
8245 return strcmp (sec1->name + sizeof ".gnu.linkonce",
8246 sec2->name + sizeof ".gnu.linkonce") == 0;
8248 /* Both sections have to be in ELF. */
8249 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8250 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8253 if (elf_section_type (sec1) != elf_section_type (sec2))
8256 if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8257 && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8259 /* If both are members of section groups, they have to have the
8261 if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8265 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8266 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8267 if (shndx1 == -1 || shndx2 == -1)
8270 bed1 = get_elf_backend_data (bfd1);
8271 bed2 = get_elf_backend_data (bfd2);
8272 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8273 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8274 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8275 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8277 if (symcount1 == 0 || symcount2 == 0)
8280 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8282 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
8286 if (isymbuf1 == NULL || isymbuf2 == NULL)
8289 /* Sort symbols by binding and section. Global definitions are at
8291 qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
8292 elf_sort_elf_symbol);
8293 qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
8294 elf_sort_elf_symbol);
8296 /* Count definitions in the section. */
8298 for (isym = isymbuf1, isymend = isym + symcount1;
8299 isym < isymend; isym++)
8301 if (isym->st_shndx == (unsigned int) shndx1)
8308 if (count1 && isym->st_shndx != (unsigned int) shndx1)
8313 for (isym = isymbuf2, isymend = isym + symcount2;
8314 isym < isymend; isym++)
8316 if (isym->st_shndx == (unsigned int) shndx2)
8323 if (count2 && isym->st_shndx != (unsigned int) shndx2)
8327 if (count1 == 0 || count2 == 0 || count1 != count2)
8330 symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8331 symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8333 if (symtable1 == NULL || symtable2 == NULL)
8337 for (isym = isymstart1, isymend = isym + count1;
8338 isym < isymend; isym++)
8341 symp->name = bfd_elf_string_from_elf_section (bfd1,
8348 for (isym = isymstart2, isymend = isym + count1;
8349 isym < isymend; isym++)
8352 symp->name = bfd_elf_string_from_elf_section (bfd2,
8358 /* Sort symbol by name. */
8359 qsort (symtable1, count1, sizeof (struct elf_symbol),
8360 elf_sym_name_compare);
8361 qsort (symtable2, count1, sizeof (struct elf_symbol),
8362 elf_sym_name_compare);
8364 for (i = 0; i < count1; i++)
8365 /* Two symbols must have the same binding, type and name. */
8366 if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8367 || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8368 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)