1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 BFD support for ELF formats is being worked on.
26 Currently, the best supported back ends are for sparc and i386
27 (running svr4 or Solaris 2).
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
31 haven't bothered yet. */
33 /* For sparc64-cross-sparc32. */
41 #include "libiberty.h"
43 static int elf_sort_sections (const void *, const void *);
44 static bfd_boolean assign_file_positions_except_relocs (bfd *);
45 static bfd_boolean prep_headers (bfd *);
46 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
47 static bfd_boolean elfcore_read_notes (bfd *, file_ptr, bfd_size_type) ;
49 /* Swap version information in and out. The version information is
50 currently size independent. If that ever changes, this code will
51 need to move into elfcode.h. */
53 /* Swap in a Verdef structure. */
56 _bfd_elf_swap_verdef_in (bfd *abfd,
57 const Elf_External_Verdef *src,
58 Elf_Internal_Verdef *dst)
60 dst->vd_version = H_GET_16 (abfd, src->vd_version);
61 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
62 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
63 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
64 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
65 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
66 dst->vd_next = H_GET_32 (abfd, src->vd_next);
69 /* Swap out a Verdef structure. */
72 _bfd_elf_swap_verdef_out (bfd *abfd,
73 const Elf_Internal_Verdef *src,
74 Elf_External_Verdef *dst)
76 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
77 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
78 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
79 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
80 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
81 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
82 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
85 /* Swap in a Verdaux structure. */
88 _bfd_elf_swap_verdaux_in (bfd *abfd,
89 const Elf_External_Verdaux *src,
90 Elf_Internal_Verdaux *dst)
92 dst->vda_name = H_GET_32 (abfd, src->vda_name);
93 dst->vda_next = H_GET_32 (abfd, src->vda_next);
96 /* Swap out a Verdaux structure. */
99 _bfd_elf_swap_verdaux_out (bfd *abfd,
100 const Elf_Internal_Verdaux *src,
101 Elf_External_Verdaux *dst)
103 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
104 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
107 /* Swap in a Verneed structure. */
110 _bfd_elf_swap_verneed_in (bfd *abfd,
111 const Elf_External_Verneed *src,
112 Elf_Internal_Verneed *dst)
114 dst->vn_version = H_GET_16 (abfd, src->vn_version);
115 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
116 dst->vn_file = H_GET_32 (abfd, src->vn_file);
117 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
118 dst->vn_next = H_GET_32 (abfd, src->vn_next);
121 /* Swap out a Verneed structure. */
124 _bfd_elf_swap_verneed_out (bfd *abfd,
125 const Elf_Internal_Verneed *src,
126 Elf_External_Verneed *dst)
128 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
129 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
130 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
131 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
132 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
135 /* Swap in a Vernaux structure. */
138 _bfd_elf_swap_vernaux_in (bfd *abfd,
139 const Elf_External_Vernaux *src,
140 Elf_Internal_Vernaux *dst)
142 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
143 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
144 dst->vna_other = H_GET_16 (abfd, src->vna_other);
145 dst->vna_name = H_GET_32 (abfd, src->vna_name);
146 dst->vna_next = H_GET_32 (abfd, src->vna_next);
149 /* Swap out a Vernaux structure. */
152 _bfd_elf_swap_vernaux_out (bfd *abfd,
153 const Elf_Internal_Vernaux *src,
154 Elf_External_Vernaux *dst)
156 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
157 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
158 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
159 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
160 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
163 /* Swap in a Versym structure. */
166 _bfd_elf_swap_versym_in (bfd *abfd,
167 const Elf_External_Versym *src,
168 Elf_Internal_Versym *dst)
170 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
173 /* Swap out a Versym structure. */
176 _bfd_elf_swap_versym_out (bfd *abfd,
177 const Elf_Internal_Versym *src,
178 Elf_External_Versym *dst)
180 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
183 /* Standard ELF hash function. Do not change this function; you will
184 cause invalid hash tables to be generated. */
187 bfd_elf_hash (const char *namearg)
189 const unsigned char *name = (const unsigned char *) namearg;
194 while ((ch = *name++) != '\0')
197 if ((g = (h & 0xf0000000)) != 0)
200 /* The ELF ABI says `h &= ~g', but this is equivalent in
201 this case and on some machines one insn instead of two. */
205 return h & 0xffffffff;
208 /* Read a specified number of bytes at a specified offset in an ELF
209 file, into a newly allocated buffer, and return a pointer to the
213 elf_read (bfd *abfd, file_ptr offset, bfd_size_type size)
217 if ((buf = bfd_alloc (abfd, size)) == NULL)
219 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
221 if (bfd_bread (buf, size, abfd) != size)
223 if (bfd_get_error () != bfd_error_system_call)
224 bfd_set_error (bfd_error_file_truncated);
231 bfd_elf_mkobject (bfd *abfd)
233 /* This just does initialization. */
234 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
235 elf_tdata (abfd) = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
236 if (elf_tdata (abfd) == 0)
238 /* Since everything is done at close time, do we need any
245 bfd_elf_mkcorefile (bfd *abfd)
247 /* I think this can be done just like an object file. */
248 return bfd_elf_mkobject (abfd);
252 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
254 Elf_Internal_Shdr **i_shdrp;
255 char *shstrtab = NULL;
257 bfd_size_type shstrtabsize;
259 i_shdrp = elf_elfsections (abfd);
260 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
263 shstrtab = (char *) i_shdrp[shindex]->contents;
264 if (shstrtab == NULL)
266 /* No cached one, attempt to read, and cache what we read. */
267 offset = i_shdrp[shindex]->sh_offset;
268 shstrtabsize = i_shdrp[shindex]->sh_size;
269 shstrtab = elf_read (abfd, offset, shstrtabsize);
270 i_shdrp[shindex]->contents = shstrtab;
276 bfd_elf_string_from_elf_section (bfd *abfd,
277 unsigned int shindex,
278 unsigned int strindex)
280 Elf_Internal_Shdr *hdr;
285 hdr = elf_elfsections (abfd)[shindex];
287 if (hdr->contents == NULL
288 && bfd_elf_get_str_section (abfd, shindex) == NULL)
291 if (strindex >= hdr->sh_size)
293 (*_bfd_error_handler)
294 (_("%s: invalid string offset %u >= %lu for section `%s'"),
295 bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
296 ((shindex == elf_elfheader(abfd)->e_shstrndx
297 && strindex == hdr->sh_name)
299 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
303 return ((char *) hdr->contents) + strindex;
306 /* Read and convert symbols to internal format.
307 SYMCOUNT specifies the number of symbols to read, starting from
308 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
309 are non-NULL, they are used to store the internal symbols, external
310 symbols, and symbol section index extensions, respectively. */
313 bfd_elf_get_elf_syms (bfd *ibfd,
314 Elf_Internal_Shdr *symtab_hdr,
317 Elf_Internal_Sym *intsym_buf,
319 Elf_External_Sym_Shndx *extshndx_buf)
321 Elf_Internal_Shdr *shndx_hdr;
323 const bfd_byte *esym;
324 Elf_External_Sym_Shndx *alloc_extshndx;
325 Elf_External_Sym_Shndx *shndx;
326 Elf_Internal_Sym *isym;
327 Elf_Internal_Sym *isymend;
328 const struct elf_backend_data *bed;
336 /* Normal syms might have section extension entries. */
338 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
339 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
341 /* Read the symbols. */
343 alloc_extshndx = NULL;
344 bed = get_elf_backend_data (ibfd);
345 extsym_size = bed->s->sizeof_sym;
346 amt = symcount * extsym_size;
347 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
348 if (extsym_buf == NULL)
350 alloc_ext = bfd_malloc (amt);
351 extsym_buf = alloc_ext;
353 if (extsym_buf == NULL
354 || bfd_seek (ibfd, pos, SEEK_SET) != 0
355 || bfd_bread (extsym_buf, amt, ibfd) != amt)
361 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
365 amt = symcount * sizeof (Elf_External_Sym_Shndx);
366 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
367 if (extshndx_buf == NULL)
369 alloc_extshndx = bfd_malloc (amt);
370 extshndx_buf = alloc_extshndx;
372 if (extshndx_buf == NULL
373 || bfd_seek (ibfd, pos, SEEK_SET) != 0
374 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
381 if (intsym_buf == NULL)
383 bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
384 intsym_buf = bfd_malloc (amt);
385 if (intsym_buf == NULL)
389 /* Convert the symbols to internal form. */
390 isymend = intsym_buf + symcount;
391 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
393 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
394 (*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym);
397 if (alloc_ext != NULL)
399 if (alloc_extshndx != NULL)
400 free (alloc_extshndx);
405 /* Look up a symbol name. */
407 bfd_elf_local_sym_name (bfd *abfd, Elf_Internal_Sym *isym)
409 unsigned int iname = isym->st_name;
410 unsigned int shindex = elf_tdata (abfd)->symtab_hdr.sh_link;
411 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION)
413 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
414 shindex = elf_elfheader (abfd)->e_shstrndx;
417 return bfd_elf_string_from_elf_section (abfd, shindex, iname);
420 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
421 sections. The first element is the flags, the rest are section
424 typedef union elf_internal_group {
425 Elf_Internal_Shdr *shdr;
427 } Elf_Internal_Group;
429 /* Return the name of the group signature symbol. Why isn't the
430 signature just a string? */
433 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
435 Elf_Internal_Shdr *hdr;
436 unsigned char esym[sizeof (Elf64_External_Sym)];
437 Elf_External_Sym_Shndx eshndx;
438 Elf_Internal_Sym isym;
440 /* First we need to ensure the symbol table is available. */
441 if (! bfd_section_from_shdr (abfd, ghdr->sh_link))
444 /* Go read the symbol. */
445 hdr = &elf_tdata (abfd)->symtab_hdr;
446 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
447 &isym, esym, &eshndx) == NULL)
450 return bfd_elf_local_sym_name (abfd, &isym);
453 /* Set next_in_group list pointer, and group name for NEWSECT. */
456 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
458 unsigned int num_group = elf_tdata (abfd)->num_group;
460 /* If num_group is zero, read in all SHT_GROUP sections. The count
461 is set to -1 if there are no SHT_GROUP sections. */
464 unsigned int i, shnum;
466 /* First count the number of groups. If we have a SHT_GROUP
467 section with just a flag word (ie. sh_size is 4), ignore it. */
468 shnum = elf_numsections (abfd);
470 for (i = 0; i < shnum; i++)
472 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
473 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
478 num_group = (unsigned) -1;
479 elf_tdata (abfd)->num_group = num_group;
483 /* We keep a list of elf section headers for group sections,
484 so we can find them quickly. */
485 bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
486 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
487 if (elf_tdata (abfd)->group_sect_ptr == NULL)
491 for (i = 0; i < shnum; i++)
493 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
494 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
497 Elf_Internal_Group *dest;
499 /* Add to list of sections. */
500 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
503 /* Read the raw contents. */
504 BFD_ASSERT (sizeof (*dest) >= 4);
505 amt = shdr->sh_size * sizeof (*dest) / 4;
506 shdr->contents = bfd_alloc (abfd, amt);
507 if (shdr->contents == NULL
508 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
509 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
513 /* Translate raw contents, a flag word followed by an
514 array of elf section indices all in target byte order,
515 to the flag word followed by an array of elf section
517 src = shdr->contents + shdr->sh_size;
518 dest = (Elf_Internal_Group *) (shdr->contents + amt);
525 idx = H_GET_32 (abfd, src);
526 if (src == shdr->contents)
529 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
530 shdr->bfd_section->flags
531 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
536 ((*_bfd_error_handler)
537 (_("%s: invalid SHT_GROUP entry"),
538 bfd_archive_filename (abfd)));
541 dest->shdr = elf_elfsections (abfd)[idx];
548 if (num_group != (unsigned) -1)
552 for (i = 0; i < num_group; i++)
554 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
555 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
556 unsigned int n_elt = shdr->sh_size / 4;
558 /* Look through this group's sections to see if current
559 section is a member. */
561 if ((++idx)->shdr == hdr)
565 /* We are a member of this group. Go looking through
566 other members to see if any others are linked via
568 idx = (Elf_Internal_Group *) shdr->contents;
569 n_elt = shdr->sh_size / 4;
571 if ((s = (++idx)->shdr->bfd_section) != NULL
572 && elf_next_in_group (s) != NULL)
576 /* Snarf the group name from other member, and
577 insert current section in circular list. */
578 elf_group_name (newsect) = elf_group_name (s);
579 elf_next_in_group (newsect) = elf_next_in_group (s);
580 elf_next_in_group (s) = newsect;
586 gname = group_signature (abfd, shdr);
589 elf_group_name (newsect) = gname;
591 /* Start a circular list with one element. */
592 elf_next_in_group (newsect) = newsect;
595 /* If the group section has been created, point to the
597 if (shdr->bfd_section != NULL)
598 elf_next_in_group (shdr->bfd_section) = newsect;
606 if (elf_group_name (newsect) == NULL)
608 (*_bfd_error_handler) (_("%s: no group info for section %s"),
609 bfd_archive_filename (abfd), newsect->name);
615 bfd_elf_discard_group (bfd *abfd ATTRIBUTE_UNUSED, asection *group)
617 asection *first = elf_next_in_group (group);
622 s->output_section = bfd_abs_section_ptr;
623 s = elf_next_in_group (s);
624 /* These lists are circular. */
631 /* Make a BFD section from an ELF section. We store a pointer to the
632 BFD section in the bfd_section field of the header. */
635 _bfd_elf_make_section_from_shdr (bfd *abfd,
636 Elf_Internal_Shdr *hdr,
641 const struct elf_backend_data *bed;
643 if (hdr->bfd_section != NULL)
645 BFD_ASSERT (strcmp (name,
646 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
650 newsect = bfd_make_section_anyway (abfd, name);
654 /* Always use the real type/flags. */
655 elf_section_type (newsect) = hdr->sh_type;
656 elf_section_flags (newsect) = hdr->sh_flags;
658 newsect->filepos = hdr->sh_offset;
660 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
661 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
662 || ! bfd_set_section_alignment (abfd, newsect,
663 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
666 flags = SEC_NO_FLAGS;
667 if (hdr->sh_type != SHT_NOBITS)
668 flags |= SEC_HAS_CONTENTS;
669 if (hdr->sh_type == SHT_GROUP)
670 flags |= SEC_GROUP | SEC_EXCLUDE;
671 if ((hdr->sh_flags & SHF_ALLOC) != 0)
674 if (hdr->sh_type != SHT_NOBITS)
677 if ((hdr->sh_flags & SHF_WRITE) == 0)
678 flags |= SEC_READONLY;
679 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
681 else if ((flags & SEC_LOAD) != 0)
683 if ((hdr->sh_flags & SHF_MERGE) != 0)
686 newsect->entsize = hdr->sh_entsize;
687 if ((hdr->sh_flags & SHF_STRINGS) != 0)
688 flags |= SEC_STRINGS;
690 if (hdr->sh_flags & SHF_GROUP)
691 if (!setup_group (abfd, hdr, newsect))
693 if ((hdr->sh_flags & SHF_TLS) != 0)
694 flags |= SEC_THREAD_LOCAL;
696 /* The debugging sections appear to be recognized only by name, not
699 static const char *debug_sec_names [] =
708 for (i = ARRAY_SIZE (debug_sec_names); i--;)
709 if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
713 flags |= SEC_DEBUGGING;
716 /* As a GNU extension, if the name begins with .gnu.linkonce, we
717 only link a single copy of the section. This is used to support
718 g++. g++ will emit each template expansion in its own section.
719 The symbols will be defined as weak, so that multiple definitions
720 are permitted. The GNU linker extension is to actually discard
721 all but one of the sections. */
722 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
723 && elf_next_in_group (newsect) == NULL)
724 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
726 bed = get_elf_backend_data (abfd);
727 if (bed->elf_backend_section_flags)
728 if (! bed->elf_backend_section_flags (&flags, hdr))
731 if (! bfd_set_section_flags (abfd, newsect, flags))
734 if ((flags & SEC_ALLOC) != 0)
736 Elf_Internal_Phdr *phdr;
739 /* Look through the phdrs to see if we need to adjust the lma.
740 If all the p_paddr fields are zero, we ignore them, since
741 some ELF linkers produce such output. */
742 phdr = elf_tdata (abfd)->phdr;
743 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
745 if (phdr->p_paddr != 0)
748 if (i < elf_elfheader (abfd)->e_phnum)
750 phdr = elf_tdata (abfd)->phdr;
751 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
753 /* This section is part of this segment if its file
754 offset plus size lies within the segment's memory
755 span and, if the section is loaded, the extent of the
756 loaded data lies within the extent of the segment.
758 Note - we used to check the p_paddr field as well, and
759 refuse to set the LMA if it was 0. This is wrong
760 though, as a perfectly valid initialised segment can
761 have a p_paddr of zero. Some architectures, eg ARM,
762 place special significance on the address 0 and
763 executables need to be able to have a segment which
764 covers this address. */
765 if (phdr->p_type == PT_LOAD
766 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
767 && (hdr->sh_offset + hdr->sh_size
768 <= phdr->p_offset + phdr->p_memsz)
769 && ((flags & SEC_LOAD) == 0
770 || (hdr->sh_offset + hdr->sh_size
771 <= phdr->p_offset + phdr->p_filesz)))
773 if ((flags & SEC_LOAD) == 0)
774 newsect->lma = (phdr->p_paddr
775 + hdr->sh_addr - phdr->p_vaddr);
777 /* We used to use the same adjustment for SEC_LOAD
778 sections, but that doesn't work if the segment
779 is packed with code from multiple VMAs.
780 Instead we calculate the section LMA based on
781 the segment LMA. It is assumed that the
782 segment will contain sections with contiguous
783 LMAs, even if the VMAs are not. */
784 newsect->lma = (phdr->p_paddr
785 + hdr->sh_offset - phdr->p_offset);
787 /* With contiguous segments, we can't tell from file
788 offsets whether a section with zero size should
789 be placed at the end of one segment or the
790 beginning of the next. Decide based on vaddr. */
791 if (hdr->sh_addr >= phdr->p_vaddr
792 && (hdr->sh_addr + hdr->sh_size
793 <= phdr->p_vaddr + phdr->p_memsz))
800 hdr->bfd_section = newsect;
801 elf_section_data (newsect)->this_hdr = *hdr;
811 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
814 Helper functions for GDB to locate the string tables.
815 Since BFD hides string tables from callers, GDB needs to use an
816 internal hook to find them. Sun's .stabstr, in particular,
817 isn't even pointed to by the .stab section, so ordinary
818 mechanisms wouldn't work to find it, even if we had some.
821 struct elf_internal_shdr *
822 bfd_elf_find_section (bfd *abfd, char *name)
824 Elf_Internal_Shdr **i_shdrp;
829 i_shdrp = elf_elfsections (abfd);
832 shstrtab = bfd_elf_get_str_section (abfd,
833 elf_elfheader (abfd)->e_shstrndx);
834 if (shstrtab != NULL)
836 max = elf_numsections (abfd);
837 for (i = 1; i < max; i++)
838 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
845 const char *const bfd_elf_section_type_names[] = {
846 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
847 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
848 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
851 /* ELF relocs are against symbols. If we are producing relocatable
852 output, and the reloc is against an external symbol, and nothing
853 has given us any additional addend, the resulting reloc will also
854 be against the same symbol. In such a case, we don't want to
855 change anything about the way the reloc is handled, since it will
856 all be done at final link time. Rather than put special case code
857 into bfd_perform_relocation, all the reloc types use this howto
858 function. It just short circuits the reloc if producing
859 relocatable output against an external symbol. */
861 bfd_reloc_status_type
862 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
863 arelent *reloc_entry,
865 void *data ATTRIBUTE_UNUSED,
866 asection *input_section,
868 char **error_message ATTRIBUTE_UNUSED)
870 if (output_bfd != NULL
871 && (symbol->flags & BSF_SECTION_SYM) == 0
872 && (! reloc_entry->howto->partial_inplace
873 || reloc_entry->addend == 0))
875 reloc_entry->address += input_section->output_offset;
879 return bfd_reloc_continue;
882 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
885 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
888 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
889 sec->sec_info_type = ELF_INFO_TYPE_NONE;
892 /* Finish SHF_MERGE section merging. */
895 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
897 if (!is_elf_hash_table (info))
899 if (elf_hash_table (info)->merge_info)
900 _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info,
901 merge_sections_remove_hook);
906 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
908 sec->output_section = bfd_abs_section_ptr;
909 sec->output_offset = sec->vma;
910 if (!is_elf_hash_table (info))
913 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
916 /* Copy the program header and other data from one object module to
920 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
922 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
923 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
926 BFD_ASSERT (!elf_flags_init (obfd)
927 || (elf_elfheader (obfd)->e_flags
928 == elf_elfheader (ibfd)->e_flags));
930 elf_gp (obfd) = elf_gp (ibfd);
931 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
932 elf_flags_init (obfd) = TRUE;
936 /* Print out the program headers. */
939 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
942 Elf_Internal_Phdr *p;
944 bfd_byte *dynbuf = NULL;
946 p = elf_tdata (abfd)->phdr;
951 fprintf (f, _("\nProgram Header:\n"));
952 c = elf_elfheader (abfd)->e_phnum;
953 for (i = 0; i < c; i++, p++)
960 case PT_NULL: pt = "NULL"; break;
961 case PT_LOAD: pt = "LOAD"; break;
962 case PT_DYNAMIC: pt = "DYNAMIC"; break;
963 case PT_INTERP: pt = "INTERP"; break;
964 case PT_NOTE: pt = "NOTE"; break;
965 case PT_SHLIB: pt = "SHLIB"; break;
966 case PT_PHDR: pt = "PHDR"; break;
967 case PT_TLS: pt = "TLS"; break;
968 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
969 case PT_GNU_STACK: pt = "STACK"; break;
970 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
972 fprintf (f, "%8s off 0x", pt);
973 bfd_fprintf_vma (abfd, f, p->p_offset);
974 fprintf (f, " vaddr 0x");
975 bfd_fprintf_vma (abfd, f, p->p_vaddr);
976 fprintf (f, " paddr 0x");
977 bfd_fprintf_vma (abfd, f, p->p_paddr);
978 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
979 fprintf (f, " filesz 0x");
980 bfd_fprintf_vma (abfd, f, p->p_filesz);
981 fprintf (f, " memsz 0x");
982 bfd_fprintf_vma (abfd, f, p->p_memsz);
983 fprintf (f, " flags %c%c%c",
984 (p->p_flags & PF_R) != 0 ? 'r' : '-',
985 (p->p_flags & PF_W) != 0 ? 'w' : '-',
986 (p->p_flags & PF_X) != 0 ? 'x' : '-');
987 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
988 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
993 s = bfd_get_section_by_name (abfd, ".dynamic");
997 unsigned long shlink;
998 bfd_byte *extdyn, *extdynend;
1000 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1002 fprintf (f, _("\nDynamic Section:\n"));
1004 dynbuf = bfd_malloc (s->_raw_size);
1007 if (! bfd_get_section_contents (abfd, s, dynbuf, 0, s->_raw_size))
1010 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1013 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1015 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1016 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1019 extdynend = extdyn + s->_raw_size;
1020 for (; extdyn < extdynend; extdyn += extdynsize)
1022 Elf_Internal_Dyn dyn;
1025 bfd_boolean stringp;
1027 (*swap_dyn_in) (abfd, extdyn, &dyn);
1029 if (dyn.d_tag == DT_NULL)
1036 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1040 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1041 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1042 case DT_PLTGOT: name = "PLTGOT"; break;
1043 case DT_HASH: name = "HASH"; break;
1044 case DT_STRTAB: name = "STRTAB"; break;
1045 case DT_SYMTAB: name = "SYMTAB"; break;
1046 case DT_RELA: name = "RELA"; break;
1047 case DT_RELASZ: name = "RELASZ"; break;
1048 case DT_RELAENT: name = "RELAENT"; break;
1049 case DT_STRSZ: name = "STRSZ"; break;
1050 case DT_SYMENT: name = "SYMENT"; break;
1051 case DT_INIT: name = "INIT"; break;
1052 case DT_FINI: name = "FINI"; break;
1053 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1054 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1055 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1056 case DT_REL: name = "REL"; break;
1057 case DT_RELSZ: name = "RELSZ"; break;
1058 case DT_RELENT: name = "RELENT"; break;
1059 case DT_PLTREL: name = "PLTREL"; break;
1060 case DT_DEBUG: name = "DEBUG"; break;
1061 case DT_TEXTREL: name = "TEXTREL"; break;
1062 case DT_JMPREL: name = "JMPREL"; break;
1063 case DT_BIND_NOW: name = "BIND_NOW"; break;
1064 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1065 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1066 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1067 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1068 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1069 case DT_FLAGS: name = "FLAGS"; break;
1070 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1071 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1072 case DT_CHECKSUM: name = "CHECKSUM"; break;
1073 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1074 case DT_MOVEENT: name = "MOVEENT"; break;
1075 case DT_MOVESZ: name = "MOVESZ"; break;
1076 case DT_FEATURE: name = "FEATURE"; break;
1077 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1078 case DT_SYMINSZ: name = "SYMINSZ"; break;
1079 case DT_SYMINENT: name = "SYMINENT"; break;
1080 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1081 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1082 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1083 case DT_PLTPAD: name = "PLTPAD"; break;
1084 case DT_MOVETAB: name = "MOVETAB"; break;
1085 case DT_SYMINFO: name = "SYMINFO"; break;
1086 case DT_RELACOUNT: name = "RELACOUNT"; break;
1087 case DT_RELCOUNT: name = "RELCOUNT"; break;
1088 case DT_FLAGS_1: name = "FLAGS_1"; break;
1089 case DT_VERSYM: name = "VERSYM"; break;
1090 case DT_VERDEF: name = "VERDEF"; break;
1091 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1092 case DT_VERNEED: name = "VERNEED"; break;
1093 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1094 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1095 case DT_USED: name = "USED"; break;
1096 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1099 fprintf (f, " %-11s ", name);
1101 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1105 unsigned int tagv = dyn.d_un.d_val;
1107 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1110 fprintf (f, "%s", string);
1119 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1120 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1122 if (! _bfd_elf_slurp_version_tables (abfd))
1126 if (elf_dynverdef (abfd) != 0)
1128 Elf_Internal_Verdef *t;
1130 fprintf (f, _("\nVersion definitions:\n"));
1131 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1133 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1134 t->vd_flags, t->vd_hash, t->vd_nodename);
1135 if (t->vd_auxptr->vda_nextptr != NULL)
1137 Elf_Internal_Verdaux *a;
1140 for (a = t->vd_auxptr->vda_nextptr;
1143 fprintf (f, "%s ", a->vda_nodename);
1149 if (elf_dynverref (abfd) != 0)
1151 Elf_Internal_Verneed *t;
1153 fprintf (f, _("\nVersion References:\n"));
1154 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1156 Elf_Internal_Vernaux *a;
1158 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1159 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1160 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1161 a->vna_flags, a->vna_other, a->vna_nodename);
1173 /* Display ELF-specific fields of a symbol. */
1176 bfd_elf_print_symbol (bfd *abfd,
1179 bfd_print_symbol_type how)
1184 case bfd_print_symbol_name:
1185 fprintf (file, "%s", symbol->name);
1187 case bfd_print_symbol_more:
1188 fprintf (file, "elf ");
1189 bfd_fprintf_vma (abfd, file, symbol->value);
1190 fprintf (file, " %lx", (long) symbol->flags);
1192 case bfd_print_symbol_all:
1194 const char *section_name;
1195 const char *name = NULL;
1196 const struct elf_backend_data *bed;
1197 unsigned char st_other;
1200 section_name = symbol->section ? symbol->section->name : "(*none*)";
1202 bed = get_elf_backend_data (abfd);
1203 if (bed->elf_backend_print_symbol_all)
1204 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1208 name = symbol->name;
1209 bfd_print_symbol_vandf (abfd, file, symbol);
1212 fprintf (file, " %s\t", section_name);
1213 /* Print the "other" value for a symbol. For common symbols,
1214 we've already printed the size; now print the alignment.
1215 For other symbols, we have no specified alignment, and
1216 we've printed the address; now print the size. */
1217 if (bfd_is_com_section (symbol->section))
1218 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1220 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1221 bfd_fprintf_vma (abfd, file, val);
1223 /* If we have version information, print it. */
1224 if (elf_tdata (abfd)->dynversym_section != 0
1225 && (elf_tdata (abfd)->dynverdef_section != 0
1226 || elf_tdata (abfd)->dynverref_section != 0))
1228 unsigned int vernum;
1229 const char *version_string;
1231 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1234 version_string = "";
1235 else if (vernum == 1)
1236 version_string = "Base";
1237 else if (vernum <= elf_tdata (abfd)->cverdefs)
1239 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1242 Elf_Internal_Verneed *t;
1244 version_string = "";
1245 for (t = elf_tdata (abfd)->verref;
1249 Elf_Internal_Vernaux *a;
1251 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1253 if (a->vna_other == vernum)
1255 version_string = a->vna_nodename;
1262 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1263 fprintf (file, " %-11s", version_string);
1268 fprintf (file, " (%s)", version_string);
1269 for (i = 10 - strlen (version_string); i > 0; --i)
1274 /* If the st_other field is not zero, print it. */
1275 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1280 case STV_INTERNAL: fprintf (file, " .internal"); break;
1281 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1282 case STV_PROTECTED: fprintf (file, " .protected"); break;
1284 /* Some other non-defined flags are also present, so print
1286 fprintf (file, " 0x%02x", (unsigned int) st_other);
1289 fprintf (file, " %s", name);
1295 /* Create an entry in an ELF linker hash table. */
1297 struct bfd_hash_entry *
1298 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1299 struct bfd_hash_table *table,
1302 /* Allocate the structure if it has not already been allocated by a
1306 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1311 /* Call the allocation method of the superclass. */
1312 entry = _bfd_link_hash_newfunc (entry, table, string);
1315 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1316 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1318 /* Set local fields. */
1321 ret->dynstr_index = 0;
1322 ret->elf_hash_value = 0;
1323 ret->weakdef = NULL;
1324 ret->verinfo.verdef = NULL;
1325 ret->vtable_entries_size = 0;
1326 ret->vtable_entries_used = NULL;
1327 ret->vtable_parent = NULL;
1328 ret->got = htab->init_refcount;
1329 ret->plt = htab->init_refcount;
1331 ret->type = STT_NOTYPE;
1333 /* Assume that we have been called by a non-ELF symbol reader.
1334 This flag is then reset by the code which reads an ELF input
1335 file. This ensures that a symbol created by a non-ELF symbol
1336 reader will have the flag set correctly. */
1337 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
1343 /* Copy data from an indirect symbol to its direct symbol, hiding the
1344 old indirect symbol. Also used for copying flags to a weakdef. */
1347 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data *bed,
1348 struct elf_link_hash_entry *dir,
1349 struct elf_link_hash_entry *ind)
1352 bfd_signed_vma lowest_valid = bed->can_refcount;
1354 /* Copy down any references that we may have already seen to the
1355 symbol which just became indirect. */
1357 dir->elf_link_hash_flags
1358 |= (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
1359 | ELF_LINK_HASH_REF_REGULAR
1360 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1361 | ELF_LINK_NON_GOT_REF
1362 | ELF_LINK_HASH_NEEDS_PLT
1363 | ELF_LINK_POINTER_EQUALITY_NEEDED));
1365 if (ind->root.type != bfd_link_hash_indirect)
1368 /* Copy over the global and procedure linkage table refcount entries.
1369 These may have been already set up by a check_relocs routine. */
1370 tmp = dir->got.refcount;
1371 if (tmp < lowest_valid)
1373 dir->got.refcount = ind->got.refcount;
1374 ind->got.refcount = tmp;
1377 BFD_ASSERT (ind->got.refcount < lowest_valid);
1379 tmp = dir->plt.refcount;
1380 if (tmp < lowest_valid)
1382 dir->plt.refcount = ind->plt.refcount;
1383 ind->plt.refcount = tmp;
1386 BFD_ASSERT (ind->plt.refcount < lowest_valid);
1388 if (dir->dynindx == -1)
1390 dir->dynindx = ind->dynindx;
1391 dir->dynstr_index = ind->dynstr_index;
1393 ind->dynstr_index = 0;
1396 BFD_ASSERT (ind->dynindx == -1);
1400 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
1401 struct elf_link_hash_entry *h,
1402 bfd_boolean force_local)
1404 h->plt = elf_hash_table (info)->init_offset;
1405 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1408 h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
1409 if (h->dynindx != -1)
1412 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1418 /* Initialize an ELF linker hash table. */
1421 _bfd_elf_link_hash_table_init
1422 (struct elf_link_hash_table *table,
1424 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
1425 struct bfd_hash_table *,
1430 table->dynamic_sections_created = FALSE;
1431 table->dynobj = NULL;
1432 /* Make sure can_refcount is extended to the width and signedness of
1433 init_refcount before we subtract one from it. */
1434 table->init_refcount.refcount = get_elf_backend_data (abfd)->can_refcount;
1435 table->init_refcount.refcount -= 1;
1436 table->init_offset.offset = -(bfd_vma) 1;
1437 /* The first dynamic symbol is a dummy. */
1438 table->dynsymcount = 1;
1439 table->dynstr = NULL;
1440 table->bucketcount = 0;
1441 table->needed = NULL;
1443 table->stab_info = NULL;
1444 table->merge_info = NULL;
1445 memset (&table->eh_info, 0, sizeof (table->eh_info));
1446 table->dynlocal = NULL;
1447 table->runpath = NULL;
1448 table->tls_sec = NULL;
1449 table->tls_size = 0;
1450 table->loaded = NULL;
1452 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
1453 table->root.type = bfd_link_elf_hash_table;
1458 /* Create an ELF linker hash table. */
1460 struct bfd_link_hash_table *
1461 _bfd_elf_link_hash_table_create (bfd *abfd)
1463 struct elf_link_hash_table *ret;
1464 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1466 ret = bfd_malloc (amt);
1470 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1479 /* This is a hook for the ELF emulation code in the generic linker to
1480 tell the backend linker what file name to use for the DT_NEEDED
1481 entry for a dynamic object. The generic linker passes name as an
1482 empty string to indicate that no DT_NEEDED entry should be made. */
1485 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
1487 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1488 && bfd_get_format (abfd) == bfd_object)
1489 elf_dt_name (abfd) = name;
1493 bfd_elf_set_dt_needed_soname (bfd *abfd, const char *name)
1495 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1496 && bfd_get_format (abfd) == bfd_object)
1497 elf_dt_soname (abfd) = name;
1500 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1501 the linker ELF emulation code. */
1503 struct bfd_link_needed_list *
1504 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1505 struct bfd_link_info *info)
1507 if (! is_elf_hash_table (info))
1509 return elf_hash_table (info)->needed;
1512 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1513 hook for the linker ELF emulation code. */
1515 struct bfd_link_needed_list *
1516 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
1517 struct bfd_link_info *info)
1519 if (! is_elf_hash_table (info))
1521 return elf_hash_table (info)->runpath;
1524 /* Get the name actually used for a dynamic object for a link. This
1525 is the SONAME entry if there is one. Otherwise, it is the string
1526 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1529 bfd_elf_get_dt_soname (bfd *abfd)
1531 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1532 && bfd_get_format (abfd) == bfd_object)
1533 return elf_dt_name (abfd);
1537 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1538 the ELF linker emulation code. */
1541 bfd_elf_get_bfd_needed_list (bfd *abfd,
1542 struct bfd_link_needed_list **pneeded)
1545 bfd_byte *dynbuf = NULL;
1547 unsigned long shlink;
1548 bfd_byte *extdyn, *extdynend;
1550 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1554 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1555 || bfd_get_format (abfd) != bfd_object)
1558 s = bfd_get_section_by_name (abfd, ".dynamic");
1559 if (s == NULL || s->_raw_size == 0)
1562 dynbuf = bfd_malloc (s->_raw_size);
1566 if (! bfd_get_section_contents (abfd, s, dynbuf, 0, s->_raw_size))
1569 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1573 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1575 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1576 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1579 extdynend = extdyn + s->_raw_size;
1580 for (; extdyn < extdynend; extdyn += extdynsize)
1582 Elf_Internal_Dyn dyn;
1584 (*swap_dyn_in) (abfd, extdyn, &dyn);
1586 if (dyn.d_tag == DT_NULL)
1589 if (dyn.d_tag == DT_NEEDED)
1592 struct bfd_link_needed_list *l;
1593 unsigned int tagv = dyn.d_un.d_val;
1596 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1601 l = bfd_alloc (abfd, amt);
1622 /* Allocate an ELF string table--force the first byte to be zero. */
1624 struct bfd_strtab_hash *
1625 _bfd_elf_stringtab_init (void)
1627 struct bfd_strtab_hash *ret;
1629 ret = _bfd_stringtab_init ();
1634 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1635 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1636 if (loc == (bfd_size_type) -1)
1638 _bfd_stringtab_free (ret);
1645 /* ELF .o/exec file reading */
1647 /* Create a new bfd section from an ELF section header. */
1650 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1652 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1653 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1654 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1657 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1659 switch (hdr->sh_type)
1662 /* Inactive section. Throw it away. */
1665 case SHT_PROGBITS: /* Normal section with contents. */
1666 case SHT_NOBITS: /* .bss section. */
1667 case SHT_HASH: /* .hash section. */
1668 case SHT_NOTE: /* .note section. */
1669 case SHT_INIT_ARRAY: /* .init_array section. */
1670 case SHT_FINI_ARRAY: /* .fini_array section. */
1671 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1672 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1674 case SHT_DYNAMIC: /* Dynamic linking information. */
1675 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1677 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1679 Elf_Internal_Shdr *dynsymhdr;
1681 /* The shared libraries distributed with hpux11 have a bogus
1682 sh_link field for the ".dynamic" section. Find the
1683 string table for the ".dynsym" section instead. */
1684 if (elf_dynsymtab (abfd) != 0)
1686 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1687 hdr->sh_link = dynsymhdr->sh_link;
1691 unsigned int i, num_sec;
1693 num_sec = elf_numsections (abfd);
1694 for (i = 1; i < num_sec; i++)
1696 dynsymhdr = elf_elfsections (abfd)[i];
1697 if (dynsymhdr->sh_type == SHT_DYNSYM)
1699 hdr->sh_link = dynsymhdr->sh_link;
1707 case SHT_SYMTAB: /* A symbol table */
1708 if (elf_onesymtab (abfd) == shindex)
1711 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1712 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1713 elf_onesymtab (abfd) = shindex;
1714 elf_tdata (abfd)->symtab_hdr = *hdr;
1715 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1716 abfd->flags |= HAS_SYMS;
1718 /* Sometimes a shared object will map in the symbol table. If
1719 SHF_ALLOC is set, and this is a shared object, then we also
1720 treat this section as a BFD section. We can not base the
1721 decision purely on SHF_ALLOC, because that flag is sometimes
1722 set in a relocatable object file, which would confuse the
1724 if ((hdr->sh_flags & SHF_ALLOC) != 0
1725 && (abfd->flags & DYNAMIC) != 0
1726 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1731 case SHT_DYNSYM: /* A dynamic symbol table */
1732 if (elf_dynsymtab (abfd) == shindex)
1735 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1736 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1737 elf_dynsymtab (abfd) = shindex;
1738 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1739 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1740 abfd->flags |= HAS_SYMS;
1742 /* Besides being a symbol table, we also treat this as a regular
1743 section, so that objcopy can handle it. */
1744 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1746 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1747 if (elf_symtab_shndx (abfd) == shindex)
1750 /* Get the associated symbol table. */
1751 if (! bfd_section_from_shdr (abfd, hdr->sh_link)
1752 || hdr->sh_link != elf_onesymtab (abfd))
1755 elf_symtab_shndx (abfd) = shindex;
1756 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1757 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1760 case SHT_STRTAB: /* A string table */
1761 if (hdr->bfd_section != NULL)
1763 if (ehdr->e_shstrndx == shindex)
1765 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1766 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1770 unsigned int i, num_sec;
1772 num_sec = elf_numsections (abfd);
1773 for (i = 1; i < num_sec; i++)
1775 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1776 if (hdr2->sh_link == shindex)
1778 if (! bfd_section_from_shdr (abfd, i))
1780 if (elf_onesymtab (abfd) == i)
1782 elf_tdata (abfd)->strtab_hdr = *hdr;
1783 elf_elfsections (abfd)[shindex] =
1784 &elf_tdata (abfd)->strtab_hdr;
1787 if (elf_dynsymtab (abfd) == i)
1789 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1790 elf_elfsections (abfd)[shindex] = hdr =
1791 &elf_tdata (abfd)->dynstrtab_hdr;
1792 /* We also treat this as a regular section, so
1793 that objcopy can handle it. */
1796 #if 0 /* Not handling other string tables specially right now. */
1797 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1798 /* We have a strtab for some random other section. */
1799 newsect = (asection *) hdr2->bfd_section;
1802 hdr->bfd_section = newsect;
1803 hdr2 = &elf_section_data (newsect)->str_hdr;
1805 elf_elfsections (abfd)[shindex] = hdr2;
1811 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1815 /* *These* do a lot of work -- but build no sections! */
1817 asection *target_sect;
1818 Elf_Internal_Shdr *hdr2;
1819 unsigned int num_sec = elf_numsections (abfd);
1821 /* Check for a bogus link to avoid crashing. */
1822 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1823 || hdr->sh_link >= num_sec)
1825 ((*_bfd_error_handler)
1826 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1827 bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
1828 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1831 /* For some incomprehensible reason Oracle distributes
1832 libraries for Solaris in which some of the objects have
1833 bogus sh_link fields. It would be nice if we could just
1834 reject them, but, unfortunately, some people need to use
1835 them. We scan through the section headers; if we find only
1836 one suitable symbol table, we clobber the sh_link to point
1837 to it. I hope this doesn't break anything. */
1838 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1839 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1845 for (scan = 1; scan < num_sec; scan++)
1847 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1848 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1859 hdr->sh_link = found;
1862 /* Get the symbol table. */
1863 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1864 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1867 /* If this reloc section does not use the main symbol table we
1868 don't treat it as a reloc section. BFD can't adequately
1869 represent such a section, so at least for now, we don't
1870 try. We just present it as a normal section. We also
1871 can't use it as a reloc section if it points to the null
1873 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1874 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1876 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1878 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1879 if (target_sect == NULL)
1882 if ((target_sect->flags & SEC_RELOC) == 0
1883 || target_sect->reloc_count == 0)
1884 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1888 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1889 amt = sizeof (*hdr2);
1890 hdr2 = bfd_alloc (abfd, amt);
1891 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1894 elf_elfsections (abfd)[shindex] = hdr2;
1895 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1896 target_sect->flags |= SEC_RELOC;
1897 target_sect->relocation = NULL;
1898 target_sect->rel_filepos = hdr->sh_offset;
1899 /* In the section to which the relocations apply, mark whether
1900 its relocations are of the REL or RELA variety. */
1901 if (hdr->sh_size != 0)
1902 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
1903 abfd->flags |= HAS_RELOC;
1908 case SHT_GNU_verdef:
1909 elf_dynverdef (abfd) = shindex;
1910 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1911 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1914 case SHT_GNU_versym:
1915 elf_dynversym (abfd) = shindex;
1916 elf_tdata (abfd)->dynversym_hdr = *hdr;
1917 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1920 case SHT_GNU_verneed:
1921 elf_dynverref (abfd) = shindex;
1922 elf_tdata (abfd)->dynverref_hdr = *hdr;
1923 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1930 /* We need a BFD section for objcopy and relocatable linking,
1931 and it's handy to have the signature available as the section
1933 name = group_signature (abfd, hdr);
1936 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
1938 if (hdr->contents != NULL)
1940 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1941 unsigned int n_elt = hdr->sh_size / 4;
1944 if (idx->flags & GRP_COMDAT)
1945 hdr->bfd_section->flags
1946 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1948 while (--n_elt != 0)
1949 if ((s = (++idx)->shdr->bfd_section) != NULL
1950 && elf_next_in_group (s) != NULL)
1952 elf_next_in_group (hdr->bfd_section) = s;
1959 /* Check for any processor-specific section types. */
1961 if (bed->elf_backend_section_from_shdr)
1962 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1970 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1971 Return SEC for sections that have no elf section, and NULL on error. */
1974 bfd_section_from_r_symndx (bfd *abfd,
1975 struct sym_sec_cache *cache,
1977 unsigned long r_symndx)
1979 Elf_Internal_Shdr *symtab_hdr;
1980 unsigned char esym[sizeof (Elf64_External_Sym)];
1981 Elf_External_Sym_Shndx eshndx;
1982 Elf_Internal_Sym isym;
1983 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
1985 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
1986 return cache->sec[ent];
1988 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1989 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
1990 &isym, esym, &eshndx) == NULL)
1993 if (cache->abfd != abfd)
1995 memset (cache->indx, -1, sizeof (cache->indx));
1998 cache->indx[ent] = r_symndx;
1999 cache->sec[ent] = sec;
2000 if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2001 || isym.st_shndx > SHN_HIRESERVE)
2004 s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2006 cache->sec[ent] = s;
2008 return cache->sec[ent];
2011 /* Given an ELF section number, retrieve the corresponding BFD
2015 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2017 if (index >= elf_numsections (abfd))
2019 return elf_elfsections (abfd)[index]->bfd_section;
2022 static struct bfd_elf_special_section const special_sections[] =
2024 { ".bss", 4, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2025 { ".comment", 8, 0, SHT_PROGBITS, 0 },
2026 { ".data", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2027 { ".data1", 6, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2028 { ".debug", 6, 0, SHT_PROGBITS, 0 },
2029 { ".fini", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2030 { ".init", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2031 { ".line", 5, 0, SHT_PROGBITS, 0 },
2032 { ".rodata", 7, -2, SHT_PROGBITS, SHF_ALLOC },
2033 { ".rodata1", 8, 0, SHT_PROGBITS, SHF_ALLOC },
2034 { ".tbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2035 { ".tdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2036 { ".text", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2037 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2038 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2039 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2040 { ".debug_line", 11, 0, SHT_PROGBITS, 0 },
2041 { ".debug_info", 11, 0, SHT_PROGBITS, 0 },
2042 { ".debug_abbrev", 13, 0, SHT_PROGBITS, 0 },
2043 { ".debug_aranges", 14, 0, SHT_PROGBITS, 0 },
2044 { ".dynamic", 8, 0, SHT_DYNAMIC, SHF_ALLOC },
2045 { ".dynstr", 7, 0, SHT_STRTAB, SHF_ALLOC },
2046 { ".dynsym", 7, 0, SHT_DYNSYM, SHF_ALLOC },
2047 { ".got", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2048 { ".hash", 5, 0, SHT_HASH, SHF_ALLOC },
2049 { ".interp", 7, 0, SHT_PROGBITS, 0 },
2050 { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2051 { ".shstrtab", 9, 0, SHT_STRTAB, 0 },
2052 { ".strtab", 7, 0, SHT_STRTAB, 0 },
2053 { ".symtab", 7, 0, SHT_SYMTAB, 0 },
2054 { ".gnu.version", 12, 0, SHT_GNU_versym, 0 },
2055 { ".gnu.version_d", 14, 0, SHT_GNU_verdef, 0 },
2056 { ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },
2057 { ".note", 5, -1, SHT_NOTE, 0 },
2058 { ".rela", 5, -1, SHT_RELA, 0 },
2059 { ".rel", 4, -1, SHT_REL, 0 },
2060 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2061 { NULL, 0, 0, 0, 0 }
2064 static const struct bfd_elf_special_section *
2065 get_special_section (const char *name,
2066 const struct bfd_elf_special_section *special_sections,
2070 int len = strlen (name);
2072 for (i = 0; special_sections[i].prefix != NULL; i++)
2075 int prefix_len = special_sections[i].prefix_length;
2077 if (len < prefix_len)
2079 if (memcmp (name, special_sections[i].prefix, prefix_len) != 0)
2082 suffix_len = special_sections[i].suffix_length;
2083 if (suffix_len <= 0)
2085 if (name[prefix_len] != 0)
2087 if (suffix_len == 0)
2089 if (name[prefix_len] != '.'
2090 && (suffix_len == -2
2091 || (rela && special_sections[i].type == SHT_REL)))
2097 if (len < prefix_len + suffix_len)
2099 if (memcmp (name + len - suffix_len,
2100 special_sections[i].prefix + prefix_len,
2104 return &special_sections[i];
2110 const struct bfd_elf_special_section *
2111 _bfd_elf_get_sec_type_attr (bfd *abfd, const char *name)
2113 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2114 const struct bfd_elf_special_section *ssect = NULL;
2116 /* See if this is one of the special sections. */
2119 unsigned int rela = bed->default_use_rela_p;
2121 if (bed->special_sections)
2122 ssect = get_special_section (name, bed->special_sections, rela);
2125 ssect = get_special_section (name, special_sections, rela);
2132 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2134 struct bfd_elf_section_data *sdata;
2135 const struct bfd_elf_special_section *ssect;
2137 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2140 sdata = bfd_zalloc (abfd, sizeof (*sdata));
2143 sec->used_by_bfd = sdata;
2146 elf_section_type (sec) = SHT_NULL;
2147 ssect = _bfd_elf_get_sec_type_attr (abfd, sec->name);
2150 elf_section_type (sec) = ssect->type;
2151 elf_section_flags (sec) = ssect->attr;
2154 /* Indicate whether or not this section should use RELA relocations. */
2155 sec->use_rela_p = get_elf_backend_data (abfd)->default_use_rela_p;
2160 /* Create a new bfd section from an ELF program header.
2162 Since program segments have no names, we generate a synthetic name
2163 of the form segment<NUM>, where NUM is generally the index in the
2164 program header table. For segments that are split (see below) we
2165 generate the names segment<NUM>a and segment<NUM>b.
2167 Note that some program segments may have a file size that is different than
2168 (less than) the memory size. All this means is that at execution the
2169 system must allocate the amount of memory specified by the memory size,
2170 but only initialize it with the first "file size" bytes read from the
2171 file. This would occur for example, with program segments consisting
2172 of combined data+bss.
2174 To handle the above situation, this routine generates TWO bfd sections
2175 for the single program segment. The first has the length specified by
2176 the file size of the segment, and the second has the length specified
2177 by the difference between the two sizes. In effect, the segment is split
2178 into it's initialized and uninitialized parts.
2183 _bfd_elf_make_section_from_phdr (bfd *abfd,
2184 Elf_Internal_Phdr *hdr,
2186 const char *typename)
2194 split = ((hdr->p_memsz > 0)
2195 && (hdr->p_filesz > 0)
2196 && (hdr->p_memsz > hdr->p_filesz));
2197 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2198 len = strlen (namebuf) + 1;
2199 name = bfd_alloc (abfd, len);
2202 memcpy (name, namebuf, len);
2203 newsect = bfd_make_section (abfd, name);
2204 if (newsect == NULL)
2206 newsect->vma = hdr->p_vaddr;
2207 newsect->lma = hdr->p_paddr;
2208 newsect->_raw_size = hdr->p_filesz;
2209 newsect->filepos = hdr->p_offset;
2210 newsect->flags |= SEC_HAS_CONTENTS;
2211 newsect->alignment_power = bfd_log2 (hdr->p_align);
2212 if (hdr->p_type == PT_LOAD)
2214 newsect->flags |= SEC_ALLOC;
2215 newsect->flags |= SEC_LOAD;
2216 if (hdr->p_flags & PF_X)
2218 /* FIXME: all we known is that it has execute PERMISSION,
2220 newsect->flags |= SEC_CODE;
2223 if (!(hdr->p_flags & PF_W))
2225 newsect->flags |= SEC_READONLY;
2230 sprintf (namebuf, "%s%db", typename, index);
2231 len = strlen (namebuf) + 1;
2232 name = bfd_alloc (abfd, len);
2235 memcpy (name, namebuf, len);
2236 newsect = bfd_make_section (abfd, name);
2237 if (newsect == NULL)
2239 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2240 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2241 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
2242 if (hdr->p_type == PT_LOAD)
2244 newsect->flags |= SEC_ALLOC;
2245 if (hdr->p_flags & PF_X)
2246 newsect->flags |= SEC_CODE;
2248 if (!(hdr->p_flags & PF_W))
2249 newsect->flags |= SEC_READONLY;
2256 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2258 const struct elf_backend_data *bed;
2260 switch (hdr->p_type)
2263 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2266 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2269 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2272 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2275 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2277 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2282 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2285 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2287 case PT_GNU_EH_FRAME:
2288 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2292 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2295 /* Check for any processor-specific program segment types.
2296 If no handler for them, default to making "segment" sections. */
2297 bed = get_elf_backend_data (abfd);
2298 if (bed->elf_backend_section_from_phdr)
2299 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
2301 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
2305 /* Initialize REL_HDR, the section-header for new section, containing
2306 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2307 relocations; otherwise, we use REL relocations. */
2310 _bfd_elf_init_reloc_shdr (bfd *abfd,
2311 Elf_Internal_Shdr *rel_hdr,
2313 bfd_boolean use_rela_p)
2316 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2317 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2319 name = bfd_alloc (abfd, amt);
2322 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2324 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2326 if (rel_hdr->sh_name == (unsigned int) -1)
2328 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2329 rel_hdr->sh_entsize = (use_rela_p
2330 ? bed->s->sizeof_rela
2331 : bed->s->sizeof_rel);
2332 rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2333 rel_hdr->sh_flags = 0;
2334 rel_hdr->sh_addr = 0;
2335 rel_hdr->sh_size = 0;
2336 rel_hdr->sh_offset = 0;
2341 /* Set up an ELF internal section header for a section. */
2344 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2346 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2347 bfd_boolean *failedptr = failedptrarg;
2348 Elf_Internal_Shdr *this_hdr;
2352 /* We already failed; just get out of the bfd_map_over_sections
2357 this_hdr = &elf_section_data (asect)->this_hdr;
2359 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2360 asect->name, FALSE);
2361 if (this_hdr->sh_name == (unsigned int) -1)
2367 this_hdr->sh_flags = 0;
2369 if ((asect->flags & SEC_ALLOC) != 0
2370 || asect->user_set_vma)
2371 this_hdr->sh_addr = asect->vma;
2373 this_hdr->sh_addr = 0;
2375 this_hdr->sh_offset = 0;
2376 this_hdr->sh_size = asect->_raw_size;
2377 this_hdr->sh_link = 0;
2378 this_hdr->sh_addralign = 1 << asect->alignment_power;
2379 /* The sh_entsize and sh_info fields may have been set already by
2380 copy_private_section_data. */
2382 this_hdr->bfd_section = asect;
2383 this_hdr->contents = NULL;
2385 /* If the section type is unspecified, we set it based on
2387 if (this_hdr->sh_type == SHT_NULL)
2389 if ((asect->flags & SEC_ALLOC) != 0
2390 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2391 || (asect->flags & SEC_NEVER_LOAD) != 0))
2392 this_hdr->sh_type = SHT_NOBITS;
2394 this_hdr->sh_type = SHT_PROGBITS;
2397 switch (this_hdr->sh_type)
2403 case SHT_INIT_ARRAY:
2404 case SHT_FINI_ARRAY:
2405 case SHT_PREINIT_ARRAY:
2412 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2416 this_hdr->sh_entsize = bed->s->sizeof_sym;
2420 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2424 if (get_elf_backend_data (abfd)->may_use_rela_p)
2425 this_hdr->sh_entsize = bed->s->sizeof_rela;
2429 if (get_elf_backend_data (abfd)->may_use_rel_p)
2430 this_hdr->sh_entsize = bed->s->sizeof_rel;
2433 case SHT_GNU_versym:
2434 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2437 case SHT_GNU_verdef:
2438 this_hdr->sh_entsize = 0;
2439 /* objcopy or strip will copy over sh_info, but may not set
2440 cverdefs. The linker will set cverdefs, but sh_info will be
2442 if (this_hdr->sh_info == 0)
2443 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2445 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2446 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2449 case SHT_GNU_verneed:
2450 this_hdr->sh_entsize = 0;
2451 /* objcopy or strip will copy over sh_info, but may not set
2452 cverrefs. The linker will set cverrefs, but sh_info will be
2454 if (this_hdr->sh_info == 0)
2455 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2457 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2458 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2462 this_hdr->sh_entsize = 4;
2466 if ((asect->flags & SEC_ALLOC) != 0)
2467 this_hdr->sh_flags |= SHF_ALLOC;
2468 if ((asect->flags & SEC_READONLY) == 0)
2469 this_hdr->sh_flags |= SHF_WRITE;
2470 if ((asect->flags & SEC_CODE) != 0)
2471 this_hdr->sh_flags |= SHF_EXECINSTR;
2472 if ((asect->flags & SEC_MERGE) != 0)
2474 this_hdr->sh_flags |= SHF_MERGE;
2475 this_hdr->sh_entsize = asect->entsize;
2476 if ((asect->flags & SEC_STRINGS) != 0)
2477 this_hdr->sh_flags |= SHF_STRINGS;
2479 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2480 this_hdr->sh_flags |= SHF_GROUP;
2481 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2483 this_hdr->sh_flags |= SHF_TLS;
2484 if (asect->_raw_size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2486 struct bfd_link_order *o;
2488 this_hdr->sh_size = 0;
2489 for (o = asect->link_order_head; o != NULL; o = o->next)
2490 if (this_hdr->sh_size < o->offset + o->size)
2491 this_hdr->sh_size = o->offset + o->size;
2492 if (this_hdr->sh_size)
2493 this_hdr->sh_type = SHT_NOBITS;
2497 /* Check for processor-specific section types. */
2498 if (bed->elf_backend_fake_sections
2499 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2502 /* If the section has relocs, set up a section header for the
2503 SHT_REL[A] section. If two relocation sections are required for
2504 this section, it is up to the processor-specific back-end to
2505 create the other. */
2506 if ((asect->flags & SEC_RELOC) != 0
2507 && !_bfd_elf_init_reloc_shdr (abfd,
2508 &elf_section_data (asect)->rel_hdr,
2514 /* Fill in the contents of a SHT_GROUP section. */
2517 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2519 bfd_boolean *failedptr = failedptrarg;
2520 unsigned long symindx;
2521 asection *elt, *first;
2523 struct bfd_link_order *l;
2526 if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2531 if (elf_group_id (sec) != NULL)
2532 symindx = elf_group_id (sec)->udata.i;
2536 /* If called from the assembler, swap_out_syms will have set up
2537 elf_section_syms; If called for "ld -r", use target_index. */
2538 if (elf_section_syms (abfd) != NULL)
2539 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2541 symindx = sec->target_index;
2543 elf_section_data (sec)->this_hdr.sh_info = symindx;
2545 /* The contents won't be allocated for "ld -r" or objcopy. */
2547 if (sec->contents == NULL)
2550 sec->contents = bfd_alloc (abfd, sec->_raw_size);
2552 /* Arrange for the section to be written out. */
2553 elf_section_data (sec)->this_hdr.contents = sec->contents;
2554 if (sec->contents == NULL)
2561 loc = sec->contents + sec->_raw_size;
2563 /* Get the pointer to the first section in the group that gas
2564 squirreled away here. objcopy arranges for this to be set to the
2565 start of the input section group. */
2566 first = elt = elf_next_in_group (sec);
2568 /* First element is a flag word. Rest of section is elf section
2569 indices for all the sections of the group. Write them backwards
2570 just to keep the group in the same order as given in .section
2571 directives, not that it matters. */
2580 s = s->output_section;
2583 idx = elf_section_data (s)->this_idx;
2584 H_PUT_32 (abfd, idx, loc);
2585 elt = elf_next_in_group (elt);
2590 /* If this is a relocatable link, then the above did nothing because
2591 SEC is the output section. Look through the input sections
2593 for (l = sec->link_order_head; l != NULL; l = l->next)
2594 if (l->type == bfd_indirect_link_order
2595 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2600 elf_section_data (elt->output_section)->this_idx, loc);
2601 elt = elf_next_in_group (elt);
2602 /* During a relocatable link, the lists are circular. */
2604 while (elt != elf_next_in_group (l->u.indirect.section));
2606 /* With ld -r, merging SHT_GROUP sections results in wasted space
2607 due to allowing for the flag word on each input. We may well
2608 duplicate entries too. */
2609 while ((loc -= 4) > sec->contents)
2610 H_PUT_32 (abfd, 0, loc);
2612 if (loc != sec->contents)
2615 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2618 /* Assign all ELF section numbers. The dummy first section is handled here
2619 too. The link/info pointers for the standard section types are filled
2620 in here too, while we're at it. */
2623 assign_section_numbers (bfd *abfd)
2625 struct elf_obj_tdata *t = elf_tdata (abfd);
2627 unsigned int section_number, secn;
2628 Elf_Internal_Shdr **i_shdrp;
2633 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2635 for (sec = abfd->sections; sec; sec = sec->next)
2637 struct bfd_elf_section_data *d = elf_section_data (sec);
2639 if (section_number == SHN_LORESERVE)
2640 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2641 d->this_idx = section_number++;
2642 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2643 if ((sec->flags & SEC_RELOC) == 0)
2647 if (section_number == SHN_LORESERVE)
2648 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2649 d->rel_idx = section_number++;
2650 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2655 if (section_number == SHN_LORESERVE)
2656 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2657 d->rel_idx2 = section_number++;
2658 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2664 if (section_number == SHN_LORESERVE)
2665 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2666 t->shstrtab_section = section_number++;
2667 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2668 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2670 if (bfd_get_symcount (abfd) > 0)
2672 if (section_number == SHN_LORESERVE)
2673 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2674 t->symtab_section = section_number++;
2675 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2676 if (section_number > SHN_LORESERVE - 2)
2678 if (section_number == SHN_LORESERVE)
2679 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2680 t->symtab_shndx_section = section_number++;
2681 t->symtab_shndx_hdr.sh_name
2682 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2683 ".symtab_shndx", FALSE);
2684 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2687 if (section_number == SHN_LORESERVE)
2688 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2689 t->strtab_section = section_number++;
2690 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2693 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2694 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2696 elf_numsections (abfd) = section_number;
2697 elf_elfheader (abfd)->e_shnum = section_number;
2698 if (section_number > SHN_LORESERVE)
2699 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2701 /* Set up the list of section header pointers, in agreement with the
2703 amt = section_number * sizeof (Elf_Internal_Shdr *);
2704 i_shdrp = bfd_zalloc (abfd, amt);
2705 if (i_shdrp == NULL)
2708 amt = sizeof (Elf_Internal_Shdr);
2709 i_shdrp[0] = bfd_zalloc (abfd, amt);
2710 if (i_shdrp[0] == NULL)
2712 bfd_release (abfd, i_shdrp);
2716 elf_elfsections (abfd) = i_shdrp;
2718 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2719 if (bfd_get_symcount (abfd) > 0)
2721 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2722 if (elf_numsections (abfd) > SHN_LORESERVE)
2724 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2725 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2727 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2728 t->symtab_hdr.sh_link = t->strtab_section;
2730 for (sec = abfd->sections; sec; sec = sec->next)
2732 struct bfd_elf_section_data *d = elf_section_data (sec);
2736 i_shdrp[d->this_idx] = &d->this_hdr;
2737 if (d->rel_idx != 0)
2738 i_shdrp[d->rel_idx] = &d->rel_hdr;
2739 if (d->rel_idx2 != 0)
2740 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2742 /* Fill in the sh_link and sh_info fields while we're at it. */
2744 /* sh_link of a reloc section is the section index of the symbol
2745 table. sh_info is the section index of the section to which
2746 the relocation entries apply. */
2747 if (d->rel_idx != 0)
2749 d->rel_hdr.sh_link = t->symtab_section;
2750 d->rel_hdr.sh_info = d->this_idx;
2752 if (d->rel_idx2 != 0)
2754 d->rel_hdr2->sh_link = t->symtab_section;
2755 d->rel_hdr2->sh_info = d->this_idx;
2758 switch (d->this_hdr.sh_type)
2762 /* A reloc section which we are treating as a normal BFD
2763 section. sh_link is the section index of the symbol
2764 table. sh_info is the section index of the section to
2765 which the relocation entries apply. We assume that an
2766 allocated reloc section uses the dynamic symbol table.
2767 FIXME: How can we be sure? */
2768 s = bfd_get_section_by_name (abfd, ".dynsym");
2770 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2772 /* We look up the section the relocs apply to by name. */
2774 if (d->this_hdr.sh_type == SHT_REL)
2778 s = bfd_get_section_by_name (abfd, name);
2780 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2784 /* We assume that a section named .stab*str is a stabs
2785 string section. We look for a section with the same name
2786 but without the trailing ``str'', and set its sh_link
2787 field to point to this section. */
2788 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2789 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2794 len = strlen (sec->name);
2795 alc = bfd_malloc (len - 2);
2798 memcpy (alc, sec->name, len - 3);
2799 alc[len - 3] = '\0';
2800 s = bfd_get_section_by_name (abfd, alc);
2804 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2806 /* This is a .stab section. */
2807 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2808 elf_section_data (s)->this_hdr.sh_entsize
2809 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
2816 case SHT_GNU_verneed:
2817 case SHT_GNU_verdef:
2818 /* sh_link is the section header index of the string table
2819 used for the dynamic entries, or the symbol table, or the
2821 s = bfd_get_section_by_name (abfd, ".dynstr");
2823 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2827 case SHT_GNU_versym:
2828 /* sh_link is the section header index of the symbol table
2829 this hash table or version table is for. */
2830 s = bfd_get_section_by_name (abfd, ".dynsym");
2832 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2836 d->this_hdr.sh_link = t->symtab_section;
2840 for (secn = 1; secn < section_number; ++secn)
2841 if (i_shdrp[secn] == NULL)
2842 i_shdrp[secn] = i_shdrp[0];
2844 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2845 i_shdrp[secn]->sh_name);
2849 /* Map symbol from it's internal number to the external number, moving
2850 all local symbols to be at the head of the list. */
2853 sym_is_global (bfd *abfd, asymbol *sym)
2855 /* If the backend has a special mapping, use it. */
2856 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2857 if (bed->elf_backend_sym_is_global)
2858 return (*bed->elf_backend_sym_is_global) (abfd, sym);
2860 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2861 || bfd_is_und_section (bfd_get_section (sym))
2862 || bfd_is_com_section (bfd_get_section (sym)));
2866 elf_map_symbols (bfd *abfd)
2868 unsigned int symcount = bfd_get_symcount (abfd);
2869 asymbol **syms = bfd_get_outsymbols (abfd);
2870 asymbol **sect_syms;
2871 unsigned int num_locals = 0;
2872 unsigned int num_globals = 0;
2873 unsigned int num_locals2 = 0;
2874 unsigned int num_globals2 = 0;
2882 fprintf (stderr, "elf_map_symbols\n");
2886 for (asect = abfd->sections; asect; asect = asect->next)
2888 if (max_index < asect->index)
2889 max_index = asect->index;
2893 amt = max_index * sizeof (asymbol *);
2894 sect_syms = bfd_zalloc (abfd, amt);
2895 if (sect_syms == NULL)
2897 elf_section_syms (abfd) = sect_syms;
2898 elf_num_section_syms (abfd) = max_index;
2900 /* Init sect_syms entries for any section symbols we have already
2901 decided to output. */
2902 for (idx = 0; idx < symcount; idx++)
2904 asymbol *sym = syms[idx];
2906 if ((sym->flags & BSF_SECTION_SYM) != 0
2913 if (sec->owner != NULL)
2915 if (sec->owner != abfd)
2917 if (sec->output_offset != 0)
2920 sec = sec->output_section;
2922 /* Empty sections in the input files may have had a
2923 section symbol created for them. (See the comment
2924 near the end of _bfd_generic_link_output_symbols in
2925 linker.c). If the linker script discards such
2926 sections then we will reach this point. Since we know
2927 that we cannot avoid this case, we detect it and skip
2928 the abort and the assignment to the sect_syms array.
2929 To reproduce this particular case try running the
2930 linker testsuite test ld-scripts/weak.exp for an ELF
2931 port that uses the generic linker. */
2932 if (sec->owner == NULL)
2935 BFD_ASSERT (sec->owner == abfd);
2937 sect_syms[sec->index] = syms[idx];
2942 /* Classify all of the symbols. */
2943 for (idx = 0; idx < symcount; idx++)
2945 if (!sym_is_global (abfd, syms[idx]))
2951 /* We will be adding a section symbol for each BFD section. Most normal
2952 sections will already have a section symbol in outsymbols, but
2953 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2954 at least in that case. */
2955 for (asect = abfd->sections; asect; asect = asect->next)
2957 if (sect_syms[asect->index] == NULL)
2959 if (!sym_is_global (abfd, asect->symbol))
2966 /* Now sort the symbols so the local symbols are first. */
2967 amt = (num_locals + num_globals) * sizeof (asymbol *);
2968 new_syms = bfd_alloc (abfd, amt);
2970 if (new_syms == NULL)
2973 for (idx = 0; idx < symcount; idx++)
2975 asymbol *sym = syms[idx];
2978 if (!sym_is_global (abfd, sym))
2981 i = num_locals + num_globals2++;
2983 sym->udata.i = i + 1;
2985 for (asect = abfd->sections; asect; asect = asect->next)
2987 if (sect_syms[asect->index] == NULL)
2989 asymbol *sym = asect->symbol;
2992 sect_syms[asect->index] = sym;
2993 if (!sym_is_global (abfd, sym))
2996 i = num_locals + num_globals2++;
2998 sym->udata.i = i + 1;
3002 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3004 elf_num_locals (abfd) = num_locals;
3005 elf_num_globals (abfd) = num_globals;
3009 /* Align to the maximum file alignment that could be required for any
3010 ELF data structure. */
3012 static inline file_ptr
3013 align_file_position (file_ptr off, int align)
3015 return (off + align - 1) & ~(align - 1);
3018 /* Assign a file position to a section, optionally aligning to the
3019 required section alignment. */
3022 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3030 al = i_shdrp->sh_addralign;
3032 offset = BFD_ALIGN (offset, al);
3034 i_shdrp->sh_offset = offset;
3035 if (i_shdrp->bfd_section != NULL)
3036 i_shdrp->bfd_section->filepos = offset;
3037 if (i_shdrp->sh_type != SHT_NOBITS)
3038 offset += i_shdrp->sh_size;
3042 /* Compute the file positions we are going to put the sections at, and
3043 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3044 is not NULL, this is being called by the ELF backend linker. */
3047 _bfd_elf_compute_section_file_positions (bfd *abfd,
3048 struct bfd_link_info *link_info)
3050 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3052 struct bfd_strtab_hash *strtab;
3053 Elf_Internal_Shdr *shstrtab_hdr;
3055 if (abfd->output_has_begun)
3058 /* Do any elf backend specific processing first. */
3059 if (bed->elf_backend_begin_write_processing)
3060 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3062 if (! prep_headers (abfd))
3065 /* Post process the headers if necessary. */
3066 if (bed->elf_backend_post_process_headers)
3067 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3070 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3074 if (!assign_section_numbers (abfd))
3077 /* The backend linker builds symbol table information itself. */
3078 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3080 /* Non-zero if doing a relocatable link. */
3081 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3083 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3087 if (link_info == NULL)
3089 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3094 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3095 /* sh_name was set in prep_headers. */
3096 shstrtab_hdr->sh_type = SHT_STRTAB;
3097 shstrtab_hdr->sh_flags = 0;
3098 shstrtab_hdr->sh_addr = 0;
3099 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3100 shstrtab_hdr->sh_entsize = 0;
3101 shstrtab_hdr->sh_link = 0;
3102 shstrtab_hdr->sh_info = 0;
3103 /* sh_offset is set in assign_file_positions_except_relocs. */
3104 shstrtab_hdr->sh_addralign = 1;
3106 if (!assign_file_positions_except_relocs (abfd))
3109 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3112 Elf_Internal_Shdr *hdr;
3114 off = elf_tdata (abfd)->next_file_pos;
3116 hdr = &elf_tdata (abfd)->symtab_hdr;
3117 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3119 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3120 if (hdr->sh_size != 0)
3121 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3123 hdr = &elf_tdata (abfd)->strtab_hdr;
3124 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3126 elf_tdata (abfd)->next_file_pos = off;
3128 /* Now that we know where the .strtab section goes, write it
3130 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3131 || ! _bfd_stringtab_emit (abfd, strtab))
3133 _bfd_stringtab_free (strtab);
3136 abfd->output_has_begun = TRUE;
3141 /* Create a mapping from a set of sections to a program segment. */
3143 static struct elf_segment_map *
3144 make_mapping (bfd *abfd,
3145 asection **sections,
3150 struct elf_segment_map *m;
3155 amt = sizeof (struct elf_segment_map);
3156 amt += (to - from - 1) * sizeof (asection *);
3157 m = bfd_zalloc (abfd, amt);
3161 m->p_type = PT_LOAD;
3162 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3163 m->sections[i - from] = *hdrpp;
3164 m->count = to - from;
3166 if (from == 0 && phdr)
3168 /* Include the headers in the first PT_LOAD segment. */
3169 m->includes_filehdr = 1;
3170 m->includes_phdrs = 1;
3176 /* Set up a mapping from BFD sections to program segments. */
3179 map_sections_to_segments (bfd *abfd)
3181 asection **sections = NULL;
3185 struct elf_segment_map *mfirst;
3186 struct elf_segment_map **pm;
3187 struct elf_segment_map *m;
3189 unsigned int phdr_index;
3190 bfd_vma maxpagesize;
3192 bfd_boolean phdr_in_segment = TRUE;
3193 bfd_boolean writable;
3195 asection *first_tls = NULL;
3196 asection *dynsec, *eh_frame_hdr;
3199 if (elf_tdata (abfd)->segment_map != NULL)
3202 if (bfd_count_sections (abfd) == 0)
3205 /* Select the allocated sections, and sort them. */
3207 amt = bfd_count_sections (abfd) * sizeof (asection *);
3208 sections = bfd_malloc (amt);
3209 if (sections == NULL)
3213 for (s = abfd->sections; s != NULL; s = s->next)
3215 if ((s->flags & SEC_ALLOC) != 0)
3221 BFD_ASSERT (i <= bfd_count_sections (abfd));
3224 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3226 /* Build the mapping. */
3231 /* If we have a .interp section, then create a PT_PHDR segment for
3232 the program headers and a PT_INTERP segment for the .interp
3234 s = bfd_get_section_by_name (abfd, ".interp");
3235 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3237 amt = sizeof (struct elf_segment_map);
3238 m = bfd_zalloc (abfd, amt);
3242 m->p_type = PT_PHDR;
3243 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3244 m->p_flags = PF_R | PF_X;
3245 m->p_flags_valid = 1;
3246 m->includes_phdrs = 1;
3251 amt = sizeof (struct elf_segment_map);
3252 m = bfd_zalloc (abfd, amt);
3256 m->p_type = PT_INTERP;
3264 /* Look through the sections. We put sections in the same program
3265 segment when the start of the second section can be placed within
3266 a few bytes of the end of the first section. */
3269 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3271 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3273 && (dynsec->flags & SEC_LOAD) == 0)
3276 /* Deal with -Ttext or something similar such that the first section
3277 is not adjacent to the program headers. This is an
3278 approximation, since at this point we don't know exactly how many
3279 program headers we will need. */
3282 bfd_size_type phdr_size;
3284 phdr_size = elf_tdata (abfd)->program_header_size;
3286 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3287 if ((abfd->flags & D_PAGED) == 0
3288 || sections[0]->lma < phdr_size
3289 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3290 phdr_in_segment = FALSE;
3293 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3296 bfd_boolean new_segment;
3300 /* See if this section and the last one will fit in the same
3303 if (last_hdr == NULL)
3305 /* If we don't have a segment yet, then we don't need a new
3306 one (we build the last one after this loop). */
3307 new_segment = FALSE;
3309 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3311 /* If this section has a different relation between the
3312 virtual address and the load address, then we need a new
3316 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3317 < BFD_ALIGN (hdr->lma, maxpagesize))
3319 /* If putting this section in this segment would force us to
3320 skip a page in the segment, then we need a new segment. */
3323 else if ((last_hdr->flags & SEC_LOAD) == 0
3324 && (hdr->flags & SEC_LOAD) != 0)
3326 /* We don't want to put a loadable section after a
3327 nonloadable section in the same segment. */
3330 else if ((abfd->flags & D_PAGED) == 0)
3332 /* If the file is not demand paged, which means that we
3333 don't require the sections to be correctly aligned in the
3334 file, then there is no other reason for a new segment. */
3335 new_segment = FALSE;
3338 && (hdr->flags & SEC_READONLY) == 0
3339 && (((last_hdr->lma + last_hdr->_raw_size - 1)
3340 & ~(maxpagesize - 1))
3341 != (hdr->lma & ~(maxpagesize - 1))))
3343 /* We don't want to put a writable section in a read only
3344 segment, unless they are on the same page in memory
3345 anyhow. We already know that the last section does not
3346 bring us past the current section on the page, so the
3347 only case in which the new section is not on the same
3348 page as the previous section is when the previous section
3349 ends precisely on a page boundary. */
3354 /* Otherwise, we can use the same segment. */
3355 new_segment = FALSE;
3360 if ((hdr->flags & SEC_READONLY) == 0)
3366 /* We need a new program segment. We must create a new program
3367 header holding all the sections from phdr_index until hdr. */
3369 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3376 if ((hdr->flags & SEC_READONLY) == 0)
3383 phdr_in_segment = FALSE;
3386 /* Create a final PT_LOAD program segment. */
3387 if (last_hdr != NULL)
3389 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3397 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3400 amt = sizeof (struct elf_segment_map);
3401 m = bfd_zalloc (abfd, amt);
3405 m->p_type = PT_DYNAMIC;
3407 m->sections[0] = dynsec;
3413 /* For each loadable .note section, add a PT_NOTE segment. We don't
3414 use bfd_get_section_by_name, because if we link together
3415 nonloadable .note sections and loadable .note sections, we will
3416 generate two .note sections in the output file. FIXME: Using
3417 names for section types is bogus anyhow. */
3418 for (s = abfd->sections; s != NULL; s = s->next)
3420 if ((s->flags & SEC_LOAD) != 0
3421 && strncmp (s->name, ".note", 5) == 0)
3423 amt = sizeof (struct elf_segment_map);
3424 m = bfd_zalloc (abfd, amt);
3428 m->p_type = PT_NOTE;
3435 if (s->flags & SEC_THREAD_LOCAL)
3443 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3448 amt = sizeof (struct elf_segment_map);
3449 amt += (tls_count - 1) * sizeof (asection *);
3450 m = bfd_zalloc (abfd, amt);
3455 m->count = tls_count;
3456 /* Mandated PF_R. */
3458 m->p_flags_valid = 1;
3459 for (i = 0; i < tls_count; ++i)
3461 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3462 m->sections[i] = first_tls;
3463 first_tls = first_tls->next;
3470 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3472 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3473 if (eh_frame_hdr != NULL
3474 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3476 amt = sizeof (struct elf_segment_map);
3477 m = bfd_zalloc (abfd, amt);
3481 m->p_type = PT_GNU_EH_FRAME;
3483 m->sections[0] = eh_frame_hdr->output_section;
3489 if (elf_tdata (abfd)->stack_flags)
3491 amt = sizeof (struct elf_segment_map);
3492 m = bfd_zalloc (abfd, amt);
3496 m->p_type = PT_GNU_STACK;
3497 m->p_flags = elf_tdata (abfd)->stack_flags;
3498 m->p_flags_valid = 1;
3507 elf_tdata (abfd)->segment_map = mfirst;
3511 if (sections != NULL)
3516 /* Sort sections by address. */
3519 elf_sort_sections (const void *arg1, const void *arg2)
3521 const asection *sec1 = *(const asection **) arg1;
3522 const asection *sec2 = *(const asection **) arg2;
3523 bfd_size_type size1, size2;
3525 /* Sort by LMA first, since this is the address used to
3526 place the section into a segment. */
3527 if (sec1->lma < sec2->lma)
3529 else if (sec1->lma > sec2->lma)
3532 /* Then sort by VMA. Normally the LMA and the VMA will be
3533 the same, and this will do nothing. */
3534 if (sec1->vma < sec2->vma)
3536 else if (sec1->vma > sec2->vma)
3539 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3541 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3547 /* If the indicies are the same, do not return 0
3548 here, but continue to try the next comparison. */
3549 if (sec1->target_index - sec2->target_index != 0)
3550 return sec1->target_index - sec2->target_index;
3555 else if (TOEND (sec2))
3560 /* Sort by size, to put zero sized sections
3561 before others at the same address. */
3563 size1 = (sec1->flags & SEC_LOAD) ? sec1->_raw_size : 0;
3564 size2 = (sec2->flags & SEC_LOAD) ? sec2->_raw_size : 0;
3571 return sec1->target_index - sec2->target_index;
3574 /* Assign file positions to the sections based on the mapping from
3575 sections to segments. This function also sets up some fields in
3576 the file header, and writes out the program headers. */
3579 assign_file_positions_for_segments (bfd *abfd)
3581 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3583 struct elf_segment_map *m;
3585 Elf_Internal_Phdr *phdrs;
3587 bfd_vma filehdr_vaddr, filehdr_paddr;
3588 bfd_vma phdrs_vaddr, phdrs_paddr;
3589 Elf_Internal_Phdr *p;
3592 if (elf_tdata (abfd)->segment_map == NULL)
3594 if (! map_sections_to_segments (abfd))
3599 /* The placement algorithm assumes that non allocated sections are
3600 not in PT_LOAD segments. We ensure this here by removing such
3601 sections from the segment map. */
3602 for (m = elf_tdata (abfd)->segment_map;
3606 unsigned int new_count;
3609 if (m->p_type != PT_LOAD)
3613 for (i = 0; i < m->count; i ++)
3615 if ((m->sections[i]->flags & SEC_ALLOC) != 0)
3618 m->sections[new_count] = m->sections[i];
3624 if (new_count != m->count)
3625 m->count = new_count;
3629 if (bed->elf_backend_modify_segment_map)
3631 if (! (*bed->elf_backend_modify_segment_map) (abfd))
3636 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3639 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3640 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3641 elf_elfheader (abfd)->e_phnum = count;
3646 /* If we already counted the number of program segments, make sure
3647 that we allocated enough space. This happens when SIZEOF_HEADERS
3648 is used in a linker script. */
3649 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3650 if (alloc != 0 && count > alloc)
3652 ((*_bfd_error_handler)
3653 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3654 bfd_get_filename (abfd), alloc, count));
3655 bfd_set_error (bfd_error_bad_value);
3662 amt = alloc * sizeof (Elf_Internal_Phdr);
3663 phdrs = bfd_alloc (abfd, amt);
3667 off = bed->s->sizeof_ehdr;
3668 off += alloc * bed->s->sizeof_phdr;
3675 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3682 /* If elf_segment_map is not from map_sections_to_segments, the
3683 sections may not be correctly ordered. NOTE: sorting should
3684 not be done to the PT_NOTE section of a corefile, which may
3685 contain several pseudo-sections artificially created by bfd.
3686 Sorting these pseudo-sections breaks things badly. */
3688 && !(elf_elfheader (abfd)->e_type == ET_CORE
3689 && m->p_type == PT_NOTE))
3690 qsort (m->sections, (size_t) m->count, sizeof (asection *),
3693 p->p_type = m->p_type;
3694 p->p_flags = m->p_flags;
3696 if (p->p_type == PT_LOAD
3698 && (m->sections[0]->flags & SEC_ALLOC) != 0)
3700 if ((abfd->flags & D_PAGED) != 0)
3701 off += (m->sections[0]->vma - off) % bed->maxpagesize;
3704 bfd_size_type align;
3707 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3709 bfd_size_type secalign;
3711 secalign = bfd_get_section_alignment (abfd, *secpp);
3712 if (secalign > align)
3716 off += (m->sections[0]->vma - off) % (1 << align);
3723 p->p_vaddr = m->sections[0]->vma;
3725 if (m->p_paddr_valid)
3726 p->p_paddr = m->p_paddr;
3727 else if (m->count == 0)
3730 p->p_paddr = m->sections[0]->lma;
3732 if (p->p_type == PT_LOAD
3733 && (abfd->flags & D_PAGED) != 0)
3734 p->p_align = bed->maxpagesize;
3735 else if (m->count == 0)
3736 p->p_align = 1 << bed->s->log_file_align;
3744 if (m->includes_filehdr)
3746 if (! m->p_flags_valid)
3749 p->p_filesz = bed->s->sizeof_ehdr;
3750 p->p_memsz = bed->s->sizeof_ehdr;
3753 BFD_ASSERT (p->p_type == PT_LOAD);
3755 if (p->p_vaddr < (bfd_vma) off)
3757 (*_bfd_error_handler)
3758 (_("%s: Not enough room for program headers, try linking with -N"),
3759 bfd_get_filename (abfd));
3760 bfd_set_error (bfd_error_bad_value);
3765 if (! m->p_paddr_valid)
3768 if (p->p_type == PT_LOAD)
3770 filehdr_vaddr = p->p_vaddr;
3771 filehdr_paddr = p->p_paddr;
3775 if (m->includes_phdrs)
3777 if (! m->p_flags_valid)
3780 if (m->includes_filehdr)
3782 if (p->p_type == PT_LOAD)
3784 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
3785 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
3790 p->p_offset = bed->s->sizeof_ehdr;
3794 BFD_ASSERT (p->p_type == PT_LOAD);
3795 p->p_vaddr -= off - p->p_offset;
3796 if (! m->p_paddr_valid)
3797 p->p_paddr -= off - p->p_offset;
3800 if (p->p_type == PT_LOAD)
3802 phdrs_vaddr = p->p_vaddr;
3803 phdrs_paddr = p->p_paddr;
3806 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
3809 p->p_filesz += alloc * bed->s->sizeof_phdr;
3810 p->p_memsz += alloc * bed->s->sizeof_phdr;
3813 if (p->p_type == PT_LOAD
3814 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
3816 if (! m->includes_filehdr && ! m->includes_phdrs)
3822 adjust = off - (p->p_offset + p->p_filesz);
3823 p->p_filesz += adjust;
3824 p->p_memsz += adjust;
3830 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3834 bfd_size_type align;
3838 align = 1 << bfd_get_section_alignment (abfd, sec);
3840 /* The section may have artificial alignment forced by a
3841 link script. Notice this case by the gap between the
3842 cumulative phdr lma and the section's lma. */
3843 if (p->p_paddr + p->p_memsz < sec->lma)
3845 bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
3847 p->p_memsz += adjust;
3848 if (p->p_type == PT_LOAD
3849 || (p->p_type == PT_NOTE
3850 && bfd_get_format (abfd) == bfd_core))
3855 if ((flags & SEC_LOAD) != 0
3856 || (flags & SEC_THREAD_LOCAL) != 0)
3857 p->p_filesz += adjust;
3860 if (p->p_type == PT_LOAD)
3862 bfd_signed_vma adjust;
3864 if ((flags & SEC_LOAD) != 0)
3866 adjust = sec->lma - (p->p_paddr + p->p_memsz);
3870 else if ((flags & SEC_ALLOC) != 0)
3872 /* The section VMA must equal the file position
3873 modulo the page size. FIXME: I'm not sure if
3874 this adjustment is really necessary. We used to
3875 not have the SEC_LOAD case just above, and then
3876 this was necessary, but now I'm not sure. */
3877 if ((abfd->flags & D_PAGED) != 0)
3878 adjust = (sec->vma - voff) % bed->maxpagesize;
3880 adjust = (sec->vma - voff) % align;
3889 (* _bfd_error_handler) (_("\
3890 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3891 bfd_section_name (abfd, sec),
3896 p->p_memsz += adjust;
3899 if ((flags & SEC_LOAD) != 0)
3900 p->p_filesz += adjust;
3905 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3906 used in a linker script we may have a section with
3907 SEC_LOAD clear but which is supposed to have
3909 if ((flags & SEC_LOAD) != 0
3910 || (flags & SEC_HAS_CONTENTS) != 0)
3911 off += sec->_raw_size;
3913 if ((flags & SEC_ALLOC) != 0
3914 && ((flags & SEC_LOAD) != 0
3915 || (flags & SEC_THREAD_LOCAL) == 0))
3916 voff += sec->_raw_size;
3919 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3921 /* The actual "note" segment has i == 0.
3922 This is the one that actually contains everything. */
3926 p->p_filesz = sec->_raw_size;
3927 off += sec->_raw_size;
3932 /* Fake sections -- don't need to be written. */
3935 flags = sec->flags = 0;
3942 if ((sec->flags & SEC_LOAD) != 0
3943 || (sec->flags & SEC_THREAD_LOCAL) == 0
3944 || p->p_type == PT_TLS)
3945 p->p_memsz += sec->_raw_size;
3947 if ((flags & SEC_LOAD) != 0)
3948 p->p_filesz += sec->_raw_size;
3950 if (p->p_type == PT_TLS
3951 && sec->_raw_size == 0
3952 && (sec->flags & SEC_HAS_CONTENTS) == 0)
3954 struct bfd_link_order *o;
3955 bfd_vma tbss_size = 0;
3957 for (o = sec->link_order_head; o != NULL; o = o->next)
3958 if (tbss_size < o->offset + o->size)
3959 tbss_size = o->offset + o->size;
3961 p->p_memsz += tbss_size;
3964 if (align > p->p_align
3965 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3969 if (! m->p_flags_valid)
3972 if ((flags & SEC_CODE) != 0)
3974 if ((flags & SEC_READONLY) == 0)
3980 /* Now that we have set the section file positions, we can set up
3981 the file positions for the non PT_LOAD segments. */
3982 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3986 if (p->p_type != PT_LOAD && m->count > 0)
3988 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3989 p->p_offset = m->sections[0]->filepos;
3993 if (m->includes_filehdr)
3995 p->p_vaddr = filehdr_vaddr;
3996 if (! m->p_paddr_valid)
3997 p->p_paddr = filehdr_paddr;
3999 else if (m->includes_phdrs)
4001 p->p_vaddr = phdrs_vaddr;
4002 if (! m->p_paddr_valid)
4003 p->p_paddr = phdrs_paddr;
4008 /* Clear out any program headers we allocated but did not use. */
4009 for (; count < alloc; count++, p++)
4011 memset (p, 0, sizeof *p);
4012 p->p_type = PT_NULL;
4015 elf_tdata (abfd)->phdr = phdrs;
4017 elf_tdata (abfd)->next_file_pos = off;
4019 /* Write out the program headers. */
4020 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4021 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4027 /* Get the size of the program header.
4029 If this is called by the linker before any of the section VMA's are set, it
4030 can't calculate the correct value for a strange memory layout. This only
4031 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4032 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4033 data segment (exclusive of .interp and .dynamic).
4035 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4036 will be two segments. */
4038 static bfd_size_type
4039 get_program_header_size (bfd *abfd)
4043 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4045 /* We can't return a different result each time we're called. */
4046 if (elf_tdata (abfd)->program_header_size != 0)
4047 return elf_tdata (abfd)->program_header_size;
4049 if (elf_tdata (abfd)->segment_map != NULL)
4051 struct elf_segment_map *m;
4054 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4056 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4057 return elf_tdata (abfd)->program_header_size;
4060 /* Assume we will need exactly two PT_LOAD segments: one for text
4061 and one for data. */
4064 s = bfd_get_section_by_name (abfd, ".interp");
4065 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4067 /* If we have a loadable interpreter section, we need a
4068 PT_INTERP segment. In this case, assume we also need a
4069 PT_PHDR segment, although that may not be true for all
4074 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4076 /* We need a PT_DYNAMIC segment. */
4080 if (elf_tdata (abfd)->eh_frame_hdr)
4082 /* We need a PT_GNU_EH_FRAME segment. */
4086 if (elf_tdata (abfd)->stack_flags)
4088 /* We need a PT_GNU_STACK segment. */
4092 for (s = abfd->sections; s != NULL; s = s->next)
4094 if ((s->flags & SEC_LOAD) != 0
4095 && strncmp (s->name, ".note", 5) == 0)
4097 /* We need a PT_NOTE segment. */
4102 for (s = abfd->sections; s != NULL; s = s->next)
4104 if (s->flags & SEC_THREAD_LOCAL)
4106 /* We need a PT_TLS segment. */
4112 /* Let the backend count up any program headers it might need. */
4113 if (bed->elf_backend_additional_program_headers)
4117 a = (*bed->elf_backend_additional_program_headers) (abfd);
4123 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4124 return elf_tdata (abfd)->program_header_size;
4127 /* Work out the file positions of all the sections. This is called by
4128 _bfd_elf_compute_section_file_positions. All the section sizes and
4129 VMAs must be known before this is called.
4131 We do not consider reloc sections at this point, unless they form
4132 part of the loadable image. Reloc sections are assigned file
4133 positions in assign_file_positions_for_relocs, which is called by
4134 write_object_contents and final_link.
4136 We also don't set the positions of the .symtab and .strtab here. */
4139 assign_file_positions_except_relocs (bfd *abfd)
4141 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4142 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4143 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4144 unsigned int num_sec = elf_numsections (abfd);
4146 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4148 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4149 && bfd_get_format (abfd) != bfd_core)
4151 Elf_Internal_Shdr **hdrpp;
4154 /* Start after the ELF header. */
4155 off = i_ehdrp->e_ehsize;
4157 /* We are not creating an executable, which means that we are
4158 not creating a program header, and that the actual order of
4159 the sections in the file is unimportant. */
4160 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4162 Elf_Internal_Shdr *hdr;
4165 if (hdr->sh_type == SHT_REL
4166 || hdr->sh_type == SHT_RELA
4167 || i == tdata->symtab_section
4168 || i == tdata->symtab_shndx_section
4169 || i == tdata->strtab_section)
4171 hdr->sh_offset = -1;
4174 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4176 if (i == SHN_LORESERVE - 1)
4178 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4179 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4186 Elf_Internal_Shdr **hdrpp;
4188 /* Assign file positions for the loaded sections based on the
4189 assignment of sections to segments. */
4190 if (! assign_file_positions_for_segments (abfd))
4193 /* Assign file positions for the other sections. */
4195 off = elf_tdata (abfd)->next_file_pos;
4196 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4198 Elf_Internal_Shdr *hdr;
4201 if (hdr->bfd_section != NULL
4202 && hdr->bfd_section->filepos != 0)
4203 hdr->sh_offset = hdr->bfd_section->filepos;
4204 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4206 ((*_bfd_error_handler)
4207 (_("%s: warning: allocated section `%s' not in segment"),
4208 bfd_get_filename (abfd),
4209 (hdr->bfd_section == NULL
4211 : hdr->bfd_section->name)));
4212 if ((abfd->flags & D_PAGED) != 0)
4213 off += (hdr->sh_addr - off) % bed->maxpagesize;
4215 off += (hdr->sh_addr - off) % hdr->sh_addralign;
4216 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4219 else if (hdr->sh_type == SHT_REL
4220 || hdr->sh_type == SHT_RELA
4221 || hdr == i_shdrpp[tdata->symtab_section]
4222 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4223 || hdr == i_shdrpp[tdata->strtab_section])
4224 hdr->sh_offset = -1;
4226 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4228 if (i == SHN_LORESERVE - 1)
4230 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4231 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4236 /* Place the section headers. */
4237 off = align_file_position (off, 1 << bed->s->log_file_align);
4238 i_ehdrp->e_shoff = off;
4239 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4241 elf_tdata (abfd)->next_file_pos = off;
4247 prep_headers (bfd *abfd)
4249 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4250 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4251 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
4252 struct elf_strtab_hash *shstrtab;
4253 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4255 i_ehdrp = elf_elfheader (abfd);
4256 i_shdrp = elf_elfsections (abfd);
4258 shstrtab = _bfd_elf_strtab_init ();
4259 if (shstrtab == NULL)
4262 elf_shstrtab (abfd) = shstrtab;
4264 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4265 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4266 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4267 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4269 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4270 i_ehdrp->e_ident[EI_DATA] =
4271 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4272 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4274 if ((abfd->flags & DYNAMIC) != 0)
4275 i_ehdrp->e_type = ET_DYN;
4276 else if ((abfd->flags & EXEC_P) != 0)
4277 i_ehdrp->e_type = ET_EXEC;
4278 else if (bfd_get_format (abfd) == bfd_core)
4279 i_ehdrp->e_type = ET_CORE;
4281 i_ehdrp->e_type = ET_REL;
4283 switch (bfd_get_arch (abfd))
4285 case bfd_arch_unknown:
4286 i_ehdrp->e_machine = EM_NONE;
4289 /* There used to be a long list of cases here, each one setting
4290 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4291 in the corresponding bfd definition. To avoid duplication,
4292 the switch was removed. Machines that need special handling
4293 can generally do it in elf_backend_final_write_processing(),
4294 unless they need the information earlier than the final write.
4295 Such need can generally be supplied by replacing the tests for
4296 e_machine with the conditions used to determine it. */
4298 i_ehdrp->e_machine = bed->elf_machine_code;
4301 i_ehdrp->e_version = bed->s->ev_current;
4302 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4304 /* No program header, for now. */
4305 i_ehdrp->e_phoff = 0;
4306 i_ehdrp->e_phentsize = 0;
4307 i_ehdrp->e_phnum = 0;
4309 /* Each bfd section is section header entry. */
4310 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4311 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4313 /* If we're building an executable, we'll need a program header table. */
4314 if (abfd->flags & EXEC_P)
4316 /* It all happens later. */
4318 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
4320 /* elf_build_phdrs() returns a (NULL-terminated) array of
4321 Elf_Internal_Phdrs. */
4322 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
4323 i_ehdrp->e_phoff = outbase;
4324 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
4329 i_ehdrp->e_phentsize = 0;
4331 i_ehdrp->e_phoff = 0;
4334 elf_tdata (abfd)->symtab_hdr.sh_name =
4335 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4336 elf_tdata (abfd)->strtab_hdr.sh_name =
4337 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4338 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4339 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4340 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4341 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4342 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4348 /* Assign file positions for all the reloc sections which are not part
4349 of the loadable file image. */
4352 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4355 unsigned int i, num_sec;
4356 Elf_Internal_Shdr **shdrpp;
4358 off = elf_tdata (abfd)->next_file_pos;
4360 num_sec = elf_numsections (abfd);
4361 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4363 Elf_Internal_Shdr *shdrp;
4366 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4367 && shdrp->sh_offset == -1)
4368 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4371 elf_tdata (abfd)->next_file_pos = off;
4375 _bfd_elf_write_object_contents (bfd *abfd)
4377 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4378 Elf_Internal_Ehdr *i_ehdrp;
4379 Elf_Internal_Shdr **i_shdrp;
4381 unsigned int count, num_sec;
4383 if (! abfd->output_has_begun
4384 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4387 i_shdrp = elf_elfsections (abfd);
4388 i_ehdrp = elf_elfheader (abfd);
4391 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4395 _bfd_elf_assign_file_positions_for_relocs (abfd);
4397 /* After writing the headers, we need to write the sections too... */
4398 num_sec = elf_numsections (abfd);
4399 for (count = 1; count < num_sec; count++)
4401 if (bed->elf_backend_section_processing)
4402 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4403 if (i_shdrp[count]->contents)
4405 bfd_size_type amt = i_shdrp[count]->sh_size;
4407 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4408 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4411 if (count == SHN_LORESERVE - 1)
4412 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4415 /* Write out the section header names. */
4416 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4417 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4420 if (bed->elf_backend_final_write_processing)
4421 (*bed->elf_backend_final_write_processing) (abfd,
4422 elf_tdata (abfd)->linker);
4424 return bed->s->write_shdrs_and_ehdr (abfd);
4428 _bfd_elf_write_corefile_contents (bfd *abfd)
4430 /* Hopefully this can be done just like an object file. */
4431 return _bfd_elf_write_object_contents (abfd);
4434 /* Given a section, search the header to find them. */
4437 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4439 const struct elf_backend_data *bed;
4442 if (elf_section_data (asect) != NULL
4443 && elf_section_data (asect)->this_idx != 0)
4444 return elf_section_data (asect)->this_idx;
4446 if (bfd_is_abs_section (asect))
4448 else if (bfd_is_com_section (asect))
4450 else if (bfd_is_und_section (asect))
4454 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4455 int maxindex = elf_numsections (abfd);
4457 for (index = 1; index < maxindex; index++)
4459 Elf_Internal_Shdr *hdr = i_shdrp[index];
4461 if (hdr != NULL && hdr->bfd_section == asect)
4467 bed = get_elf_backend_data (abfd);
4468 if (bed->elf_backend_section_from_bfd_section)
4472 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4477 bfd_set_error (bfd_error_nonrepresentable_section);
4482 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4486 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4488 asymbol *asym_ptr = *asym_ptr_ptr;
4490 flagword flags = asym_ptr->flags;
4492 /* When gas creates relocations against local labels, it creates its
4493 own symbol for the section, but does put the symbol into the
4494 symbol chain, so udata is 0. When the linker is generating
4495 relocatable output, this section symbol may be for one of the
4496 input sections rather than the output section. */
4497 if (asym_ptr->udata.i == 0
4498 && (flags & BSF_SECTION_SYM)
4499 && asym_ptr->section)
4503 if (asym_ptr->section->output_section != NULL)
4504 indx = asym_ptr->section->output_section->index;
4506 indx = asym_ptr->section->index;
4507 if (indx < elf_num_section_syms (abfd)
4508 && elf_section_syms (abfd)[indx] != NULL)
4509 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4512 idx = asym_ptr->udata.i;
4516 /* This case can occur when using --strip-symbol on a symbol
4517 which is used in a relocation entry. */
4518 (*_bfd_error_handler)
4519 (_("%s: symbol `%s' required but not present"),
4520 bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
4521 bfd_set_error (bfd_error_no_symbols);
4528 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4529 (long) asym_ptr, asym_ptr->name, idx, flags,
4530 elf_symbol_flags (flags));
4538 /* Copy private BFD data. This copies any program header information. */
4541 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4543 Elf_Internal_Ehdr *iehdr;
4544 struct elf_segment_map *map;
4545 struct elf_segment_map *map_first;
4546 struct elf_segment_map **pointer_to_map;
4547 Elf_Internal_Phdr *segment;
4550 unsigned int num_segments;
4551 bfd_boolean phdr_included = FALSE;
4552 bfd_vma maxpagesize;
4553 struct elf_segment_map *phdr_adjust_seg = NULL;
4554 unsigned int phdr_adjust_num = 0;
4555 const struct elf_backend_data *bed;
4557 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4558 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4561 if (elf_tdata (ibfd)->phdr == NULL)
4564 bed = get_elf_backend_data (ibfd);
4565 iehdr = elf_elfheader (ibfd);
4568 pointer_to_map = &map_first;
4570 num_segments = elf_elfheader (ibfd)->e_phnum;
4571 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4573 /* Returns the end address of the segment + 1. */
4574 #define SEGMENT_END(segment, start) \
4575 (start + (segment->p_memsz > segment->p_filesz \
4576 ? segment->p_memsz : segment->p_filesz))
4578 #define SECTION_SIZE(section, segment) \
4579 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
4580 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
4581 ? section->_raw_size : 0)
4583 /* Returns TRUE if the given section is contained within
4584 the given segment. VMA addresses are compared. */
4585 #define IS_CONTAINED_BY_VMA(section, segment) \
4586 (section->vma >= segment->p_vaddr \
4587 && (section->vma + SECTION_SIZE (section, segment) \
4588 <= (SEGMENT_END (segment, segment->p_vaddr))))
4590 /* Returns TRUE if the given section is contained within
4591 the given segment. LMA addresses are compared. */
4592 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4593 (section->lma >= base \
4594 && (section->lma + SECTION_SIZE (section, segment) \
4595 <= SEGMENT_END (segment, base)))
4597 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4598 #define IS_COREFILE_NOTE(p, s) \
4599 (p->p_type == PT_NOTE \
4600 && bfd_get_format (ibfd) == bfd_core \
4601 && s->vma == 0 && s->lma == 0 \
4602 && (bfd_vma) s->filepos >= p->p_offset \
4603 && ((bfd_vma) s->filepos + s->_raw_size \
4604 <= p->p_offset + p->p_filesz))
4606 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4607 linker, which generates a PT_INTERP section with p_vaddr and
4608 p_memsz set to 0. */
4609 #define IS_SOLARIS_PT_INTERP(p, s) \
4611 && p->p_paddr == 0 \
4612 && p->p_memsz == 0 \
4613 && p->p_filesz > 0 \
4614 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4615 && s->_raw_size > 0 \
4616 && (bfd_vma) s->filepos >= p->p_offset \
4617 && ((bfd_vma) s->filepos + s->_raw_size \
4618 <= p->p_offset + p->p_filesz))
4620 /* Decide if the given section should be included in the given segment.
4621 A section will be included if:
4622 1. It is within the address space of the segment -- we use the LMA
4623 if that is set for the segment and the VMA otherwise,
4624 2. It is an allocated segment,
4625 3. There is an output section associated with it,
4626 4. The section has not already been allocated to a previous segment.
4627 5. PT_TLS segment includes only SHF_TLS sections.
4628 6. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
4629 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
4630 ((((segment->p_paddr \
4631 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4632 : IS_CONTAINED_BY_VMA (section, segment)) \
4633 && (section->flags & SEC_ALLOC) != 0) \
4634 || IS_COREFILE_NOTE (segment, section)) \
4635 && section->output_section != NULL \
4636 && (segment->p_type != PT_TLS \
4637 || (section->flags & SEC_THREAD_LOCAL)) \
4638 && (segment->p_type == PT_LOAD \
4639 || segment->p_type == PT_TLS \
4640 || (section->flags & SEC_THREAD_LOCAL) == 0) \
4641 && ! section->segment_mark)
4643 /* Returns TRUE iff seg1 starts after the end of seg2. */
4644 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
4645 (seg1->field >= SEGMENT_END (seg2, seg2->field))
4647 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4648 their VMA address ranges and their LMA address ranges overlap.
4649 It is possible to have overlapping VMA ranges without overlapping LMA
4650 ranges. RedBoot images for example can have both .data and .bss mapped
4651 to the same VMA range, but with the .data section mapped to a different
4653 #define SEGMENT_OVERLAPS(seg1, seg2) \
4654 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
4655 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
4656 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
4657 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
4659 /* Initialise the segment mark field. */
4660 for (section = ibfd->sections; section != NULL; section = section->next)
4661 section->segment_mark = FALSE;
4663 /* Scan through the segments specified in the program header
4664 of the input BFD. For this first scan we look for overlaps
4665 in the loadable segments. These can be created by weird
4666 parameters to objcopy. Also, fix some solaris weirdness. */
4667 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4672 Elf_Internal_Phdr *segment2;
4674 if (segment->p_type == PT_INTERP)
4675 for (section = ibfd->sections; section; section = section->next)
4676 if (IS_SOLARIS_PT_INTERP (segment, section))
4678 /* Mininal change so that the normal section to segment
4679 assigment code will work. */
4680 segment->p_vaddr = section->vma;
4684 if (segment->p_type != PT_LOAD)
4687 /* Determine if this segment overlaps any previous segments. */
4688 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
4690 bfd_signed_vma extra_length;
4692 if (segment2->p_type != PT_LOAD
4693 || ! SEGMENT_OVERLAPS (segment, segment2))
4696 /* Merge the two segments together. */
4697 if (segment2->p_vaddr < segment->p_vaddr)
4699 /* Extend SEGMENT2 to include SEGMENT and then delete
4702 SEGMENT_END (segment, segment->p_vaddr)
4703 - SEGMENT_END (segment2, segment2->p_vaddr);
4705 if (extra_length > 0)
4707 segment2->p_memsz += extra_length;
4708 segment2->p_filesz += extra_length;
4711 segment->p_type = PT_NULL;
4713 /* Since we have deleted P we must restart the outer loop. */
4715 segment = elf_tdata (ibfd)->phdr;
4720 /* Extend SEGMENT to include SEGMENT2 and then delete
4723 SEGMENT_END (segment2, segment2->p_vaddr)
4724 - SEGMENT_END (segment, segment->p_vaddr);
4726 if (extra_length > 0)
4728 segment->p_memsz += extra_length;
4729 segment->p_filesz += extra_length;
4732 segment2->p_type = PT_NULL;
4737 /* The second scan attempts to assign sections to segments. */
4738 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4742 unsigned int section_count;
4743 asection ** sections;
4744 asection * output_section;
4746 bfd_vma matching_lma;
4747 bfd_vma suggested_lma;
4751 if (segment->p_type == PT_NULL)
4754 /* Compute how many sections might be placed into this segment. */
4755 for (section = ibfd->sections, section_count = 0;
4757 section = section->next)
4758 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4761 /* Allocate a segment map big enough to contain
4762 all of the sections we have selected. */
4763 amt = sizeof (struct elf_segment_map);
4764 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4765 map = bfd_alloc (obfd, amt);
4769 /* Initialise the fields of the segment map. Default to
4770 using the physical address of the segment in the input BFD. */
4772 map->p_type = segment->p_type;
4773 map->p_flags = segment->p_flags;
4774 map->p_flags_valid = 1;
4775 map->p_paddr = segment->p_paddr;
4776 map->p_paddr_valid = 1;
4778 /* Determine if this segment contains the ELF file header
4779 and if it contains the program headers themselves. */
4780 map->includes_filehdr = (segment->p_offset == 0
4781 && segment->p_filesz >= iehdr->e_ehsize);
4783 map->includes_phdrs = 0;
4785 if (! phdr_included || segment->p_type != PT_LOAD)
4787 map->includes_phdrs =
4788 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
4789 && (segment->p_offset + segment->p_filesz
4790 >= ((bfd_vma) iehdr->e_phoff
4791 + iehdr->e_phnum * iehdr->e_phentsize)));
4793 if (segment->p_type == PT_LOAD && map->includes_phdrs)
4794 phdr_included = TRUE;
4797 if (section_count == 0)
4799 /* Special segments, such as the PT_PHDR segment, may contain
4800 no sections, but ordinary, loadable segments should contain
4801 something. They are allowed by the ELF spec however, so only
4802 a warning is produced. */
4803 if (segment->p_type == PT_LOAD)
4804 (*_bfd_error_handler)
4805 (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4806 bfd_archive_filename (ibfd));
4809 *pointer_to_map = map;
4810 pointer_to_map = &map->next;
4815 /* Now scan the sections in the input BFD again and attempt
4816 to add their corresponding output sections to the segment map.
4817 The problem here is how to handle an output section which has
4818 been moved (ie had its LMA changed). There are four possibilities:
4820 1. None of the sections have been moved.
4821 In this case we can continue to use the segment LMA from the
4824 2. All of the sections have been moved by the same amount.
4825 In this case we can change the segment's LMA to match the LMA
4826 of the first section.
4828 3. Some of the sections have been moved, others have not.
4829 In this case those sections which have not been moved can be
4830 placed in the current segment which will have to have its size,
4831 and possibly its LMA changed, and a new segment or segments will
4832 have to be created to contain the other sections.
4834 4. The sections have been moved, but not by the same amount.
4835 In this case we can change the segment's LMA to match the LMA
4836 of the first section and we will have to create a new segment
4837 or segments to contain the other sections.
4839 In order to save time, we allocate an array to hold the section
4840 pointers that we are interested in. As these sections get assigned
4841 to a segment, they are removed from this array. */
4843 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
4844 to work around this long long bug. */
4845 amt = section_count * sizeof (asection *);
4846 sections = bfd_malloc (amt);
4847 if (sections == NULL)
4850 /* Step One: Scan for segment vs section LMA conflicts.
4851 Also add the sections to the section array allocated above.
4852 Also add the sections to the current segment. In the common
4853 case, where the sections have not been moved, this means that
4854 we have completely filled the segment, and there is nothing
4860 for (j = 0, section = ibfd->sections;
4862 section = section->next)
4864 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4866 output_section = section->output_section;
4868 sections[j ++] = section;
4870 /* The Solaris native linker always sets p_paddr to 0.
4871 We try to catch that case here, and set it to the
4872 correct value. Note - some backends require that
4873 p_paddr be left as zero. */
4874 if (segment->p_paddr == 0
4875 && segment->p_vaddr != 0
4876 && (! bed->want_p_paddr_set_to_zero)
4878 && output_section->lma != 0
4879 && (output_section->vma == (segment->p_vaddr
4880 + (map->includes_filehdr
4883 + (map->includes_phdrs
4885 * iehdr->e_phentsize)
4887 map->p_paddr = segment->p_vaddr;
4889 /* Match up the physical address of the segment with the
4890 LMA address of the output section. */
4891 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4892 || IS_COREFILE_NOTE (segment, section)
4893 || (bed->want_p_paddr_set_to_zero &&
4894 IS_CONTAINED_BY_VMA (output_section, segment))
4897 if (matching_lma == 0)
4898 matching_lma = output_section->lma;
4900 /* We assume that if the section fits within the segment
4901 then it does not overlap any other section within that
4903 map->sections[isec ++] = output_section;
4905 else if (suggested_lma == 0)
4906 suggested_lma = output_section->lma;
4910 BFD_ASSERT (j == section_count);
4912 /* Step Two: Adjust the physical address of the current segment,
4914 if (isec == section_count)
4916 /* All of the sections fitted within the segment as currently
4917 specified. This is the default case. Add the segment to
4918 the list of built segments and carry on to process the next
4919 program header in the input BFD. */
4920 map->count = section_count;
4921 *pointer_to_map = map;
4922 pointer_to_map = &map->next;
4929 if (matching_lma != 0)
4931 /* At least one section fits inside the current segment.
4932 Keep it, but modify its physical address to match the
4933 LMA of the first section that fitted. */
4934 map->p_paddr = matching_lma;
4938 /* None of the sections fitted inside the current segment.
4939 Change the current segment's physical address to match
4940 the LMA of the first section. */
4941 map->p_paddr = suggested_lma;
4944 /* Offset the segment physical address from the lma
4945 to allow for space taken up by elf headers. */
4946 if (map->includes_filehdr)
4947 map->p_paddr -= iehdr->e_ehsize;
4949 if (map->includes_phdrs)
4951 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4953 /* iehdr->e_phnum is just an estimate of the number
4954 of program headers that we will need. Make a note
4955 here of the number we used and the segment we chose
4956 to hold these headers, so that we can adjust the
4957 offset when we know the correct value. */
4958 phdr_adjust_num = iehdr->e_phnum;
4959 phdr_adjust_seg = map;
4963 /* Step Three: Loop over the sections again, this time assigning
4964 those that fit to the current segment and removing them from the
4965 sections array; but making sure not to leave large gaps. Once all
4966 possible sections have been assigned to the current segment it is
4967 added to the list of built segments and if sections still remain
4968 to be assigned, a new segment is constructed before repeating
4976 /* Fill the current segment with sections that fit. */
4977 for (j = 0; j < section_count; j++)
4979 section = sections[j];
4981 if (section == NULL)
4984 output_section = section->output_section;
4986 BFD_ASSERT (output_section != NULL);
4988 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4989 || IS_COREFILE_NOTE (segment, section))
4991 if (map->count == 0)
4993 /* If the first section in a segment does not start at
4994 the beginning of the segment, then something is
4996 if (output_section->lma !=
4998 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4999 + (map->includes_phdrs
5000 ? iehdr->e_phnum * iehdr->e_phentsize
5006 asection * prev_sec;
5008 prev_sec = map->sections[map->count - 1];
5010 /* If the gap between the end of the previous section
5011 and the start of this section is more than
5012 maxpagesize then we need to start a new segment. */
5013 if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
5015 < BFD_ALIGN (output_section->lma, maxpagesize))
5016 || ((prev_sec->lma + prev_sec->_raw_size)
5017 > output_section->lma))
5019 if (suggested_lma == 0)
5020 suggested_lma = output_section->lma;
5026 map->sections[map->count++] = output_section;
5029 section->segment_mark = TRUE;
5031 else if (suggested_lma == 0)
5032 suggested_lma = output_section->lma;
5035 BFD_ASSERT (map->count > 0);
5037 /* Add the current segment to the list of built segments. */
5038 *pointer_to_map = map;
5039 pointer_to_map = &map->next;
5041 if (isec < section_count)
5043 /* We still have not allocated all of the sections to
5044 segments. Create a new segment here, initialise it
5045 and carry on looping. */
5046 amt = sizeof (struct elf_segment_map);
5047 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5048 map = bfd_alloc (obfd, amt);
5055 /* Initialise the fields of the segment map. Set the physical
5056 physical address to the LMA of the first section that has
5057 not yet been assigned. */
5059 map->p_type = segment->p_type;
5060 map->p_flags = segment->p_flags;
5061 map->p_flags_valid = 1;
5062 map->p_paddr = suggested_lma;
5063 map->p_paddr_valid = 1;
5064 map->includes_filehdr = 0;
5065 map->includes_phdrs = 0;
5068 while (isec < section_count);
5073 /* The Solaris linker creates program headers in which all the
5074 p_paddr fields are zero. When we try to objcopy or strip such a
5075 file, we get confused. Check for this case, and if we find it
5076 reset the p_paddr_valid fields. */
5077 for (map = map_first; map != NULL; map = map->next)
5078 if (map->p_paddr != 0)
5081 for (map = map_first; map != NULL; map = map->next)
5082 map->p_paddr_valid = 0;
5084 elf_tdata (obfd)->segment_map = map_first;
5086 /* If we had to estimate the number of program headers that were
5087 going to be needed, then check our estimate now and adjust
5088 the offset if necessary. */
5089 if (phdr_adjust_seg != NULL)
5093 for (count = 0, map = map_first; map != NULL; map = map->next)
5096 if (count > phdr_adjust_num)
5097 phdr_adjust_seg->p_paddr
5098 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5102 /* Final Step: Sort the segments into ascending order of physical
5104 if (map_first != NULL)
5106 struct elf_segment_map *prev;
5109 for (map = map_first->next; map != NULL; prev = map, map = map->next)
5111 /* Yes I know - its a bubble sort.... */
5112 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
5114 /* Swap map and map->next. */
5115 prev->next = map->next;
5116 map->next = map->next->next;
5117 prev->next->next = map;
5128 #undef IS_CONTAINED_BY_VMA
5129 #undef IS_CONTAINED_BY_LMA
5130 #undef IS_COREFILE_NOTE
5131 #undef IS_SOLARIS_PT_INTERP
5132 #undef INCLUDE_SECTION_IN_SEGMENT
5133 #undef SEGMENT_AFTER_SEGMENT
5134 #undef SEGMENT_OVERLAPS
5138 /* Copy private section information. This copies over the entsize
5139 field, and sometimes the info field. */
5142 _bfd_elf_copy_private_section_data (bfd *ibfd,
5147 Elf_Internal_Shdr *ihdr, *ohdr;
5149 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5150 || obfd->xvec->flavour != bfd_target_elf_flavour)
5153 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5157 /* Only set up the segments if there are no more SEC_ALLOC
5158 sections. FIXME: This won't do the right thing if objcopy is
5159 used to remove the last SEC_ALLOC section, since objcopy
5160 won't call this routine in that case. */
5161 for (s = isec->next; s != NULL; s = s->next)
5162 if ((s->flags & SEC_ALLOC) != 0)
5166 if (! copy_private_bfd_data (ibfd, obfd))
5171 ihdr = &elf_section_data (isec)->this_hdr;
5172 ohdr = &elf_section_data (osec)->this_hdr;
5174 ohdr->sh_entsize = ihdr->sh_entsize;
5176 if (ihdr->sh_type == SHT_SYMTAB
5177 || ihdr->sh_type == SHT_DYNSYM
5178 || ihdr->sh_type == SHT_GNU_verneed
5179 || ihdr->sh_type == SHT_GNU_verdef)
5180 ohdr->sh_info = ihdr->sh_info;
5182 /* Set things up for objcopy. The output SHT_GROUP section will
5183 have its elf_next_in_group pointing back to the input group
5185 elf_next_in_group (osec) = elf_next_in_group (isec);
5186 elf_group_name (osec) = elf_group_name (isec);
5188 osec->use_rela_p = isec->use_rela_p;
5193 /* Copy private symbol information. If this symbol is in a section
5194 which we did not map into a BFD section, try to map the section
5195 index correctly. We use special macro definitions for the mapped
5196 section indices; these definitions are interpreted by the
5197 swap_out_syms function. */
5199 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5200 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5201 #define MAP_STRTAB (SHN_HIOS + 3)
5202 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5203 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5206 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5211 elf_symbol_type *isym, *osym;
5213 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5214 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5217 isym = elf_symbol_from (ibfd, isymarg);
5218 osym = elf_symbol_from (obfd, osymarg);
5222 && bfd_is_abs_section (isym->symbol.section))
5226 shndx = isym->internal_elf_sym.st_shndx;
5227 if (shndx == elf_onesymtab (ibfd))
5228 shndx = MAP_ONESYMTAB;
5229 else if (shndx == elf_dynsymtab (ibfd))
5230 shndx = MAP_DYNSYMTAB;
5231 else if (shndx == elf_tdata (ibfd)->strtab_section)
5233 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5234 shndx = MAP_SHSTRTAB;
5235 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5236 shndx = MAP_SYM_SHNDX;
5237 osym->internal_elf_sym.st_shndx = shndx;
5243 /* Swap out the symbols. */
5246 swap_out_syms (bfd *abfd,
5247 struct bfd_strtab_hash **sttp,
5250 const struct elf_backend_data *bed;
5253 struct bfd_strtab_hash *stt;
5254 Elf_Internal_Shdr *symtab_hdr;
5255 Elf_Internal_Shdr *symtab_shndx_hdr;
5256 Elf_Internal_Shdr *symstrtab_hdr;
5257 char *outbound_syms;
5258 char *outbound_shndx;
5262 if (!elf_map_symbols (abfd))
5265 /* Dump out the symtabs. */
5266 stt = _bfd_elf_stringtab_init ();
5270 bed = get_elf_backend_data (abfd);
5271 symcount = bfd_get_symcount (abfd);
5272 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5273 symtab_hdr->sh_type = SHT_SYMTAB;
5274 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5275 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5276 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5277 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5279 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5280 symstrtab_hdr->sh_type = SHT_STRTAB;
5282 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5283 outbound_syms = bfd_alloc (abfd, amt);
5284 if (outbound_syms == NULL)
5286 _bfd_stringtab_free (stt);
5289 symtab_hdr->contents = outbound_syms;
5291 outbound_shndx = NULL;
5292 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5293 if (symtab_shndx_hdr->sh_name != 0)
5295 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5296 outbound_shndx = bfd_zalloc (abfd, amt);
5297 if (outbound_shndx == NULL)
5299 _bfd_stringtab_free (stt);
5303 symtab_shndx_hdr->contents = outbound_shndx;
5304 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5305 symtab_shndx_hdr->sh_size = amt;
5306 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5307 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5310 /* Now generate the data (for "contents"). */
5312 /* Fill in zeroth symbol and swap it out. */
5313 Elf_Internal_Sym sym;
5319 sym.st_shndx = SHN_UNDEF;
5320 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5321 outbound_syms += bed->s->sizeof_sym;
5322 if (outbound_shndx != NULL)
5323 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5326 syms = bfd_get_outsymbols (abfd);
5327 for (idx = 0; idx < symcount; idx++)
5329 Elf_Internal_Sym sym;
5330 bfd_vma value = syms[idx]->value;
5331 elf_symbol_type *type_ptr;
5332 flagword flags = syms[idx]->flags;
5335 if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5337 /* Local section symbols have no name. */
5342 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5345 if (sym.st_name == (unsigned long) -1)
5347 _bfd_stringtab_free (stt);
5352 type_ptr = elf_symbol_from (abfd, syms[idx]);
5354 if ((flags & BSF_SECTION_SYM) == 0
5355 && bfd_is_com_section (syms[idx]->section))
5357 /* ELF common symbols put the alignment into the `value' field,
5358 and the size into the `size' field. This is backwards from
5359 how BFD handles it, so reverse it here. */
5360 sym.st_size = value;
5361 if (type_ptr == NULL
5362 || type_ptr->internal_elf_sym.st_value == 0)
5363 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5365 sym.st_value = type_ptr->internal_elf_sym.st_value;
5366 sym.st_shndx = _bfd_elf_section_from_bfd_section
5367 (abfd, syms[idx]->section);
5371 asection *sec = syms[idx]->section;
5374 if (sec->output_section)
5376 value += sec->output_offset;
5377 sec = sec->output_section;
5380 /* Don't add in the section vma for relocatable output. */
5381 if (! relocatable_p)
5383 sym.st_value = value;
5384 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5386 if (bfd_is_abs_section (sec)
5388 && type_ptr->internal_elf_sym.st_shndx != 0)
5390 /* This symbol is in a real ELF section which we did
5391 not create as a BFD section. Undo the mapping done
5392 by copy_private_symbol_data. */
5393 shndx = type_ptr->internal_elf_sym.st_shndx;
5397 shndx = elf_onesymtab (abfd);
5400 shndx = elf_dynsymtab (abfd);
5403 shndx = elf_tdata (abfd)->strtab_section;
5406 shndx = elf_tdata (abfd)->shstrtab_section;
5409 shndx = elf_tdata (abfd)->symtab_shndx_section;
5417 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5423 /* Writing this would be a hell of a lot easier if
5424 we had some decent documentation on bfd, and
5425 knew what to expect of the library, and what to
5426 demand of applications. For example, it
5427 appears that `objcopy' might not set the
5428 section of a symbol to be a section that is
5429 actually in the output file. */
5430 sec2 = bfd_get_section_by_name (abfd, sec->name);
5433 _bfd_error_handler (_("\
5434 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5435 syms[idx]->name ? syms[idx]->name : "<Local sym>",
5437 bfd_set_error (bfd_error_invalid_operation);
5438 _bfd_stringtab_free (stt);
5442 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5443 BFD_ASSERT (shndx != -1);
5447 sym.st_shndx = shndx;
5450 if ((flags & BSF_THREAD_LOCAL) != 0)
5452 else if ((flags & BSF_FUNCTION) != 0)
5454 else if ((flags & BSF_OBJECT) != 0)
5459 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5462 /* Processor-specific types. */
5463 if (type_ptr != NULL
5464 && bed->elf_backend_get_symbol_type)
5465 type = ((*bed->elf_backend_get_symbol_type)
5466 (&type_ptr->internal_elf_sym, type));
5468 if (flags & BSF_SECTION_SYM)
5470 if (flags & BSF_GLOBAL)
5471 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5473 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5475 else if (bfd_is_com_section (syms[idx]->section))
5476 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5477 else if (bfd_is_und_section (syms[idx]->section))
5478 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5482 else if (flags & BSF_FILE)
5483 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5486 int bind = STB_LOCAL;
5488 if (flags & BSF_LOCAL)
5490 else if (flags & BSF_WEAK)
5492 else if (flags & BSF_GLOBAL)
5495 sym.st_info = ELF_ST_INFO (bind, type);
5498 if (type_ptr != NULL)
5499 sym.st_other = type_ptr->internal_elf_sym.st_other;
5503 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5504 outbound_syms += bed->s->sizeof_sym;
5505 if (outbound_shndx != NULL)
5506 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5510 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5511 symstrtab_hdr->sh_type = SHT_STRTAB;
5513 symstrtab_hdr->sh_flags = 0;
5514 symstrtab_hdr->sh_addr = 0;
5515 symstrtab_hdr->sh_entsize = 0;
5516 symstrtab_hdr->sh_link = 0;
5517 symstrtab_hdr->sh_info = 0;
5518 symstrtab_hdr->sh_addralign = 1;
5523 /* Return the number of bytes required to hold the symtab vector.
5525 Note that we base it on the count plus 1, since we will null terminate
5526 the vector allocated based on this size. However, the ELF symbol table
5527 always has a dummy entry as symbol #0, so it ends up even. */
5530 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
5534 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5536 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5537 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5539 symtab_size -= sizeof (asymbol *);
5545 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
5549 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5551 if (elf_dynsymtab (abfd) == 0)
5553 bfd_set_error (bfd_error_invalid_operation);
5557 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5558 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5560 symtab_size -= sizeof (asymbol *);
5566 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
5569 return (asect->reloc_count + 1) * sizeof (arelent *);
5572 /* Canonicalize the relocs. */
5575 _bfd_elf_canonicalize_reloc (bfd *abfd,
5582 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5584 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
5587 tblptr = section->relocation;
5588 for (i = 0; i < section->reloc_count; i++)
5589 *relptr++ = tblptr++;
5593 return section->reloc_count;
5597 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
5599 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5600 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
5603 bfd_get_symcount (abfd) = symcount;
5608 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
5609 asymbol **allocation)
5611 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5612 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
5615 bfd_get_dynamic_symcount (abfd) = symcount;
5619 /* Return the size required for the dynamic reloc entries. Any
5620 section that was actually installed in the BFD, and has type
5621 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5622 considered to be a dynamic reloc section. */
5625 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
5630 if (elf_dynsymtab (abfd) == 0)
5632 bfd_set_error (bfd_error_invalid_operation);
5636 ret = sizeof (arelent *);
5637 for (s = abfd->sections; s != NULL; s = s->next)
5638 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5639 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5640 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5641 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
5642 * sizeof (arelent *));
5647 /* Canonicalize the dynamic relocation entries. Note that we return
5648 the dynamic relocations as a single block, although they are
5649 actually associated with particular sections; the interface, which
5650 was designed for SunOS style shared libraries, expects that there
5651 is only one set of dynamic relocs. Any section that was actually
5652 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5653 the dynamic symbol table, is considered to be a dynamic reloc
5657 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
5661 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5665 if (elf_dynsymtab (abfd) == 0)
5667 bfd_set_error (bfd_error_invalid_operation);
5671 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5673 for (s = abfd->sections; s != NULL; s = s->next)
5675 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5676 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5677 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5682 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
5684 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
5686 for (i = 0; i < count; i++)
5697 /* Read in the version information. */
5700 _bfd_elf_slurp_version_tables (bfd *abfd)
5702 bfd_byte *contents = NULL;
5705 if (elf_dynverdef (abfd) != 0)
5707 Elf_Internal_Shdr *hdr;
5708 Elf_External_Verdef *everdef;
5709 Elf_Internal_Verdef *iverdef;
5710 Elf_Internal_Verdef *iverdefarr;
5711 Elf_Internal_Verdef iverdefmem;
5713 unsigned int maxidx;
5715 hdr = &elf_tdata (abfd)->dynverdef_hdr;
5717 contents = bfd_malloc (hdr->sh_size);
5718 if (contents == NULL)
5720 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5721 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
5724 /* We know the number of entries in the section but not the maximum
5725 index. Therefore we have to run through all entries and find
5727 everdef = (Elf_External_Verdef *) contents;
5729 for (i = 0; i < hdr->sh_info; ++i)
5731 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5733 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
5734 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
5736 everdef = ((Elf_External_Verdef *)
5737 ((bfd_byte *) everdef + iverdefmem.vd_next));
5740 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
5741 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
5742 if (elf_tdata (abfd)->verdef == NULL)
5745 elf_tdata (abfd)->cverdefs = maxidx;
5747 everdef = (Elf_External_Verdef *) contents;
5748 iverdefarr = elf_tdata (abfd)->verdef;
5749 for (i = 0; i < hdr->sh_info; i++)
5751 Elf_External_Verdaux *everdaux;
5752 Elf_Internal_Verdaux *iverdaux;
5755 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5757 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
5758 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
5760 iverdef->vd_bfd = abfd;
5762 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
5763 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
5764 if (iverdef->vd_auxptr == NULL)
5767 everdaux = ((Elf_External_Verdaux *)
5768 ((bfd_byte *) everdef + iverdef->vd_aux));
5769 iverdaux = iverdef->vd_auxptr;
5770 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
5772 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
5774 iverdaux->vda_nodename =
5775 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5776 iverdaux->vda_name);
5777 if (iverdaux->vda_nodename == NULL)
5780 if (j + 1 < iverdef->vd_cnt)
5781 iverdaux->vda_nextptr = iverdaux + 1;
5783 iverdaux->vda_nextptr = NULL;
5785 everdaux = ((Elf_External_Verdaux *)
5786 ((bfd_byte *) everdaux + iverdaux->vda_next));
5789 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
5791 if (i + 1 < hdr->sh_info)
5792 iverdef->vd_nextdef = iverdef + 1;
5794 iverdef->vd_nextdef = NULL;
5796 everdef = ((Elf_External_Verdef *)
5797 ((bfd_byte *) everdef + iverdef->vd_next));
5804 if (elf_dynverref (abfd) != 0)
5806 Elf_Internal_Shdr *hdr;
5807 Elf_External_Verneed *everneed;
5808 Elf_Internal_Verneed *iverneed;
5811 hdr = &elf_tdata (abfd)->dynverref_hdr;
5813 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
5814 elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
5815 if (elf_tdata (abfd)->verref == NULL)
5818 elf_tdata (abfd)->cverrefs = hdr->sh_info;
5820 contents = bfd_malloc (hdr->sh_size);
5821 if (contents == NULL)
5823 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5824 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
5827 everneed = (Elf_External_Verneed *) contents;
5828 iverneed = elf_tdata (abfd)->verref;
5829 for (i = 0; i < hdr->sh_info; i++, iverneed++)
5831 Elf_External_Vernaux *evernaux;
5832 Elf_Internal_Vernaux *ivernaux;
5835 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
5837 iverneed->vn_bfd = abfd;
5839 iverneed->vn_filename =
5840 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5842 if (iverneed->vn_filename == NULL)
5845 amt = iverneed->vn_cnt;
5846 amt *= sizeof (Elf_Internal_Vernaux);
5847 iverneed->vn_auxptr = bfd_alloc (abfd, amt);
5849 evernaux = ((Elf_External_Vernaux *)
5850 ((bfd_byte *) everneed + iverneed->vn_aux));
5851 ivernaux = iverneed->vn_auxptr;
5852 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
5854 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
5856 ivernaux->vna_nodename =
5857 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5858 ivernaux->vna_name);
5859 if (ivernaux->vna_nodename == NULL)
5862 if (j + 1 < iverneed->vn_cnt)
5863 ivernaux->vna_nextptr = ivernaux + 1;
5865 ivernaux->vna_nextptr = NULL;
5867 evernaux = ((Elf_External_Vernaux *)
5868 ((bfd_byte *) evernaux + ivernaux->vna_next));
5871 if (i + 1 < hdr->sh_info)
5872 iverneed->vn_nextref = iverneed + 1;
5874 iverneed->vn_nextref = NULL;
5876 everneed = ((Elf_External_Verneed *)
5877 ((bfd_byte *) everneed + iverneed->vn_next));
5887 if (contents != NULL)
5893 _bfd_elf_make_empty_symbol (bfd *abfd)
5895 elf_symbol_type *newsym;
5896 bfd_size_type amt = sizeof (elf_symbol_type);
5898 newsym = bfd_zalloc (abfd, amt);
5903 newsym->symbol.the_bfd = abfd;
5904 return &newsym->symbol;
5909 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
5913 bfd_symbol_info (symbol, ret);
5916 /* Return whether a symbol name implies a local symbol. Most targets
5917 use this function for the is_local_label_name entry point, but some
5921 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
5924 /* Normal local symbols start with ``.L''. */
5925 if (name[0] == '.' && name[1] == 'L')
5928 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5929 DWARF debugging symbols starting with ``..''. */
5930 if (name[0] == '.' && name[1] == '.')
5933 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5934 emitting DWARF debugging output. I suspect this is actually a
5935 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5936 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5937 underscore to be emitted on some ELF targets). For ease of use,
5938 we treat such symbols as local. */
5939 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5946 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
5947 asymbol *symbol ATTRIBUTE_UNUSED)
5954 _bfd_elf_set_arch_mach (bfd *abfd,
5955 enum bfd_architecture arch,
5956 unsigned long machine)
5958 /* If this isn't the right architecture for this backend, and this
5959 isn't the generic backend, fail. */
5960 if (arch != get_elf_backend_data (abfd)->arch
5961 && arch != bfd_arch_unknown
5962 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5965 return bfd_default_set_arch_mach (abfd, arch, machine);
5968 /* Find the function to a particular section and offset,
5969 for error reporting. */
5972 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
5976 const char **filename_ptr,
5977 const char **functionname_ptr)
5979 const char *filename;
5988 for (p = symbols; *p != NULL; p++)
5992 q = (elf_symbol_type *) *p;
5994 if (bfd_get_section (&q->symbol) != section)
5997 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6002 filename = bfd_asymbol_name (&q->symbol);
6006 if (q->symbol.section == section
6007 && q->symbol.value >= low_func
6008 && q->symbol.value <= offset)
6010 func = (asymbol *) q;
6011 low_func = q->symbol.value;
6021 *filename_ptr = filename;
6022 if (functionname_ptr)
6023 *functionname_ptr = bfd_asymbol_name (func);
6028 /* Find the nearest line to a particular section and offset,
6029 for error reporting. */
6032 _bfd_elf_find_nearest_line (bfd *abfd,
6036 const char **filename_ptr,
6037 const char **functionname_ptr,
6038 unsigned int *line_ptr)
6042 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6043 filename_ptr, functionname_ptr,
6046 if (!*functionname_ptr)
6047 elf_find_function (abfd, section, symbols, offset,
6048 *filename_ptr ? NULL : filename_ptr,
6054 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6055 filename_ptr, functionname_ptr,
6057 &elf_tdata (abfd)->dwarf2_find_line_info))
6059 if (!*functionname_ptr)
6060 elf_find_function (abfd, section, symbols, offset,
6061 *filename_ptr ? NULL : filename_ptr,
6067 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6068 &found, filename_ptr,
6069 functionname_ptr, line_ptr,
6070 &elf_tdata (abfd)->line_info))
6072 if (found && (*functionname_ptr || *line_ptr))
6075 if (symbols == NULL)
6078 if (! elf_find_function (abfd, section, symbols, offset,
6079 filename_ptr, functionname_ptr))
6087 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
6091 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6093 ret += get_program_header_size (abfd);
6098 _bfd_elf_set_section_contents (bfd *abfd,
6100 const void *location,
6102 bfd_size_type count)
6104 Elf_Internal_Shdr *hdr;
6107 if (! abfd->output_has_begun
6108 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6111 hdr = &elf_section_data (section)->this_hdr;
6112 pos = hdr->sh_offset + offset;
6113 if (bfd_seek (abfd, pos, SEEK_SET) != 0
6114 || bfd_bwrite (location, count, abfd) != count)
6121 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6122 arelent *cache_ptr ATTRIBUTE_UNUSED,
6123 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6128 /* Try to convert a non-ELF reloc into an ELF one. */
6131 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6133 /* Check whether we really have an ELF howto. */
6135 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6137 bfd_reloc_code_real_type code;
6138 reloc_howto_type *howto;
6140 /* Alien reloc: Try to determine its type to replace it with an
6141 equivalent ELF reloc. */
6143 if (areloc->howto->pc_relative)
6145 switch (areloc->howto->bitsize)
6148 code = BFD_RELOC_8_PCREL;
6151 code = BFD_RELOC_12_PCREL;
6154 code = BFD_RELOC_16_PCREL;
6157 code = BFD_RELOC_24_PCREL;
6160 code = BFD_RELOC_32_PCREL;
6163 code = BFD_RELOC_64_PCREL;
6169 howto = bfd_reloc_type_lookup (abfd, code);
6171 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6173 if (howto->pcrel_offset)
6174 areloc->addend += areloc->address;
6176 areloc->addend -= areloc->address; /* addend is unsigned!! */
6181 switch (areloc->howto->bitsize)
6187 code = BFD_RELOC_14;
6190 code = BFD_RELOC_16;
6193 code = BFD_RELOC_26;
6196 code = BFD_RELOC_32;
6199 code = BFD_RELOC_64;
6205 howto = bfd_reloc_type_lookup (abfd, code);
6209 areloc->howto = howto;
6217 (*_bfd_error_handler)
6218 (_("%s: unsupported relocation type %s"),
6219 bfd_archive_filename (abfd), areloc->howto->name);
6220 bfd_set_error (bfd_error_bad_value);
6225 _bfd_elf_close_and_cleanup (bfd *abfd)
6227 if (bfd_get_format (abfd) == bfd_object)
6229 if (elf_shstrtab (abfd) != NULL)
6230 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6233 return _bfd_generic_close_and_cleanup (abfd);
6236 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6237 in the relocation's offset. Thus we cannot allow any sort of sanity
6238 range-checking to interfere. There is nothing else to do in processing
6241 bfd_reloc_status_type
6242 _bfd_elf_rel_vtable_reloc_fn
6243 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
6244 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
6245 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6246 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
6248 return bfd_reloc_ok;
6251 /* Elf core file support. Much of this only works on native
6252 toolchains, since we rely on knowing the
6253 machine-dependent procfs structure in order to pick
6254 out details about the corefile. */
6256 #ifdef HAVE_SYS_PROCFS_H
6257 # include <sys/procfs.h>
6260 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6263 elfcore_make_pid (bfd *abfd)
6265 return ((elf_tdata (abfd)->core_lwpid << 16)
6266 + (elf_tdata (abfd)->core_pid));
6269 /* If there isn't a section called NAME, make one, using
6270 data from SECT. Note, this function will generate a
6271 reference to NAME, so you shouldn't deallocate or
6275 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
6279 if (bfd_get_section_by_name (abfd, name) != NULL)
6282 sect2 = bfd_make_section (abfd, name);
6286 sect2->_raw_size = sect->_raw_size;
6287 sect2->filepos = sect->filepos;
6288 sect2->flags = sect->flags;
6289 sect2->alignment_power = sect->alignment_power;
6293 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6294 actually creates up to two pseudosections:
6295 - For the single-threaded case, a section named NAME, unless
6296 such a section already exists.
6297 - For the multi-threaded case, a section named "NAME/PID", where
6298 PID is elfcore_make_pid (abfd).
6299 Both pseudosections have identical contents. */
6301 _bfd_elfcore_make_pseudosection (bfd *abfd,
6307 char *threaded_name;
6311 /* Build the section name. */
6313 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6314 len = strlen (buf) + 1;
6315 threaded_name = bfd_alloc (abfd, len);
6316 if (threaded_name == NULL)
6318 memcpy (threaded_name, buf, len);
6320 sect = bfd_make_section_anyway (abfd, threaded_name);
6323 sect->_raw_size = size;
6324 sect->filepos = filepos;
6325 sect->flags = SEC_HAS_CONTENTS;
6326 sect->alignment_power = 2;
6328 return elfcore_maybe_make_sect (abfd, name, sect);
6331 /* prstatus_t exists on:
6333 linux 2.[01] + glibc
6337 #if defined (HAVE_PRSTATUS_T)
6340 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6345 if (note->descsz == sizeof (prstatus_t))
6349 raw_size = sizeof (prstat.pr_reg);
6350 offset = offsetof (prstatus_t, pr_reg);
6351 memcpy (&prstat, note->descdata, sizeof (prstat));
6353 /* Do not overwrite the core signal if it
6354 has already been set by another thread. */
6355 if (elf_tdata (abfd)->core_signal == 0)
6356 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6357 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6359 /* pr_who exists on:
6362 pr_who doesn't exist on:
6365 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6366 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6369 #if defined (HAVE_PRSTATUS32_T)
6370 else if (note->descsz == sizeof (prstatus32_t))
6372 /* 64-bit host, 32-bit corefile */
6373 prstatus32_t prstat;
6375 raw_size = sizeof (prstat.pr_reg);
6376 offset = offsetof (prstatus32_t, pr_reg);
6377 memcpy (&prstat, note->descdata, sizeof (prstat));
6379 /* Do not overwrite the core signal if it
6380 has already been set by another thread. */
6381 if (elf_tdata (abfd)->core_signal == 0)
6382 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6383 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6385 /* pr_who exists on:
6388 pr_who doesn't exist on:
6391 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6392 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6395 #endif /* HAVE_PRSTATUS32_T */
6398 /* Fail - we don't know how to handle any other
6399 note size (ie. data object type). */
6403 /* Make a ".reg/999" section and a ".reg" section. */
6404 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6405 raw_size, note->descpos + offset);
6407 #endif /* defined (HAVE_PRSTATUS_T) */
6409 /* Create a pseudosection containing the exact contents of NOTE. */
6411 elfcore_make_note_pseudosection (bfd *abfd,
6413 Elf_Internal_Note *note)
6415 return _bfd_elfcore_make_pseudosection (abfd, name,
6416 note->descsz, note->descpos);
6419 /* There isn't a consistent prfpregset_t across platforms,
6420 but it doesn't matter, because we don't have to pick this
6421 data structure apart. */
6424 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
6426 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6429 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6430 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6434 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
6436 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6439 #if defined (HAVE_PRPSINFO_T)
6440 typedef prpsinfo_t elfcore_psinfo_t;
6441 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6442 typedef prpsinfo32_t elfcore_psinfo32_t;
6446 #if defined (HAVE_PSINFO_T)
6447 typedef psinfo_t elfcore_psinfo_t;
6448 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6449 typedef psinfo32_t elfcore_psinfo32_t;
6453 /* return a malloc'ed copy of a string at START which is at
6454 most MAX bytes long, possibly without a terminating '\0'.
6455 the copy will always have a terminating '\0'. */
6458 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
6461 char *end = memchr (start, '\0', max);
6469 dups = bfd_alloc (abfd, len + 1);
6473 memcpy (dups, start, len);
6479 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6481 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6483 if (note->descsz == sizeof (elfcore_psinfo_t))
6485 elfcore_psinfo_t psinfo;
6487 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6489 elf_tdata (abfd)->core_program
6490 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6491 sizeof (psinfo.pr_fname));
6493 elf_tdata (abfd)->core_command
6494 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6495 sizeof (psinfo.pr_psargs));
6497 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6498 else if (note->descsz == sizeof (elfcore_psinfo32_t))
6500 /* 64-bit host, 32-bit corefile */
6501 elfcore_psinfo32_t psinfo;
6503 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6505 elf_tdata (abfd)->core_program
6506 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6507 sizeof (psinfo.pr_fname));
6509 elf_tdata (abfd)->core_command
6510 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6511 sizeof (psinfo.pr_psargs));
6517 /* Fail - we don't know how to handle any other
6518 note size (ie. data object type). */
6522 /* Note that for some reason, a spurious space is tacked
6523 onto the end of the args in some (at least one anyway)
6524 implementations, so strip it off if it exists. */
6527 char *command = elf_tdata (abfd)->core_command;
6528 int n = strlen (command);
6530 if (0 < n && command[n - 1] == ' ')
6531 command[n - 1] = '\0';
6536 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6538 #if defined (HAVE_PSTATUS_T)
6540 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
6542 if (note->descsz == sizeof (pstatus_t)
6543 #if defined (HAVE_PXSTATUS_T)
6544 || note->descsz == sizeof (pxstatus_t)
6550 memcpy (&pstat, note->descdata, sizeof (pstat));
6552 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6554 #if defined (HAVE_PSTATUS32_T)
6555 else if (note->descsz == sizeof (pstatus32_t))
6557 /* 64-bit host, 32-bit corefile */
6560 memcpy (&pstat, note->descdata, sizeof (pstat));
6562 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6565 /* Could grab some more details from the "representative"
6566 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6567 NT_LWPSTATUS note, presumably. */
6571 #endif /* defined (HAVE_PSTATUS_T) */
6573 #if defined (HAVE_LWPSTATUS_T)
6575 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
6577 lwpstatus_t lwpstat;
6583 if (note->descsz != sizeof (lwpstat)
6584 #if defined (HAVE_LWPXSTATUS_T)
6585 && note->descsz != sizeof (lwpxstatus_t)
6590 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6592 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6593 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6595 /* Make a ".reg/999" section. */
6597 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6598 len = strlen (buf) + 1;
6599 name = bfd_alloc (abfd, len);
6602 memcpy (name, buf, len);
6604 sect = bfd_make_section_anyway (abfd, name);
6608 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6609 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6610 sect->filepos = note->descpos
6611 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6614 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6615 sect->_raw_size = sizeof (lwpstat.pr_reg);
6616 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6619 sect->flags = SEC_HAS_CONTENTS;
6620 sect->alignment_power = 2;
6622 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
6625 /* Make a ".reg2/999" section */
6627 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
6628 len = strlen (buf) + 1;
6629 name = bfd_alloc (abfd, len);
6632 memcpy (name, buf, len);
6634 sect = bfd_make_section_anyway (abfd, name);
6638 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6639 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
6640 sect->filepos = note->descpos
6641 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6644 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6645 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
6646 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6649 sect->flags = SEC_HAS_CONTENTS;
6650 sect->alignment_power = 2;
6652 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
6654 #endif /* defined (HAVE_LWPSTATUS_T) */
6656 #if defined (HAVE_WIN32_PSTATUS_T)
6658 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
6664 win32_pstatus_t pstatus;
6666 if (note->descsz < sizeof (pstatus))
6669 memcpy (&pstatus, note->descdata, sizeof (pstatus));
6671 switch (pstatus.data_type)
6673 case NOTE_INFO_PROCESS:
6674 /* FIXME: need to add ->core_command. */
6675 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
6676 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
6679 case NOTE_INFO_THREAD:
6680 /* Make a ".reg/999" section. */
6681 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
6683 len = strlen (buf) + 1;
6684 name = bfd_alloc (abfd, len);
6688 memcpy (name, buf, len);
6690 sect = bfd_make_section_anyway (abfd, name);
6694 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
6695 sect->filepos = (note->descpos
6696 + offsetof (struct win32_pstatus,
6697 data.thread_info.thread_context));
6698 sect->flags = SEC_HAS_CONTENTS;
6699 sect->alignment_power = 2;
6701 if (pstatus.data.thread_info.is_active_thread)
6702 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
6706 case NOTE_INFO_MODULE:
6707 /* Make a ".module/xxxxxxxx" section. */
6708 sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
6710 len = strlen (buf) + 1;
6711 name = bfd_alloc (abfd, len);
6715 memcpy (name, buf, len);
6717 sect = bfd_make_section_anyway (abfd, name);
6722 sect->_raw_size = note->descsz;
6723 sect->filepos = note->descpos;
6724 sect->flags = SEC_HAS_CONTENTS;
6725 sect->alignment_power = 2;
6734 #endif /* HAVE_WIN32_PSTATUS_T */
6737 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
6739 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6747 if (bed->elf_backend_grok_prstatus)
6748 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
6750 #if defined (HAVE_PRSTATUS_T)
6751 return elfcore_grok_prstatus (abfd, note);
6756 #if defined (HAVE_PSTATUS_T)
6758 return elfcore_grok_pstatus (abfd, note);
6761 #if defined (HAVE_LWPSTATUS_T)
6763 return elfcore_grok_lwpstatus (abfd, note);
6766 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
6767 return elfcore_grok_prfpreg (abfd, note);
6769 #if defined (HAVE_WIN32_PSTATUS_T)
6770 case NT_WIN32PSTATUS:
6771 return elfcore_grok_win32pstatus (abfd, note);
6774 case NT_PRXFPREG: /* Linux SSE extension */
6775 if (note->namesz == 6
6776 && strcmp (note->namedata, "LINUX") == 0)
6777 return elfcore_grok_prxfpreg (abfd, note);
6783 if (bed->elf_backend_grok_psinfo)
6784 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
6786 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6787 return elfcore_grok_psinfo (abfd, note);
6794 asection *sect = bfd_make_section_anyway (abfd, ".auxv");
6798 sect->_raw_size = note->descsz;
6799 sect->filepos = note->descpos;
6800 sect->flags = SEC_HAS_CONTENTS;
6801 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
6809 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
6813 cp = strchr (note->namedata, '@');
6816 *lwpidp = atoi(cp + 1);
6823 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
6826 /* Signal number at offset 0x08. */
6827 elf_tdata (abfd)->core_signal
6828 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
6830 /* Process ID at offset 0x50. */
6831 elf_tdata (abfd)->core_pid
6832 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
6834 /* Command name at 0x7c (max 32 bytes, including nul). */
6835 elf_tdata (abfd)->core_command
6836 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
6842 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
6846 if (elfcore_netbsd_get_lwpid (note, &lwp))
6847 elf_tdata (abfd)->core_lwpid = lwp;
6849 if (note->type == NT_NETBSDCORE_PROCINFO)
6851 /* NetBSD-specific core "procinfo". Note that we expect to
6852 find this note before any of the others, which is fine,
6853 since the kernel writes this note out first when it
6854 creates a core file. */
6856 return elfcore_grok_netbsd_procinfo (abfd, note);
6859 /* As of Jan 2002 there are no other machine-independent notes
6860 defined for NetBSD core files. If the note type is less
6861 than the start of the machine-dependent note types, we don't
6864 if (note->type < NT_NETBSDCORE_FIRSTMACH)
6868 switch (bfd_get_arch (abfd))
6870 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6871 PT_GETFPREGS == mach+2. */
6873 case bfd_arch_alpha:
6874 case bfd_arch_sparc:
6877 case NT_NETBSDCORE_FIRSTMACH+0:
6878 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6880 case NT_NETBSDCORE_FIRSTMACH+2:
6881 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6887 /* On all other arch's, PT_GETREGS == mach+1 and
6888 PT_GETFPREGS == mach+3. */
6893 case NT_NETBSDCORE_FIRSTMACH+1:
6894 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6896 case NT_NETBSDCORE_FIRSTMACH+3:
6897 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6907 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
6909 void *ddata = note->descdata;
6916 /* nto_procfs_status 'pid' field is at offset 0. */
6917 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
6919 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
6920 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
6922 /* nto_procfs_status 'flags' field is at offset 8. */
6923 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
6925 /* nto_procfs_status 'what' field is at offset 14. */
6926 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
6928 elf_tdata (abfd)->core_signal = sig;
6929 elf_tdata (abfd)->core_lwpid = *tid;
6932 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
6933 do not come from signals so we make sure we set the current
6934 thread just in case. */
6935 if (flags & 0x00000080)
6936 elf_tdata (abfd)->core_lwpid = *tid;
6938 /* Make a ".qnx_core_status/%d" section. */
6939 sprintf (buf, ".qnx_core_status/%d", *tid);
6941 name = bfd_alloc (abfd, strlen (buf) + 1);
6946 sect = bfd_make_section_anyway (abfd, name);
6950 sect->_raw_size = note->descsz;
6951 sect->filepos = note->descpos;
6952 sect->flags = SEC_HAS_CONTENTS;
6953 sect->alignment_power = 2;
6955 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
6959 elfcore_grok_nto_gregs (bfd *abfd, Elf_Internal_Note *note, pid_t tid)
6965 /* Make a ".reg/%d" section. */
6966 sprintf (buf, ".reg/%d", tid);
6968 name = bfd_alloc (abfd, strlen (buf) + 1);
6973 sect = bfd_make_section_anyway (abfd, name);
6977 sect->_raw_size = note->descsz;
6978 sect->filepos = note->descpos;
6979 sect->flags = SEC_HAS_CONTENTS;
6980 sect->alignment_power = 2;
6982 /* This is the current thread. */
6983 if (elf_tdata (abfd)->core_lwpid == tid)
6984 return elfcore_maybe_make_sect (abfd, ".reg", sect);
6989 #define BFD_QNT_CORE_INFO 7
6990 #define BFD_QNT_CORE_STATUS 8
6991 #define BFD_QNT_CORE_GREG 9
6992 #define BFD_QNT_CORE_FPREG 10
6995 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
6997 /* Every GREG section has a STATUS section before it. Store the
6998 tid from the previous call to pass down to the next gregs
7000 static pid_t tid = 1;
7004 case BFD_QNT_CORE_INFO: return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7005 case BFD_QNT_CORE_STATUS: return elfcore_grok_nto_status (abfd, note, &tid);
7006 case BFD_QNT_CORE_GREG: return elfcore_grok_nto_gregs (abfd, note, tid);
7007 case BFD_QNT_CORE_FPREG: return elfcore_grok_prfpreg (abfd, note);
7008 default: return TRUE;
7012 /* Function: elfcore_write_note
7019 size of data for note
7022 End of buffer containing note. */
7025 elfcore_write_note (bfd *abfd,
7033 Elf_External_Note *xnp;
7043 const struct elf_backend_data *bed;
7045 namesz = strlen (name) + 1;
7046 bed = get_elf_backend_data (abfd);
7047 pad = -namesz & ((1 << bed->s->log_file_align) - 1);
7050 newspace = 12 + namesz + pad + size;
7052 p = realloc (buf, *bufsiz + newspace);
7054 *bufsiz += newspace;
7055 xnp = (Elf_External_Note *) dest;
7056 H_PUT_32 (abfd, namesz, xnp->namesz);
7057 H_PUT_32 (abfd, size, xnp->descsz);
7058 H_PUT_32 (abfd, type, xnp->type);
7062 memcpy (dest, name, namesz);
7070 memcpy (dest, input, size);
7074 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7076 elfcore_write_prpsinfo (bfd *abfd,
7083 char *note_name = "CORE";
7085 #if defined (HAVE_PSINFO_T)
7087 note_type = NT_PSINFO;
7090 note_type = NT_PRPSINFO;
7093 memset (&data, 0, sizeof (data));
7094 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7095 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7096 return elfcore_write_note (abfd, buf, bufsiz,
7097 note_name, note_type, &data, sizeof (data));
7099 #endif /* PSINFO_T or PRPSINFO_T */
7101 #if defined (HAVE_PRSTATUS_T)
7103 elfcore_write_prstatus (bfd *abfd,
7111 char *note_name = "CORE";
7113 memset (&prstat, 0, sizeof (prstat));
7114 prstat.pr_pid = pid;
7115 prstat.pr_cursig = cursig;
7116 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7117 return elfcore_write_note (abfd, buf, bufsiz,
7118 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7120 #endif /* HAVE_PRSTATUS_T */
7122 #if defined (HAVE_LWPSTATUS_T)
7124 elfcore_write_lwpstatus (bfd *abfd,
7131 lwpstatus_t lwpstat;
7132 char *note_name = "CORE";
7134 memset (&lwpstat, 0, sizeof (lwpstat));
7135 lwpstat.pr_lwpid = pid >> 16;
7136 lwpstat.pr_cursig = cursig;
7137 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7138 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7139 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7141 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7142 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7144 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7145 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7148 return elfcore_write_note (abfd, buf, bufsiz, note_name,
7149 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7151 #endif /* HAVE_LWPSTATUS_T */
7153 #if defined (HAVE_PSTATUS_T)
7155 elfcore_write_pstatus (bfd *abfd,
7163 char *note_name = "CORE";
7165 memset (&pstat, 0, sizeof (pstat));
7166 pstat.pr_pid = pid & 0xffff;
7167 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7168 NT_PSTATUS, &pstat, sizeof (pstat));
7171 #endif /* HAVE_PSTATUS_T */
7174 elfcore_write_prfpreg (bfd *abfd,
7180 char *note_name = "CORE";
7181 return elfcore_write_note (abfd, buf, bufsiz,
7182 note_name, NT_FPREGSET, fpregs, size);
7186 elfcore_write_prxfpreg (bfd *abfd,
7189 const void *xfpregs,
7192 char *note_name = "LINUX";
7193 return elfcore_write_note (abfd, buf, bufsiz,
7194 note_name, NT_PRXFPREG, xfpregs, size);
7198 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
7206 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7209 buf = bfd_malloc (size);
7213 if (bfd_bread (buf, size, abfd) != size)
7221 while (p < buf + size)
7223 /* FIXME: bad alignment assumption. */
7224 Elf_External_Note *xnp = (Elf_External_Note *) p;
7225 Elf_Internal_Note in;
7227 in.type = H_GET_32 (abfd, xnp->type);
7229 in.namesz = H_GET_32 (abfd, xnp->namesz);
7230 in.namedata = xnp->name;
7232 in.descsz = H_GET_32 (abfd, xnp->descsz);
7233 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7234 in.descpos = offset + (in.descdata - buf);
7236 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7238 if (! elfcore_grok_netbsd_note (abfd, &in))
7241 else if (strncmp (in.namedata, "QNX", 3) == 0)
7243 if (! elfcore_grok_nto_note (abfd, &in))
7248 if (! elfcore_grok_note (abfd, &in))
7252 p = in.descdata + BFD_ALIGN (in.descsz, 4);
7259 /* Providing external access to the ELF program header table. */
7261 /* Return an upper bound on the number of bytes required to store a
7262 copy of ABFD's program header table entries. Return -1 if an error
7263 occurs; bfd_get_error will return an appropriate code. */
7266 bfd_get_elf_phdr_upper_bound (bfd *abfd)
7268 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7270 bfd_set_error (bfd_error_wrong_format);
7274 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7277 /* Copy ABFD's program header table entries to *PHDRS. The entries
7278 will be stored as an array of Elf_Internal_Phdr structures, as
7279 defined in include/elf/internal.h. To find out how large the
7280 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7282 Return the number of program header table entries read, or -1 if an
7283 error occurs; bfd_get_error will return an appropriate code. */
7286 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
7290 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7292 bfd_set_error (bfd_error_wrong_format);
7296 num_phdrs = elf_elfheader (abfd)->e_phnum;
7297 memcpy (phdrs, elf_tdata (abfd)->phdr,
7298 num_phdrs * sizeof (Elf_Internal_Phdr));
7304 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
7307 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7309 i_ehdrp = elf_elfheader (abfd);
7310 if (i_ehdrp == NULL)
7311 sprintf_vma (buf, value);
7314 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7316 #if BFD_HOST_64BIT_LONG
7317 sprintf (buf, "%016lx", value);
7319 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7320 _bfd_int64_low (value));
7324 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7327 sprintf_vma (buf, value);
7332 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
7335 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7337 i_ehdrp = elf_elfheader (abfd);
7338 if (i_ehdrp == NULL)
7339 fprintf_vma ((FILE *) stream, value);
7342 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7344 #if BFD_HOST_64BIT_LONG
7345 fprintf ((FILE *) stream, "%016lx", value);
7347 fprintf ((FILE *) stream, "%08lx%08lx",
7348 _bfd_int64_high (value), _bfd_int64_low (value));
7352 fprintf ((FILE *) stream, "%08lx",
7353 (unsigned long) (value & 0xffffffff));
7356 fprintf_vma ((FILE *) stream, value);
7360 enum elf_reloc_type_class
7361 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
7363 return reloc_class_normal;
7366 /* For RELA architectures, return the relocation value for a
7367 relocation against a local symbol. */
7370 _bfd_elf_rela_local_sym (bfd *abfd,
7371 Elf_Internal_Sym *sym,
7373 Elf_Internal_Rela *rel)
7375 asection *sec = *psec;
7378 relocation = (sec->output_section->vma
7379 + sec->output_offset
7381 if ((sec->flags & SEC_MERGE)
7382 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
7383 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
7386 _bfd_merged_section_offset (abfd, psec,
7387 elf_section_data (sec)->sec_info,
7388 sym->st_value + rel->r_addend,
7391 rel->r_addend -= relocation;
7392 rel->r_addend += sec->output_section->vma + sec->output_offset;
7398 _bfd_elf_rel_local_sym (bfd *abfd,
7399 Elf_Internal_Sym *sym,
7403 asection *sec = *psec;
7405 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
7406 return sym->st_value + addend;
7408 return _bfd_merged_section_offset (abfd, psec,
7409 elf_section_data (sec)->sec_info,
7410 sym->st_value + addend, 0);
7414 _bfd_elf_section_offset (bfd *abfd,
7415 struct bfd_link_info *info,
7419 struct bfd_elf_section_data *sec_data;
7421 sec_data = elf_section_data (sec);
7422 switch (sec->sec_info_type)
7424 case ELF_INFO_TYPE_STABS:
7425 return _bfd_stab_section_offset (abfd,
7426 &elf_hash_table (info)->merge_info,
7427 sec, &sec_data->sec_info, offset);
7428 case ELF_INFO_TYPE_EH_FRAME:
7429 return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);
7435 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
7436 reconstruct an ELF file by reading the segments out of remote memory
7437 based on the ELF file header at EHDR_VMA and the ELF program headers it
7438 points to. If not null, *LOADBASEP is filled in with the difference
7439 between the VMAs from which the segments were read, and the VMAs the
7440 file headers (and hence BFD's idea of each section's VMA) put them at.
7442 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
7443 remote memory at target address VMA into the local buffer at MYADDR; it
7444 should return zero on success or an `errno' code on failure. TEMPL must
7445 be a BFD for an ELF target with the word size and byte order found in
7446 the remote memory. */
7449 bfd_elf_bfd_from_remote_memory
7453 int (*target_read_memory) (bfd_vma, char *, int))
7455 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
7456 (templ, ehdr_vma, loadbasep, target_read_memory);