1 /* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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
41 static INLINE struct elf_segment_map *make_mapping
42 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
43 static boolean map_sections_to_segments PARAMS ((bfd *));
44 static int elf_sort_sections PARAMS ((const PTR, const PTR));
45 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
46 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
47 static boolean prep_headers PARAMS ((bfd *));
48 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
49 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
50 static char *elf_read PARAMS ((bfd *, long, unsigned int));
51 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
52 static boolean assign_section_numbers PARAMS ((bfd *));
53 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
54 static boolean elf_map_symbols PARAMS ((bfd *));
55 static bfd_size_type get_program_header_size PARAMS ((bfd *));
56 static boolean elfcore_read_notes PARAMS ((bfd *, bfd_vma, bfd_vma));
58 /* Swap version information in and out. The version information is
59 currently size independent. If that ever changes, this code will
60 need to move into elfcode.h. */
62 /* Swap in a Verdef structure. */
65 _bfd_elf_swap_verdef_in (abfd, src, dst)
67 const Elf_External_Verdef *src;
68 Elf_Internal_Verdef *dst;
70 dst->vd_version = bfd_h_get_16 (abfd, src->vd_version);
71 dst->vd_flags = bfd_h_get_16 (abfd, src->vd_flags);
72 dst->vd_ndx = bfd_h_get_16 (abfd, src->vd_ndx);
73 dst->vd_cnt = bfd_h_get_16 (abfd, src->vd_cnt);
74 dst->vd_hash = bfd_h_get_32 (abfd, src->vd_hash);
75 dst->vd_aux = bfd_h_get_32 (abfd, src->vd_aux);
76 dst->vd_next = bfd_h_get_32 (abfd, src->vd_next);
79 /* Swap out a Verdef structure. */
82 _bfd_elf_swap_verdef_out (abfd, src, dst)
84 const Elf_Internal_Verdef *src;
85 Elf_External_Verdef *dst;
87 bfd_h_put_16 (abfd, src->vd_version, dst->vd_version);
88 bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags);
89 bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx);
90 bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt);
91 bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash);
92 bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux);
93 bfd_h_put_32 (abfd, src->vd_next, dst->vd_next);
96 /* Swap in a Verdaux structure. */
99 _bfd_elf_swap_verdaux_in (abfd, src, dst)
101 const Elf_External_Verdaux *src;
102 Elf_Internal_Verdaux *dst;
104 dst->vda_name = bfd_h_get_32 (abfd, src->vda_name);
105 dst->vda_next = bfd_h_get_32 (abfd, src->vda_next);
108 /* Swap out a Verdaux structure. */
111 _bfd_elf_swap_verdaux_out (abfd, src, dst)
113 const Elf_Internal_Verdaux *src;
114 Elf_External_Verdaux *dst;
116 bfd_h_put_32 (abfd, src->vda_name, dst->vda_name);
117 bfd_h_put_32 (abfd, src->vda_next, dst->vda_next);
120 /* Swap in a Verneed structure. */
123 _bfd_elf_swap_verneed_in (abfd, src, dst)
125 const Elf_External_Verneed *src;
126 Elf_Internal_Verneed *dst;
128 dst->vn_version = bfd_h_get_16 (abfd, src->vn_version);
129 dst->vn_cnt = bfd_h_get_16 (abfd, src->vn_cnt);
130 dst->vn_file = bfd_h_get_32 (abfd, src->vn_file);
131 dst->vn_aux = bfd_h_get_32 (abfd, src->vn_aux);
132 dst->vn_next = bfd_h_get_32 (abfd, src->vn_next);
135 /* Swap out a Verneed structure. */
138 _bfd_elf_swap_verneed_out (abfd, src, dst)
140 const Elf_Internal_Verneed *src;
141 Elf_External_Verneed *dst;
143 bfd_h_put_16 (abfd, src->vn_version, dst->vn_version);
144 bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt);
145 bfd_h_put_32 (abfd, src->vn_file, dst->vn_file);
146 bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux);
147 bfd_h_put_32 (abfd, src->vn_next, dst->vn_next);
150 /* Swap in a Vernaux structure. */
153 _bfd_elf_swap_vernaux_in (abfd, src, dst)
155 const Elf_External_Vernaux *src;
156 Elf_Internal_Vernaux *dst;
158 dst->vna_hash = bfd_h_get_32 (abfd, src->vna_hash);
159 dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags);
160 dst->vna_other = bfd_h_get_16 (abfd, src->vna_other);
161 dst->vna_name = bfd_h_get_32 (abfd, src->vna_name);
162 dst->vna_next = bfd_h_get_32 (abfd, src->vna_next);
165 /* Swap out a Vernaux structure. */
168 _bfd_elf_swap_vernaux_out (abfd, src, dst)
170 const Elf_Internal_Vernaux *src;
171 Elf_External_Vernaux *dst;
173 bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash);
174 bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags);
175 bfd_h_put_16 (abfd, src->vna_other, dst->vna_other);
176 bfd_h_put_32 (abfd, src->vna_name, dst->vna_name);
177 bfd_h_put_32 (abfd, src->vna_next, dst->vna_next);
180 /* Swap in a Versym structure. */
183 _bfd_elf_swap_versym_in (abfd, src, dst)
185 const Elf_External_Versym *src;
186 Elf_Internal_Versym *dst;
188 dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers);
191 /* Swap out a Versym structure. */
194 _bfd_elf_swap_versym_out (abfd, src, dst)
196 const Elf_Internal_Versym *src;
197 Elf_External_Versym *dst;
199 bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers);
202 /* Standard ELF hash function. Do not change this function; you will
203 cause invalid hash tables to be generated. */
206 bfd_elf_hash (namearg)
209 const unsigned char *name = (const unsigned char *) namearg;
214 while ((ch = *name++) != '\0')
217 if ((g = (h & 0xf0000000)) != 0)
220 /* The ELF ABI says `h &= ~g', but this is equivalent in
221 this case and on some machines one insn instead of two. */
228 /* Read a specified number of bytes at a specified offset in an ELF
229 file, into a newly allocated buffer, and return a pointer to the
233 elf_read (abfd, offset, size)
240 if ((buf = bfd_alloc (abfd, size)) == NULL)
242 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
244 if (bfd_read ((PTR) buf, size, 1, abfd) != size)
246 if (bfd_get_error () != bfd_error_system_call)
247 bfd_set_error (bfd_error_file_truncated);
254 bfd_elf_mkobject (abfd)
257 /* this just does initialization */
258 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
259 elf_tdata (abfd) = (struct elf_obj_tdata *)
260 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
261 if (elf_tdata (abfd) == 0)
263 /* since everything is done at close time, do we need any
270 bfd_elf_mkcorefile (abfd)
273 /* I think this can be done just like an object file. */
274 return bfd_elf_mkobject (abfd);
278 bfd_elf_get_str_section (abfd, shindex)
280 unsigned int shindex;
282 Elf_Internal_Shdr **i_shdrp;
283 char *shstrtab = NULL;
285 unsigned int shstrtabsize;
287 i_shdrp = elf_elfsections (abfd);
288 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
291 shstrtab = (char *) i_shdrp[shindex]->contents;
292 if (shstrtab == NULL)
294 /* No cached one, attempt to read, and cache what we read. */
295 offset = i_shdrp[shindex]->sh_offset;
296 shstrtabsize = i_shdrp[shindex]->sh_size;
297 shstrtab = elf_read (abfd, offset, shstrtabsize);
298 i_shdrp[shindex]->contents = (PTR) shstrtab;
304 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
306 unsigned int shindex;
307 unsigned int strindex;
309 Elf_Internal_Shdr *hdr;
314 hdr = elf_elfsections (abfd)[shindex];
316 if (hdr->contents == NULL
317 && bfd_elf_get_str_section (abfd, shindex) == NULL)
320 if (strindex >= hdr->sh_size)
322 (*_bfd_error_handler)
323 (_("%s: invalid string offset %u >= %lu for section `%s'"),
324 bfd_get_filename (abfd), strindex, (unsigned long) hdr->sh_size,
325 ((shindex == elf_elfheader(abfd)->e_shstrndx
326 && strindex == hdr->sh_name)
328 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
332 return ((char *) hdr->contents) + strindex;
335 /* Make a BFD section from an ELF section. We store a pointer to the
336 BFD section in the bfd_section field of the header. */
339 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
341 Elf_Internal_Shdr *hdr;
347 if (hdr->bfd_section != NULL)
349 BFD_ASSERT (strcmp (name,
350 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
354 newsect = bfd_make_section_anyway (abfd, name);
358 newsect->filepos = hdr->sh_offset;
360 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
361 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
362 || ! bfd_set_section_alignment (abfd, newsect,
363 bfd_log2 (hdr->sh_addralign)))
366 flags = SEC_NO_FLAGS;
367 if (hdr->sh_type != SHT_NOBITS)
368 flags |= SEC_HAS_CONTENTS;
369 if ((hdr->sh_flags & SHF_ALLOC) != 0)
372 if (hdr->sh_type != SHT_NOBITS)
375 if ((hdr->sh_flags & SHF_WRITE) == 0)
376 flags |= SEC_READONLY;
377 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
379 else if ((flags & SEC_LOAD) != 0)
382 /* The debugging sections appear to be recognized only by name, not
384 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
385 || strncmp (name, ".line", sizeof ".line" - 1) == 0
386 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
387 flags |= SEC_DEBUGGING;
389 /* As a GNU extension, if the name begins with .gnu.linkonce, we
390 only link a single copy of the section. This is used to support
391 g++. g++ will emit each template expansion in its own section.
392 The symbols will be defined as weak, so that multiple definitions
393 are permitted. The GNU linker extension is to actually discard
394 all but one of the sections. */
395 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
396 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
398 if (! bfd_set_section_flags (abfd, newsect, flags))
401 if ((flags & SEC_ALLOC) != 0)
403 Elf_Internal_Phdr *phdr;
406 /* Look through the phdrs to see if we need to adjust the lma.
407 If all the p_paddr fields are zero, we ignore them, since
408 some ELF linkers produce such output. */
409 phdr = elf_tdata (abfd)->phdr;
410 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
412 if (phdr->p_paddr != 0)
415 if (i < elf_elfheader (abfd)->e_phnum)
417 phdr = elf_tdata (abfd)->phdr;
418 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
420 if (phdr->p_type == PT_LOAD
421 && phdr->p_vaddr != phdr->p_paddr
422 && phdr->p_vaddr <= hdr->sh_addr
423 && (phdr->p_vaddr + phdr->p_memsz
424 >= hdr->sh_addr + hdr->sh_size)
425 && ((flags & SEC_LOAD) == 0
426 || (phdr->p_offset <= (bfd_vma) hdr->sh_offset
427 && (phdr->p_offset + phdr->p_filesz
428 >= hdr->sh_offset + hdr->sh_size))))
430 newsect->lma += phdr->p_paddr - phdr->p_vaddr;
437 hdr->bfd_section = newsect;
438 elf_section_data (newsect)->this_hdr = *hdr;
448 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
451 Helper functions for GDB to locate the string tables.
452 Since BFD hides string tables from callers, GDB needs to use an
453 internal hook to find them. Sun's .stabstr, in particular,
454 isn't even pointed to by the .stab section, so ordinary
455 mechanisms wouldn't work to find it, even if we had some.
458 struct elf_internal_shdr *
459 bfd_elf_find_section (abfd, name)
463 Elf_Internal_Shdr **i_shdrp;
468 i_shdrp = elf_elfsections (abfd);
471 shstrtab = bfd_elf_get_str_section
472 (abfd, elf_elfheader (abfd)->e_shstrndx);
473 if (shstrtab != NULL)
475 max = elf_elfheader (abfd)->e_shnum;
476 for (i = 1; i < max; i++)
477 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
484 const char *const bfd_elf_section_type_names[] = {
485 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
486 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
487 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
490 /* ELF relocs are against symbols. If we are producing relocateable
491 output, and the reloc is against an external symbol, and nothing
492 has given us any additional addend, the resulting reloc will also
493 be against the same symbol. In such a case, we don't want to
494 change anything about the way the reloc is handled, since it will
495 all be done at final link time. Rather than put special case code
496 into bfd_perform_relocation, all the reloc types use this howto
497 function. It just short circuits the reloc if producing
498 relocateable output against an external symbol. */
501 bfd_reloc_status_type
502 bfd_elf_generic_reloc (abfd,
509 bfd *abfd ATTRIBUTE_UNUSED;
510 arelent *reloc_entry;
512 PTR data ATTRIBUTE_UNUSED;
513 asection *input_section;
515 char **error_message ATTRIBUTE_UNUSED;
517 if (output_bfd != (bfd *) NULL
518 && (symbol->flags & BSF_SECTION_SYM) == 0
519 && (! reloc_entry->howto->partial_inplace
520 || reloc_entry->addend == 0))
522 reloc_entry->address += input_section->output_offset;
526 return bfd_reloc_continue;
529 /* Print out the program headers. */
532 _bfd_elf_print_private_bfd_data (abfd, farg)
536 FILE *f = (FILE *) farg;
537 Elf_Internal_Phdr *p;
539 bfd_byte *dynbuf = NULL;
541 p = elf_tdata (abfd)->phdr;
546 fprintf (f, _("\nProgram Header:\n"));
547 c = elf_elfheader (abfd)->e_phnum;
548 for (i = 0; i < c; i++, p++)
555 case PT_NULL: s = "NULL"; break;
556 case PT_LOAD: s = "LOAD"; break;
557 case PT_DYNAMIC: s = "DYNAMIC"; break;
558 case PT_INTERP: s = "INTERP"; break;
559 case PT_NOTE: s = "NOTE"; break;
560 case PT_SHLIB: s = "SHLIB"; break;
561 case PT_PHDR: s = "PHDR"; break;
562 default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
564 fprintf (f, "%8s off 0x", s);
565 fprintf_vma (f, p->p_offset);
566 fprintf (f, " vaddr 0x");
567 fprintf_vma (f, p->p_vaddr);
568 fprintf (f, " paddr 0x");
569 fprintf_vma (f, p->p_paddr);
570 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
571 fprintf (f, " filesz 0x");
572 fprintf_vma (f, p->p_filesz);
573 fprintf (f, " memsz 0x");
574 fprintf_vma (f, p->p_memsz);
575 fprintf (f, " flags %c%c%c",
576 (p->p_flags & PF_R) != 0 ? 'r' : '-',
577 (p->p_flags & PF_W) != 0 ? 'w' : '-',
578 (p->p_flags & PF_X) != 0 ? 'x' : '-');
579 if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
580 fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
585 s = bfd_get_section_by_name (abfd, ".dynamic");
590 bfd_byte *extdyn, *extdynend;
592 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
594 fprintf (f, _("\nDynamic Section:\n"));
596 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
599 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
603 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
606 link = elf_elfsections (abfd)[elfsec]->sh_link;
608 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
609 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
612 extdynend = extdyn + s->_raw_size;
613 for (; extdyn < extdynend; extdyn += extdynsize)
615 Elf_Internal_Dyn dyn;
620 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
622 if (dyn.d_tag == DT_NULL)
629 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
633 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
634 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
635 case DT_PLTGOT: name = "PLTGOT"; break;
636 case DT_HASH: name = "HASH"; break;
637 case DT_STRTAB: name = "STRTAB"; break;
638 case DT_SYMTAB: name = "SYMTAB"; break;
639 case DT_RELA: name = "RELA"; break;
640 case DT_RELASZ: name = "RELASZ"; break;
641 case DT_RELAENT: name = "RELAENT"; break;
642 case DT_STRSZ: name = "STRSZ"; break;
643 case DT_SYMENT: name = "SYMENT"; break;
644 case DT_INIT: name = "INIT"; break;
645 case DT_FINI: name = "FINI"; break;
646 case DT_SONAME: name = "SONAME"; stringp = true; break;
647 case DT_RPATH: name = "RPATH"; stringp = true; break;
648 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
649 case DT_REL: name = "REL"; break;
650 case DT_RELSZ: name = "RELSZ"; break;
651 case DT_RELENT: name = "RELENT"; break;
652 case DT_PLTREL: name = "PLTREL"; break;
653 case DT_DEBUG: name = "DEBUG"; break;
654 case DT_TEXTREL: name = "TEXTREL"; break;
655 case DT_JMPREL: name = "JMPREL"; break;
656 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
657 case DT_FILTER: name = "FILTER"; stringp = true; break;
658 case DT_VERSYM: name = "VERSYM"; break;
659 case DT_VERDEF: name = "VERDEF"; break;
660 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
661 case DT_VERNEED: name = "VERNEED"; break;
662 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
665 fprintf (f, " %-11s ", name);
667 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
672 string = bfd_elf_string_from_elf_section (abfd, link,
676 fprintf (f, "%s", string);
685 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
686 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
688 if (! _bfd_elf_slurp_version_tables (abfd))
692 if (elf_dynverdef (abfd) != 0)
694 Elf_Internal_Verdef *t;
696 fprintf (f, _("\nVersion definitions:\n"));
697 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
699 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
700 t->vd_flags, t->vd_hash, t->vd_nodename);
701 if (t->vd_auxptr->vda_nextptr != NULL)
703 Elf_Internal_Verdaux *a;
706 for (a = t->vd_auxptr->vda_nextptr;
709 fprintf (f, "%s ", a->vda_nodename);
715 if (elf_dynverref (abfd) != 0)
717 Elf_Internal_Verneed *t;
719 fprintf (f, _("\nVersion References:\n"));
720 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
722 Elf_Internal_Vernaux *a;
724 fprintf (f, _(" required from %s:\n"), t->vn_filename);
725 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
726 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
727 a->vna_flags, a->vna_other, a->vna_nodename);
739 /* Display ELF-specific fields of a symbol. */
742 bfd_elf_print_symbol (abfd, filep, symbol, how)
746 bfd_print_symbol_type how;
748 FILE *file = (FILE *) filep;
751 case bfd_print_symbol_name:
752 fprintf (file, "%s", symbol->name);
754 case bfd_print_symbol_more:
755 fprintf (file, "elf ");
756 fprintf_vma (file, symbol->value);
757 fprintf (file, " %lx", (long) symbol->flags);
759 case bfd_print_symbol_all:
761 CONST char *section_name;
762 CONST char *name = NULL;
763 struct elf_backend_data *bed;
764 unsigned char st_other;
766 section_name = symbol->section ? symbol->section->name : "(*none*)";
768 bed = get_elf_backend_data (abfd);
769 if (bed->elf_backend_print_symbol_all)
770 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
775 bfd_print_symbol_vandf ((PTR) file, symbol);
778 fprintf (file, " %s\t", section_name);
779 /* Print the "other" value for a symbol. For common symbols,
780 we've already printed the size; now print the alignment.
781 For other symbols, we have no specified alignment, and
782 we've printed the address; now print the size. */
784 (bfd_is_com_section (symbol->section)
785 ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
786 : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
788 /* If we have version information, print it. */
789 if (elf_tdata (abfd)->dynversym_section != 0
790 && (elf_tdata (abfd)->dynverdef_section != 0
791 || elf_tdata (abfd)->dynverref_section != 0))
794 const char *version_string;
796 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
800 else if (vernum == 1)
801 version_string = "Base";
802 else if (vernum <= elf_tdata (abfd)->cverdefs)
804 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
807 Elf_Internal_Verneed *t;
810 for (t = elf_tdata (abfd)->verref;
814 Elf_Internal_Vernaux *a;
816 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
818 if (a->vna_other == vernum)
820 version_string = a->vna_nodename;
827 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
828 fprintf (file, " %-11s", version_string);
833 fprintf (file, " (%s)", version_string);
834 for (i = 10 - strlen (version_string); i > 0; --i)
839 /* If the st_other field is not zero, print it. */
840 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
845 case STV_INTERNAL: fprintf (file, " .internal"); break;
846 case STV_HIDDEN: fprintf (file, " .hidden"); break;
847 case STV_PROTECTED: fprintf (file, " .protected"); break;
849 /* Some other non-defined flags are also present, so print
851 fprintf (file, " 0x%02x", (unsigned int) st_other);
854 fprintf (file, " %s", name);
860 /* Create an entry in an ELF linker hash table. */
862 struct bfd_hash_entry *
863 _bfd_elf_link_hash_newfunc (entry, table, string)
864 struct bfd_hash_entry *entry;
865 struct bfd_hash_table *table;
868 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
870 /* Allocate the structure if it has not already been allocated by a
872 if (ret == (struct elf_link_hash_entry *) NULL)
873 ret = ((struct elf_link_hash_entry *)
874 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
875 if (ret == (struct elf_link_hash_entry *) NULL)
876 return (struct bfd_hash_entry *) ret;
878 /* Call the allocation method of the superclass. */
879 ret = ((struct elf_link_hash_entry *)
880 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
882 if (ret != (struct elf_link_hash_entry *) NULL)
884 /* Set local fields. */
888 ret->dynstr_index = 0;
890 ret->got.offset = (bfd_vma) -1;
891 ret->plt.offset = (bfd_vma) -1;
892 ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
893 ret->verinfo.verdef = NULL;
894 ret->vtable_entries_used = NULL;
895 ret->vtable_entries_size = 0;
896 ret->vtable_parent = NULL;
897 ret->type = STT_NOTYPE;
899 /* Assume that we have been called by a non-ELF symbol reader.
900 This flag is then reset by the code which reads an ELF input
901 file. This ensures that a symbol created by a non-ELF symbol
902 reader will have the flag set correctly. */
903 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
906 return (struct bfd_hash_entry *) ret;
909 /* Initialize an ELF linker hash table. */
912 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
913 struct elf_link_hash_table *table;
915 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
916 struct bfd_hash_table *,
919 table->dynamic_sections_created = false;
920 table->dynobj = NULL;
921 /* The first dynamic symbol is a dummy. */
922 table->dynsymcount = 1;
923 table->dynstr = NULL;
924 table->bucketcount = 0;
925 table->needed = NULL;
927 table->stab_info = NULL;
928 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
931 /* Create an ELF linker hash table. */
933 struct bfd_link_hash_table *
934 _bfd_elf_link_hash_table_create (abfd)
937 struct elf_link_hash_table *ret;
939 ret = ((struct elf_link_hash_table *)
940 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
941 if (ret == (struct elf_link_hash_table *) NULL)
944 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
946 bfd_release (abfd, ret);
953 /* This is a hook for the ELF emulation code in the generic linker to
954 tell the backend linker what file name to use for the DT_NEEDED
955 entry for a dynamic object. The generic linker passes name as an
956 empty string to indicate that no DT_NEEDED entry should be made. */
959 bfd_elf_set_dt_needed_name (abfd, name)
963 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
964 && bfd_get_format (abfd) == bfd_object)
965 elf_dt_name (abfd) = name;
968 /* Get the list of DT_NEEDED entries for a link. This is a hook for
969 the linker ELF emulation code. */
971 struct bfd_link_needed_list *
972 bfd_elf_get_needed_list (abfd, info)
973 bfd *abfd ATTRIBUTE_UNUSED;
974 struct bfd_link_info *info;
976 if (info->hash->creator->flavour != bfd_target_elf_flavour)
978 return elf_hash_table (info)->needed;
981 /* Get the name actually used for a dynamic object for a link. This
982 is the SONAME entry if there is one. Otherwise, it is the string
983 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
986 bfd_elf_get_dt_soname (abfd)
989 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
990 && bfd_get_format (abfd) == bfd_object)
991 return elf_dt_name (abfd);
995 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
996 the ELF linker emulation code. */
999 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1001 struct bfd_link_needed_list **pneeded;
1004 bfd_byte *dynbuf = NULL;
1007 bfd_byte *extdyn, *extdynend;
1009 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1013 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1014 || bfd_get_format (abfd) != bfd_object)
1017 s = bfd_get_section_by_name (abfd, ".dynamic");
1018 if (s == NULL || s->_raw_size == 0)
1021 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1025 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1029 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1033 link = elf_elfsections (abfd)[elfsec]->sh_link;
1035 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1036 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1039 extdynend = extdyn + s->_raw_size;
1040 for (; extdyn < extdynend; extdyn += extdynsize)
1042 Elf_Internal_Dyn dyn;
1044 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1046 if (dyn.d_tag == DT_NULL)
1049 if (dyn.d_tag == DT_NEEDED)
1052 struct bfd_link_needed_list *l;
1054 string = bfd_elf_string_from_elf_section (abfd, link,
1059 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof *l);
1080 /* Allocate an ELF string table--force the first byte to be zero. */
1082 struct bfd_strtab_hash *
1083 _bfd_elf_stringtab_init ()
1085 struct bfd_strtab_hash *ret;
1087 ret = _bfd_stringtab_init ();
1092 loc = _bfd_stringtab_add (ret, "", true, false);
1093 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1094 if (loc == (bfd_size_type) -1)
1096 _bfd_stringtab_free (ret);
1103 /* ELF .o/exec file reading */
1105 /* Create a new bfd section from an ELF section header. */
1108 bfd_section_from_shdr (abfd, shindex)
1110 unsigned int shindex;
1112 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1113 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1114 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1117 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1119 switch (hdr->sh_type)
1122 /* Inactive section. Throw it away. */
1125 case SHT_PROGBITS: /* Normal section with contents. */
1126 case SHT_DYNAMIC: /* Dynamic linking information. */
1127 case SHT_NOBITS: /* .bss section. */
1128 case SHT_HASH: /* .hash section. */
1129 case SHT_NOTE: /* .note section. */
1130 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1132 case SHT_SYMTAB: /* A symbol table */
1133 if (elf_onesymtab (abfd) == shindex)
1136 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1137 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1138 elf_onesymtab (abfd) = shindex;
1139 elf_tdata (abfd)->symtab_hdr = *hdr;
1140 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1141 abfd->flags |= HAS_SYMS;
1143 /* Sometimes a shared object will map in the symbol table. If
1144 SHF_ALLOC is set, and this is a shared object, then we also
1145 treat this section as a BFD section. We can not base the
1146 decision purely on SHF_ALLOC, because that flag is sometimes
1147 set in a relocateable object file, which would confuse the
1149 if ((hdr->sh_flags & SHF_ALLOC) != 0
1150 && (abfd->flags & DYNAMIC) != 0
1151 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1156 case SHT_DYNSYM: /* A dynamic symbol table */
1157 if (elf_dynsymtab (abfd) == shindex)
1160 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1161 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1162 elf_dynsymtab (abfd) = shindex;
1163 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1164 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1165 abfd->flags |= HAS_SYMS;
1167 /* Besides being a symbol table, we also treat this as a regular
1168 section, so that objcopy can handle it. */
1169 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1171 case SHT_STRTAB: /* A string table */
1172 if (hdr->bfd_section != NULL)
1174 if (ehdr->e_shstrndx == shindex)
1176 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1177 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1183 for (i = 1; i < ehdr->e_shnum; i++)
1185 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1186 if (hdr2->sh_link == shindex)
1188 if (! bfd_section_from_shdr (abfd, i))
1190 if (elf_onesymtab (abfd) == i)
1192 elf_tdata (abfd)->strtab_hdr = *hdr;
1193 elf_elfsections (abfd)[shindex] =
1194 &elf_tdata (abfd)->strtab_hdr;
1197 if (elf_dynsymtab (abfd) == i)
1199 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1200 elf_elfsections (abfd)[shindex] = hdr =
1201 &elf_tdata (abfd)->dynstrtab_hdr;
1202 /* We also treat this as a regular section, so
1203 that objcopy can handle it. */
1206 #if 0 /* Not handling other string tables specially right now. */
1207 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1208 /* We have a strtab for some random other section. */
1209 newsect = (asection *) hdr2->bfd_section;
1212 hdr->bfd_section = newsect;
1213 hdr2 = &elf_section_data (newsect)->str_hdr;
1215 elf_elfsections (abfd)[shindex] = hdr2;
1221 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1225 /* *These* do a lot of work -- but build no sections! */
1227 asection *target_sect;
1228 Elf_Internal_Shdr *hdr2;
1230 /* Check for a bogus link to avoid crashing. */
1231 if (hdr->sh_link >= ehdr->e_shnum)
1233 ((*_bfd_error_handler)
1234 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1235 bfd_get_filename (abfd), hdr->sh_link, name, shindex));
1236 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1239 /* For some incomprehensible reason Oracle distributes
1240 libraries for Solaris in which some of the objects have
1241 bogus sh_link fields. It would be nice if we could just
1242 reject them, but, unfortunately, some people need to use
1243 them. We scan through the section headers; if we find only
1244 one suitable symbol table, we clobber the sh_link to point
1245 to it. I hope this doesn't break anything. */
1246 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1247 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1253 for (scan = 1; scan < ehdr->e_shnum; scan++)
1255 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1256 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1267 hdr->sh_link = found;
1270 /* Get the symbol table. */
1271 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1272 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1275 /* If this reloc section does not use the main symbol table we
1276 don't treat it as a reloc section. BFD can't adequately
1277 represent such a section, so at least for now, we don't
1278 try. We just present it as a normal section. */
1279 if (hdr->sh_link != elf_onesymtab (abfd))
1280 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1282 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1284 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1285 if (target_sect == NULL)
1288 if ((target_sect->flags & SEC_RELOC) == 0
1289 || target_sect->reloc_count == 0)
1290 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1293 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1294 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
1295 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1298 elf_elfsections (abfd)[shindex] = hdr2;
1299 target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
1300 target_sect->flags |= SEC_RELOC;
1301 target_sect->relocation = NULL;
1302 target_sect->rel_filepos = hdr->sh_offset;
1303 /* In the section to which the relocations apply, mark whether
1304 its relocations are of the REL or RELA variety. */
1305 elf_section_data (target_sect)->use_rela_p
1306 = (hdr->sh_type == SHT_RELA);
1307 abfd->flags |= HAS_RELOC;
1312 case SHT_GNU_verdef:
1313 elf_dynverdef (abfd) = shindex;
1314 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1315 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1318 case SHT_GNU_versym:
1319 elf_dynversym (abfd) = shindex;
1320 elf_tdata (abfd)->dynversym_hdr = *hdr;
1321 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1324 case SHT_GNU_verneed:
1325 elf_dynverref (abfd) = shindex;
1326 elf_tdata (abfd)->dynverref_hdr = *hdr;
1327 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1334 /* Check for any processor-specific section types. */
1336 if (bed->elf_backend_section_from_shdr)
1337 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1345 /* Given an ELF section number, retrieve the corresponding BFD
1349 bfd_section_from_elf_index (abfd, index)
1353 BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
1354 if (index >= elf_elfheader (abfd)->e_shnum)
1356 return elf_elfsections (abfd)[index]->bfd_section;
1360 _bfd_elf_new_section_hook (abfd, sec)
1364 struct bfd_elf_section_data *sdata;
1366 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, sizeof (*sdata));
1369 sec->used_by_bfd = (PTR) sdata;
1371 /* Indicate whether or not this section should use RELA relocations. */
1373 = get_elf_backend_data (abfd)->default_use_rela_p;
1378 /* Create a new bfd section from an ELF program header.
1380 Since program segments have no names, we generate a synthetic name
1381 of the form segment<NUM>, where NUM is generally the index in the
1382 program header table. For segments that are split (see below) we
1383 generate the names segment<NUM>a and segment<NUM>b.
1385 Note that some program segments may have a file size that is different than
1386 (less than) the memory size. All this means is that at execution the
1387 system must allocate the amount of memory specified by the memory size,
1388 but only initialize it with the first "file size" bytes read from the
1389 file. This would occur for example, with program segments consisting
1390 of combined data+bss.
1392 To handle the above situation, this routine generates TWO bfd sections
1393 for the single program segment. The first has the length specified by
1394 the file size of the segment, and the second has the length specified
1395 by the difference between the two sizes. In effect, the segment is split
1396 into it's initialized and uninitialized parts.
1401 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
1403 Elf_Internal_Phdr *hdr;
1405 const char *typename;
1412 split = ((hdr->p_memsz > 0)
1413 && (hdr->p_filesz > 0)
1414 && (hdr->p_memsz > hdr->p_filesz));
1415 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
1416 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1419 strcpy (name, namebuf);
1420 newsect = bfd_make_section (abfd, name);
1421 if (newsect == NULL)
1423 newsect->vma = hdr->p_vaddr;
1424 newsect->lma = hdr->p_paddr;
1425 newsect->_raw_size = hdr->p_filesz;
1426 newsect->filepos = hdr->p_offset;
1427 newsect->flags |= SEC_HAS_CONTENTS;
1428 if (hdr->p_type == PT_LOAD)
1430 newsect->flags |= SEC_ALLOC;
1431 newsect->flags |= SEC_LOAD;
1432 if (hdr->p_flags & PF_X)
1434 /* FIXME: all we known is that it has execute PERMISSION,
1436 newsect->flags |= SEC_CODE;
1439 if (!(hdr->p_flags & PF_W))
1441 newsect->flags |= SEC_READONLY;
1446 sprintf (namebuf, "%s%db", typename, index);
1447 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1450 strcpy (name, namebuf);
1451 newsect = bfd_make_section (abfd, name);
1452 if (newsect == NULL)
1454 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1455 newsect->lma = hdr->p_paddr + hdr->p_filesz;
1456 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1457 if (hdr->p_type == PT_LOAD)
1459 newsect->flags |= SEC_ALLOC;
1460 if (hdr->p_flags & PF_X)
1461 newsect->flags |= SEC_CODE;
1463 if (!(hdr->p_flags & PF_W))
1464 newsect->flags |= SEC_READONLY;
1471 bfd_section_from_phdr (abfd, hdr, index)
1473 Elf_Internal_Phdr *hdr;
1476 struct elf_backend_data *bed;
1478 switch (hdr->p_type)
1481 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
1484 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
1487 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
1490 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
1493 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
1495 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
1500 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
1503 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
1506 /* Check for any processor-specific program segment types.
1507 If no handler for them, default to making "segment" sections. */
1508 bed = get_elf_backend_data (abfd);
1509 if (bed->elf_backend_section_from_phdr)
1510 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
1512 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
1516 /* Initialize REL_HDR, the section-header for new section, containing
1517 relocations against ASECT. If USE_RELA_P is true, we use RELA
1518 relocations; otherwise, we use REL relocations. */
1521 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
1523 Elf_Internal_Shdr *rel_hdr;
1528 struct elf_backend_data *bed;
1530 bed = get_elf_backend_data (abfd);
1531 name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1534 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1536 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1538 if (rel_hdr->sh_name == (unsigned int) -1)
1540 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1541 rel_hdr->sh_entsize = (use_rela_p
1542 ? bed->s->sizeof_rela
1543 : bed->s->sizeof_rel);
1544 rel_hdr->sh_addralign = bed->s->file_align;
1545 rel_hdr->sh_flags = 0;
1546 rel_hdr->sh_addr = 0;
1547 rel_hdr->sh_size = 0;
1548 rel_hdr->sh_offset = 0;
1553 /* Set up an ELF internal section header for a section. */
1557 elf_fake_sections (abfd, asect, failedptrarg)
1562 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1563 boolean *failedptr = (boolean *) failedptrarg;
1564 Elf_Internal_Shdr *this_hdr;
1568 /* We already failed; just get out of the bfd_map_over_sections
1573 this_hdr = &elf_section_data (asect)->this_hdr;
1575 this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1578 if (this_hdr->sh_name == (unsigned long) -1)
1584 this_hdr->sh_flags = 0;
1586 if ((asect->flags & SEC_ALLOC) != 0
1587 || asect->user_set_vma)
1588 this_hdr->sh_addr = asect->vma;
1590 this_hdr->sh_addr = 0;
1592 this_hdr->sh_offset = 0;
1593 this_hdr->sh_size = asect->_raw_size;
1594 this_hdr->sh_link = 0;
1595 this_hdr->sh_addralign = 1 << asect->alignment_power;
1596 /* The sh_entsize and sh_info fields may have been set already by
1597 copy_private_section_data. */
1599 this_hdr->bfd_section = asect;
1600 this_hdr->contents = NULL;
1602 /* FIXME: This should not be based on section names. */
1603 if (strcmp (asect->name, ".dynstr") == 0)
1604 this_hdr->sh_type = SHT_STRTAB;
1605 else if (strcmp (asect->name, ".hash") == 0)
1607 this_hdr->sh_type = SHT_HASH;
1608 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
1610 else if (strcmp (asect->name, ".dynsym") == 0)
1612 this_hdr->sh_type = SHT_DYNSYM;
1613 this_hdr->sh_entsize = bed->s->sizeof_sym;
1615 else if (strcmp (asect->name, ".dynamic") == 0)
1617 this_hdr->sh_type = SHT_DYNAMIC;
1618 this_hdr->sh_entsize = bed->s->sizeof_dyn;
1620 else if (strncmp (asect->name, ".rela", 5) == 0
1621 && get_elf_backend_data (abfd)->may_use_rela_p)
1623 this_hdr->sh_type = SHT_RELA;
1624 this_hdr->sh_entsize = bed->s->sizeof_rela;
1626 else if (strncmp (asect->name, ".rel", 4) == 0
1627 && get_elf_backend_data (abfd)->may_use_rel_p)
1629 this_hdr->sh_type = SHT_REL;
1630 this_hdr->sh_entsize = bed->s->sizeof_rel;
1632 else if (strncmp (asect->name, ".note", 5) == 0)
1633 this_hdr->sh_type = SHT_NOTE;
1634 else if (strncmp (asect->name, ".stab", 5) == 0
1635 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1636 this_hdr->sh_type = SHT_STRTAB;
1637 else if (strcmp (asect->name, ".gnu.version") == 0)
1639 this_hdr->sh_type = SHT_GNU_versym;
1640 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
1642 else if (strcmp (asect->name, ".gnu.version_d") == 0)
1644 this_hdr->sh_type = SHT_GNU_verdef;
1645 this_hdr->sh_entsize = 0;
1646 /* objcopy or strip will copy over sh_info, but may not set
1647 cverdefs. The linker will set cverdefs, but sh_info will be
1649 if (this_hdr->sh_info == 0)
1650 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
1652 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
1653 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
1655 else if (strcmp (asect->name, ".gnu.version_r") == 0)
1657 this_hdr->sh_type = SHT_GNU_verneed;
1658 this_hdr->sh_entsize = 0;
1659 /* objcopy or strip will copy over sh_info, but may not set
1660 cverrefs. The linker will set cverrefs, but sh_info will be
1662 if (this_hdr->sh_info == 0)
1663 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
1665 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
1666 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
1668 else if ((asect->flags & SEC_ALLOC) != 0
1669 && (asect->flags & SEC_LOAD) != 0)
1670 this_hdr->sh_type = SHT_PROGBITS;
1671 else if ((asect->flags & SEC_ALLOC) != 0
1672 && ((asect->flags & SEC_LOAD) == 0))
1673 this_hdr->sh_type = SHT_NOBITS;
1677 this_hdr->sh_type = SHT_PROGBITS;
1680 if ((asect->flags & SEC_ALLOC) != 0)
1681 this_hdr->sh_flags |= SHF_ALLOC;
1682 if ((asect->flags & SEC_READONLY) == 0)
1683 this_hdr->sh_flags |= SHF_WRITE;
1684 if ((asect->flags & SEC_CODE) != 0)
1685 this_hdr->sh_flags |= SHF_EXECINSTR;
1687 /* Check for processor-specific section types. */
1688 if (bed->elf_backend_fake_sections)
1689 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1691 /* If the section has relocs, set up a section header for the
1692 SHT_REL[A] section. If two relocation sections are required for
1693 this section, it is up to the processor-specific back-end to
1694 create the other. */
1695 if ((asect->flags & SEC_RELOC) != 0
1696 && !_bfd_elf_init_reloc_shdr (abfd,
1697 &elf_section_data (asect)->rel_hdr,
1699 elf_section_data (asect)->use_rela_p))
1703 /* Assign all ELF section numbers. The dummy first section is handled here
1704 too. The link/info pointers for the standard section types are filled
1705 in here too, while we're at it. */
1708 assign_section_numbers (abfd)
1711 struct elf_obj_tdata *t = elf_tdata (abfd);
1713 unsigned int section_number;
1714 Elf_Internal_Shdr **i_shdrp;
1715 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1719 for (sec = abfd->sections; sec; sec = sec->next)
1721 struct bfd_elf_section_data *d = elf_section_data (sec);
1723 d->this_idx = section_number++;
1724 if ((sec->flags & SEC_RELOC) == 0)
1727 d->rel_idx = section_number++;
1730 d->rel_idx2 = section_number++;
1735 t->shstrtab_section = section_number++;
1736 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1737 t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1739 if (bfd_get_symcount (abfd) > 0)
1741 t->symtab_section = section_number++;
1742 t->strtab_section = section_number++;
1745 elf_elfheader (abfd)->e_shnum = section_number;
1747 /* Set up the list of section header pointers, in agreement with the
1749 i_shdrp = ((Elf_Internal_Shdr **)
1750 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1751 if (i_shdrp == NULL)
1754 i_shdrp[0] = ((Elf_Internal_Shdr *)
1755 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1756 if (i_shdrp[0] == NULL)
1758 bfd_release (abfd, i_shdrp);
1761 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1763 elf_elfsections (abfd) = i_shdrp;
1765 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1766 if (bfd_get_symcount (abfd) > 0)
1768 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1769 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1770 t->symtab_hdr.sh_link = t->strtab_section;
1772 for (sec = abfd->sections; sec; sec = sec->next)
1774 struct bfd_elf_section_data *d = elf_section_data (sec);
1778 i_shdrp[d->this_idx] = &d->this_hdr;
1779 if (d->rel_idx != 0)
1780 i_shdrp[d->rel_idx] = &d->rel_hdr;
1781 if (d->rel_idx2 != 0)
1782 i_shdrp[d->rel_idx2] = d->rel_hdr2;
1784 /* Fill in the sh_link and sh_info fields while we're at it. */
1786 /* sh_link of a reloc section is the section index of the symbol
1787 table. sh_info is the section index of the section to which
1788 the relocation entries apply. */
1789 if (d->rel_idx != 0)
1791 d->rel_hdr.sh_link = t->symtab_section;
1792 d->rel_hdr.sh_info = d->this_idx;
1794 if (d->rel_idx2 != 0)
1796 d->rel_hdr2->sh_link = t->symtab_section;
1797 d->rel_hdr2->sh_info = d->this_idx;
1800 switch (d->this_hdr.sh_type)
1804 /* A reloc section which we are treating as a normal BFD
1805 section. sh_link is the section index of the symbol
1806 table. sh_info is the section index of the section to
1807 which the relocation entries apply. We assume that an
1808 allocated reloc section uses the dynamic symbol table.
1809 FIXME: How can we be sure? */
1810 s = bfd_get_section_by_name (abfd, ".dynsym");
1812 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1814 /* We look up the section the relocs apply to by name. */
1816 if (d->this_hdr.sh_type == SHT_REL)
1820 s = bfd_get_section_by_name (abfd, name);
1822 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1826 /* We assume that a section named .stab*str is a stabs
1827 string section. We look for a section with the same name
1828 but without the trailing ``str'', and set its sh_link
1829 field to point to this section. */
1830 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1831 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1836 len = strlen (sec->name);
1837 alc = (char *) bfd_malloc (len - 2);
1840 strncpy (alc, sec->name, len - 3);
1841 alc[len - 3] = '\0';
1842 s = bfd_get_section_by_name (abfd, alc);
1846 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
1848 /* This is a .stab section. */
1849 elf_section_data (s)->this_hdr.sh_entsize =
1850 4 + 2 * (bed->s->arch_size / 8);
1857 case SHT_GNU_verneed:
1858 case SHT_GNU_verdef:
1859 /* sh_link is the section header index of the string table
1860 used for the dynamic entries, or the symbol table, or the
1862 s = bfd_get_section_by_name (abfd, ".dynstr");
1864 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1868 case SHT_GNU_versym:
1869 /* sh_link is the section header index of the symbol table
1870 this hash table or version table is for. */
1871 s = bfd_get_section_by_name (abfd, ".dynsym");
1873 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1881 /* Map symbol from it's internal number to the external number, moving
1882 all local symbols to be at the head of the list. */
1885 sym_is_global (abfd, sym)
1889 /* If the backend has a special mapping, use it. */
1890 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1891 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1894 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1895 || bfd_is_und_section (bfd_get_section (sym))
1896 || bfd_is_com_section (bfd_get_section (sym)));
1900 elf_map_symbols (abfd)
1903 int symcount = bfd_get_symcount (abfd);
1904 asymbol **syms = bfd_get_outsymbols (abfd);
1905 asymbol **sect_syms;
1907 int num_globals = 0;
1908 int num_locals2 = 0;
1909 int num_globals2 = 0;
1911 int num_sections = 0;
1918 fprintf (stderr, "elf_map_symbols\n");
1922 /* Add a section symbol for each BFD section. FIXME: Is this really
1924 for (asect = abfd->sections; asect; asect = asect->next)
1926 if (max_index < asect->index)
1927 max_index = asect->index;
1931 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
1932 if (sect_syms == NULL)
1934 elf_section_syms (abfd) = sect_syms;
1936 for (idx = 0; idx < symcount; idx++)
1940 if ((sym->flags & BSF_SECTION_SYM) != 0
1947 if (sec->owner != NULL)
1949 if (sec->owner != abfd)
1951 if (sec->output_offset != 0)
1954 sec = sec->output_section;
1956 /* Empty sections in the input files may have had a section
1957 symbol created for them. (See the comment near the end of
1958 _bfd_generic_link_output_symbols in linker.c). If the linker
1959 script discards such sections then we will reach this point.
1960 Since we know that we cannot avoid this case, we detect it
1961 and skip the abort and the assignment to the sect_syms array.
1962 To reproduce this particular case try running the linker
1963 testsuite test ld-scripts/weak.exp for an ELF port that uses
1964 the generic linker. */
1965 if (sec->owner == NULL)
1968 BFD_ASSERT (sec->owner == abfd);
1970 sect_syms[sec->index] = syms[idx];
1975 for (asect = abfd->sections; asect; asect = asect->next)
1977 if (sect_syms[asect->index] != NULL)
1980 sym = bfd_make_empty_symbol (abfd);
1983 sym->the_bfd = abfd;
1984 sym->name = asect->name;
1986 /* Set the flags to 0 to indicate that this one was newly added. */
1988 sym->section = asect;
1989 sect_syms[asect->index] = sym;
1993 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
1994 asect->name, (long) asect->vma, asect->index, (long) asect);
1998 /* Classify all of the symbols. */
1999 for (idx = 0; idx < symcount; idx++)
2001 if (!sym_is_global (abfd, syms[idx]))
2006 for (asect = abfd->sections; asect; asect = asect->next)
2008 if (sect_syms[asect->index] != NULL
2009 && sect_syms[asect->index]->flags == 0)
2011 sect_syms[asect->index]->flags = BSF_SECTION_SYM;
2012 if (!sym_is_global (abfd, sect_syms[asect->index]))
2016 sect_syms[asect->index]->flags = 0;
2020 /* Now sort the symbols so the local symbols are first. */
2021 new_syms = ((asymbol **)
2023 (num_locals + num_globals) * sizeof (asymbol *)));
2024 if (new_syms == NULL)
2027 for (idx = 0; idx < symcount; idx++)
2029 asymbol *sym = syms[idx];
2032 if (!sym_is_global (abfd, sym))
2035 i = num_locals + num_globals2++;
2037 sym->udata.i = i + 1;
2039 for (asect = abfd->sections; asect; asect = asect->next)
2041 if (sect_syms[asect->index] != NULL
2042 && sect_syms[asect->index]->flags == 0)
2044 asymbol *sym = sect_syms[asect->index];
2047 sym->flags = BSF_SECTION_SYM;
2048 if (!sym_is_global (abfd, sym))
2051 i = num_locals + num_globals2++;
2053 sym->udata.i = i + 1;
2057 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2059 elf_num_locals (abfd) = num_locals;
2060 elf_num_globals (abfd) = num_globals;
2064 /* Align to the maximum file alignment that could be required for any
2065 ELF data structure. */
2067 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2068 static INLINE file_ptr
2069 align_file_position (off, align)
2073 return (off + align - 1) & ~(align - 1);
2076 /* Assign a file position to a section, optionally aligning to the
2077 required section alignment. */
2080 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2081 Elf_Internal_Shdr *i_shdrp;
2089 al = i_shdrp->sh_addralign;
2091 offset = BFD_ALIGN (offset, al);
2093 i_shdrp->sh_offset = offset;
2094 if (i_shdrp->bfd_section != NULL)
2095 i_shdrp->bfd_section->filepos = offset;
2096 if (i_shdrp->sh_type != SHT_NOBITS)
2097 offset += i_shdrp->sh_size;
2101 /* Compute the file positions we are going to put the sections at, and
2102 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2103 is not NULL, this is being called by the ELF backend linker. */
2106 _bfd_elf_compute_section_file_positions (abfd, link_info)
2108 struct bfd_link_info *link_info;
2110 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2112 struct bfd_strtab_hash *strtab;
2113 Elf_Internal_Shdr *shstrtab_hdr;
2115 if (abfd->output_has_begun)
2118 /* Do any elf backend specific processing first. */
2119 if (bed->elf_backend_begin_write_processing)
2120 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2122 if (! prep_headers (abfd))
2125 /* Post process the headers if necessary. */
2126 if (bed->elf_backend_post_process_headers)
2127 (*bed->elf_backend_post_process_headers) (abfd, link_info);
2130 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2134 if (!assign_section_numbers (abfd))
2137 /* The backend linker builds symbol table information itself. */
2138 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2140 /* Non-zero if doing a relocatable link. */
2141 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2143 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2147 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2148 /* sh_name was set in prep_headers. */
2149 shstrtab_hdr->sh_type = SHT_STRTAB;
2150 shstrtab_hdr->sh_flags = 0;
2151 shstrtab_hdr->sh_addr = 0;
2152 shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
2153 shstrtab_hdr->sh_entsize = 0;
2154 shstrtab_hdr->sh_link = 0;
2155 shstrtab_hdr->sh_info = 0;
2156 /* sh_offset is set in assign_file_positions_except_relocs. */
2157 shstrtab_hdr->sh_addralign = 1;
2159 if (!assign_file_positions_except_relocs (abfd))
2162 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2165 Elf_Internal_Shdr *hdr;
2167 off = elf_tdata (abfd)->next_file_pos;
2169 hdr = &elf_tdata (abfd)->symtab_hdr;
2170 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2172 hdr = &elf_tdata (abfd)->strtab_hdr;
2173 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2175 elf_tdata (abfd)->next_file_pos = off;
2177 /* Now that we know where the .strtab section goes, write it
2179 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2180 || ! _bfd_stringtab_emit (abfd, strtab))
2182 _bfd_stringtab_free (strtab);
2185 abfd->output_has_begun = true;
2190 /* Create a mapping from a set of sections to a program segment. */
2192 static INLINE struct elf_segment_map *
2193 make_mapping (abfd, sections, from, to, phdr)
2195 asection **sections;
2200 struct elf_segment_map *m;
2204 m = ((struct elf_segment_map *)
2206 (sizeof (struct elf_segment_map)
2207 + (to - from - 1) * sizeof (asection *))));
2211 m->p_type = PT_LOAD;
2212 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2213 m->sections[i - from] = *hdrpp;
2214 m->count = to - from;
2216 if (from == 0 && phdr)
2218 /* Include the headers in the first PT_LOAD segment. */
2219 m->includes_filehdr = 1;
2220 m->includes_phdrs = 1;
2226 /* Set up a mapping from BFD sections to program segments. */
2229 map_sections_to_segments (abfd)
2232 asection **sections = NULL;
2236 struct elf_segment_map *mfirst;
2237 struct elf_segment_map **pm;
2238 struct elf_segment_map *m;
2240 unsigned int phdr_index;
2241 bfd_vma maxpagesize;
2243 boolean phdr_in_segment = true;
2247 if (elf_tdata (abfd)->segment_map != NULL)
2250 if (bfd_count_sections (abfd) == 0)
2253 /* Select the allocated sections, and sort them. */
2255 sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
2256 * sizeof (asection *));
2257 if (sections == NULL)
2261 for (s = abfd->sections; s != NULL; s = s->next)
2263 if ((s->flags & SEC_ALLOC) != 0)
2269 BFD_ASSERT (i <= bfd_count_sections (abfd));
2272 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2274 /* Build the mapping. */
2279 /* If we have a .interp section, then create a PT_PHDR segment for
2280 the program headers and a PT_INTERP segment for the .interp
2282 s = bfd_get_section_by_name (abfd, ".interp");
2283 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2285 m = ((struct elf_segment_map *)
2286 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2290 m->p_type = PT_PHDR;
2291 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2292 m->p_flags = PF_R | PF_X;
2293 m->p_flags_valid = 1;
2294 m->includes_phdrs = 1;
2299 m = ((struct elf_segment_map *)
2300 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2304 m->p_type = PT_INTERP;
2312 /* Look through the sections. We put sections in the same program
2313 segment when the start of the second section can be placed within
2314 a few bytes of the end of the first section. */
2317 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2319 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2321 && (dynsec->flags & SEC_LOAD) == 0)
2324 /* Deal with -Ttext or something similar such that the first section
2325 is not adjacent to the program headers. This is an
2326 approximation, since at this point we don't know exactly how many
2327 program headers we will need. */
2330 bfd_size_type phdr_size;
2332 phdr_size = elf_tdata (abfd)->program_header_size;
2334 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2335 if ((abfd->flags & D_PAGED) == 0
2336 || sections[0]->lma < phdr_size
2337 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2338 phdr_in_segment = false;
2341 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2344 boolean new_segment;
2348 /* See if this section and the last one will fit in the same
2351 if (last_hdr == NULL)
2353 /* If we don't have a segment yet, then we don't need a new
2354 one (we build the last one after this loop). */
2355 new_segment = false;
2357 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
2359 /* If this section has a different relation between the
2360 virtual address and the load address, then we need a new
2364 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2365 < BFD_ALIGN (hdr->lma, maxpagesize))
2367 /* If putting this section in this segment would force us to
2368 skip a page in the segment, then we need a new segment. */
2371 else if ((last_hdr->flags & SEC_LOAD) == 0
2372 && (hdr->flags & SEC_LOAD) != 0)
2374 /* We don't want to put a loadable section after a
2375 nonloadable section in the same segment. */
2378 else if ((abfd->flags & D_PAGED) == 0)
2380 /* If the file is not demand paged, which means that we
2381 don't require the sections to be correctly aligned in the
2382 file, then there is no other reason for a new segment. */
2383 new_segment = false;
2386 && (hdr->flags & SEC_READONLY) == 0
2387 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2390 /* We don't want to put a writable section in a read only
2391 segment, unless they are on the same page in memory
2392 anyhow. We already know that the last section does not
2393 bring us past the current section on the page, so the
2394 only case in which the new section is not on the same
2395 page as the previous section is when the previous section
2396 ends precisely on a page boundary. */
2401 /* Otherwise, we can use the same segment. */
2402 new_segment = false;
2407 if ((hdr->flags & SEC_READONLY) == 0)
2413 /* We need a new program segment. We must create a new program
2414 header holding all the sections from phdr_index until hdr. */
2416 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2423 if ((hdr->flags & SEC_READONLY) == 0)
2430 phdr_in_segment = false;
2433 /* Create a final PT_LOAD program segment. */
2434 if (last_hdr != NULL)
2436 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2444 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2447 m = ((struct elf_segment_map *)
2448 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2452 m->p_type = PT_DYNAMIC;
2454 m->sections[0] = dynsec;
2460 /* For each loadable .note section, add a PT_NOTE segment. We don't
2461 use bfd_get_section_by_name, because if we link together
2462 nonloadable .note sections and loadable .note sections, we will
2463 generate two .note sections in the output file. FIXME: Using
2464 names for section types is bogus anyhow. */
2465 for (s = abfd->sections; s != NULL; s = s->next)
2467 if ((s->flags & SEC_LOAD) != 0
2468 && strncmp (s->name, ".note", 5) == 0)
2470 m = ((struct elf_segment_map *)
2471 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2475 m->p_type = PT_NOTE;
2487 elf_tdata (abfd)->segment_map = mfirst;
2491 if (sections != NULL)
2496 /* Sort sections by address. */
2499 elf_sort_sections (arg1, arg2)
2503 const asection *sec1 = *(const asection **) arg1;
2504 const asection *sec2 = *(const asection **) arg2;
2506 /* Sort by LMA first, since this is the address used to
2507 place the section into a segment. */
2508 if (sec1->lma < sec2->lma)
2510 else if (sec1->lma > sec2->lma)
2513 /* Then sort by VMA. Normally the LMA and the VMA will be
2514 the same, and this will do nothing. */
2515 if (sec1->vma < sec2->vma)
2517 else if (sec1->vma > sec2->vma)
2520 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2522 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2527 return sec1->target_index - sec2->target_index;
2537 /* Sort by size, to put zero sized sections before others at the
2540 if (sec1->_raw_size < sec2->_raw_size)
2542 if (sec1->_raw_size > sec2->_raw_size)
2545 return sec1->target_index - sec2->target_index;
2548 /* Assign file positions to the sections based on the mapping from
2549 sections to segments. This function also sets up some fields in
2550 the file header, and writes out the program headers. */
2553 assign_file_positions_for_segments (abfd)
2556 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2558 struct elf_segment_map *m;
2560 Elf_Internal_Phdr *phdrs;
2562 bfd_vma filehdr_vaddr, filehdr_paddr;
2563 bfd_vma phdrs_vaddr, phdrs_paddr;
2564 Elf_Internal_Phdr *p;
2566 if (elf_tdata (abfd)->segment_map == NULL)
2568 if (! map_sections_to_segments (abfd))
2572 if (bed->elf_backend_modify_segment_map)
2574 if (! (*bed->elf_backend_modify_segment_map) (abfd))
2579 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2582 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
2583 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
2584 elf_elfheader (abfd)->e_phnum = count;
2589 /* If we already counted the number of program segments, make sure
2590 that we allocated enough space. This happens when SIZEOF_HEADERS
2591 is used in a linker script. */
2592 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
2593 if (alloc != 0 && count > alloc)
2595 ((*_bfd_error_handler)
2596 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2597 bfd_get_filename (abfd), alloc, count));
2598 bfd_set_error (bfd_error_bad_value);
2605 phdrs = ((Elf_Internal_Phdr *)
2606 bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
2610 off = bed->s->sizeof_ehdr;
2611 off += alloc * bed->s->sizeof_phdr;
2618 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2625 /* If elf_segment_map is not from map_sections_to_segments, the
2626 sections may not be correctly ordered. */
2628 qsort (m->sections, (size_t) m->count, sizeof (asection *),
2631 p->p_type = m->p_type;
2632 p->p_flags = m->p_flags;
2634 if (p->p_type == PT_LOAD
2636 && (m->sections[0]->flags & SEC_ALLOC) != 0)
2638 if ((abfd->flags & D_PAGED) != 0)
2639 off += (m->sections[0]->vma - off) % bed->maxpagesize;
2642 bfd_size_type align;
2645 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2647 bfd_size_type secalign;
2649 secalign = bfd_get_section_alignment (abfd, *secpp);
2650 if (secalign > align)
2654 off += (m->sections[0]->vma - off) % (1 << align);
2661 p->p_vaddr = m->sections[0]->vma;
2663 if (m->p_paddr_valid)
2664 p->p_paddr = m->p_paddr;
2665 else if (m->count == 0)
2668 p->p_paddr = m->sections[0]->lma;
2670 if (p->p_type == PT_LOAD
2671 && (abfd->flags & D_PAGED) != 0)
2672 p->p_align = bed->maxpagesize;
2673 else if (m->count == 0)
2674 p->p_align = bed->s->file_align;
2682 if (m->includes_filehdr)
2684 if (! m->p_flags_valid)
2687 p->p_filesz = bed->s->sizeof_ehdr;
2688 p->p_memsz = bed->s->sizeof_ehdr;
2691 BFD_ASSERT (p->p_type == PT_LOAD);
2693 if (p->p_vaddr < (bfd_vma) off)
2695 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2696 bfd_get_filename (abfd));
2697 bfd_set_error (bfd_error_bad_value);
2702 if (! m->p_paddr_valid)
2705 if (p->p_type == PT_LOAD)
2707 filehdr_vaddr = p->p_vaddr;
2708 filehdr_paddr = p->p_paddr;
2712 if (m->includes_phdrs)
2714 if (! m->p_flags_valid)
2717 if (m->includes_filehdr)
2719 if (p->p_type == PT_LOAD)
2721 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
2722 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
2727 p->p_offset = bed->s->sizeof_ehdr;
2731 BFD_ASSERT (p->p_type == PT_LOAD);
2732 p->p_vaddr -= off - p->p_offset;
2733 if (! m->p_paddr_valid)
2734 p->p_paddr -= off - p->p_offset;
2737 if (p->p_type == PT_LOAD)
2739 phdrs_vaddr = p->p_vaddr;
2740 phdrs_paddr = p->p_paddr;
2743 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
2746 p->p_filesz += alloc * bed->s->sizeof_phdr;
2747 p->p_memsz += alloc * bed->s->sizeof_phdr;
2750 if (p->p_type == PT_LOAD
2751 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
2753 if (! m->includes_filehdr && ! m->includes_phdrs)
2759 adjust = off - (p->p_offset + p->p_filesz);
2760 p->p_filesz += adjust;
2761 p->p_memsz += adjust;
2767 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2771 bfd_size_type align;
2775 align = 1 << bfd_get_section_alignment (abfd, sec);
2777 /* The section may have artificial alignment forced by a
2778 link script. Notice this case by the gap between the
2779 cumulative phdr vma and the section's vma. */
2780 if (p->p_vaddr + p->p_memsz < sec->vma)
2782 bfd_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
2784 p->p_memsz += adjust;
2787 if ((flags & SEC_LOAD) != 0)
2788 p->p_filesz += adjust;
2791 if (p->p_type == PT_LOAD)
2793 bfd_signed_vma adjust;
2795 if ((flags & SEC_LOAD) != 0)
2797 adjust = sec->lma - (p->p_paddr + p->p_memsz);
2801 else if ((flags & SEC_ALLOC) != 0)
2803 /* The section VMA must equal the file position
2804 modulo the page size. FIXME: I'm not sure if
2805 this adjustment is really necessary. We used to
2806 not have the SEC_LOAD case just above, and then
2807 this was necessary, but now I'm not sure. */
2808 if ((abfd->flags & D_PAGED) != 0)
2809 adjust = (sec->vma - voff) % bed->maxpagesize;
2811 adjust = (sec->vma - voff) % align;
2820 (* _bfd_error_handler)
2821 (_("Error: First section in segment (%s) starts at 0x%x"),
2822 bfd_section_name (abfd, sec), sec->lma);
2823 (* _bfd_error_handler)
2824 (_(" whereas segment starts at 0x%x"),
2829 p->p_memsz += adjust;
2832 if ((flags & SEC_LOAD) != 0)
2833 p->p_filesz += adjust;
2838 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2839 used in a linker script we may have a section with
2840 SEC_LOAD clear but which is supposed to have
2842 if ((flags & SEC_LOAD) != 0
2843 || (flags & SEC_HAS_CONTENTS) != 0)
2844 off += sec->_raw_size;
2846 if ((flags & SEC_ALLOC) != 0)
2847 voff += sec->_raw_size;
2850 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
2852 if (i == 0) /* the actual "note" segment */
2853 { /* this one actually contains everything. */
2855 p->p_filesz = sec->_raw_size;
2856 off += sec->_raw_size;
2859 else /* fake sections -- don't need to be written */
2863 flags = sec->flags = 0; /* no contents */
2870 p->p_memsz += sec->_raw_size;
2872 if ((flags & SEC_LOAD) != 0)
2873 p->p_filesz += sec->_raw_size;
2875 if (align > p->p_align
2876 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
2880 if (! m->p_flags_valid)
2883 if ((flags & SEC_CODE) != 0)
2885 if ((flags & SEC_READONLY) == 0)
2891 /* Now that we have set the section file positions, we can set up
2892 the file positions for the non PT_LOAD segments. */
2893 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2897 if (p->p_type != PT_LOAD && m->count > 0)
2899 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
2900 p->p_offset = m->sections[0]->filepos;
2904 if (m->includes_filehdr)
2906 p->p_vaddr = filehdr_vaddr;
2907 if (! m->p_paddr_valid)
2908 p->p_paddr = filehdr_paddr;
2910 else if (m->includes_phdrs)
2912 p->p_vaddr = phdrs_vaddr;
2913 if (! m->p_paddr_valid)
2914 p->p_paddr = phdrs_paddr;
2919 /* Clear out any program headers we allocated but did not use. */
2920 for (; count < alloc; count++, p++)
2922 memset (p, 0, sizeof *p);
2923 p->p_type = PT_NULL;
2926 elf_tdata (abfd)->phdr = phdrs;
2928 elf_tdata (abfd)->next_file_pos = off;
2930 /* Write out the program headers. */
2931 if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
2932 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
2938 /* Get the size of the program header.
2940 If this is called by the linker before any of the section VMA's are set, it
2941 can't calculate the correct value for a strange memory layout. This only
2942 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2943 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2944 data segment (exclusive of .interp and .dynamic).
2946 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2947 will be two segments. */
2949 static bfd_size_type
2950 get_program_header_size (abfd)
2955 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2957 /* We can't return a different result each time we're called. */
2958 if (elf_tdata (abfd)->program_header_size != 0)
2959 return elf_tdata (abfd)->program_header_size;
2961 if (elf_tdata (abfd)->segment_map != NULL)
2963 struct elf_segment_map *m;
2966 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2968 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
2969 return elf_tdata (abfd)->program_header_size;
2972 /* Assume we will need exactly two PT_LOAD segments: one for text
2973 and one for data. */
2976 s = bfd_get_section_by_name (abfd, ".interp");
2977 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2979 /* If we have a loadable interpreter section, we need a
2980 PT_INTERP segment. In this case, assume we also need a
2981 PT_PHDR segment, although that may not be true for all
2986 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
2988 /* We need a PT_DYNAMIC segment. */
2992 for (s = abfd->sections; s != NULL; s = s->next)
2994 if ((s->flags & SEC_LOAD) != 0
2995 && strncmp (s->name, ".note", 5) == 0)
2997 /* We need a PT_NOTE segment. */
3002 /* Let the backend count up any program headers it might need. */
3003 if (bed->elf_backend_additional_program_headers)
3007 a = (*bed->elf_backend_additional_program_headers) (abfd);
3013 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3014 return elf_tdata (abfd)->program_header_size;
3017 /* Work out the file positions of all the sections. This is called by
3018 _bfd_elf_compute_section_file_positions. All the section sizes and
3019 VMAs must be known before this is called.
3021 We do not consider reloc sections at this point, unless they form
3022 part of the loadable image. Reloc sections are assigned file
3023 positions in assign_file_positions_for_relocs, which is called by
3024 write_object_contents and final_link.
3026 We also don't set the positions of the .symtab and .strtab here. */
3029 assign_file_positions_except_relocs (abfd)
3032 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
3033 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
3034 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
3036 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3038 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3039 && bfd_get_format (abfd) != bfd_core)
3041 Elf_Internal_Shdr **hdrpp;
3044 /* Start after the ELF header. */
3045 off = i_ehdrp->e_ehsize;
3047 /* We are not creating an executable, which means that we are
3048 not creating a program header, and that the actual order of
3049 the sections in the file is unimportant. */
3050 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3052 Elf_Internal_Shdr *hdr;
3055 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
3057 hdr->sh_offset = -1;
3060 if (i == tdata->symtab_section
3061 || i == tdata->strtab_section)
3063 hdr->sh_offset = -1;
3067 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3073 Elf_Internal_Shdr **hdrpp;
3075 /* Assign file positions for the loaded sections based on the
3076 assignment of sections to segments. */
3077 if (! assign_file_positions_for_segments (abfd))
3080 /* Assign file positions for the other sections. */
3082 off = elf_tdata (abfd)->next_file_pos;
3083 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3085 Elf_Internal_Shdr *hdr;
3088 if (hdr->bfd_section != NULL
3089 && hdr->bfd_section->filepos != 0)
3090 hdr->sh_offset = hdr->bfd_section->filepos;
3091 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3093 ((*_bfd_error_handler)
3094 (_("%s: warning: allocated section `%s' not in segment"),
3095 bfd_get_filename (abfd),
3096 (hdr->bfd_section == NULL
3098 : hdr->bfd_section->name)));
3099 if ((abfd->flags & D_PAGED) != 0)
3100 off += (hdr->sh_addr - off) % bed->maxpagesize;
3102 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3103 off = _bfd_elf_assign_file_position_for_section (hdr, off,
3106 else if (hdr->sh_type == SHT_REL
3107 || hdr->sh_type == SHT_RELA
3108 || hdr == i_shdrpp[tdata->symtab_section]
3109 || hdr == i_shdrpp[tdata->strtab_section])
3110 hdr->sh_offset = -1;
3112 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3116 /* Place the section headers. */
3117 off = align_file_position (off, bed->s->file_align);
3118 i_ehdrp->e_shoff = off;
3119 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3121 elf_tdata (abfd)->next_file_pos = off;
3130 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3131 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3132 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3134 struct bfd_strtab_hash *shstrtab;
3135 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3137 i_ehdrp = elf_elfheader (abfd);
3138 i_shdrp = elf_elfsections (abfd);
3140 shstrtab = _bfd_elf_stringtab_init ();
3141 if (shstrtab == NULL)
3144 elf_shstrtab (abfd) = shstrtab;
3146 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3147 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3148 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3149 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3151 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3152 i_ehdrp->e_ident[EI_DATA] =
3153 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3154 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3156 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_SYSV;
3157 i_ehdrp->e_ident[EI_ABIVERSION] = 0;
3159 for (count = EI_PAD; count < EI_NIDENT; count++)
3160 i_ehdrp->e_ident[count] = 0;
3162 if ((abfd->flags & DYNAMIC) != 0)
3163 i_ehdrp->e_type = ET_DYN;
3164 else if ((abfd->flags & EXEC_P) != 0)
3165 i_ehdrp->e_type = ET_EXEC;
3166 else if (bfd_get_format (abfd) == bfd_core)
3167 i_ehdrp->e_type = ET_CORE;
3169 i_ehdrp->e_type = ET_REL;
3171 switch (bfd_get_arch (abfd))
3173 case bfd_arch_unknown:
3174 i_ehdrp->e_machine = EM_NONE;
3176 case bfd_arch_sparc:
3177 if (bed->s->arch_size == 64)
3178 i_ehdrp->e_machine = EM_SPARCV9;
3180 i_ehdrp->e_machine = EM_SPARC;
3183 i_ehdrp->e_machine = EM_386;
3186 i_ehdrp->e_machine = EM_68K;
3189 i_ehdrp->e_machine = EM_88K;
3192 i_ehdrp->e_machine = EM_860;
3195 i_ehdrp->e_machine = EM_960;
3197 case bfd_arch_mips: /* MIPS Rxxxx */
3198 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
3201 i_ehdrp->e_machine = EM_PARISC;
3203 case bfd_arch_powerpc:
3204 i_ehdrp->e_machine = EM_PPC;
3206 case bfd_arch_alpha:
3207 i_ehdrp->e_machine = EM_ALPHA;
3210 i_ehdrp->e_machine = EM_SH;
3213 i_ehdrp->e_machine = EM_CYGNUS_D10V;
3216 i_ehdrp->e_machine = EM_CYGNUS_D30V;
3219 i_ehdrp->e_machine = EM_CYGNUS_FR30;
3221 case bfd_arch_mcore:
3222 i_ehdrp->e_machine = EM_MCORE;
3225 switch (bfd_get_mach (abfd))
3228 case 0: i_ehdrp->e_machine = EM_CYGNUS_V850; break;
3232 i_ehdrp->e_machine = EM_CYGNUS_ARC;
3235 i_ehdrp->e_machine = EM_ARM;
3238 i_ehdrp->e_machine = EM_CYGNUS_M32R;
3240 case bfd_arch_mn10200:
3241 i_ehdrp->e_machine = EM_CYGNUS_MN10200;
3243 case bfd_arch_mn10300:
3244 i_ehdrp->e_machine = EM_CYGNUS_MN10300;
3247 i_ehdrp->e_machine = EM_PJ;
3249 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3251 i_ehdrp->e_machine = EM_NONE;
3253 i_ehdrp->e_version = bed->s->ev_current;
3254 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3256 /* no program header, for now. */
3257 i_ehdrp->e_phoff = 0;
3258 i_ehdrp->e_phentsize = 0;
3259 i_ehdrp->e_phnum = 0;
3261 /* each bfd section is section header entry */
3262 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3263 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3265 /* if we're building an executable, we'll need a program header table */
3266 if (abfd->flags & EXEC_P)
3268 /* it all happens later */
3270 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3272 /* elf_build_phdrs() returns a (NULL-terminated) array of
3273 Elf_Internal_Phdrs */
3274 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3275 i_ehdrp->e_phoff = outbase;
3276 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3281 i_ehdrp->e_phentsize = 0;
3283 i_ehdrp->e_phoff = 0;
3286 elf_tdata (abfd)->symtab_hdr.sh_name =
3287 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
3288 elf_tdata (abfd)->strtab_hdr.sh_name =
3289 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
3290 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3291 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
3292 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3293 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3294 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3300 /* Assign file positions for all the reloc sections which are not part
3301 of the loadable file image. */
3304 _bfd_elf_assign_file_positions_for_relocs (abfd)
3309 Elf_Internal_Shdr **shdrpp;
3311 off = elf_tdata (abfd)->next_file_pos;
3313 for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
3314 i < elf_elfheader (abfd)->e_shnum;
3317 Elf_Internal_Shdr *shdrp;
3320 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3321 && shdrp->sh_offset == -1)
3322 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3325 elf_tdata (abfd)->next_file_pos = off;
3329 _bfd_elf_write_object_contents (abfd)
3332 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3333 Elf_Internal_Ehdr *i_ehdrp;
3334 Elf_Internal_Shdr **i_shdrp;
3338 if (! abfd->output_has_begun
3339 && ! _bfd_elf_compute_section_file_positions
3340 (abfd, (struct bfd_link_info *) NULL))
3343 i_shdrp = elf_elfsections (abfd);
3344 i_ehdrp = elf_elfheader (abfd);
3347 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3351 _bfd_elf_assign_file_positions_for_relocs (abfd);
3353 /* After writing the headers, we need to write the sections too... */
3354 for (count = 1; count < i_ehdrp->e_shnum; count++)
3356 if (bed->elf_backend_section_processing)
3357 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3358 if (i_shdrp[count]->contents)
3360 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3361 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
3363 != i_shdrp[count]->sh_size))
3368 /* Write out the section header names. */
3369 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
3370 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
3373 if (bed->elf_backend_final_write_processing)
3374 (*bed->elf_backend_final_write_processing) (abfd,
3375 elf_tdata (abfd)->linker);
3377 return bed->s->write_shdrs_and_ehdr (abfd);
3381 _bfd_elf_write_corefile_contents (abfd)
3384 /* Hopefully this can be done just like an object file. */
3385 return _bfd_elf_write_object_contents (abfd);
3387 /* given a section, search the header to find them... */
3389 _bfd_elf_section_from_bfd_section (abfd, asect)
3393 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3394 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
3396 Elf_Internal_Shdr *hdr;
3397 int maxindex = elf_elfheader (abfd)->e_shnum;
3399 for (index = 0; index < maxindex; index++)
3401 hdr = i_shdrp[index];
3402 if (hdr->bfd_section == asect)
3406 if (bed->elf_backend_section_from_bfd_section)
3408 for (index = 0; index < maxindex; index++)
3412 hdr = i_shdrp[index];
3414 if ((*bed->elf_backend_section_from_bfd_section)
3415 (abfd, hdr, asect, &retval))
3420 if (bfd_is_abs_section (asect))
3422 if (bfd_is_com_section (asect))
3424 if (bfd_is_und_section (asect))
3427 bfd_set_error (bfd_error_nonrepresentable_section);
3432 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3436 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
3438 asymbol **asym_ptr_ptr;
3440 asymbol *asym_ptr = *asym_ptr_ptr;
3442 flagword flags = asym_ptr->flags;
3444 /* When gas creates relocations against local labels, it creates its
3445 own symbol for the section, but does put the symbol into the
3446 symbol chain, so udata is 0. When the linker is generating
3447 relocatable output, this section symbol may be for one of the
3448 input sections rather than the output section. */
3449 if (asym_ptr->udata.i == 0
3450 && (flags & BSF_SECTION_SYM)
3451 && asym_ptr->section)
3455 if (asym_ptr->section->output_section != NULL)
3456 indx = asym_ptr->section->output_section->index;
3458 indx = asym_ptr->section->index;
3459 if (elf_section_syms (abfd)[indx])
3460 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
3463 idx = asym_ptr->udata.i;
3467 /* This case can occur when using --strip-symbol on a symbol
3468 which is used in a relocation entry. */
3469 (*_bfd_error_handler)
3470 (_("%s: symbol `%s' required but not present"),
3471 bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
3472 bfd_set_error (bfd_error_no_symbols);
3479 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3480 (long) asym_ptr, asym_ptr->name, idx, flags,
3481 elf_symbol_flags (flags));
3489 /* Copy private BFD data. This copies any program header information. */
3492 copy_private_bfd_data (ibfd, obfd)
3496 Elf_Internal_Ehdr *iehdr;
3497 struct elf_segment_map *mfirst;
3498 struct elf_segment_map **pm;
3499 struct elf_segment_map *m;
3500 Elf_Internal_Phdr *p;
3502 unsigned int num_segments;
3503 boolean phdr_included = false;
3505 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3506 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3509 if (elf_tdata (ibfd)->phdr == NULL)
3512 iehdr = elf_elfheader (ibfd);
3517 num_segments = elf_elfheader (ibfd)->e_phnum;
3519 #define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3520 ((addr) >= (bottom) \
3521 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3522 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3524 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3526 #define IS_COREFILE_NOTE(p, s) \
3527 (p->p_type == PT_NOTE \
3528 && bfd_get_format (ibfd) == bfd_core \
3529 && s->vma == 0 && s->lma == 0 \
3530 && (bfd_vma) s->filepos >= p->p_offset \
3531 && (bfd_vma) s->filepos + s->_raw_size \
3532 <= p->p_offset + p->p_filesz)
3534 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3535 linker, which generates a PT_INTERP section with p_vaddr and
3536 p_memsz set to 0. */
3538 #define IS_SOLARIS_PT_INTERP(p, s) \
3540 && p->p_filesz > 0 \
3541 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3542 && s->_raw_size > 0 \
3543 && (bfd_vma) s->filepos >= p->p_offset \
3544 && ((bfd_vma) s->filepos + s->_raw_size \
3545 <= p->p_offset + p->p_filesz))
3547 /* Scan through the segments specified in the program header
3548 of the input BFD. */
3549 for (i = 0, p = elf_tdata (ibfd)->phdr; i < num_segments; i++, p++)
3553 asection **sections;
3556 bfd_vma matching_lma;
3557 bfd_vma suggested_lma;
3560 /* For each section in the input BFD, decide if it should be
3561 included in the current segment. A section will be included
3562 if it is within the address space of the segment, and it is
3563 an allocated segment, and there is an output section
3564 associated with it. */
3566 for (s = ibfd->sections; s != NULL; s = s->next)
3567 if (s->output_section != NULL)
3569 if ((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3570 || IS_SOLARIS_PT_INTERP (p, s))
3571 && (s->flags & SEC_ALLOC) != 0)
3573 else if (IS_COREFILE_NOTE (p, s))
3577 /* Allocate a segment map big enough to contain all of the
3578 sections we have selected. */
3579 m = ((struct elf_segment_map *)
3581 (sizeof (struct elf_segment_map)
3582 + ((size_t) csecs - 1) * sizeof (asection *))));
3586 /* Initialise the fields of the segment map. Default to
3587 using the physical address of the segment in the input BFD. */
3589 m->p_type = p->p_type;
3590 m->p_flags = p->p_flags;
3591 m->p_flags_valid = 1;
3592 m->p_paddr = p->p_paddr;
3593 m->p_paddr_valid = 1;
3595 /* Determine if this segment contains the ELF file header
3596 and if it contains the program headers themselves. */
3597 m->includes_filehdr = (p->p_offset == 0
3598 && p->p_filesz >= iehdr->e_ehsize);
3600 m->includes_phdrs = 0;
3602 if (! phdr_included || p->p_type != PT_LOAD)
3605 (p->p_offset <= (bfd_vma) iehdr->e_phoff
3606 && (p->p_offset + p->p_filesz
3607 >= ((bfd_vma) iehdr->e_phoff
3608 + iehdr->e_phnum * iehdr->e_phentsize)));
3609 if (p->p_type == PT_LOAD && m->includes_phdrs)
3610 phdr_included = true;
3615 /* Special segments, such as the PT_PHDR segment, may contain
3616 no sections, but ordinary, loadable segments should contain
3619 if (p->p_type == PT_LOAD)
3621 (_("%s: warning: Empty loadable segment detected\n"),
3622 bfd_get_filename (ibfd));
3631 /* Now scan the sections in the input BFD again and attempt
3632 to add their corresponding output sections to the segment map.
3633 The problem here is how to handle an output section which has
3634 been moved (ie had its LMA changed). There are four possibilities:
3636 1. None of the sections have been moved.
3637 In this case we can continue to use the segment LMA from the
3640 2. All of the sections have been moved by the same amount.
3641 In this case we can change the segment's LMA to match the LMA
3642 of the first section.
3644 3. Some of the sections have been moved, others have not.
3645 In this case those sections which have not been moved can be
3646 placed in the current segment which will have to have its size,
3647 and possibly its LMA changed, and a new segment or segments will
3648 have to be created to contain the other sections.
3650 4. The sections have been moved, but not be the same amount.
3651 In this case we can change the segment's LMA to match the LMA
3652 of the first section and we will have to create a new segment
3653 or segments to contain the other sections.
3655 In order to save time, we allocate an array to hold the section
3656 pointers that we are interested in. As these sections get assigned
3657 to a segment, they are removed from this array. */
3659 sections = (asection **) bfd_malloc (sizeof (asection *) * csecs);
3660 if (sections == NULL)
3663 /* Step One: Scan for segment vs section LMA conflicts.
3664 Also add the sections to the section array allocated above.
3665 Also add the sections to the current segment. In the common
3666 case, where the sections have not been moved, this means that
3667 we have completely filled the segment, and there is nothing
3671 matching_lma = false;
3674 for (j = 0, s = ibfd->sections; s != NULL; s = s->next)
3676 os = s->output_section;
3678 if ((((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3679 || IS_SOLARIS_PT_INTERP (p, s))
3680 && (s->flags & SEC_ALLOC) != 0)
3681 || IS_COREFILE_NOTE (p, s))
3686 /* The Solaris native linker always sets p_paddr to 0.
3687 We try to catch that case here, and set it to the
3693 && (os->vma == (p->p_vaddr
3694 + (m->includes_filehdr
3697 + (m->includes_phdrs
3698 ? iehdr->e_phnum * iehdr->e_phentsize
3700 m->p_paddr = p->p_vaddr;
3702 /* Match up the physical address of the segment with the
3703 LMA address of the output section. */
3704 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3705 || IS_COREFILE_NOTE (p, s))
3707 if (matching_lma == 0)
3708 matching_lma = os->lma;
3710 /* We assume that if the section fits within the segment
3711 that it does not overlap any other section within that
3713 m->sections[isec++] = os;
3715 else if (suggested_lma == 0)
3716 suggested_lma = os->lma;
3720 BFD_ASSERT (j == csecs);
3722 /* Step Two: Adjust the physical address of the current segment,
3726 /* All of the sections fitted within the segment as currently
3727 specified. This is the default case. Add the segment to
3728 the list of built segments and carry on to process the next
3729 program header in the input BFD. */
3737 else if (matching_lma != 0)
3739 /* At least one section fits inside the current segment.
3740 Keep it, but modify its physical address to match the
3741 LMA of the first section that fitted. */
3743 m->p_paddr = matching_lma;
3747 /* None of the sections fitted inside the current segment.
3748 Change the current segment's physical address to match
3749 the LMA of the first section. */
3751 m->p_paddr = suggested_lma;
3754 /* Step Three: Loop over the sections again, this time assigning
3755 those that fit to the current segment and remvoing them from the
3756 sections array; but making sure not to leave large gaps. Once all
3757 possible sections have been assigned to the current segment it is
3758 added to the list of built segments and if sections still remain
3759 to be assigned, a new segment is constructed before repeating
3767 /* Fill the current segment with sections that fit. */
3768 for (j = 0; j < csecs; j++)
3775 os = s->output_section;
3777 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3778 || IS_COREFILE_NOTE (p, s))
3782 /* If the first section in a segment does not start at
3783 the beginning of the segment, then something is wrong. */
3784 if (os->lma != m->p_paddr)
3789 asection * prev_sec;
3790 bfd_vma maxpagesize;
3792 prev_sec = m->sections[m->count - 1];
3793 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
3795 /* If the gap between the end of the previous section
3796 and the start of this section is more than maxpagesize
3797 then we need to start a new segment. */
3798 if (BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
3799 < BFD_ALIGN (os->lma, maxpagesize))
3801 if (suggested_lma == 0)
3802 suggested_lma = os->lma;
3808 m->sections[m->count++] = os;
3812 else if (suggested_lma == 0)
3813 suggested_lma = os->lma;
3816 BFD_ASSERT (m->count > 0);
3818 /* Add the current segment to the list of built segments. */
3824 /* We still have not allocated all of the sections to
3825 segments. Create a new segment here, initialise it
3826 and carry on looping. */
3828 m = ((struct elf_segment_map *)
3830 (sizeof (struct elf_segment_map)
3831 + ((size_t) csecs - 1) * sizeof (asection *))));
3835 /* Initialise the fields of the segment map. Set the physical
3836 physical address to the LMA of the first section that has
3837 not yet been assigned. */
3840 m->p_type = p->p_type;
3841 m->p_flags = p->p_flags;
3842 m->p_flags_valid = 1;
3843 m->p_paddr = suggested_lma;
3844 m->p_paddr_valid = 1;
3845 m->includes_filehdr = 0;
3846 m->includes_phdrs = 0;
3849 while (isec < csecs);
3854 /* The Solaris linker creates program headers in which all the
3855 p_paddr fields are zero. When we try to objcopy or strip such a
3856 file, we get confused. Check for this case, and if we find it
3857 reset the p_paddr_valid fields. */
3858 for (m = mfirst; m != NULL; m = m->next)
3859 if (m->p_paddr != 0)
3863 for (m = mfirst; m != NULL; m = m->next)
3864 m->p_paddr_valid = 0;
3867 elf_tdata (obfd)->segment_map = mfirst;
3870 /* Final Step: Sort the segments into ascending order of physical address. */
3873 struct elf_segment_map* prev;
3876 for (m = mfirst->next; m != NULL; prev = m, m = m->next)
3878 /* Yes I know - its a bubble sort....*/
3879 if (m->next != NULL && (m->next->p_paddr < m->p_paddr))
3881 /* swap m and m->next */
3882 prev->next = m->next;
3883 m->next = m->next->next;
3884 prev->next->next = m;
3893 #undef IS_CONTAINED_BY
3894 #undef IS_SOLARIS_PT_INTERP
3895 #undef IS_COREFILE_NOTE
3899 /* Copy private section information. This copies over the entsize
3900 field, and sometimes the info field. */
3903 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
3909 Elf_Internal_Shdr *ihdr, *ohdr;
3911 if (ibfd->xvec->flavour != bfd_target_elf_flavour
3912 || obfd->xvec->flavour != bfd_target_elf_flavour)
3915 /* Copy over private BFD data if it has not already been copied.
3916 This must be done here, rather than in the copy_private_bfd_data
3917 entry point, because the latter is called after the section
3918 contents have been set, which means that the program headers have
3919 already been worked out. */
3920 if (elf_tdata (obfd)->segment_map == NULL
3921 && elf_tdata (ibfd)->phdr != NULL)
3925 /* Only set up the segments if there are no more SEC_ALLOC
3926 sections. FIXME: This won't do the right thing if objcopy is
3927 used to remove the last SEC_ALLOC section, since objcopy
3928 won't call this routine in that case. */
3929 for (s = isec->next; s != NULL; s = s->next)
3930 if ((s->flags & SEC_ALLOC) != 0)
3934 if (! copy_private_bfd_data (ibfd, obfd))
3939 ihdr = &elf_section_data (isec)->this_hdr;
3940 ohdr = &elf_section_data (osec)->this_hdr;
3942 ohdr->sh_entsize = ihdr->sh_entsize;
3944 if (ihdr->sh_type == SHT_SYMTAB
3945 || ihdr->sh_type == SHT_DYNSYM
3946 || ihdr->sh_type == SHT_GNU_verneed
3947 || ihdr->sh_type == SHT_GNU_verdef)
3948 ohdr->sh_info = ihdr->sh_info;
3950 elf_section_data (osec)->use_rela_p
3951 = elf_section_data (isec)->use_rela_p;
3956 /* Copy private symbol information. If this symbol is in a section
3957 which we did not map into a BFD section, try to map the section
3958 index correctly. We use special macro definitions for the mapped
3959 section indices; these definitions are interpreted by the
3960 swap_out_syms function. */
3962 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3963 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3964 #define MAP_STRTAB (SHN_LORESERVE - 3)
3965 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3968 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
3974 elf_symbol_type *isym, *osym;
3976 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3977 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3980 isym = elf_symbol_from (ibfd, isymarg);
3981 osym = elf_symbol_from (obfd, osymarg);
3985 && bfd_is_abs_section (isym->symbol.section))
3989 shndx = isym->internal_elf_sym.st_shndx;
3990 if (shndx == elf_onesymtab (ibfd))
3991 shndx = MAP_ONESYMTAB;
3992 else if (shndx == elf_dynsymtab (ibfd))
3993 shndx = MAP_DYNSYMTAB;
3994 else if (shndx == elf_tdata (ibfd)->strtab_section)
3996 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
3997 shndx = MAP_SHSTRTAB;
3998 osym->internal_elf_sym.st_shndx = shndx;
4004 /* Swap out the symbols. */
4007 swap_out_syms (abfd, sttp, relocatable_p)
4009 struct bfd_strtab_hash **sttp;
4012 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4014 if (!elf_map_symbols (abfd))
4017 /* Dump out the symtabs. */
4019 int symcount = bfd_get_symcount (abfd);
4020 asymbol **syms = bfd_get_outsymbols (abfd);
4021 struct bfd_strtab_hash *stt;
4022 Elf_Internal_Shdr *symtab_hdr;
4023 Elf_Internal_Shdr *symstrtab_hdr;
4024 char *outbound_syms;
4027 stt = _bfd_elf_stringtab_init ();
4031 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4032 symtab_hdr->sh_type = SHT_SYMTAB;
4033 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
4034 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
4035 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
4036 symtab_hdr->sh_addralign = bed->s->file_align;
4038 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4039 symstrtab_hdr->sh_type = SHT_STRTAB;
4041 outbound_syms = bfd_alloc (abfd,
4042 (1 + symcount) * bed->s->sizeof_sym);
4043 if (outbound_syms == NULL)
4045 symtab_hdr->contents = (PTR) outbound_syms;
4047 /* now generate the data (for "contents") */
4049 /* Fill in zeroth symbol and swap it out. */
4050 Elf_Internal_Sym sym;
4056 sym.st_shndx = SHN_UNDEF;
4057 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4058 outbound_syms += bed->s->sizeof_sym;
4060 for (idx = 0; idx < symcount; idx++)
4062 Elf_Internal_Sym sym;
4063 bfd_vma value = syms[idx]->value;
4064 elf_symbol_type *type_ptr;
4065 flagword flags = syms[idx]->flags;
4068 if (flags & BSF_SECTION_SYM)
4069 /* Section symbols have no names. */
4073 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4076 if (sym.st_name == (unsigned long) -1)
4080 type_ptr = elf_symbol_from (abfd, syms[idx]);
4082 if ((flags & BSF_SECTION_SYM) == 0
4083 && bfd_is_com_section (syms[idx]->section))
4085 /* ELF common symbols put the alignment into the `value' field,
4086 and the size into the `size' field. This is backwards from
4087 how BFD handles it, so reverse it here. */
4088 sym.st_size = value;
4089 if (type_ptr == NULL
4090 || type_ptr->internal_elf_sym.st_value == 0)
4091 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4093 sym.st_value = type_ptr->internal_elf_sym.st_value;
4094 sym.st_shndx = _bfd_elf_section_from_bfd_section
4095 (abfd, syms[idx]->section);
4099 asection *sec = syms[idx]->section;
4102 if (sec->output_section)
4104 value += sec->output_offset;
4105 sec = sec->output_section;
4107 /* Don't add in the section vma for relocatable output. */
4108 if (! relocatable_p)
4110 sym.st_value = value;
4111 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4113 if (bfd_is_abs_section (sec)
4115 && type_ptr->internal_elf_sym.st_shndx != 0)
4117 /* This symbol is in a real ELF section which we did
4118 not create as a BFD section. Undo the mapping done
4119 by copy_private_symbol_data. */
4120 shndx = type_ptr->internal_elf_sym.st_shndx;
4124 shndx = elf_onesymtab (abfd);
4127 shndx = elf_dynsymtab (abfd);
4130 shndx = elf_tdata (abfd)->strtab_section;
4133 shndx = elf_tdata (abfd)->shstrtab_section;
4141 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4147 /* Writing this would be a hell of a lot easier if
4148 we had some decent documentation on bfd, and
4149 knew what to expect of the library, and what to
4150 demand of applications. For example, it
4151 appears that `objcopy' might not set the
4152 section of a symbol to be a section that is
4153 actually in the output file. */
4154 sec2 = bfd_get_section_by_name (abfd, sec->name);
4155 BFD_ASSERT (sec2 != 0);
4156 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4157 BFD_ASSERT (shndx != -1);
4161 sym.st_shndx = shndx;
4164 if ((flags & BSF_FUNCTION) != 0)
4166 else if ((flags & BSF_OBJECT) != 0)
4171 /* Processor-specific types */
4172 if (bed->elf_backend_get_symbol_type)
4173 type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
4175 if (flags & BSF_SECTION_SYM)
4176 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4177 else if (bfd_is_com_section (syms[idx]->section))
4178 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
4179 else if (bfd_is_und_section (syms[idx]->section))
4180 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
4184 else if (flags & BSF_FILE)
4185 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4188 int bind = STB_LOCAL;
4190 if (flags & BSF_LOCAL)
4192 else if (flags & BSF_WEAK)
4194 else if (flags & BSF_GLOBAL)
4197 sym.st_info = ELF_ST_INFO (bind, type);
4200 if (type_ptr != NULL)
4201 sym.st_other = type_ptr->internal_elf_sym.st_other;
4205 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4206 outbound_syms += bed->s->sizeof_sym;
4210 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
4211 symstrtab_hdr->sh_type = SHT_STRTAB;
4213 symstrtab_hdr->sh_flags = 0;
4214 symstrtab_hdr->sh_addr = 0;
4215 symstrtab_hdr->sh_entsize = 0;
4216 symstrtab_hdr->sh_link = 0;
4217 symstrtab_hdr->sh_info = 0;
4218 symstrtab_hdr->sh_addralign = 1;
4224 /* Return the number of bytes required to hold the symtab vector.
4226 Note that we base it on the count plus 1, since we will null terminate
4227 the vector allocated based on this size. However, the ELF symbol table
4228 always has a dummy entry as symbol #0, so it ends up even. */
4231 _bfd_elf_get_symtab_upper_bound (abfd)
4236 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
4238 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4239 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4245 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
4250 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4252 if (elf_dynsymtab (abfd) == 0)
4254 bfd_set_error (bfd_error_invalid_operation);
4258 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4259 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4265 _bfd_elf_get_reloc_upper_bound (abfd, asect)
4266 bfd *abfd ATTRIBUTE_UNUSED;
4269 return (asect->reloc_count + 1) * sizeof (arelent *);
4272 /* Canonicalize the relocs. */
4275 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
4284 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd,
4290 tblptr = section->relocation;
4291 for (i = 0; i < section->reloc_count; i++)
4292 *relptr++ = tblptr++;
4296 return section->reloc_count;
4300 _bfd_elf_get_symtab (abfd, alocation)
4302 asymbol **alocation;
4304 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table
4305 (abfd, alocation, false);
4308 bfd_get_symcount (abfd) = symcount;
4313 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
4315 asymbol **alocation;
4317 return get_elf_backend_data (abfd)->s->slurp_symbol_table
4318 (abfd, alocation, true);
4321 /* Return the size required for the dynamic reloc entries. Any
4322 section that was actually installed in the BFD, and has type
4323 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4324 considered to be a dynamic reloc section. */
4327 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
4333 if (elf_dynsymtab (abfd) == 0)
4335 bfd_set_error (bfd_error_invalid_operation);
4339 ret = sizeof (arelent *);
4340 for (s = abfd->sections; s != NULL; s = s->next)
4341 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4342 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4343 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4344 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
4345 * sizeof (arelent *));
4350 /* Canonicalize the dynamic relocation entries. Note that we return
4351 the dynamic relocations as a single block, although they are
4352 actually associated with particular sections; the interface, which
4353 was designed for SunOS style shared libraries, expects that there
4354 is only one set of dynamic relocs. Any section that was actually
4355 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4356 the dynamic symbol table, is considered to be a dynamic reloc
4360 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
4365 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
4369 if (elf_dynsymtab (abfd) == 0)
4371 bfd_set_error (bfd_error_invalid_operation);
4375 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
4377 for (s = abfd->sections; s != NULL; s = s->next)
4379 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4380 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4381 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4386 if (! (*slurp_relocs) (abfd, s, syms, true))
4388 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
4390 for (i = 0; i < count; i++)
4401 /* Read in the version information. */
4404 _bfd_elf_slurp_version_tables (abfd)
4407 bfd_byte *contents = NULL;
4409 if (elf_dynverdef (abfd) != 0)
4411 Elf_Internal_Shdr *hdr;
4412 Elf_External_Verdef *everdef;
4413 Elf_Internal_Verdef *iverdef;
4416 hdr = &elf_tdata (abfd)->dynverdef_hdr;
4418 elf_tdata (abfd)->verdef =
4419 ((Elf_Internal_Verdef *)
4420 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verdef)));
4421 if (elf_tdata (abfd)->verdef == NULL)
4424 elf_tdata (abfd)->cverdefs = hdr->sh_info;
4426 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4427 if (contents == NULL)
4429 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4430 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4433 everdef = (Elf_External_Verdef *) contents;
4434 iverdef = elf_tdata (abfd)->verdef;
4435 for (i = 0; i < hdr->sh_info; i++, iverdef++)
4437 Elf_External_Verdaux *everdaux;
4438 Elf_Internal_Verdaux *iverdaux;
4441 _bfd_elf_swap_verdef_in (abfd, everdef, iverdef);
4443 iverdef->vd_bfd = abfd;
4445 iverdef->vd_auxptr = ((Elf_Internal_Verdaux *)
4448 * sizeof (Elf_Internal_Verdaux))));
4449 if (iverdef->vd_auxptr == NULL)
4452 everdaux = ((Elf_External_Verdaux *)
4453 ((bfd_byte *) everdef + iverdef->vd_aux));
4454 iverdaux = iverdef->vd_auxptr;
4455 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
4457 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
4459 iverdaux->vda_nodename =
4460 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4461 iverdaux->vda_name);
4462 if (iverdaux->vda_nodename == NULL)
4465 if (j + 1 < iverdef->vd_cnt)
4466 iverdaux->vda_nextptr = iverdaux + 1;
4468 iverdaux->vda_nextptr = NULL;
4470 everdaux = ((Elf_External_Verdaux *)
4471 ((bfd_byte *) everdaux + iverdaux->vda_next));
4474 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
4476 if (i + 1 < hdr->sh_info)
4477 iverdef->vd_nextdef = iverdef + 1;
4479 iverdef->vd_nextdef = NULL;
4481 everdef = ((Elf_External_Verdef *)
4482 ((bfd_byte *) everdef + iverdef->vd_next));
4489 if (elf_dynverref (abfd) != 0)
4491 Elf_Internal_Shdr *hdr;
4492 Elf_External_Verneed *everneed;
4493 Elf_Internal_Verneed *iverneed;
4496 hdr = &elf_tdata (abfd)->dynverref_hdr;
4498 elf_tdata (abfd)->verref =
4499 ((Elf_Internal_Verneed *)
4500 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed)));
4501 if (elf_tdata (abfd)->verref == NULL)
4504 elf_tdata (abfd)->cverrefs = hdr->sh_info;
4506 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4507 if (contents == NULL)
4509 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4510 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4513 everneed = (Elf_External_Verneed *) contents;
4514 iverneed = elf_tdata (abfd)->verref;
4515 for (i = 0; i < hdr->sh_info; i++, iverneed++)
4517 Elf_External_Vernaux *evernaux;
4518 Elf_Internal_Vernaux *ivernaux;
4521 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
4523 iverneed->vn_bfd = abfd;
4525 iverneed->vn_filename =
4526 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4528 if (iverneed->vn_filename == NULL)
4531 iverneed->vn_auxptr =
4532 ((Elf_Internal_Vernaux *)
4534 iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux)));
4536 evernaux = ((Elf_External_Vernaux *)
4537 ((bfd_byte *) everneed + iverneed->vn_aux));
4538 ivernaux = iverneed->vn_auxptr;
4539 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
4541 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
4543 ivernaux->vna_nodename =
4544 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4545 ivernaux->vna_name);
4546 if (ivernaux->vna_nodename == NULL)
4549 if (j + 1 < iverneed->vn_cnt)
4550 ivernaux->vna_nextptr = ivernaux + 1;
4552 ivernaux->vna_nextptr = NULL;
4554 evernaux = ((Elf_External_Vernaux *)
4555 ((bfd_byte *) evernaux + ivernaux->vna_next));
4558 if (i + 1 < hdr->sh_info)
4559 iverneed->vn_nextref = iverneed + 1;
4561 iverneed->vn_nextref = NULL;
4563 everneed = ((Elf_External_Verneed *)
4564 ((bfd_byte *) everneed + iverneed->vn_next));
4574 if (contents == NULL)
4580 _bfd_elf_make_empty_symbol (abfd)
4583 elf_symbol_type *newsym;
4585 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
4590 newsym->symbol.the_bfd = abfd;
4591 return &newsym->symbol;
4596 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
4597 bfd *ignore_abfd ATTRIBUTE_UNUSED;
4601 bfd_symbol_info (symbol, ret);
4604 /* Return whether a symbol name implies a local symbol. Most targets
4605 use this function for the is_local_label_name entry point, but some
4609 _bfd_elf_is_local_label_name (abfd, name)
4610 bfd *abfd ATTRIBUTE_UNUSED;
4613 /* Normal local symbols start with ``.L''. */
4614 if (name[0] == '.' && name[1] == 'L')
4617 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4618 DWARF debugging symbols starting with ``..''. */
4619 if (name[0] == '.' && name[1] == '.')
4622 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4623 emitting DWARF debugging output. I suspect this is actually a
4624 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4625 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4626 underscore to be emitted on some ELF targets). For ease of use,
4627 we treat such symbols as local. */
4628 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
4635 _bfd_elf_get_lineno (ignore_abfd, symbol)
4636 bfd *ignore_abfd ATTRIBUTE_UNUSED;
4637 asymbol *symbol ATTRIBUTE_UNUSED;
4644 _bfd_elf_set_arch_mach (abfd, arch, machine)
4646 enum bfd_architecture arch;
4647 unsigned long machine;
4649 /* If this isn't the right architecture for this backend, and this
4650 isn't the generic backend, fail. */
4651 if (arch != get_elf_backend_data (abfd)->arch
4652 && arch != bfd_arch_unknown
4653 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
4656 return bfd_default_set_arch_mach (abfd, arch, machine);
4659 /* Find the nearest line to a particular section and offset, for error
4663 _bfd_elf_find_nearest_line (abfd,
4674 CONST char **filename_ptr;
4675 CONST char **functionname_ptr;
4676 unsigned int *line_ptr;
4679 const char *filename;
4684 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4685 filename_ptr, functionname_ptr,
4689 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4690 filename_ptr, functionname_ptr,
4694 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4695 &found, filename_ptr,
4696 functionname_ptr, line_ptr,
4697 &elf_tdata (abfd)->line_info))
4702 if (symbols == NULL)
4709 for (p = symbols; *p != NULL; p++)
4713 q = (elf_symbol_type *) *p;
4715 if (bfd_get_section (&q->symbol) != section)
4718 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4723 filename = bfd_asymbol_name (&q->symbol);
4727 if (q->symbol.section == section
4728 && q->symbol.value >= low_func
4729 && q->symbol.value <= offset)
4731 func = (asymbol *) q;
4732 low_func = q->symbol.value;
4741 *filename_ptr = filename;
4742 *functionname_ptr = bfd_asymbol_name (func);
4748 _bfd_elf_sizeof_headers (abfd, reloc)
4754 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
4756 ret += get_program_header_size (abfd);
4761 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
4766 bfd_size_type count;
4768 Elf_Internal_Shdr *hdr;
4770 if (! abfd->output_has_begun
4771 && ! _bfd_elf_compute_section_file_positions
4772 (abfd, (struct bfd_link_info *) NULL))
4775 hdr = &elf_section_data (section)->this_hdr;
4777 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
4779 if (bfd_write (location, 1, count, abfd) != count)
4786 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
4787 bfd *abfd ATTRIBUTE_UNUSED;
4788 arelent *cache_ptr ATTRIBUTE_UNUSED;
4789 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
4796 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
4799 Elf_Internal_Rel *dst;
4805 /* Try to convert a non-ELF reloc into an ELF one. */
4808 _bfd_elf_validate_reloc (abfd, areloc)
4812 /* Check whether we really have an ELF howto. */
4814 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
4816 bfd_reloc_code_real_type code;
4817 reloc_howto_type *howto;
4819 /* Alien reloc: Try to determine its type to replace it with an
4820 equivalent ELF reloc. */
4822 if (areloc->howto->pc_relative)
4824 switch (areloc->howto->bitsize)
4827 code = BFD_RELOC_8_PCREL;
4830 code = BFD_RELOC_12_PCREL;
4833 code = BFD_RELOC_16_PCREL;
4836 code = BFD_RELOC_24_PCREL;
4839 code = BFD_RELOC_32_PCREL;
4842 code = BFD_RELOC_64_PCREL;
4848 howto = bfd_reloc_type_lookup (abfd, code);
4850 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
4852 if (howto->pcrel_offset)
4853 areloc->addend += areloc->address;
4855 areloc->addend -= areloc->address; /* addend is unsigned!! */
4860 switch (areloc->howto->bitsize)
4866 code = BFD_RELOC_14;
4869 code = BFD_RELOC_16;
4872 code = BFD_RELOC_26;
4875 code = BFD_RELOC_32;
4878 code = BFD_RELOC_64;
4884 howto = bfd_reloc_type_lookup (abfd, code);
4888 areloc->howto = howto;
4896 (*_bfd_error_handler)
4897 (_("%s: unsupported relocation type %s"),
4898 bfd_get_filename (abfd), areloc->howto->name);
4899 bfd_set_error (bfd_error_bad_value);
4904 _bfd_elf_close_and_cleanup (abfd)
4907 if (bfd_get_format (abfd) == bfd_object)
4909 if (elf_shstrtab (abfd) != NULL)
4910 _bfd_stringtab_free (elf_shstrtab (abfd));
4913 return _bfd_generic_close_and_cleanup (abfd);
4916 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
4917 in the relocation's offset. Thus we cannot allow any sort of sanity
4918 range-checking to interfere. There is nothing else to do in processing
4921 bfd_reloc_status_type
4922 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
4923 bfd *abfd ATTRIBUTE_UNUSED;
4924 arelent *re ATTRIBUTE_UNUSED;
4925 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
4926 PTR data ATTRIBUTE_UNUSED;
4927 asection *is ATTRIBUTE_UNUSED;
4928 bfd *obfd ATTRIBUTE_UNUSED;
4929 char **errmsg ATTRIBUTE_UNUSED;
4931 return bfd_reloc_ok;
4935 /* Elf core file support. Much of this only works on native
4936 toolchains, since we rely on knowing the
4937 machine-dependent procfs structure in order to pick
4938 out details about the corefile. */
4940 #ifdef HAVE_SYS_PROCFS_H
4941 # include <sys/procfs.h>
4945 /* Define offsetof for those systems which lack it. */
4948 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
4952 /* FIXME: this is kinda wrong, but it's what gdb wants. */
4955 elfcore_make_pid (abfd)
4958 return ((elf_tdata (abfd)->core_lwpid << 16)
4959 + (elf_tdata (abfd)->core_pid));
4963 /* If there isn't a section called NAME, make one, using
4964 data from SECT. Note, this function will generate a
4965 reference to NAME, so you shouldn't deallocate or
4969 elfcore_maybe_make_sect (abfd, name, sect)
4976 if (bfd_get_section_by_name (abfd, name) != NULL)
4979 sect2 = bfd_make_section (abfd, name);
4983 sect2->_raw_size = sect->_raw_size;
4984 sect2->filepos = sect->filepos;
4985 sect2->flags = sect->flags;
4986 sect2->alignment_power = sect->alignment_power;
4991 /* prstatus_t exists on:
4993 linux 2.[01] + glibc
4997 #if defined (HAVE_PRSTATUS_T)
4999 elfcore_grok_prstatus (abfd, note)
5001 Elf_Internal_Note* note;
5008 if (note->descsz != sizeof (prstat))
5011 memcpy (&prstat, note->descdata, sizeof (prstat));
5013 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5014 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5016 /* pr_who exists on:
5019 pr_who doesn't exist on:
5022 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5023 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5026 /* Make a ".reg/999" section. */
5028 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5029 name = bfd_alloc (abfd, strlen (buf) + 1);
5034 sect = bfd_make_section (abfd, name);
5037 sect->_raw_size = sizeof (prstat.pr_reg);
5038 sect->filepos = note->descpos + offsetof (prstatus_t, pr_reg);
5039 sect->flags = SEC_HAS_CONTENTS;
5040 sect->alignment_power = 2;
5042 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
5047 #endif /* defined (HAVE_PRSTATUS_T) */
5050 /* Create a pseudosection containing the exact contents of NOTE. This
5051 actually creates up to two pseudosections:
5052 - For the single-threaded case, a section named NAME, unless
5053 such a section already exists.
5054 - For the multi-threaded case, a section named "NAME/PID", where
5055 PID is elfcore_make_pid (abfd).
5056 Both pseudosections have identical contents: the contents of NOTE. */
5059 elfcore_make_note_pseudosection (abfd, name, note)
5062 Elf_Internal_Note* note;
5065 char *threaded_name;
5068 /* Build the section name. */
5070 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
5071 threaded_name = bfd_alloc (abfd, strlen (buf) + 1);
5072 if (threaded_name == NULL)
5074 strcpy (threaded_name, buf);
5076 sect = bfd_make_section (abfd, threaded_name);
5079 sect->_raw_size = note->descsz;
5080 sect->filepos = note->descpos;
5081 sect->flags = SEC_HAS_CONTENTS;
5082 sect->alignment_power = 2;
5084 if (! elfcore_maybe_make_sect (abfd, name, sect))
5091 /* There isn't a consistent prfpregset_t across platforms,
5092 but it doesn't matter, because we don't have to pick this
5093 data structure apart. */
5095 elfcore_grok_prfpreg (abfd, note)
5097 Elf_Internal_Note* note;
5099 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
5103 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
5104 type of 5 (NT_PRXFPREG). Just include the whole note's contents
5107 elfcore_grok_prxfpreg (abfd, note)
5109 Elf_Internal_Note* note;
5111 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
5115 #if defined (HAVE_PRPSINFO_T)
5116 # define elfcore_psinfo_t prpsinfo_t
5119 #if defined (HAVE_PSINFO_T)
5120 # define elfcore_psinfo_t psinfo_t
5124 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5126 /* return a malloc'ed copy of a string at START which is at
5127 most MAX bytes long, possibly without a terminating '\0'.
5128 the copy will always have a terminating '\0'. */
5131 elfcore_strndup (abfd, start, max)
5137 char* end = memchr (start, '\0', max);
5145 dup = bfd_alloc (abfd, len + 1);
5149 memcpy (dup, start, len);
5156 elfcore_grok_psinfo (abfd, note)
5158 Elf_Internal_Note* note;
5160 elfcore_psinfo_t psinfo;
5162 if (note->descsz != sizeof (elfcore_psinfo_t))
5165 memcpy (&psinfo, note->descdata, note->descsz);
5167 elf_tdata (abfd)->core_program
5168 = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
5170 elf_tdata (abfd)->core_command
5171 = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
5173 /* Note that for some reason, a spurious space is tacked
5174 onto the end of the args in some (at least one anyway)
5175 implementations, so strip it off if it exists. */
5178 char* command = elf_tdata (abfd)->core_command;
5179 int n = strlen (command);
5181 if (0 < n && command[n - 1] == ' ')
5182 command[n - 1] = '\0';
5187 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5190 #if defined (HAVE_PSTATUS_T)
5192 elfcore_grok_pstatus (abfd, note)
5194 Elf_Internal_Note* note;
5198 if (note->descsz != sizeof (pstat))
5201 memcpy (&pstat, note->descdata, sizeof (pstat));
5203 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5205 /* Could grab some more details from the "representative"
5206 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5207 NT_LWPSTATUS note, presumably. */
5211 #endif /* defined (HAVE_PSTATUS_T) */
5214 #if defined (HAVE_LWPSTATUS_T)
5216 elfcore_grok_lwpstatus (abfd, note)
5218 Elf_Internal_Note* note;
5220 lwpstatus_t lwpstat;
5225 if (note->descsz != sizeof (lwpstat))
5228 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
5230 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
5231 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
5233 /* Make a ".reg/999" section. */
5235 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5236 name = bfd_alloc (abfd, strlen (buf) + 1);
5241 sect = bfd_make_section (abfd, name);
5245 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5246 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
5247 sect->filepos = note->descpos
5248 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
5251 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5252 sect->_raw_size = sizeof (lwpstat.pr_reg);
5253 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
5256 sect->flags = SEC_HAS_CONTENTS;
5257 sect->alignment_power = 2;
5259 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
5262 /* Make a ".reg2/999" section */
5264 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
5265 name = bfd_alloc (abfd, strlen (buf) + 1);
5270 sect = bfd_make_section (abfd, name);
5274 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5275 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
5276 sect->filepos = note->descpos
5277 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
5280 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5281 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
5282 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
5285 sect->flags = SEC_HAS_CONTENTS;
5286 sect->alignment_power = 2;
5288 if (!elfcore_maybe_make_sect (abfd, ".reg2", sect))
5293 #endif /* defined (HAVE_LWPSTATUS_T) */
5295 #if defined (HAVE_WIN32_PSTATUS_T)
5297 elfcore_grok_win32pstatus (abfd, note)
5299 Elf_Internal_Note * note;
5304 win32_pstatus_t pstatus;
5306 if (note->descsz < sizeof (pstatus))
5309 memcpy (& pstatus, note->descdata, note->descsz);
5311 switch (pstatus.data_type)
5313 case NOTE_INFO_PROCESS:
5314 /* FIXME: need to add ->core_command. */
5315 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
5316 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
5319 case NOTE_INFO_THREAD:
5320 /* Make a ".reg/999" section. */
5321 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
5323 name = bfd_alloc (abfd, strlen (buf) + 1);
5329 sect = bfd_make_section (abfd, name);
5333 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
5334 sect->filepos = note->descpos + offsetof (struct win32_pstatus,
5335 data.thread_info.thread_context);
5336 sect->flags = SEC_HAS_CONTENTS;
5337 sect->alignment_power = 2;
5339 if (pstatus.data.thread_info.is_active_thread)
5340 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
5344 case NOTE_INFO_MODULE:
5345 /* Make a ".module/xxxxxxxx" section. */
5346 sprintf (buf, ".module/%08x" , pstatus.data.module_info.base_address);
5348 name = bfd_alloc (abfd, strlen (buf) + 1);
5354 sect = bfd_make_section (abfd, name);
5359 sect->_raw_size = note->descsz;
5360 sect->filepos = note->descpos;
5361 sect->flags = SEC_HAS_CONTENTS;
5362 sect->alignment_power = 2;
5371 #endif /* HAVE_WIN32_PSTATUS_T */
5374 elfcore_grok_note (abfd, note)
5376 Elf_Internal_Note* note;
5383 #if defined (HAVE_PRSTATUS_T)
5385 return elfcore_grok_prstatus (abfd, note);
5388 #if defined (HAVE_PSTATUS_T)
5390 return elfcore_grok_pstatus (abfd, note);
5393 #if defined (HAVE_LWPSTATUS_T)
5395 return elfcore_grok_lwpstatus (abfd, note);
5398 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
5399 return elfcore_grok_prfpreg (abfd, note);
5401 #if defined (HAVE_WIN32_PSTATUS_T)
5402 case NT_WIN32PSTATUS:
5403 return elfcore_grok_win32pstatus (abfd, note);
5406 case NT_PRXFPREG: /* Linux SSE extension */
5407 if (note->namesz == 5
5408 && ! strcmp (note->namedata, "LINUX"))
5409 return elfcore_grok_prxfpreg (abfd, note);
5413 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5416 return elfcore_grok_psinfo (abfd, note);
5423 elfcore_read_notes (abfd, offset, size)
5434 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5437 buf = bfd_malloc ((size_t) size);
5441 if (bfd_read (buf, size, 1, abfd) != size)
5449 while (p < buf + size)
5451 /* FIXME: bad alignment assumption. */
5452 Elf_External_Note* xnp = (Elf_External_Note*) p;
5453 Elf_Internal_Note in;
5455 in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
5457 in.namesz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->namesz);
5458 in.namedata = xnp->name;
5460 in.descsz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->descsz);
5461 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
5462 in.descpos = offset + (in.descdata - buf);
5464 if (! elfcore_grok_note (abfd, &in))
5467 p = in.descdata + BFD_ALIGN (in.descsz, 4);
5475 /* FIXME: This function is now unnecessary. Callers can just call
5476 bfd_section_from_phdr directly. */
5479 _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
5481 Elf_Internal_Phdr* phdr;
5484 if (! bfd_section_from_phdr (abfd, phdr, sec_num))
5492 /* Providing external access to the ELF program header table. */
5494 /* Return an upper bound on the number of bytes required to store a
5495 copy of ABFD's program header table entries. Return -1 if an error
5496 occurs; bfd_get_error will return an appropriate code. */
5498 bfd_get_elf_phdr_upper_bound (abfd)
5501 if (abfd->xvec->flavour != bfd_target_elf_flavour)
5503 bfd_set_error (bfd_error_wrong_format);
5507 return (elf_elfheader (abfd)->e_phnum
5508 * sizeof (Elf_Internal_Phdr));
5512 /* Copy ABFD's program header table entries to *PHDRS. The entries
5513 will be stored as an array of Elf_Internal_Phdr structures, as
5514 defined in include/elf/internal.h. To find out how large the
5515 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
5517 Return the number of program header table entries read, or -1 if an
5518 error occurs; bfd_get_error will return an appropriate code. */
5520 bfd_get_elf_phdrs (abfd, phdrs)
5526 if (abfd->xvec->flavour != bfd_target_elf_flavour)
5528 bfd_set_error (bfd_error_wrong_format);
5532 num_phdrs = elf_elfheader (abfd)->e_phnum;
5533 memcpy (phdrs, elf_tdata (abfd)->phdr,
5534 num_phdrs * sizeof (Elf_Internal_Phdr));