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 *));
57 /* Swap version information in and out. The version information is
58 currently size independent. If that ever changes, this code will
59 need to move into elfcode.h. */
61 /* Swap in a Verdef structure. */
64 _bfd_elf_swap_verdef_in (abfd, src, dst)
66 const Elf_External_Verdef *src;
67 Elf_Internal_Verdef *dst;
69 dst->vd_version = bfd_h_get_16 (abfd, src->vd_version);
70 dst->vd_flags = bfd_h_get_16 (abfd, src->vd_flags);
71 dst->vd_ndx = bfd_h_get_16 (abfd, src->vd_ndx);
72 dst->vd_cnt = bfd_h_get_16 (abfd, src->vd_cnt);
73 dst->vd_hash = bfd_h_get_32 (abfd, src->vd_hash);
74 dst->vd_aux = bfd_h_get_32 (abfd, src->vd_aux);
75 dst->vd_next = bfd_h_get_32 (abfd, src->vd_next);
78 /* Swap out a Verdef structure. */
81 _bfd_elf_swap_verdef_out (abfd, src, dst)
83 const Elf_Internal_Verdef *src;
84 Elf_External_Verdef *dst;
86 bfd_h_put_16 (abfd, src->vd_version, dst->vd_version);
87 bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags);
88 bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx);
89 bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt);
90 bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash);
91 bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux);
92 bfd_h_put_32 (abfd, src->vd_next, dst->vd_next);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (abfd, src, dst)
100 const Elf_External_Verdaux *src;
101 Elf_Internal_Verdaux *dst;
103 dst->vda_name = bfd_h_get_32 (abfd, src->vda_name);
104 dst->vda_next = bfd_h_get_32 (abfd, src->vda_next);
107 /* Swap out a Verdaux structure. */
110 _bfd_elf_swap_verdaux_out (abfd, src, dst)
112 const Elf_Internal_Verdaux *src;
113 Elf_External_Verdaux *dst;
115 bfd_h_put_32 (abfd, src->vda_name, dst->vda_name);
116 bfd_h_put_32 (abfd, src->vda_next, dst->vda_next);
119 /* Swap in a Verneed structure. */
122 _bfd_elf_swap_verneed_in (abfd, src, dst)
124 const Elf_External_Verneed *src;
125 Elf_Internal_Verneed *dst;
127 dst->vn_version = bfd_h_get_16 (abfd, src->vn_version);
128 dst->vn_cnt = bfd_h_get_16 (abfd, src->vn_cnt);
129 dst->vn_file = bfd_h_get_32 (abfd, src->vn_file);
130 dst->vn_aux = bfd_h_get_32 (abfd, src->vn_aux);
131 dst->vn_next = bfd_h_get_32 (abfd, src->vn_next);
134 /* Swap out a Verneed structure. */
137 _bfd_elf_swap_verneed_out (abfd, src, dst)
139 const Elf_Internal_Verneed *src;
140 Elf_External_Verneed *dst;
142 bfd_h_put_16 (abfd, src->vn_version, dst->vn_version);
143 bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt);
144 bfd_h_put_32 (abfd, src->vn_file, dst->vn_file);
145 bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux);
146 bfd_h_put_32 (abfd, src->vn_next, dst->vn_next);
149 /* Swap in a Vernaux structure. */
152 _bfd_elf_swap_vernaux_in (abfd, src, dst)
154 const Elf_External_Vernaux *src;
155 Elf_Internal_Vernaux *dst;
157 dst->vna_hash = bfd_h_get_32 (abfd, src->vna_hash);
158 dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags);
159 dst->vna_other = bfd_h_get_16 (abfd, src->vna_other);
160 dst->vna_name = bfd_h_get_32 (abfd, src->vna_name);
161 dst->vna_next = bfd_h_get_32 (abfd, src->vna_next);
164 /* Swap out a Vernaux structure. */
167 _bfd_elf_swap_vernaux_out (abfd, src, dst)
169 const Elf_Internal_Vernaux *src;
170 Elf_External_Vernaux *dst;
172 bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash);
173 bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags);
174 bfd_h_put_16 (abfd, src->vna_other, dst->vna_other);
175 bfd_h_put_32 (abfd, src->vna_name, dst->vna_name);
176 bfd_h_put_32 (abfd, src->vna_next, dst->vna_next);
179 /* Swap in a Versym structure. */
182 _bfd_elf_swap_versym_in (abfd, src, dst)
184 const Elf_External_Versym *src;
185 Elf_Internal_Versym *dst;
187 dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers);
190 /* Swap out a Versym structure. */
193 _bfd_elf_swap_versym_out (abfd, src, dst)
195 const Elf_Internal_Versym *src;
196 Elf_External_Versym *dst;
198 bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers);
201 /* Standard ELF hash function. Do not change this function; you will
202 cause invalid hash tables to be generated. */
205 CONST unsigned char *name;
211 while ((ch = *name++) != '\0')
214 if ((g = (h & 0xf0000000)) != 0)
217 /* The ELF ABI says `h &= ~g', but this is equivalent in
218 this case and on some machines one insn instead of two. */
225 /* Read a specified number of bytes at a specified offset in an ELF
226 file, into a newly allocated buffer, and return a pointer to the
230 elf_read (abfd, offset, size)
237 if ((buf = bfd_alloc (abfd, size)) == NULL)
239 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
241 if (bfd_read ((PTR) buf, size, 1, abfd) != size)
243 if (bfd_get_error () != bfd_error_system_call)
244 bfd_set_error (bfd_error_file_truncated);
251 bfd_elf_mkobject (abfd)
254 /* this just does initialization */
255 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
256 elf_tdata (abfd) = (struct elf_obj_tdata *)
257 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
258 if (elf_tdata (abfd) == 0)
260 /* since everything is done at close time, do we need any
267 bfd_elf_mkcorefile (abfd)
270 /* I think this can be done just like an object file. */
271 return bfd_elf_mkobject (abfd);
275 bfd_elf_get_str_section (abfd, shindex)
277 unsigned int shindex;
279 Elf_Internal_Shdr **i_shdrp;
280 char *shstrtab = NULL;
282 unsigned int shstrtabsize;
284 i_shdrp = elf_elfsections (abfd);
285 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
288 shstrtab = (char *) i_shdrp[shindex]->contents;
289 if (shstrtab == NULL)
291 /* No cached one, attempt to read, and cache what we read. */
292 offset = i_shdrp[shindex]->sh_offset;
293 shstrtabsize = i_shdrp[shindex]->sh_size;
294 shstrtab = elf_read (abfd, offset, shstrtabsize);
295 i_shdrp[shindex]->contents = (PTR) shstrtab;
301 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
303 unsigned int shindex;
304 unsigned int strindex;
306 Elf_Internal_Shdr *hdr;
311 hdr = elf_elfsections (abfd)[shindex];
313 if (hdr->contents == NULL
314 && bfd_elf_get_str_section (abfd, shindex) == NULL)
317 if (strindex >= hdr->sh_size)
319 (*_bfd_error_handler)
320 (_("%s: invalid string offset %u >= %lu for section `%s'"),
321 bfd_get_filename (abfd), strindex, (unsigned long) hdr->sh_size,
322 ((shindex == elf_elfheader(abfd)->e_shstrndx
323 && strindex == hdr->sh_name)
325 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
329 return ((char *) hdr->contents) + strindex;
332 /* Make a BFD section from an ELF section. We store a pointer to the
333 BFD section in the bfd_section field of the header. */
336 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
338 Elf_Internal_Shdr *hdr;
344 if (hdr->bfd_section != NULL)
346 BFD_ASSERT (strcmp (name,
347 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
351 newsect = bfd_make_section_anyway (abfd, name);
355 newsect->filepos = hdr->sh_offset;
357 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
358 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
359 || ! bfd_set_section_alignment (abfd, newsect,
360 bfd_log2 (hdr->sh_addralign)))
363 flags = SEC_NO_FLAGS;
364 if (hdr->sh_type != SHT_NOBITS)
365 flags |= SEC_HAS_CONTENTS;
366 if ((hdr->sh_flags & SHF_ALLOC) != 0)
369 if (hdr->sh_type != SHT_NOBITS)
372 if ((hdr->sh_flags & SHF_WRITE) == 0)
373 flags |= SEC_READONLY;
374 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
376 else if ((flags & SEC_LOAD) != 0)
379 /* The debugging sections appear to be recognized only by name, not
381 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
382 || strncmp (name, ".line", sizeof ".line" - 1) == 0
383 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
384 flags |= SEC_DEBUGGING;
386 /* As a GNU extension, if the name begins with .gnu.linkonce, we
387 only link a single copy of the section. This is used to support
388 g++. g++ will emit each template expansion in its own section.
389 The symbols will be defined as weak, so that multiple definitions
390 are permitted. The GNU linker extension is to actually discard
391 all but one of the sections. */
392 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
393 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
395 if (! bfd_set_section_flags (abfd, newsect, flags))
398 if ((flags & SEC_ALLOC) != 0)
400 Elf_Internal_Phdr *phdr;
403 /* Look through the phdrs to see if we need to adjust the lma.
404 If all the p_paddr fields are zero, we ignore them, since
405 some ELF linkers produce such output. */
406 phdr = elf_tdata (abfd)->phdr;
407 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
409 if (phdr->p_paddr != 0)
412 if (i < elf_elfheader (abfd)->e_phnum)
414 phdr = elf_tdata (abfd)->phdr;
415 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
417 if (phdr->p_type == PT_LOAD
418 && phdr->p_vaddr != phdr->p_paddr
419 && phdr->p_vaddr <= hdr->sh_addr
420 && (phdr->p_vaddr + phdr->p_memsz
421 >= hdr->sh_addr + hdr->sh_size)
422 && ((flags & SEC_LOAD) == 0
423 || (phdr->p_offset <= (bfd_vma) hdr->sh_offset
424 && (phdr->p_offset + phdr->p_filesz
425 >= hdr->sh_offset + hdr->sh_size))))
427 newsect->lma += phdr->p_paddr - phdr->p_vaddr;
434 hdr->bfd_section = newsect;
435 elf_section_data (newsect)->this_hdr = *hdr;
445 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
448 Helper functions for GDB to locate the string tables.
449 Since BFD hides string tables from callers, GDB needs to use an
450 internal hook to find them. Sun's .stabstr, in particular,
451 isn't even pointed to by the .stab section, so ordinary
452 mechanisms wouldn't work to find it, even if we had some.
455 struct elf_internal_shdr *
456 bfd_elf_find_section (abfd, name)
460 Elf_Internal_Shdr **i_shdrp;
465 i_shdrp = elf_elfsections (abfd);
468 shstrtab = bfd_elf_get_str_section
469 (abfd, elf_elfheader (abfd)->e_shstrndx);
470 if (shstrtab != NULL)
472 max = elf_elfheader (abfd)->e_shnum;
473 for (i = 1; i < max; i++)
474 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
481 const char *const bfd_elf_section_type_names[] = {
482 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
483 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
484 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
487 /* ELF relocs are against symbols. If we are producing relocateable
488 output, and the reloc is against an external symbol, and nothing
489 has given us any additional addend, the resulting reloc will also
490 be against the same symbol. In such a case, we don't want to
491 change anything about the way the reloc is handled, since it will
492 all be done at final link time. Rather than put special case code
493 into bfd_perform_relocation, all the reloc types use this howto
494 function. It just short circuits the reloc if producing
495 relocateable output against an external symbol. */
498 bfd_reloc_status_type
499 bfd_elf_generic_reloc (abfd,
507 arelent *reloc_entry;
510 asection *input_section;
512 char **error_message;
514 if (output_bfd != (bfd *) NULL
515 && (symbol->flags & BSF_SECTION_SYM) == 0
516 && (! reloc_entry->howto->partial_inplace
517 || reloc_entry->addend == 0))
519 reloc_entry->address += input_section->output_offset;
523 return bfd_reloc_continue;
526 /* Print out the program headers. */
529 _bfd_elf_print_private_bfd_data (abfd, farg)
533 FILE *f = (FILE *) farg;
534 Elf_Internal_Phdr *p;
536 bfd_byte *dynbuf = NULL;
538 p = elf_tdata (abfd)->phdr;
543 fprintf (f, _("\nProgram Header:\n"));
544 c = elf_elfheader (abfd)->e_phnum;
545 for (i = 0; i < c; i++, p++)
552 case PT_NULL: s = "NULL"; break;
553 case PT_LOAD: s = "LOAD"; break;
554 case PT_DYNAMIC: s = "DYNAMIC"; break;
555 case PT_INTERP: s = "INTERP"; break;
556 case PT_NOTE: s = "NOTE"; break;
557 case PT_SHLIB: s = "SHLIB"; break;
558 case PT_PHDR: s = "PHDR"; break;
559 default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
561 fprintf (f, "%8s off 0x", s);
562 fprintf_vma (f, p->p_offset);
563 fprintf (f, " vaddr 0x");
564 fprintf_vma (f, p->p_vaddr);
565 fprintf (f, " paddr 0x");
566 fprintf_vma (f, p->p_paddr);
567 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
568 fprintf (f, " filesz 0x");
569 fprintf_vma (f, p->p_filesz);
570 fprintf (f, " memsz 0x");
571 fprintf_vma (f, p->p_memsz);
572 fprintf (f, " flags %c%c%c",
573 (p->p_flags & PF_R) != 0 ? 'r' : '-',
574 (p->p_flags & PF_W) != 0 ? 'w' : '-',
575 (p->p_flags & PF_X) != 0 ? 'x' : '-');
576 if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
577 fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
582 s = bfd_get_section_by_name (abfd, ".dynamic");
587 bfd_byte *extdyn, *extdynend;
589 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
591 fprintf (f, _("\nDynamic Section:\n"));
593 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
596 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
600 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
603 link = elf_elfsections (abfd)[elfsec]->sh_link;
605 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
606 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
609 extdynend = extdyn + s->_raw_size;
610 for (; extdyn < extdynend; extdyn += extdynsize)
612 Elf_Internal_Dyn dyn;
617 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
619 if (dyn.d_tag == DT_NULL)
626 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
630 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
631 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
632 case DT_PLTGOT: name = "PLTGOT"; break;
633 case DT_HASH: name = "HASH"; break;
634 case DT_STRTAB: name = "STRTAB"; break;
635 case DT_SYMTAB: name = "SYMTAB"; break;
636 case DT_RELA: name = "RELA"; break;
637 case DT_RELASZ: name = "RELASZ"; break;
638 case DT_RELAENT: name = "RELAENT"; break;
639 case DT_STRSZ: name = "STRSZ"; break;
640 case DT_SYMENT: name = "SYMENT"; break;
641 case DT_INIT: name = "INIT"; break;
642 case DT_FINI: name = "FINI"; break;
643 case DT_SONAME: name = "SONAME"; stringp = true; break;
644 case DT_RPATH: name = "RPATH"; stringp = true; break;
645 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
646 case DT_REL: name = "REL"; break;
647 case DT_RELSZ: name = "RELSZ"; break;
648 case DT_RELENT: name = "RELENT"; break;
649 case DT_PLTREL: name = "PLTREL"; break;
650 case DT_DEBUG: name = "DEBUG"; break;
651 case DT_TEXTREL: name = "TEXTREL"; break;
652 case DT_JMPREL: name = "JMPREL"; break;
653 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
654 case DT_FILTER: name = "FILTER"; stringp = true; break;
655 case DT_VERSYM: name = "VERSYM"; break;
656 case DT_VERDEF: name = "VERDEF"; break;
657 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
658 case DT_VERNEED: name = "VERNEED"; break;
659 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
662 fprintf (f, " %-11s ", name);
664 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
669 string = bfd_elf_string_from_elf_section (abfd, link,
673 fprintf (f, "%s", string);
682 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
683 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
685 if (! _bfd_elf_slurp_version_tables (abfd))
689 if (elf_dynverdef (abfd) != 0)
691 Elf_Internal_Verdef *t;
693 fprintf (f, _("\nVersion definitions:\n"));
694 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
696 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
697 t->vd_flags, t->vd_hash, t->vd_nodename);
698 if (t->vd_auxptr->vda_nextptr != NULL)
700 Elf_Internal_Verdaux *a;
703 for (a = t->vd_auxptr->vda_nextptr;
706 fprintf (f, "%s ", a->vda_nodename);
712 if (elf_dynverref (abfd) != 0)
714 Elf_Internal_Verneed *t;
716 fprintf (f, _("\nVersion References:\n"));
717 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
719 Elf_Internal_Vernaux *a;
721 fprintf (f, _(" required from %s:\n"), t->vn_filename);
722 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
723 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
724 a->vna_flags, a->vna_other, a->vna_nodename);
736 /* Display ELF-specific fields of a symbol. */
739 bfd_elf_print_symbol (abfd, filep, symbol, how)
743 bfd_print_symbol_type how;
745 FILE *file = (FILE *) filep;
748 case bfd_print_symbol_name:
749 fprintf (file, "%s", symbol->name);
751 case bfd_print_symbol_more:
752 fprintf (file, "elf ");
753 fprintf_vma (file, symbol->value);
754 fprintf (file, " %lx", (long) symbol->flags);
756 case bfd_print_symbol_all:
758 CONST char *section_name;
759 section_name = symbol->section ? symbol->section->name : "(*none*)";
760 bfd_print_symbol_vandf ((PTR) file, symbol);
761 fprintf (file, " %s\t", section_name);
762 /* Print the "other" value for a symbol. For common symbols,
763 we've already printed the size; now print the alignment.
764 For other symbols, we have no specified alignment, and
765 we've printed the address; now print the size. */
767 (bfd_is_com_section (symbol->section)
768 ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
769 : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
771 /* If we have version information, print it. */
772 if (elf_tdata (abfd)->dynversym_section != 0
773 && (elf_tdata (abfd)->dynverdef_section != 0
774 || elf_tdata (abfd)->dynverref_section != 0))
777 const char *version_string;
779 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
783 else if (vernum == 1)
784 version_string = "Base";
785 else if (vernum <= elf_tdata (abfd)->cverdefs)
787 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
790 Elf_Internal_Verneed *t;
793 for (t = elf_tdata (abfd)->verref;
797 Elf_Internal_Vernaux *a;
799 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
801 if (a->vna_other == vernum)
803 version_string = a->vna_nodename;
810 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
811 fprintf (file, " %-11s", version_string);
816 fprintf (file, " (%s)", version_string);
817 for (i = 10 - strlen (version_string); i > 0; --i)
822 /* If the st_other field is not zero, print it. */
823 if (((elf_symbol_type *) symbol)->internal_elf_sym.st_other != 0)
824 fprintf (file, " 0x%02x",
826 ((elf_symbol_type *) symbol)->internal_elf_sym.st_other));
828 fprintf (file, " %s", symbol->name);
834 /* Create an entry in an ELF linker hash table. */
836 struct bfd_hash_entry *
837 _bfd_elf_link_hash_newfunc (entry, table, string)
838 struct bfd_hash_entry *entry;
839 struct bfd_hash_table *table;
842 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
844 /* Allocate the structure if it has not already been allocated by a
846 if (ret == (struct elf_link_hash_entry *) NULL)
847 ret = ((struct elf_link_hash_entry *)
848 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
849 if (ret == (struct elf_link_hash_entry *) NULL)
850 return (struct bfd_hash_entry *) ret;
852 /* Call the allocation method of the superclass. */
853 ret = ((struct elf_link_hash_entry *)
854 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
856 if (ret != (struct elf_link_hash_entry *) NULL)
858 /* Set local fields. */
862 ret->dynstr_index = 0;
864 ret->got.offset = (bfd_vma) -1;
865 ret->plt.offset = (bfd_vma) -1;
866 ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
867 ret->verinfo.verdef = NULL;
868 ret->vtable_entries_used = NULL;
869 ret->vtable_entries_size = 0;
870 ret->vtable_parent = NULL;
871 ret->type = STT_NOTYPE;
873 /* Assume that we have been called by a non-ELF symbol reader.
874 This flag is then reset by the code which reads an ELF input
875 file. This ensures that a symbol created by a non-ELF symbol
876 reader will have the flag set correctly. */
877 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
880 return (struct bfd_hash_entry *) ret;
883 /* Initialize an ELF linker hash table. */
886 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
887 struct elf_link_hash_table *table;
889 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
890 struct bfd_hash_table *,
893 table->dynamic_sections_created = false;
894 table->dynobj = NULL;
895 /* The first dynamic symbol is a dummy. */
896 table->dynsymcount = 1;
897 table->dynstr = NULL;
898 table->bucketcount = 0;
899 table->needed = NULL;
901 table->stab_info = NULL;
902 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
905 /* Create an ELF linker hash table. */
907 struct bfd_link_hash_table *
908 _bfd_elf_link_hash_table_create (abfd)
911 struct elf_link_hash_table *ret;
913 ret = ((struct elf_link_hash_table *)
914 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
915 if (ret == (struct elf_link_hash_table *) NULL)
918 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
920 bfd_release (abfd, ret);
927 /* This is a hook for the ELF emulation code in the generic linker to
928 tell the backend linker what file name to use for the DT_NEEDED
929 entry for a dynamic object. The generic linker passes name as an
930 empty string to indicate that no DT_NEEDED entry should be made. */
933 bfd_elf_set_dt_needed_name (abfd, name)
937 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
938 && bfd_get_format (abfd) == bfd_object)
939 elf_dt_name (abfd) = name;
942 /* Get the list of DT_NEEDED entries for a link. This is a hook for
943 the linker ELF emulation code. */
945 struct bfd_link_needed_list *
946 bfd_elf_get_needed_list (abfd, info)
948 struct bfd_link_info *info;
950 if (info->hash->creator->flavour != bfd_target_elf_flavour)
952 return elf_hash_table (info)->needed;
955 /* Get the name actually used for a dynamic object for a link. This
956 is the SONAME entry if there is one. Otherwise, it is the string
957 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
960 bfd_elf_get_dt_soname (abfd)
963 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
964 && bfd_get_format (abfd) == bfd_object)
965 return elf_dt_name (abfd);
969 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
970 the ELF linker emulation code. */
973 bfd_elf_get_bfd_needed_list (abfd, pneeded)
975 struct bfd_link_needed_list **pneeded;
978 bfd_byte *dynbuf = NULL;
981 bfd_byte *extdyn, *extdynend;
983 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
987 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
988 || bfd_get_format (abfd) != bfd_object)
991 s = bfd_get_section_by_name (abfd, ".dynamic");
992 if (s == NULL || s->_raw_size == 0)
995 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
999 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1003 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1007 link = elf_elfsections (abfd)[elfsec]->sh_link;
1009 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1010 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1013 extdynend = extdyn + s->_raw_size;
1014 for (; extdyn < extdynend; extdyn += extdynsize)
1016 Elf_Internal_Dyn dyn;
1018 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1020 if (dyn.d_tag == DT_NULL)
1023 if (dyn.d_tag == DT_NEEDED)
1026 struct bfd_link_needed_list *l;
1028 string = bfd_elf_string_from_elf_section (abfd, link,
1033 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof *l);
1054 /* Allocate an ELF string table--force the first byte to be zero. */
1056 struct bfd_strtab_hash *
1057 _bfd_elf_stringtab_init ()
1059 struct bfd_strtab_hash *ret;
1061 ret = _bfd_stringtab_init ();
1066 loc = _bfd_stringtab_add (ret, "", true, false);
1067 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1068 if (loc == (bfd_size_type) -1)
1070 _bfd_stringtab_free (ret);
1077 /* ELF .o/exec file reading */
1079 /* Create a new bfd section from an ELF section header. */
1082 bfd_section_from_shdr (abfd, shindex)
1084 unsigned int shindex;
1086 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1087 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1088 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1091 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1093 switch (hdr->sh_type)
1096 /* Inactive section. Throw it away. */
1099 case SHT_PROGBITS: /* Normal section with contents. */
1100 case SHT_DYNAMIC: /* Dynamic linking information. */
1101 case SHT_NOBITS: /* .bss section. */
1102 case SHT_HASH: /* .hash section. */
1103 case SHT_NOTE: /* .note section. */
1104 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1106 case SHT_SYMTAB: /* A symbol table */
1107 if (elf_onesymtab (abfd) == shindex)
1110 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1111 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1112 elf_onesymtab (abfd) = shindex;
1113 elf_tdata (abfd)->symtab_hdr = *hdr;
1114 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1115 abfd->flags |= HAS_SYMS;
1117 /* Sometimes a shared object will map in the symbol table. If
1118 SHF_ALLOC is set, and this is a shared object, then we also
1119 treat this section as a BFD section. We can not base the
1120 decision purely on SHF_ALLOC, because that flag is sometimes
1121 set in a relocateable object file, which would confuse the
1123 if ((hdr->sh_flags & SHF_ALLOC) != 0
1124 && (abfd->flags & DYNAMIC) != 0
1125 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1130 case SHT_DYNSYM: /* A dynamic symbol table */
1131 if (elf_dynsymtab (abfd) == shindex)
1134 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1135 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1136 elf_dynsymtab (abfd) = shindex;
1137 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1138 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1139 abfd->flags |= HAS_SYMS;
1141 /* Besides being a symbol table, we also treat this as a regular
1142 section, so that objcopy can handle it. */
1143 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1145 case SHT_STRTAB: /* A string table */
1146 if (hdr->bfd_section != NULL)
1148 if (ehdr->e_shstrndx == shindex)
1150 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1151 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1157 for (i = 1; i < ehdr->e_shnum; i++)
1159 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1160 if (hdr2->sh_link == shindex)
1162 if (! bfd_section_from_shdr (abfd, i))
1164 if (elf_onesymtab (abfd) == i)
1166 elf_tdata (abfd)->strtab_hdr = *hdr;
1167 elf_elfsections (abfd)[shindex] =
1168 &elf_tdata (abfd)->strtab_hdr;
1171 if (elf_dynsymtab (abfd) == i)
1173 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1174 elf_elfsections (abfd)[shindex] = hdr =
1175 &elf_tdata (abfd)->dynstrtab_hdr;
1176 /* We also treat this as a regular section, so
1177 that objcopy can handle it. */
1180 #if 0 /* Not handling other string tables specially right now. */
1181 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1182 /* We have a strtab for some random other section. */
1183 newsect = (asection *) hdr2->bfd_section;
1186 hdr->bfd_section = newsect;
1187 hdr2 = &elf_section_data (newsect)->str_hdr;
1189 elf_elfsections (abfd)[shindex] = hdr2;
1195 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1199 /* *These* do a lot of work -- but build no sections! */
1201 asection *target_sect;
1202 Elf_Internal_Shdr *hdr2;
1204 /* Check for a bogus link to avoid crashing. */
1205 if (hdr->sh_link >= ehdr->e_shnum)
1207 ((*_bfd_error_handler)
1208 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1209 bfd_get_filename (abfd), hdr->sh_link, name, shindex));
1210 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1213 /* For some incomprehensible reason Oracle distributes
1214 libraries for Solaris in which some of the objects have
1215 bogus sh_link fields. It would be nice if we could just
1216 reject them, but, unfortunately, some people need to use
1217 them. We scan through the section headers; if we find only
1218 one suitable symbol table, we clobber the sh_link to point
1219 to it. I hope this doesn't break anything. */
1220 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1221 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1227 for (scan = 1; scan < ehdr->e_shnum; scan++)
1229 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1230 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1241 hdr->sh_link = found;
1244 /* Get the symbol table. */
1245 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1246 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1249 /* If this reloc section does not use the main symbol table we
1250 don't treat it as a reloc section. BFD can't adequately
1251 represent such a section, so at least for now, we don't
1252 try. We just present it as a normal section. */
1253 if (hdr->sh_link != elf_onesymtab (abfd))
1254 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1256 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1258 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1259 if (target_sect == NULL)
1262 if ((target_sect->flags & SEC_RELOC) == 0
1263 || target_sect->reloc_count == 0)
1264 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1267 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1268 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
1269 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1272 elf_elfsections (abfd)[shindex] = hdr2;
1273 target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
1274 target_sect->flags |= SEC_RELOC;
1275 target_sect->relocation = NULL;
1276 target_sect->rel_filepos = hdr->sh_offset;
1277 /* In the section to which the relocations apply, mark whether
1278 its relocations are of the REL or RELA variety. */
1279 elf_section_data (target_sect)->use_rela_p
1280 = (hdr->sh_type == SHT_RELA);
1281 abfd->flags |= HAS_RELOC;
1286 case SHT_GNU_verdef:
1287 elf_dynverdef (abfd) = shindex;
1288 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1289 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1292 case SHT_GNU_versym:
1293 elf_dynversym (abfd) = shindex;
1294 elf_tdata (abfd)->dynversym_hdr = *hdr;
1295 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1298 case SHT_GNU_verneed:
1299 elf_dynverref (abfd) = shindex;
1300 elf_tdata (abfd)->dynverref_hdr = *hdr;
1301 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1308 /* Check for any processor-specific section types. */
1310 if (bed->elf_backend_section_from_shdr)
1311 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1319 /* Given an ELF section number, retrieve the corresponding BFD
1323 bfd_section_from_elf_index (abfd, index)
1327 BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
1328 if (index >= elf_elfheader (abfd)->e_shnum)
1330 return elf_elfsections (abfd)[index]->bfd_section;
1334 _bfd_elf_new_section_hook (abfd, sec)
1338 struct bfd_elf_section_data *sdata;
1340 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, sizeof (*sdata));
1343 sec->used_by_bfd = (PTR) sdata;
1345 /* Indicate whether or not this section should use RELA relocations. */
1347 = get_elf_backend_data (abfd)->default_use_rela_p;
1352 /* Create a new bfd section from an ELF program header.
1354 Since program segments have no names, we generate a synthetic name
1355 of the form segment<NUM>, where NUM is generally the index in the
1356 program header table. For segments that are split (see below) we
1357 generate the names segment<NUM>a and segment<NUM>b.
1359 Note that some program segments may have a file size that is different than
1360 (less than) the memory size. All this means is that at execution the
1361 system must allocate the amount of memory specified by the memory size,
1362 but only initialize it with the first "file size" bytes read from the
1363 file. This would occur for example, with program segments consisting
1364 of combined data+bss.
1366 To handle the above situation, this routine generates TWO bfd sections
1367 for the single program segment. The first has the length specified by
1368 the file size of the segment, and the second has the length specified
1369 by the difference between the two sizes. In effect, the segment is split
1370 into it's initialized and uninitialized parts.
1375 bfd_section_from_phdr (abfd, hdr, index)
1377 Elf_Internal_Phdr *hdr;
1385 split = ((hdr->p_memsz > 0)
1386 && (hdr->p_filesz > 0)
1387 && (hdr->p_memsz > hdr->p_filesz));
1388 sprintf (namebuf, split ? "segment%da" : "segment%d", index);
1389 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1392 strcpy (name, namebuf);
1393 newsect = bfd_make_section (abfd, name);
1394 if (newsect == NULL)
1396 newsect->vma = hdr->p_vaddr;
1397 newsect->lma = hdr->p_paddr;
1398 newsect->_raw_size = hdr->p_filesz;
1399 newsect->filepos = hdr->p_offset;
1400 newsect->flags |= SEC_HAS_CONTENTS;
1401 if (hdr->p_type == PT_LOAD)
1403 newsect->flags |= SEC_ALLOC;
1404 newsect->flags |= SEC_LOAD;
1405 if (hdr->p_flags & PF_X)
1407 /* FIXME: all we known is that it has execute PERMISSION,
1409 newsect->flags |= SEC_CODE;
1412 if (!(hdr->p_flags & PF_W))
1414 newsect->flags |= SEC_READONLY;
1419 sprintf (namebuf, "segment%db", index);
1420 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1423 strcpy (name, namebuf);
1424 newsect = bfd_make_section (abfd, name);
1425 if (newsect == NULL)
1427 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1428 newsect->lma = hdr->p_paddr + hdr->p_filesz;
1429 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1430 if (hdr->p_type == PT_LOAD)
1432 newsect->flags |= SEC_ALLOC;
1433 if (hdr->p_flags & PF_X)
1434 newsect->flags |= SEC_CODE;
1436 if (!(hdr->p_flags & PF_W))
1437 newsect->flags |= SEC_READONLY;
1443 /* Initialize REL_HDR, the section-header for new section, containing
1444 relocations against ASECT. If USE_RELA_P is true, we use RELA
1445 relocations; otherwise, we use REL relocations. */
1448 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
1450 Elf_Internal_Shdr *rel_hdr;
1455 struct elf_backend_data *bed;
1457 bed = get_elf_backend_data (abfd);
1458 name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1461 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1463 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1465 if (rel_hdr->sh_name == (unsigned int) -1)
1467 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1468 rel_hdr->sh_entsize = (use_rela_p
1469 ? bed->s->sizeof_rela
1470 : bed->s->sizeof_rel);
1471 rel_hdr->sh_addralign = bed->s->file_align;
1472 rel_hdr->sh_flags = 0;
1473 rel_hdr->sh_addr = 0;
1474 rel_hdr->sh_size = 0;
1475 rel_hdr->sh_offset = 0;
1480 /* Set up an ELF internal section header for a section. */
1484 elf_fake_sections (abfd, asect, failedptrarg)
1489 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1490 boolean *failedptr = (boolean *) failedptrarg;
1491 Elf_Internal_Shdr *this_hdr;
1495 /* We already failed; just get out of the bfd_map_over_sections
1500 this_hdr = &elf_section_data (asect)->this_hdr;
1502 this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1505 if (this_hdr->sh_name == (unsigned long) -1)
1511 this_hdr->sh_flags = 0;
1513 if ((asect->flags & SEC_ALLOC) != 0
1514 || asect->user_set_vma)
1515 this_hdr->sh_addr = asect->vma;
1517 this_hdr->sh_addr = 0;
1519 this_hdr->sh_offset = 0;
1520 this_hdr->sh_size = asect->_raw_size;
1521 this_hdr->sh_link = 0;
1522 this_hdr->sh_addralign = 1 << asect->alignment_power;
1523 /* The sh_entsize and sh_info fields may have been set already by
1524 copy_private_section_data. */
1526 this_hdr->bfd_section = asect;
1527 this_hdr->contents = NULL;
1529 /* FIXME: This should not be based on section names. */
1530 if (strcmp (asect->name, ".dynstr") == 0)
1531 this_hdr->sh_type = SHT_STRTAB;
1532 else if (strcmp (asect->name, ".hash") == 0)
1534 this_hdr->sh_type = SHT_HASH;
1535 this_hdr->sh_entsize = bed->s->arch_size / 8;
1537 else if (strcmp (asect->name, ".dynsym") == 0)
1539 this_hdr->sh_type = SHT_DYNSYM;
1540 this_hdr->sh_entsize = bed->s->sizeof_sym;
1542 else if (strcmp (asect->name, ".dynamic") == 0)
1544 this_hdr->sh_type = SHT_DYNAMIC;
1545 this_hdr->sh_entsize = bed->s->sizeof_dyn;
1547 else if (strncmp (asect->name, ".rela", 5) == 0
1548 && get_elf_backend_data (abfd)->may_use_rela_p)
1550 this_hdr->sh_type = SHT_RELA;
1551 this_hdr->sh_entsize = bed->s->sizeof_rela;
1553 else if (strncmp (asect->name, ".rel", 4) == 0
1554 && get_elf_backend_data (abfd)->may_use_rel_p)
1556 this_hdr->sh_type = SHT_REL;
1557 this_hdr->sh_entsize = bed->s->sizeof_rel;
1559 else if (strncmp (asect->name, ".note", 5) == 0)
1560 this_hdr->sh_type = SHT_NOTE;
1561 else if (strncmp (asect->name, ".stab", 5) == 0
1562 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1563 this_hdr->sh_type = SHT_STRTAB;
1564 else if (strcmp (asect->name, ".gnu.version") == 0)
1566 this_hdr->sh_type = SHT_GNU_versym;
1567 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
1569 else if (strcmp (asect->name, ".gnu.version_d") == 0)
1571 this_hdr->sh_type = SHT_GNU_verdef;
1572 this_hdr->sh_entsize = 0;
1573 /* objcopy or strip will copy over sh_info, but may not set
1574 cverdefs. The linker will set cverdefs, but sh_info will be
1576 if (this_hdr->sh_info == 0)
1577 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
1579 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
1580 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
1582 else if (strcmp (asect->name, ".gnu.version_r") == 0)
1584 this_hdr->sh_type = SHT_GNU_verneed;
1585 this_hdr->sh_entsize = 0;
1586 /* objcopy or strip will copy over sh_info, but may not set
1587 cverrefs. The linker will set cverrefs, but sh_info will be
1589 if (this_hdr->sh_info == 0)
1590 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
1592 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
1593 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
1595 else if ((asect->flags & SEC_ALLOC) != 0
1596 && (asect->flags & SEC_LOAD) != 0)
1597 this_hdr->sh_type = SHT_PROGBITS;
1598 else if ((asect->flags & SEC_ALLOC) != 0
1599 && ((asect->flags & SEC_LOAD) == 0))
1600 this_hdr->sh_type = SHT_NOBITS;
1604 this_hdr->sh_type = SHT_PROGBITS;
1607 if ((asect->flags & SEC_ALLOC) != 0)
1608 this_hdr->sh_flags |= SHF_ALLOC;
1609 if ((asect->flags & SEC_READONLY) == 0)
1610 this_hdr->sh_flags |= SHF_WRITE;
1611 if ((asect->flags & SEC_CODE) != 0)
1612 this_hdr->sh_flags |= SHF_EXECINSTR;
1614 /* Check for processor-specific section types. */
1615 if (bed->elf_backend_fake_sections)
1616 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1618 /* If the section has relocs, set up a section header for the
1619 SHT_REL[A] section. If two relocation sections are required for
1620 this section, it is up to the processor-specific back-end to
1621 create the other. */
1622 if ((asect->flags & SEC_RELOC) != 0
1623 && !_bfd_elf_init_reloc_shdr (abfd,
1624 &elf_section_data (asect)->rel_hdr,
1626 elf_section_data (asect)->use_rela_p))
1630 /* Assign all ELF section numbers. The dummy first section is handled here
1631 too. The link/info pointers for the standard section types are filled
1632 in here too, while we're at it. */
1635 assign_section_numbers (abfd)
1638 struct elf_obj_tdata *t = elf_tdata (abfd);
1640 unsigned int section_number;
1641 Elf_Internal_Shdr **i_shdrp;
1642 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1646 for (sec = abfd->sections; sec; sec = sec->next)
1648 struct bfd_elf_section_data *d = elf_section_data (sec);
1650 d->this_idx = section_number++;
1651 if ((sec->flags & SEC_RELOC) == 0)
1654 d->rel_idx = section_number++;
1657 d->rel_idx2 = section_number++;
1662 t->shstrtab_section = section_number++;
1663 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1664 t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1666 if (bfd_get_symcount (abfd) > 0)
1668 t->symtab_section = section_number++;
1669 t->strtab_section = section_number++;
1672 elf_elfheader (abfd)->e_shnum = section_number;
1674 /* Set up the list of section header pointers, in agreement with the
1676 i_shdrp = ((Elf_Internal_Shdr **)
1677 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1678 if (i_shdrp == NULL)
1681 i_shdrp[0] = ((Elf_Internal_Shdr *)
1682 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1683 if (i_shdrp[0] == NULL)
1685 bfd_release (abfd, i_shdrp);
1688 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1690 elf_elfsections (abfd) = i_shdrp;
1692 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1693 if (bfd_get_symcount (abfd) > 0)
1695 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1696 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1697 t->symtab_hdr.sh_link = t->strtab_section;
1699 for (sec = abfd->sections; sec; sec = sec->next)
1701 struct bfd_elf_section_data *d = elf_section_data (sec);
1705 i_shdrp[d->this_idx] = &d->this_hdr;
1706 if (d->rel_idx != 0)
1707 i_shdrp[d->rel_idx] = &d->rel_hdr;
1708 if (d->rel_idx2 != 0)
1709 i_shdrp[d->rel_idx2] = d->rel_hdr2;
1711 /* Fill in the sh_link and sh_info fields while we're at it. */
1713 /* sh_link of a reloc section is the section index of the symbol
1714 table. sh_info is the section index of the section to which
1715 the relocation entries apply. */
1716 if (d->rel_idx != 0)
1718 d->rel_hdr.sh_link = t->symtab_section;
1719 d->rel_hdr.sh_info = d->this_idx;
1721 if (d->rel_idx2 != 0)
1723 d->rel_hdr2->sh_link = t->symtab_section;
1724 d->rel_hdr2->sh_info = d->this_idx;
1727 switch (d->this_hdr.sh_type)
1731 /* A reloc section which we are treating as a normal BFD
1732 section. sh_link is the section index of the symbol
1733 table. sh_info is the section index of the section to
1734 which the relocation entries apply. We assume that an
1735 allocated reloc section uses the dynamic symbol table.
1736 FIXME: How can we be sure? */
1737 s = bfd_get_section_by_name (abfd, ".dynsym");
1739 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1741 /* We look up the section the relocs apply to by name. */
1743 if (d->this_hdr.sh_type == SHT_REL)
1747 s = bfd_get_section_by_name (abfd, name);
1749 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1753 /* We assume that a section named .stab*str is a stabs
1754 string section. We look for a section with the same name
1755 but without the trailing ``str'', and set its sh_link
1756 field to point to this section. */
1757 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1758 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1763 len = strlen (sec->name);
1764 alc = (char *) bfd_malloc (len - 2);
1767 strncpy (alc, sec->name, len - 3);
1768 alc[len - 3] = '\0';
1769 s = bfd_get_section_by_name (abfd, alc);
1773 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
1775 /* This is a .stab section. */
1776 elf_section_data (s)->this_hdr.sh_entsize =
1777 4 + 2 * (bed->s->arch_size / 8);
1784 case SHT_GNU_verneed:
1785 case SHT_GNU_verdef:
1786 /* sh_link is the section header index of the string table
1787 used for the dynamic entries, or the symbol table, or the
1789 s = bfd_get_section_by_name (abfd, ".dynstr");
1791 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1795 case SHT_GNU_versym:
1796 /* sh_link is the section header index of the symbol table
1797 this hash table or version table is for. */
1798 s = bfd_get_section_by_name (abfd, ".dynsym");
1800 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1808 /* Map symbol from it's internal number to the external number, moving
1809 all local symbols to be at the head of the list. */
1812 sym_is_global (abfd, sym)
1816 /* If the backend has a special mapping, use it. */
1817 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1818 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1821 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1822 || bfd_is_und_section (bfd_get_section (sym))
1823 || bfd_is_com_section (bfd_get_section (sym)));
1827 elf_map_symbols (abfd)
1830 int symcount = bfd_get_symcount (abfd);
1831 asymbol **syms = bfd_get_outsymbols (abfd);
1832 asymbol **sect_syms;
1834 int num_globals = 0;
1835 int num_locals2 = 0;
1836 int num_globals2 = 0;
1838 int num_sections = 0;
1845 fprintf (stderr, "elf_map_symbols\n");
1849 /* Add a section symbol for each BFD section. FIXME: Is this really
1851 for (asect = abfd->sections; asect; asect = asect->next)
1853 if (max_index < asect->index)
1854 max_index = asect->index;
1858 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
1859 if (sect_syms == NULL)
1861 elf_section_syms (abfd) = sect_syms;
1863 for (idx = 0; idx < symcount; idx++)
1867 if ((sym->flags & BSF_SECTION_SYM) != 0
1874 if (sec->owner != NULL)
1876 if (sec->owner != abfd)
1878 if (sec->output_offset != 0)
1881 sec = sec->output_section;
1883 /* Empty sections in the input files may have had a section
1884 symbol created for them. (See the comment near the end of
1885 _bfd_generic_link_output_symbols in linker.c). If the linker
1886 script discards such sections then we will reach this point.
1887 Since we know that we cannot avoid this case, we detect it
1888 and skip the abort and the assignment to the sect_syms array.
1889 To reproduce this particular case try running the linker
1890 testsuite test ld-scripts/weak.exp for an ELF port that uses
1891 the generic linker. */
1892 if (sec->owner == NULL)
1895 BFD_ASSERT (sec->owner == abfd);
1897 sect_syms[sec->index] = syms[idx];
1902 for (asect = abfd->sections; asect; asect = asect->next)
1904 if (sect_syms[asect->index] != NULL)
1907 sym = bfd_make_empty_symbol (abfd);
1910 sym->the_bfd = abfd;
1911 sym->name = asect->name;
1913 /* Set the flags to 0 to indicate that this one was newly added. */
1915 sym->section = asect;
1916 sect_syms[asect->index] = sym;
1920 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
1921 asect->name, (long) asect->vma, asect->index, (long) asect);
1925 /* Classify all of the symbols. */
1926 for (idx = 0; idx < symcount; idx++)
1928 if (!sym_is_global (abfd, syms[idx]))
1933 for (asect = abfd->sections; asect; asect = asect->next)
1935 if (sect_syms[asect->index] != NULL
1936 && sect_syms[asect->index]->flags == 0)
1938 sect_syms[asect->index]->flags = BSF_SECTION_SYM;
1939 if (!sym_is_global (abfd, sect_syms[asect->index]))
1943 sect_syms[asect->index]->flags = 0;
1947 /* Now sort the symbols so the local symbols are first. */
1948 new_syms = ((asymbol **)
1950 (num_locals + num_globals) * sizeof (asymbol *)));
1951 if (new_syms == NULL)
1954 for (idx = 0; idx < symcount; idx++)
1956 asymbol *sym = syms[idx];
1959 if (!sym_is_global (abfd, sym))
1962 i = num_locals + num_globals2++;
1964 sym->udata.i = i + 1;
1966 for (asect = abfd->sections; asect; asect = asect->next)
1968 if (sect_syms[asect->index] != NULL
1969 && sect_syms[asect->index]->flags == 0)
1971 asymbol *sym = sect_syms[asect->index];
1974 sym->flags = BSF_SECTION_SYM;
1975 if (!sym_is_global (abfd, sym))
1978 i = num_locals + num_globals2++;
1980 sym->udata.i = i + 1;
1984 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
1986 elf_num_locals (abfd) = num_locals;
1987 elf_num_globals (abfd) = num_globals;
1991 /* Align to the maximum file alignment that could be required for any
1992 ELF data structure. */
1994 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
1995 static INLINE file_ptr
1996 align_file_position (off, align)
2000 return (off + align - 1) & ~(align - 1);
2003 /* Assign a file position to a section, optionally aligning to the
2004 required section alignment. */
2007 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2008 Elf_Internal_Shdr *i_shdrp;
2016 al = i_shdrp->sh_addralign;
2018 offset = BFD_ALIGN (offset, al);
2020 i_shdrp->sh_offset = offset;
2021 if (i_shdrp->bfd_section != NULL)
2022 i_shdrp->bfd_section->filepos = offset;
2023 if (i_shdrp->sh_type != SHT_NOBITS)
2024 offset += i_shdrp->sh_size;
2028 /* Compute the file positions we are going to put the sections at, and
2029 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2030 is not NULL, this is being called by the ELF backend linker. */
2033 _bfd_elf_compute_section_file_positions (abfd, link_info)
2035 struct bfd_link_info *link_info;
2037 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2039 struct bfd_strtab_hash *strtab;
2040 Elf_Internal_Shdr *shstrtab_hdr;
2042 if (abfd->output_has_begun)
2045 /* Do any elf backend specific processing first. */
2046 if (bed->elf_backend_begin_write_processing)
2047 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2049 if (! prep_headers (abfd))
2052 /* Post process the headers if necessary. */
2053 if (bed->elf_backend_post_process_headers)
2054 (*bed->elf_backend_post_process_headers) (abfd, link_info);
2057 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2061 if (!assign_section_numbers (abfd))
2064 /* The backend linker builds symbol table information itself. */
2065 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2067 /* Non-zero if doing a relocatable link. */
2068 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2070 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2074 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2075 /* sh_name was set in prep_headers. */
2076 shstrtab_hdr->sh_type = SHT_STRTAB;
2077 shstrtab_hdr->sh_flags = 0;
2078 shstrtab_hdr->sh_addr = 0;
2079 shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
2080 shstrtab_hdr->sh_entsize = 0;
2081 shstrtab_hdr->sh_link = 0;
2082 shstrtab_hdr->sh_info = 0;
2083 /* sh_offset is set in assign_file_positions_except_relocs. */
2084 shstrtab_hdr->sh_addralign = 1;
2086 if (!assign_file_positions_except_relocs (abfd))
2089 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2092 Elf_Internal_Shdr *hdr;
2094 off = elf_tdata (abfd)->next_file_pos;
2096 hdr = &elf_tdata (abfd)->symtab_hdr;
2097 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2099 hdr = &elf_tdata (abfd)->strtab_hdr;
2100 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2102 elf_tdata (abfd)->next_file_pos = off;
2104 /* Now that we know where the .strtab section goes, write it
2106 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2107 || ! _bfd_stringtab_emit (abfd, strtab))
2109 _bfd_stringtab_free (strtab);
2112 abfd->output_has_begun = true;
2117 /* Create a mapping from a set of sections to a program segment. */
2119 static INLINE struct elf_segment_map *
2120 make_mapping (abfd, sections, from, to, phdr)
2122 asection **sections;
2127 struct elf_segment_map *m;
2131 m = ((struct elf_segment_map *)
2133 (sizeof (struct elf_segment_map)
2134 + (to - from - 1) * sizeof (asection *))));
2138 m->p_type = PT_LOAD;
2139 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2140 m->sections[i - from] = *hdrpp;
2141 m->count = to - from;
2143 if (from == 0 && phdr)
2145 /* Include the headers in the first PT_LOAD segment. */
2146 m->includes_filehdr = 1;
2147 m->includes_phdrs = 1;
2153 /* Set up a mapping from BFD sections to program segments. */
2156 map_sections_to_segments (abfd)
2159 asection **sections = NULL;
2163 struct elf_segment_map *mfirst;
2164 struct elf_segment_map **pm;
2165 struct elf_segment_map *m;
2167 unsigned int phdr_index;
2168 bfd_vma maxpagesize;
2170 boolean phdr_in_segment = true;
2174 if (elf_tdata (abfd)->segment_map != NULL)
2177 if (bfd_count_sections (abfd) == 0)
2180 /* Select the allocated sections, and sort them. */
2182 sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
2183 * sizeof (asection *));
2184 if (sections == NULL)
2188 for (s = abfd->sections; s != NULL; s = s->next)
2190 if ((s->flags & SEC_ALLOC) != 0)
2196 BFD_ASSERT (i <= bfd_count_sections (abfd));
2199 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2201 /* Build the mapping. */
2206 /* If we have a .interp section, then create a PT_PHDR segment for
2207 the program headers and a PT_INTERP segment for the .interp
2209 s = bfd_get_section_by_name (abfd, ".interp");
2210 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2212 m = ((struct elf_segment_map *)
2213 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2217 m->p_type = PT_PHDR;
2218 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2219 m->p_flags = PF_R | PF_X;
2220 m->p_flags_valid = 1;
2221 m->includes_phdrs = 1;
2226 m = ((struct elf_segment_map *)
2227 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2231 m->p_type = PT_INTERP;
2239 /* Look through the sections. We put sections in the same program
2240 segment when the start of the second section can be placed within
2241 a few bytes of the end of the first section. */
2244 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2246 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2248 && (dynsec->flags & SEC_LOAD) == 0)
2251 /* Deal with -Ttext or something similar such that the first section
2252 is not adjacent to the program headers. This is an
2253 approximation, since at this point we don't know exactly how many
2254 program headers we will need. */
2257 bfd_size_type phdr_size;
2259 phdr_size = elf_tdata (abfd)->program_header_size;
2261 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2262 if ((abfd->flags & D_PAGED) == 0
2263 || sections[0]->lma < phdr_size
2264 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2265 phdr_in_segment = false;
2268 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2271 boolean new_segment;
2275 /* See if this section and the last one will fit in the same
2278 if (last_hdr == NULL)
2280 /* If we don't have a segment yet, then we don't need a new
2281 one (we build the last one after this loop). */
2282 new_segment = false;
2284 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
2286 /* If this section has a different relation between the
2287 virtual address and the load address, then we need a new
2291 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2292 < BFD_ALIGN (hdr->lma, maxpagesize))
2294 /* If putting this section in this segment would force us to
2295 skip a page in the segment, then we need a new segment. */
2298 else if ((last_hdr->flags & SEC_LOAD) == 0
2299 && (hdr->flags & SEC_LOAD) != 0)
2301 /* We don't want to put a loadable section after a
2302 nonloadable section in the same segment. */
2305 else if ((abfd->flags & D_PAGED) == 0)
2307 /* If the file is not demand paged, which means that we
2308 don't require the sections to be correctly aligned in the
2309 file, then there is no other reason for a new segment. */
2310 new_segment = false;
2313 && (hdr->flags & SEC_READONLY) == 0
2314 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2317 /* We don't want to put a writable section in a read only
2318 segment, unless they are on the same page in memory
2319 anyhow. We already know that the last section does not
2320 bring us past the current section on the page, so the
2321 only case in which the new section is not on the same
2322 page as the previous section is when the previous section
2323 ends precisely on a page boundary. */
2328 /* Otherwise, we can use the same segment. */
2329 new_segment = false;
2334 if ((hdr->flags & SEC_READONLY) == 0)
2340 /* We need a new program segment. We must create a new program
2341 header holding all the sections from phdr_index until hdr. */
2343 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2350 if ((hdr->flags & SEC_READONLY) == 0)
2357 phdr_in_segment = false;
2360 /* Create a final PT_LOAD program segment. */
2361 if (last_hdr != NULL)
2363 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2371 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2374 m = ((struct elf_segment_map *)
2375 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2379 m->p_type = PT_DYNAMIC;
2381 m->sections[0] = dynsec;
2387 /* For each loadable .note section, add a PT_NOTE segment. We don't
2388 use bfd_get_section_by_name, because if we link together
2389 nonloadable .note sections and loadable .note sections, we will
2390 generate two .note sections in the output file. FIXME: Using
2391 names for section types is bogus anyhow. */
2392 for (s = abfd->sections; s != NULL; s = s->next)
2394 if ((s->flags & SEC_LOAD) != 0
2395 && strncmp (s->name, ".note", 5) == 0)
2397 m = ((struct elf_segment_map *)
2398 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2402 m->p_type = PT_NOTE;
2414 elf_tdata (abfd)->segment_map = mfirst;
2418 if (sections != NULL)
2423 /* Sort sections by address. */
2426 elf_sort_sections (arg1, arg2)
2430 const asection *sec1 = *(const asection **) arg1;
2431 const asection *sec2 = *(const asection **) arg2;
2433 /* Sort by LMA first, since this is the address used to
2434 place the section into a segment. */
2435 if (sec1->lma < sec2->lma)
2437 else if (sec1->lma > sec2->lma)
2440 /* Then sort by VMA. Normally the LMA and the VMA will be
2441 the same, and this will do nothing. */
2442 if (sec1->vma < sec2->vma)
2444 else if (sec1->vma > sec2->vma)
2447 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2449 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2454 return sec1->target_index - sec2->target_index;
2464 /* Sort by size, to put zero sized sections before others at the
2467 if (sec1->_raw_size < sec2->_raw_size)
2469 if (sec1->_raw_size > sec2->_raw_size)
2472 return sec1->target_index - sec2->target_index;
2475 /* Assign file positions to the sections based on the mapping from
2476 sections to segments. This function also sets up some fields in
2477 the file header, and writes out the program headers. */
2480 assign_file_positions_for_segments (abfd)
2483 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2485 struct elf_segment_map *m;
2487 Elf_Internal_Phdr *phdrs;
2489 bfd_vma filehdr_vaddr, filehdr_paddr;
2490 bfd_vma phdrs_vaddr, phdrs_paddr;
2491 Elf_Internal_Phdr *p;
2493 if (elf_tdata (abfd)->segment_map == NULL)
2495 if (! map_sections_to_segments (abfd))
2499 if (bed->elf_backend_modify_segment_map)
2501 if (! (*bed->elf_backend_modify_segment_map) (abfd))
2506 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2509 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
2510 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
2511 elf_elfheader (abfd)->e_phnum = count;
2516 /* If we already counted the number of program segments, make sure
2517 that we allocated enough space. This happens when SIZEOF_HEADERS
2518 is used in a linker script. */
2519 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
2520 if (alloc != 0 && count > alloc)
2522 ((*_bfd_error_handler)
2523 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2524 bfd_get_filename (abfd), alloc, count));
2525 bfd_set_error (bfd_error_bad_value);
2532 phdrs = ((Elf_Internal_Phdr *)
2533 bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
2537 off = bed->s->sizeof_ehdr;
2538 off += alloc * bed->s->sizeof_phdr;
2545 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2552 /* If elf_segment_map is not from map_sections_to_segments, the
2553 sections may not be correctly ordered. */
2555 qsort (m->sections, (size_t) m->count, sizeof (asection *),
2558 p->p_type = m->p_type;
2560 if (m->p_flags_valid)
2561 p->p_flags = m->p_flags;
2565 if (p->p_type == PT_LOAD
2567 && (m->sections[0]->flags & SEC_ALLOC) != 0)
2569 if ((abfd->flags & D_PAGED) != 0)
2570 off += (m->sections[0]->vma - off) % bed->maxpagesize;
2573 bfd_size_type align;
2576 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2578 bfd_size_type secalign;
2580 secalign = bfd_get_section_alignment (abfd, *secpp);
2581 if (secalign > align)
2585 off += (m->sections[0]->vma - off) % (1 << align);
2592 p->p_vaddr = m->sections[0]->vma;
2594 if (m->p_paddr_valid)
2595 p->p_paddr = m->p_paddr;
2596 else if (m->count == 0)
2599 p->p_paddr = m->sections[0]->lma;
2601 if (p->p_type == PT_LOAD
2602 && (abfd->flags & D_PAGED) != 0)
2603 p->p_align = bed->maxpagesize;
2604 else if (m->count == 0)
2605 p->p_align = bed->s->file_align;
2613 if (m->includes_filehdr)
2615 if (! m->p_flags_valid)
2618 p->p_filesz = bed->s->sizeof_ehdr;
2619 p->p_memsz = bed->s->sizeof_ehdr;
2622 BFD_ASSERT (p->p_type == PT_LOAD);
2624 if (p->p_vaddr < (bfd_vma) off)
2626 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2627 bfd_get_filename (abfd));
2628 bfd_set_error (bfd_error_bad_value);
2633 if (! m->p_paddr_valid)
2636 if (p->p_type == PT_LOAD)
2638 filehdr_vaddr = p->p_vaddr;
2639 filehdr_paddr = p->p_paddr;
2643 if (m->includes_phdrs)
2645 if (! m->p_flags_valid)
2648 if (m->includes_filehdr)
2650 if (p->p_type == PT_LOAD)
2652 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
2653 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
2658 p->p_offset = bed->s->sizeof_ehdr;
2662 BFD_ASSERT (p->p_type == PT_LOAD);
2663 p->p_vaddr -= off - p->p_offset;
2664 if (! m->p_paddr_valid)
2665 p->p_paddr -= off - p->p_offset;
2668 if (p->p_type == PT_LOAD)
2670 phdrs_vaddr = p->p_vaddr;
2671 phdrs_paddr = p->p_paddr;
2674 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
2677 p->p_filesz += alloc * bed->s->sizeof_phdr;
2678 p->p_memsz += alloc * bed->s->sizeof_phdr;
2681 if (p->p_type == PT_LOAD
2682 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
2684 if (! m->includes_filehdr && ! m->includes_phdrs)
2690 adjust = off - (p->p_offset + p->p_filesz);
2691 p->p_filesz += adjust;
2692 p->p_memsz += adjust;
2698 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2702 bfd_size_type align;
2706 align = 1 << bfd_get_section_alignment (abfd, sec);
2708 /* The section may have artificial alignment forced by a
2709 link script. Notice this case by the gap between the
2710 cumulative phdr vma and the section's vma. */
2711 if (p->p_vaddr + p->p_memsz < sec->vma)
2713 bfd_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
2715 p->p_memsz += adjust;
2718 if ((flags & SEC_LOAD) != 0)
2719 p->p_filesz += adjust;
2722 if (p->p_type == PT_LOAD)
2724 bfd_signed_vma adjust;
2726 if ((flags & SEC_LOAD) != 0)
2728 adjust = sec->lma - (p->p_paddr + p->p_memsz);
2732 else if ((flags & SEC_ALLOC) != 0)
2734 /* The section VMA must equal the file position
2735 modulo the page size. FIXME: I'm not sure if
2736 this adjustment is really necessary. We used to
2737 not have the SEC_LOAD case just above, and then
2738 this was necessary, but now I'm not sure. */
2739 if ((abfd->flags & D_PAGED) != 0)
2740 adjust = (sec->vma - voff) % bed->maxpagesize;
2742 adjust = (sec->vma - voff) % align;
2751 (* _bfd_error_handler)
2752 (_("Error: First section in segment (%s) starts at 0x%x"),
2753 bfd_section_name (abfd, sec), sec->lma);
2754 (* _bfd_error_handler)
2755 (_(" whereas segment starts at 0x%x"),
2760 p->p_memsz += adjust;
2763 if ((flags & SEC_LOAD) != 0)
2764 p->p_filesz += adjust;
2769 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2770 used in a linker script we may have a section with
2771 SEC_LOAD clear but which is supposed to have
2773 if ((flags & SEC_LOAD) != 0
2774 || (flags & SEC_HAS_CONTENTS) != 0)
2775 off += sec->_raw_size;
2777 if ((flags & SEC_ALLOC) != 0)
2778 voff += sec->_raw_size;
2781 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
2783 if (i == 0) /* the actual "note" segment */
2784 { /* this one actually contains everything. */
2786 p->p_filesz = sec->_raw_size;
2787 off += sec->_raw_size;
2790 else /* fake sections -- don't need to be written */
2794 flags = sec->flags = 0; /* no contents */
2801 p->p_memsz += sec->_raw_size;
2803 if ((flags & SEC_LOAD) != 0)
2804 p->p_filesz += sec->_raw_size;
2806 if (align > p->p_align
2807 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
2811 if (! m->p_flags_valid)
2814 if ((flags & SEC_CODE) != 0)
2816 if ((flags & SEC_READONLY) == 0)
2822 /* Now that we have set the section file positions, we can set up
2823 the file positions for the non PT_LOAD segments. */
2824 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2828 if (p->p_type != PT_LOAD && m->count > 0)
2830 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
2831 p->p_offset = m->sections[0]->filepos;
2835 if (m->includes_filehdr)
2837 p->p_vaddr = filehdr_vaddr;
2838 if (! m->p_paddr_valid)
2839 p->p_paddr = filehdr_paddr;
2841 else if (m->includes_phdrs)
2843 p->p_vaddr = phdrs_vaddr;
2844 if (! m->p_paddr_valid)
2845 p->p_paddr = phdrs_paddr;
2850 /* Clear out any program headers we allocated but did not use. */
2851 for (; count < alloc; count++, p++)
2853 memset (p, 0, sizeof *p);
2854 p->p_type = PT_NULL;
2857 elf_tdata (abfd)->phdr = phdrs;
2859 elf_tdata (abfd)->next_file_pos = off;
2861 /* Write out the program headers. */
2862 if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
2863 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
2869 /* Get the size of the program header.
2871 If this is called by the linker before any of the section VMA's are set, it
2872 can't calculate the correct value for a strange memory layout. This only
2873 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2874 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2875 data segment (exclusive of .interp and .dynamic).
2877 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2878 will be two segments. */
2880 static bfd_size_type
2881 get_program_header_size (abfd)
2886 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2888 /* We can't return a different result each time we're called. */
2889 if (elf_tdata (abfd)->program_header_size != 0)
2890 return elf_tdata (abfd)->program_header_size;
2892 if (elf_tdata (abfd)->segment_map != NULL)
2894 struct elf_segment_map *m;
2897 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2899 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
2900 return elf_tdata (abfd)->program_header_size;
2903 /* Assume we will need exactly two PT_LOAD segments: one for text
2904 and one for data. */
2907 s = bfd_get_section_by_name (abfd, ".interp");
2908 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2910 /* If we have a loadable interpreter section, we need a
2911 PT_INTERP segment. In this case, assume we also need a
2912 PT_PHDR segment, although that may not be true for all
2917 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
2919 /* We need a PT_DYNAMIC segment. */
2923 for (s = abfd->sections; s != NULL; s = s->next)
2925 if ((s->flags & SEC_LOAD) != 0
2926 && strncmp (s->name, ".note", 5) == 0)
2928 /* We need a PT_NOTE segment. */
2933 /* Let the backend count up any program headers it might need. */
2934 if (bed->elf_backend_additional_program_headers)
2938 a = (*bed->elf_backend_additional_program_headers) (abfd);
2944 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
2945 return elf_tdata (abfd)->program_header_size;
2948 /* Work out the file positions of all the sections. This is called by
2949 _bfd_elf_compute_section_file_positions. All the section sizes and
2950 VMAs must be known before this is called.
2952 We do not consider reloc sections at this point, unless they form
2953 part of the loadable image. Reloc sections are assigned file
2954 positions in assign_file_positions_for_relocs, which is called by
2955 write_object_contents and final_link.
2957 We also don't set the positions of the .symtab and .strtab here. */
2960 assign_file_positions_except_relocs (abfd)
2963 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
2964 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
2965 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
2967 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2969 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
2970 && bfd_get_format (abfd) != bfd_core)
2972 Elf_Internal_Shdr **hdrpp;
2975 /* Start after the ELF header. */
2976 off = i_ehdrp->e_ehsize;
2978 /* We are not creating an executable, which means that we are
2979 not creating a program header, and that the actual order of
2980 the sections in the file is unimportant. */
2981 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
2983 Elf_Internal_Shdr *hdr;
2986 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
2988 hdr->sh_offset = -1;
2991 if (i == tdata->symtab_section
2992 || i == tdata->strtab_section)
2994 hdr->sh_offset = -1;
2998 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3004 Elf_Internal_Shdr **hdrpp;
3006 /* Assign file positions for the loaded sections based on the
3007 assignment of sections to segments. */
3008 if (! assign_file_positions_for_segments (abfd))
3011 /* Assign file positions for the other sections. */
3013 off = elf_tdata (abfd)->next_file_pos;
3014 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3016 Elf_Internal_Shdr *hdr;
3019 if (hdr->bfd_section != NULL
3020 && hdr->bfd_section->filepos != 0)
3021 hdr->sh_offset = hdr->bfd_section->filepos;
3022 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3024 ((*_bfd_error_handler)
3025 (_("%s: warning: allocated section `%s' not in segment"),
3026 bfd_get_filename (abfd),
3027 (hdr->bfd_section == NULL
3029 : hdr->bfd_section->name)));
3030 if ((abfd->flags & D_PAGED) != 0)
3031 off += (hdr->sh_addr - off) % bed->maxpagesize;
3033 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3034 off = _bfd_elf_assign_file_position_for_section (hdr, off,
3037 else if (hdr->sh_type == SHT_REL
3038 || hdr->sh_type == SHT_RELA
3039 || hdr == i_shdrpp[tdata->symtab_section]
3040 || hdr == i_shdrpp[tdata->strtab_section])
3041 hdr->sh_offset = -1;
3043 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3047 /* Place the section headers. */
3048 off = align_file_position (off, bed->s->file_align);
3049 i_ehdrp->e_shoff = off;
3050 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3052 elf_tdata (abfd)->next_file_pos = off;
3061 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3062 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3063 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3065 struct bfd_strtab_hash *shstrtab;
3066 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3068 i_ehdrp = elf_elfheader (abfd);
3069 i_shdrp = elf_elfsections (abfd);
3071 shstrtab = _bfd_elf_stringtab_init ();
3072 if (shstrtab == NULL)
3075 elf_shstrtab (abfd) = shstrtab;
3077 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3078 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3079 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3080 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3082 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3083 i_ehdrp->e_ident[EI_DATA] =
3084 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3085 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3087 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_SYSV;
3088 i_ehdrp->e_ident[EI_ABIVERSION] = 0;
3090 for (count = EI_PAD; count < EI_NIDENT; count++)
3091 i_ehdrp->e_ident[count] = 0;
3093 if ((abfd->flags & DYNAMIC) != 0)
3094 i_ehdrp->e_type = ET_DYN;
3095 else if ((abfd->flags & EXEC_P) != 0)
3096 i_ehdrp->e_type = ET_EXEC;
3097 else if (bfd_get_format (abfd) == bfd_core)
3098 i_ehdrp->e_type = ET_CORE;
3100 i_ehdrp->e_type = ET_REL;
3102 switch (bfd_get_arch (abfd))
3104 case bfd_arch_unknown:
3105 i_ehdrp->e_machine = EM_NONE;
3107 case bfd_arch_sparc:
3108 if (bed->s->arch_size == 64)
3109 i_ehdrp->e_machine = EM_SPARCV9;
3111 i_ehdrp->e_machine = EM_SPARC;
3114 i_ehdrp->e_machine = EM_386;
3117 i_ehdrp->e_machine = EM_68K;
3120 i_ehdrp->e_machine = EM_88K;
3123 i_ehdrp->e_machine = EM_860;
3126 i_ehdrp->e_machine = EM_960;
3128 case bfd_arch_mips: /* MIPS Rxxxx */
3129 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
3132 i_ehdrp->e_machine = EM_PARISC;
3134 case bfd_arch_powerpc:
3135 i_ehdrp->e_machine = EM_PPC;
3137 case bfd_arch_alpha:
3138 i_ehdrp->e_machine = EM_ALPHA;
3141 i_ehdrp->e_machine = EM_SH;
3144 i_ehdrp->e_machine = EM_CYGNUS_D10V;
3147 i_ehdrp->e_machine = EM_CYGNUS_D30V;
3150 i_ehdrp->e_machine = EM_CYGNUS_FR30;
3152 case bfd_arch_mcore:
3153 i_ehdrp->e_machine = EM_MCORE;
3156 switch (bfd_get_mach (abfd))
3159 case 0: i_ehdrp->e_machine = EM_CYGNUS_V850; break;
3163 i_ehdrp->e_machine = EM_CYGNUS_ARC;
3166 i_ehdrp->e_machine = EM_ARM;
3169 i_ehdrp->e_machine = EM_CYGNUS_M32R;
3171 case bfd_arch_mn10200:
3172 i_ehdrp->e_machine = EM_CYGNUS_MN10200;
3174 case bfd_arch_mn10300:
3175 i_ehdrp->e_machine = EM_CYGNUS_MN10300;
3177 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3179 i_ehdrp->e_machine = EM_NONE;
3181 i_ehdrp->e_version = bed->s->ev_current;
3182 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3184 /* no program header, for now. */
3185 i_ehdrp->e_phoff = 0;
3186 i_ehdrp->e_phentsize = 0;
3187 i_ehdrp->e_phnum = 0;
3189 /* each bfd section is section header entry */
3190 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3191 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3193 /* if we're building an executable, we'll need a program header table */
3194 if (abfd->flags & EXEC_P)
3196 /* it all happens later */
3198 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3200 /* elf_build_phdrs() returns a (NULL-terminated) array of
3201 Elf_Internal_Phdrs */
3202 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3203 i_ehdrp->e_phoff = outbase;
3204 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3209 i_ehdrp->e_phentsize = 0;
3211 i_ehdrp->e_phoff = 0;
3214 elf_tdata (abfd)->symtab_hdr.sh_name =
3215 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
3216 elf_tdata (abfd)->strtab_hdr.sh_name =
3217 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
3218 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3219 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
3220 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3221 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3222 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3228 /* Assign file positions for all the reloc sections which are not part
3229 of the loadable file image. */
3232 _bfd_elf_assign_file_positions_for_relocs (abfd)
3237 Elf_Internal_Shdr **shdrpp;
3239 off = elf_tdata (abfd)->next_file_pos;
3241 for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
3242 i < elf_elfheader (abfd)->e_shnum;
3245 Elf_Internal_Shdr *shdrp;
3248 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3249 && shdrp->sh_offset == -1)
3250 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3253 elf_tdata (abfd)->next_file_pos = off;
3257 _bfd_elf_write_object_contents (abfd)
3260 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3261 Elf_Internal_Ehdr *i_ehdrp;
3262 Elf_Internal_Shdr **i_shdrp;
3266 if (! abfd->output_has_begun
3267 && ! _bfd_elf_compute_section_file_positions
3268 (abfd, (struct bfd_link_info *) NULL))
3271 i_shdrp = elf_elfsections (abfd);
3272 i_ehdrp = elf_elfheader (abfd);
3275 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3279 _bfd_elf_assign_file_positions_for_relocs (abfd);
3281 /* After writing the headers, we need to write the sections too... */
3282 for (count = 1; count < i_ehdrp->e_shnum; count++)
3284 if (bed->elf_backend_section_processing)
3285 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3286 if (i_shdrp[count]->contents)
3288 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3289 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
3291 != i_shdrp[count]->sh_size))
3296 /* Write out the section header names. */
3297 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
3298 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
3301 if (bed->elf_backend_final_write_processing)
3302 (*bed->elf_backend_final_write_processing) (abfd,
3303 elf_tdata (abfd)->linker);
3305 return bed->s->write_shdrs_and_ehdr (abfd);
3309 _bfd_elf_write_corefile_contents (abfd)
3312 /* Hopefully this can be done just like an object file. */
3313 return _bfd_elf_write_object_contents (abfd);
3315 /* given a section, search the header to find them... */
3317 _bfd_elf_section_from_bfd_section (abfd, asect)
3321 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3322 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
3324 Elf_Internal_Shdr *hdr;
3325 int maxindex = elf_elfheader (abfd)->e_shnum;
3327 for (index = 0; index < maxindex; index++)
3329 hdr = i_shdrp[index];
3330 if (hdr->bfd_section == asect)
3334 if (bed->elf_backend_section_from_bfd_section)
3336 for (index = 0; index < maxindex; index++)
3340 hdr = i_shdrp[index];
3342 if ((*bed->elf_backend_section_from_bfd_section)
3343 (abfd, hdr, asect, &retval))
3348 if (bfd_is_abs_section (asect))
3350 if (bfd_is_com_section (asect))
3352 if (bfd_is_und_section (asect))
3355 bfd_set_error (bfd_error_nonrepresentable_section);
3360 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3364 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
3366 asymbol **asym_ptr_ptr;
3368 asymbol *asym_ptr = *asym_ptr_ptr;
3370 flagword flags = asym_ptr->flags;
3372 /* When gas creates relocations against local labels, it creates its
3373 own symbol for the section, but does put the symbol into the
3374 symbol chain, so udata is 0. When the linker is generating
3375 relocatable output, this section symbol may be for one of the
3376 input sections rather than the output section. */
3377 if (asym_ptr->udata.i == 0
3378 && (flags & BSF_SECTION_SYM)
3379 && asym_ptr->section)
3383 if (asym_ptr->section->output_section != NULL)
3384 indx = asym_ptr->section->output_section->index;
3386 indx = asym_ptr->section->index;
3387 if (elf_section_syms (abfd)[indx])
3388 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
3391 idx = asym_ptr->udata.i;
3395 /* This case can occur when using --strip-symbol on a symbol
3396 which is used in a relocation entry. */
3397 (*_bfd_error_handler)
3398 (_("%s: symbol `%s' required but not present"),
3399 bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
3400 bfd_set_error (bfd_error_no_symbols);
3407 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3408 (long) asym_ptr, asym_ptr->name, idx, flags,
3409 elf_symbol_flags (flags));
3417 /* Copy private BFD data. This copies any program header information. */
3420 copy_private_bfd_data (ibfd, obfd)
3424 Elf_Internal_Ehdr *iehdr;
3425 struct elf_segment_map *mfirst;
3426 struct elf_segment_map **pm;
3427 struct elf_segment_map *m;
3428 Elf_Internal_Phdr *p;
3430 unsigned int num_segments;
3431 boolean phdr_included = false;
3433 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3434 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3437 if (elf_tdata (ibfd)->phdr == NULL)
3440 iehdr = elf_elfheader (ibfd);
3445 num_segments = elf_elfheader (ibfd)->e_phnum;
3447 #define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3448 ((addr) >= (bottom) \
3449 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3450 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3452 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3454 #define IS_COREFILE_NOTE(p, s) \
3455 (p->p_type == PT_NOTE \
3456 && bfd_get_format (ibfd) == bfd_core \
3457 && s->vma == 0 && s->lma == 0 \
3458 && (bfd_vma) s->filepos >= p->p_offset \
3459 && (bfd_vma) s->filepos + s->_raw_size \
3460 <= p->p_offset + p->p_filesz)
3462 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3463 linker, which generates a PT_INTERP section with p_vaddr and
3464 p_memsz set to 0. */
3466 #define IS_SOLARIS_PT_INTERP(p, s) \
3468 && p->p_filesz > 0 \
3469 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3470 && s->_raw_size > 0 \
3471 && (bfd_vma) s->filepos >= p->p_offset \
3472 && ((bfd_vma) s->filepos + s->_raw_size \
3473 <= p->p_offset + p->p_filesz))
3475 /* Scan through the segments specified in the program header
3476 of the input BFD. */
3477 for (i = 0, p = elf_tdata (ibfd)->phdr; i < num_segments; i++, p++)
3481 asection **sections;
3484 bfd_vma matching_lma;
3485 bfd_vma suggested_lma;
3488 /* For each section in the input BFD, decide if it should be
3489 included in the current segment. A section will be included
3490 if it is within the address space of the segment, and it is
3491 an allocated segment, and there is an output section
3492 associated with it. */
3494 for (s = ibfd->sections; s != NULL; s = s->next)
3495 if (s->output_section != NULL)
3497 if ((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3498 || IS_SOLARIS_PT_INTERP (p, s))
3499 && (s->flags & SEC_ALLOC) != 0)
3501 else if (IS_COREFILE_NOTE (p, s))
3505 /* Allocate a segment map big enough to contain all of the
3506 sections we have selected. */
3507 m = ((struct elf_segment_map *)
3509 (sizeof (struct elf_segment_map)
3510 + ((size_t) csecs - 1) * sizeof (asection *))));
3514 /* Initialise the fields of the segment map. Default to
3515 using the physical address of the segment in the input BFD. */
3517 m->p_type = p->p_type;
3518 m->p_flags = p->p_flags;
3519 m->p_flags_valid = 1;
3520 m->p_paddr = p->p_paddr;
3521 m->p_paddr_valid = 1;
3523 /* Determine if this segment contains the ELF file header
3524 and if it contains the program headers themselves. */
3525 m->includes_filehdr = (p->p_offset == 0
3526 && p->p_filesz >= iehdr->e_ehsize);
3528 m->includes_phdrs = 0;
3530 if (! phdr_included || p->p_type != PT_LOAD)
3533 (p->p_offset <= (bfd_vma) iehdr->e_phoff
3534 && (p->p_offset + p->p_filesz
3535 >= ((bfd_vma) iehdr->e_phoff
3536 + iehdr->e_phnum * iehdr->e_phentsize)));
3537 if (p->p_type == PT_LOAD && m->includes_phdrs)
3538 phdr_included = true;
3543 /* Special segments, such as the PT_PHDR segment, may contain
3544 no sections, but ordinary, loadable segments should contain
3547 if (p->p_type == PT_LOAD)
3549 (_("%s: warning: Empty loadable segment detected\n"),
3550 bfd_get_filename (ibfd));
3559 /* Now scan the sections in the input BFD again and attempt
3560 to add their corresponding output sections to the segment map.
3561 The problem here is how to handle an output section which has
3562 been moved (ie had its LMA changed). There are four possibilities:
3564 1. None of the sections have been moved.
3565 In this case we can continue to use the segment LMA from the
3568 2. All of the sections have been moved by the same amount.
3569 In this case we can change the segment's LMA to match the LMA
3570 of the first section.
3572 3. Some of the sections have been moved, others have not.
3573 In this case those sections which have not been moved can be
3574 placed in the current segment which will have to have its size,
3575 and possibly its LMA changed, and a new segment or segments will
3576 have to be created to contain the other sections.
3578 4. The sections have been moved, but not be the same amount.
3579 In this case we can change the segment's LMA to match the LMA
3580 of the first section and we will have to create a new segment
3581 or segments to contain the other sections.
3583 In order to save time, we allocate an array to hold the section
3584 pointers that we are interested in. As these sections get assigned
3585 to a segment, they are removed from this array. */
3587 sections = (asection **) bfd_malloc (sizeof (asection *) * csecs);
3588 if (sections == NULL)
3591 /* Step One: Scan for segment vs section LMA conflicts.
3592 Also add the sections to the section array allocated above.
3593 Also add the sections to the current segment. In the common
3594 case, where the sections have not been moved, this means that
3595 we have completely filled the segment, and there is nothing
3599 matching_lma = false;
3602 for (j = 0, s = ibfd->sections; s != NULL; s = s->next)
3604 os = s->output_section;
3606 if ((((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3607 || IS_SOLARIS_PT_INTERP (p, s))
3608 && (s->flags & SEC_ALLOC) != 0)
3609 || IS_COREFILE_NOTE (p, s))
3614 /* The Solaris native linker always sets p_paddr to 0.
3615 We try to catch that case here, and set it to the
3621 && (os->vma == (p->p_vaddr
3622 + (m->includes_filehdr
3625 + (m->includes_phdrs
3626 ? iehdr->e_phnum * iehdr->e_phentsize
3628 m->p_paddr = p->p_vaddr;
3630 /* Match up the physical address of the segment with the
3631 LMA address of the output section. */
3632 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3633 || IS_COREFILE_NOTE (p, s))
3635 if (matching_lma == 0)
3636 matching_lma = os->lma;
3638 /* We assume that if the section fits within the segment
3639 that it does not overlap any other section within that
3641 m->sections[isec++] = os;
3643 else if (suggested_lma == 0)
3644 suggested_lma = os->lma;
3648 BFD_ASSERT (j == csecs);
3650 /* Step Two: Adjust the physical address of the current segment,
3654 /* All of the sections fitted within the segment as currently
3655 specified. This is the default case. Add the segment to
3656 the list of built segments and carry on to process the next
3657 program header in the input BFD. */
3665 else if (matching_lma != 0)
3667 /* At least one section fits inside the current segment.
3668 Keep it, but modify its physical address to match the
3669 LMA of the first section that fitted. */
3671 m->p_paddr = matching_lma;
3675 /* None of the sections fitted inside the current segment.
3676 Change the current segment's physical address to match
3677 the LMA of the first section. */
3679 m->p_paddr = suggested_lma;
3682 /* Step Three: Loop over the sections again, this time assigning
3683 those that fit to the current segment and remvoing them from the
3684 sections array; but making sure not to leave large gaps. Once all
3685 possible sections have been assigned to the current segment it is
3686 added to the list of built segments and if sections still remain
3687 to be assigned, a new segment is constructed before repeating
3695 /* Fill the current segment with sections that fit. */
3696 for (j = 0; j < csecs; j++)
3703 os = s->output_section;
3705 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3706 || IS_COREFILE_NOTE (p, s))
3710 /* If the first section in a segment does not start at
3711 the beginning of the segment, then something is wrong. */
3712 if (os->lma != m->p_paddr)
3717 asection * prev_sec;
3718 bfd_vma maxpagesize;
3720 prev_sec = m->sections[m->count - 1];
3721 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
3723 /* If the gap between the end of the previous section
3724 and the start of this section is more than maxpagesize
3725 then we need to start a new segment. */
3726 if (BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
3727 < BFD_ALIGN (os->lma, maxpagesize))
3729 if (suggested_lma == 0)
3730 suggested_lma = os->lma;
3736 m->sections[m->count++] = os;
3740 else if (suggested_lma == 0)
3741 suggested_lma = os->lma;
3744 BFD_ASSERT (m->count > 0);
3746 /* Add the current segment to the list of built segments. */
3752 /* We still have not allocated all of the sections to
3753 segments. Create a new segment here, initialise it
3754 and carry on looping. */
3756 m = ((struct elf_segment_map *)
3758 (sizeof (struct elf_segment_map)
3759 + ((size_t) csecs - 1) * sizeof (asection *))));
3763 /* Initialise the fields of the segment map. Set the physical
3764 physical address to the LMA of the first section that has
3765 not yet been assigned. */
3768 m->p_type = p->p_type;
3769 m->p_flags = p->p_flags;
3770 m->p_flags_valid = 1;
3771 m->p_paddr = suggested_lma;
3772 m->p_paddr_valid = 1;
3773 m->includes_filehdr = 0;
3774 m->includes_phdrs = 0;
3777 while (isec < csecs);
3782 /* The Solaris linker creates program headers in which all the
3783 p_paddr fields are zero. When we try to objcopy or strip such a
3784 file, we get confused. Check for this case, and if we find it
3785 reset the p_paddr_valid fields. */
3786 for (m = mfirst; m != NULL; m = m->next)
3787 if (m->p_paddr != 0)
3791 for (m = mfirst; m != NULL; m = m->next)
3792 m->p_paddr_valid = 0;
3795 elf_tdata (obfd)->segment_map = mfirst;
3798 /* Final Step: Sort the segments into ascending order of physical address. */
3801 struct elf_segment_map* prev;
3804 for (m = mfirst->next; m != NULL; prev = m, m = m->next)
3806 /* Yes I know - its a bubble sort....*/
3807 if (m->next != NULL && (m->next->p_paddr < m->p_paddr))
3809 /* swap m and m->next */
3810 prev->next = m->next;
3811 m->next = m->next->next;
3812 prev->next->next = m;
3821 #undef IS_CONTAINED_BY
3822 #undef IS_SOLARIS_PT_INTERP
3823 #undef IS_COREFILE_NOTE
3827 /* Copy private section information. This copies over the entsize
3828 field, and sometimes the info field. */
3831 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
3837 Elf_Internal_Shdr *ihdr, *ohdr;
3839 if (ibfd->xvec->flavour != bfd_target_elf_flavour
3840 || obfd->xvec->flavour != bfd_target_elf_flavour)
3843 /* Copy over private BFD data if it has not already been copied.
3844 This must be done here, rather than in the copy_private_bfd_data
3845 entry point, because the latter is called after the section
3846 contents have been set, which means that the program headers have
3847 already been worked out. */
3848 if (elf_tdata (obfd)->segment_map == NULL
3849 && elf_tdata (ibfd)->phdr != NULL)
3853 /* Only set up the segments if there are no more SEC_ALLOC
3854 sections. FIXME: This won't do the right thing if objcopy is
3855 used to remove the last SEC_ALLOC section, since objcopy
3856 won't call this routine in that case. */
3857 for (s = isec->next; s != NULL; s = s->next)
3858 if ((s->flags & SEC_ALLOC) != 0)
3862 if (! copy_private_bfd_data (ibfd, obfd))
3867 ihdr = &elf_section_data (isec)->this_hdr;
3868 ohdr = &elf_section_data (osec)->this_hdr;
3870 ohdr->sh_entsize = ihdr->sh_entsize;
3872 if (ihdr->sh_type == SHT_SYMTAB
3873 || ihdr->sh_type == SHT_DYNSYM
3874 || ihdr->sh_type == SHT_GNU_verneed
3875 || ihdr->sh_type == SHT_GNU_verdef)
3876 ohdr->sh_info = ihdr->sh_info;
3878 elf_section_data (osec)->use_rela_p
3879 = elf_section_data (isec)->use_rela_p;
3884 /* Copy private symbol information. If this symbol is in a section
3885 which we did not map into a BFD section, try to map the section
3886 index correctly. We use special macro definitions for the mapped
3887 section indices; these definitions are interpreted by the
3888 swap_out_syms function. */
3890 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3891 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3892 #define MAP_STRTAB (SHN_LORESERVE - 3)
3893 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3896 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
3902 elf_symbol_type *isym, *osym;
3904 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3905 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3908 isym = elf_symbol_from (ibfd, isymarg);
3909 osym = elf_symbol_from (obfd, osymarg);
3913 && bfd_is_abs_section (isym->symbol.section))
3917 shndx = isym->internal_elf_sym.st_shndx;
3918 if (shndx == elf_onesymtab (ibfd))
3919 shndx = MAP_ONESYMTAB;
3920 else if (shndx == elf_dynsymtab (ibfd))
3921 shndx = MAP_DYNSYMTAB;
3922 else if (shndx == elf_tdata (ibfd)->strtab_section)
3924 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
3925 shndx = MAP_SHSTRTAB;
3926 osym->internal_elf_sym.st_shndx = shndx;
3932 /* Swap out the symbols. */
3935 swap_out_syms (abfd, sttp, relocatable_p)
3937 struct bfd_strtab_hash **sttp;
3940 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3942 if (!elf_map_symbols (abfd))
3945 /* Dump out the symtabs. */
3947 int symcount = bfd_get_symcount (abfd);
3948 asymbol **syms = bfd_get_outsymbols (abfd);
3949 struct bfd_strtab_hash *stt;
3950 Elf_Internal_Shdr *symtab_hdr;
3951 Elf_Internal_Shdr *symstrtab_hdr;
3952 char *outbound_syms;
3955 stt = _bfd_elf_stringtab_init ();
3959 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3960 symtab_hdr->sh_type = SHT_SYMTAB;
3961 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
3962 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
3963 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
3964 symtab_hdr->sh_addralign = bed->s->file_align;
3966 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
3967 symstrtab_hdr->sh_type = SHT_STRTAB;
3969 outbound_syms = bfd_alloc (abfd,
3970 (1 + symcount) * bed->s->sizeof_sym);
3971 if (outbound_syms == NULL)
3973 symtab_hdr->contents = (PTR) outbound_syms;
3975 /* now generate the data (for "contents") */
3977 /* Fill in zeroth symbol and swap it out. */
3978 Elf_Internal_Sym sym;
3984 sym.st_shndx = SHN_UNDEF;
3985 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
3986 outbound_syms += bed->s->sizeof_sym;
3988 for (idx = 0; idx < symcount; idx++)
3990 Elf_Internal_Sym sym;
3991 bfd_vma value = syms[idx]->value;
3992 elf_symbol_type *type_ptr;
3993 flagword flags = syms[idx]->flags;
3996 if (flags & BSF_SECTION_SYM)
3997 /* Section symbols have no names. */
4001 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4004 if (sym.st_name == (unsigned long) -1)
4008 type_ptr = elf_symbol_from (abfd, syms[idx]);
4010 if ((flags & BSF_SECTION_SYM) == 0
4011 && bfd_is_com_section (syms[idx]->section))
4013 /* ELF common symbols put the alignment into the `value' field,
4014 and the size into the `size' field. This is backwards from
4015 how BFD handles it, so reverse it here. */
4016 sym.st_size = value;
4017 if (type_ptr == NULL
4018 || type_ptr->internal_elf_sym.st_value == 0)
4019 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4021 sym.st_value = type_ptr->internal_elf_sym.st_value;
4022 sym.st_shndx = _bfd_elf_section_from_bfd_section
4023 (abfd, syms[idx]->section);
4027 asection *sec = syms[idx]->section;
4030 if (sec->output_section)
4032 value += sec->output_offset;
4033 sec = sec->output_section;
4035 /* Don't add in the section vma for relocatable output. */
4036 if (! relocatable_p)
4038 sym.st_value = value;
4039 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4041 if (bfd_is_abs_section (sec)
4043 && type_ptr->internal_elf_sym.st_shndx != 0)
4045 /* This symbol is in a real ELF section which we did
4046 not create as a BFD section. Undo the mapping done
4047 by copy_private_symbol_data. */
4048 shndx = type_ptr->internal_elf_sym.st_shndx;
4052 shndx = elf_onesymtab (abfd);
4055 shndx = elf_dynsymtab (abfd);
4058 shndx = elf_tdata (abfd)->strtab_section;
4061 shndx = elf_tdata (abfd)->shstrtab_section;
4069 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4075 /* Writing this would be a hell of a lot easier if
4076 we had some decent documentation on bfd, and
4077 knew what to expect of the library, and what to
4078 demand of applications. For example, it
4079 appears that `objcopy' might not set the
4080 section of a symbol to be a section that is
4081 actually in the output file. */
4082 sec2 = bfd_get_section_by_name (abfd, sec->name);
4083 BFD_ASSERT (sec2 != 0);
4084 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4085 BFD_ASSERT (shndx != -1);
4089 sym.st_shndx = shndx;
4092 if ((flags & BSF_FUNCTION) != 0)
4094 else if ((flags & BSF_OBJECT) != 0)
4099 /* Processor-specific types */
4100 if (bed->elf_backend_get_symbol_type)
4101 type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
4103 if (flags & BSF_SECTION_SYM)
4104 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4105 else if (bfd_is_com_section (syms[idx]->section))
4106 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
4107 else if (bfd_is_und_section (syms[idx]->section))
4108 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
4112 else if (flags & BSF_FILE)
4113 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4116 int bind = STB_LOCAL;
4118 if (flags & BSF_LOCAL)
4120 else if (flags & BSF_WEAK)
4122 else if (flags & BSF_GLOBAL)
4125 sym.st_info = ELF_ST_INFO (bind, type);
4128 if (type_ptr != NULL)
4129 sym.st_other = type_ptr->internal_elf_sym.st_other;
4133 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4134 outbound_syms += bed->s->sizeof_sym;
4138 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
4139 symstrtab_hdr->sh_type = SHT_STRTAB;
4141 symstrtab_hdr->sh_flags = 0;
4142 symstrtab_hdr->sh_addr = 0;
4143 symstrtab_hdr->sh_entsize = 0;
4144 symstrtab_hdr->sh_link = 0;
4145 symstrtab_hdr->sh_info = 0;
4146 symstrtab_hdr->sh_addralign = 1;
4152 /* Return the number of bytes required to hold the symtab vector.
4154 Note that we base it on the count plus 1, since we will null terminate
4155 the vector allocated based on this size. However, the ELF symbol table
4156 always has a dummy entry as symbol #0, so it ends up even. */
4159 _bfd_elf_get_symtab_upper_bound (abfd)
4164 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
4166 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4167 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4173 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
4178 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4180 if (elf_dynsymtab (abfd) == 0)
4182 bfd_set_error (bfd_error_invalid_operation);
4186 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4187 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4193 _bfd_elf_get_reloc_upper_bound (abfd, asect)
4197 return (asect->reloc_count + 1) * sizeof (arelent *);
4200 /* Canonicalize the relocs. */
4203 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
4212 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd,
4218 tblptr = section->relocation;
4219 for (i = 0; i < section->reloc_count; i++)
4220 *relptr++ = tblptr++;
4224 return section->reloc_count;
4228 _bfd_elf_get_symtab (abfd, alocation)
4230 asymbol **alocation;
4232 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table
4233 (abfd, alocation, false);
4236 bfd_get_symcount (abfd) = symcount;
4241 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
4243 asymbol **alocation;
4245 return get_elf_backend_data (abfd)->s->slurp_symbol_table
4246 (abfd, alocation, true);
4249 /* Return the size required for the dynamic reloc entries. Any
4250 section that was actually installed in the BFD, and has type
4251 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4252 considered to be a dynamic reloc section. */
4255 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
4261 if (elf_dynsymtab (abfd) == 0)
4263 bfd_set_error (bfd_error_invalid_operation);
4267 ret = sizeof (arelent *);
4268 for (s = abfd->sections; s != NULL; s = s->next)
4269 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4270 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4271 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4272 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
4273 * sizeof (arelent *));
4278 /* Canonicalize the dynamic relocation entries. Note that we return
4279 the dynamic relocations as a single block, although they are
4280 actually associated with particular sections; the interface, which
4281 was designed for SunOS style shared libraries, expects that there
4282 is only one set of dynamic relocs. Any section that was actually
4283 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4284 the dynamic symbol table, is considered to be a dynamic reloc
4288 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
4293 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
4297 if (elf_dynsymtab (abfd) == 0)
4299 bfd_set_error (bfd_error_invalid_operation);
4303 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
4305 for (s = abfd->sections; s != NULL; s = s->next)
4307 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4308 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4309 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4314 if (! (*slurp_relocs) (abfd, s, syms, true))
4316 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
4318 for (i = 0; i < count; i++)
4329 /* Read in the version information. */
4332 _bfd_elf_slurp_version_tables (abfd)
4335 bfd_byte *contents = NULL;
4337 if (elf_dynverdef (abfd) != 0)
4339 Elf_Internal_Shdr *hdr;
4340 Elf_External_Verdef *everdef;
4341 Elf_Internal_Verdef *iverdef;
4344 hdr = &elf_tdata (abfd)->dynverdef_hdr;
4346 elf_tdata (abfd)->verdef =
4347 ((Elf_Internal_Verdef *)
4348 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verdef)));
4349 if (elf_tdata (abfd)->verdef == NULL)
4352 elf_tdata (abfd)->cverdefs = hdr->sh_info;
4354 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4355 if (contents == NULL)
4357 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4358 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4361 everdef = (Elf_External_Verdef *) contents;
4362 iverdef = elf_tdata (abfd)->verdef;
4363 for (i = 0; i < hdr->sh_info; i++, iverdef++)
4365 Elf_External_Verdaux *everdaux;
4366 Elf_Internal_Verdaux *iverdaux;
4369 _bfd_elf_swap_verdef_in (abfd, everdef, iverdef);
4371 iverdef->vd_bfd = abfd;
4373 iverdef->vd_auxptr = ((Elf_Internal_Verdaux *)
4376 * sizeof (Elf_Internal_Verdaux))));
4377 if (iverdef->vd_auxptr == NULL)
4380 everdaux = ((Elf_External_Verdaux *)
4381 ((bfd_byte *) everdef + iverdef->vd_aux));
4382 iverdaux = iverdef->vd_auxptr;
4383 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
4385 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
4387 iverdaux->vda_nodename =
4388 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4389 iverdaux->vda_name);
4390 if (iverdaux->vda_nodename == NULL)
4393 if (j + 1 < iverdef->vd_cnt)
4394 iverdaux->vda_nextptr = iverdaux + 1;
4396 iverdaux->vda_nextptr = NULL;
4398 everdaux = ((Elf_External_Verdaux *)
4399 ((bfd_byte *) everdaux + iverdaux->vda_next));
4402 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
4404 if (i + 1 < hdr->sh_info)
4405 iverdef->vd_nextdef = iverdef + 1;
4407 iverdef->vd_nextdef = NULL;
4409 everdef = ((Elf_External_Verdef *)
4410 ((bfd_byte *) everdef + iverdef->vd_next));
4417 if (elf_dynverref (abfd) != 0)
4419 Elf_Internal_Shdr *hdr;
4420 Elf_External_Verneed *everneed;
4421 Elf_Internal_Verneed *iverneed;
4424 hdr = &elf_tdata (abfd)->dynverref_hdr;
4426 elf_tdata (abfd)->verref =
4427 ((Elf_Internal_Verneed *)
4428 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed)));
4429 if (elf_tdata (abfd)->verref == NULL)
4432 elf_tdata (abfd)->cverrefs = hdr->sh_info;
4434 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4435 if (contents == NULL)
4437 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4438 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4441 everneed = (Elf_External_Verneed *) contents;
4442 iverneed = elf_tdata (abfd)->verref;
4443 for (i = 0; i < hdr->sh_info; i++, iverneed++)
4445 Elf_External_Vernaux *evernaux;
4446 Elf_Internal_Vernaux *ivernaux;
4449 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
4451 iverneed->vn_bfd = abfd;
4453 iverneed->vn_filename =
4454 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4456 if (iverneed->vn_filename == NULL)
4459 iverneed->vn_auxptr =
4460 ((Elf_Internal_Vernaux *)
4462 iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux)));
4464 evernaux = ((Elf_External_Vernaux *)
4465 ((bfd_byte *) everneed + iverneed->vn_aux));
4466 ivernaux = iverneed->vn_auxptr;
4467 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
4469 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
4471 ivernaux->vna_nodename =
4472 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4473 ivernaux->vna_name);
4474 if (ivernaux->vna_nodename == NULL)
4477 if (j + 1 < iverneed->vn_cnt)
4478 ivernaux->vna_nextptr = ivernaux + 1;
4480 ivernaux->vna_nextptr = NULL;
4482 evernaux = ((Elf_External_Vernaux *)
4483 ((bfd_byte *) evernaux + ivernaux->vna_next));
4486 if (i + 1 < hdr->sh_info)
4487 iverneed->vn_nextref = iverneed + 1;
4489 iverneed->vn_nextref = NULL;
4491 everneed = ((Elf_External_Verneed *)
4492 ((bfd_byte *) everneed + iverneed->vn_next));
4502 if (contents == NULL)
4508 _bfd_elf_make_empty_symbol (abfd)
4511 elf_symbol_type *newsym;
4513 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
4518 newsym->symbol.the_bfd = abfd;
4519 return &newsym->symbol;
4524 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
4529 bfd_symbol_info (symbol, ret);
4532 /* Return whether a symbol name implies a local symbol. Most targets
4533 use this function for the is_local_label_name entry point, but some
4537 _bfd_elf_is_local_label_name (abfd, name)
4541 /* Normal local symbols start with ``.L''. */
4542 if (name[0] == '.' && name[1] == 'L')
4545 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4546 DWARF debugging symbols starting with ``..''. */
4547 if (name[0] == '.' && name[1] == '.')
4550 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4551 emitting DWARF debugging output. I suspect this is actually a
4552 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4553 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4554 underscore to be emitted on some ELF targets). For ease of use,
4555 we treat such symbols as local. */
4556 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
4563 _bfd_elf_get_lineno (ignore_abfd, symbol)
4572 _bfd_elf_set_arch_mach (abfd, arch, machine)
4574 enum bfd_architecture arch;
4575 unsigned long machine;
4577 /* If this isn't the right architecture for this backend, and this
4578 isn't the generic backend, fail. */
4579 if (arch != get_elf_backend_data (abfd)->arch
4580 && arch != bfd_arch_unknown
4581 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
4584 return bfd_default_set_arch_mach (abfd, arch, machine);
4587 /* Find the nearest line to a particular section and offset, for error
4591 _bfd_elf_find_nearest_line (abfd,
4602 CONST char **filename_ptr;
4603 CONST char **functionname_ptr;
4604 unsigned int *line_ptr;
4607 const char *filename;
4612 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4613 filename_ptr, functionname_ptr,
4617 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4618 filename_ptr, functionname_ptr,
4622 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4623 &found, filename_ptr,
4624 functionname_ptr, line_ptr,
4625 &elf_tdata (abfd)->line_info))
4630 if (symbols == NULL)
4637 for (p = symbols; *p != NULL; p++)
4641 q = (elf_symbol_type *) *p;
4643 if (bfd_get_section (&q->symbol) != section)
4646 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4651 filename = bfd_asymbol_name (&q->symbol);
4655 if (q->symbol.section == section
4656 && q->symbol.value >= low_func
4657 && q->symbol.value <= offset)
4659 func = (asymbol *) q;
4660 low_func = q->symbol.value;
4669 *filename_ptr = filename;
4670 *functionname_ptr = bfd_asymbol_name (func);
4676 _bfd_elf_sizeof_headers (abfd, reloc)
4682 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
4684 ret += get_program_header_size (abfd);
4689 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
4694 bfd_size_type count;
4696 Elf_Internal_Shdr *hdr;
4698 if (! abfd->output_has_begun
4699 && ! _bfd_elf_compute_section_file_positions
4700 (abfd, (struct bfd_link_info *) NULL))
4703 hdr = &elf_section_data (section)->this_hdr;
4705 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
4707 if (bfd_write (location, 1, count, abfd) != count)
4714 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
4717 Elf_Internal_Rela *dst;
4724 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
4727 Elf_Internal_Rel *dst;
4733 /* Try to convert a non-ELF reloc into an ELF one. */
4736 _bfd_elf_validate_reloc (abfd, areloc)
4740 /* Check whether we really have an ELF howto. */
4742 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
4744 bfd_reloc_code_real_type code;
4745 reloc_howto_type *howto;
4747 /* Alien reloc: Try to determine its type to replace it with an
4748 equivalent ELF reloc. */
4750 if (areloc->howto->pc_relative)
4752 switch (areloc->howto->bitsize)
4755 code = BFD_RELOC_8_PCREL;
4758 code = BFD_RELOC_12_PCREL;
4761 code = BFD_RELOC_16_PCREL;
4764 code = BFD_RELOC_24_PCREL;
4767 code = BFD_RELOC_32_PCREL;
4770 code = BFD_RELOC_64_PCREL;
4776 howto = bfd_reloc_type_lookup (abfd, code);
4778 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
4780 if (howto->pcrel_offset)
4781 areloc->addend += areloc->address;
4783 areloc->addend -= areloc->address; /* addend is unsigned!! */
4788 switch (areloc->howto->bitsize)
4794 code = BFD_RELOC_14;
4797 code = BFD_RELOC_16;
4800 code = BFD_RELOC_26;
4803 code = BFD_RELOC_32;
4806 code = BFD_RELOC_64;
4812 howto = bfd_reloc_type_lookup (abfd, code);
4816 areloc->howto = howto;
4824 (*_bfd_error_handler)
4825 (_("%s: unsupported relocation type %s"),
4826 bfd_get_filename (abfd), areloc->howto->name);
4827 bfd_set_error (bfd_error_bad_value);
4832 _bfd_elf_close_and_cleanup (abfd)
4835 if (bfd_get_format (abfd) == bfd_object)
4837 if (elf_shstrtab (abfd) != NULL)
4838 _bfd_stringtab_free (elf_shstrtab (abfd));
4841 return _bfd_generic_close_and_cleanup (abfd);
4844 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
4845 in the relocation's offset. Thus we cannot allow any sort of sanity
4846 range-checking to interfere. There is nothing else to do in processing
4849 bfd_reloc_status_type
4850 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
4853 struct symbol_cache_entry *symbol;
4859 return bfd_reloc_ok;
4863 /* Elf core file support. Much of this only works on native
4864 toolchains, since we rely on knowing the
4865 machine-dependent procfs structure in order to pick
4866 out details about the corefile. */
4868 #ifdef HAVE_SYS_PROCFS_H
4869 # include <sys/procfs.h>
4873 /* Define offsetof for those systems which lack it. */
4876 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
4880 /* FIXME: this is kinda wrong, but it's what gdb wants. */
4883 elfcore_make_pid (abfd)
4886 return ((elf_tdata (abfd)->core_lwpid << 16)
4887 + (elf_tdata (abfd)->core_pid));
4891 /* If there isn't a section called NAME, make one, using
4892 data from SECT. Note, this function will generate a
4893 reference to NAME, so you shouldn't deallocate or
4897 elfcore_maybe_make_sect (abfd, name, sect)
4904 if (bfd_get_section_by_name (abfd, name) != NULL)
4907 sect2 = bfd_make_section (abfd, name);
4911 sect2->_raw_size = sect->_raw_size;
4912 sect2->filepos = sect->filepos;
4913 sect2->flags = sect->flags;
4914 sect2->alignment_power = sect->alignment_power;
4919 /* prstatus_t exists on:
4921 linux 2.[01] + glibc
4925 #if defined (HAVE_PRSTATUS_T)
4927 elfcore_grok_prstatus (abfd, note)
4929 Elf_Internal_Note* note;
4936 if (note->descsz != sizeof (prstat))
4939 memcpy (&prstat, note->descdata, sizeof (prstat));
4941 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4942 elf_tdata (abfd)->core_pid = prstat.pr_pid;
4944 /* pr_who exists on:
4947 pr_who doesn't exist on:
4950 #if defined (HAVE_PRSTATUS_T_PR_WHO)
4951 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
4954 /* Make a ".reg/999" section. */
4956 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
4957 name = bfd_alloc (abfd, strlen (buf) + 1);
4962 sect = bfd_make_section (abfd, name);
4965 sect->_raw_size = sizeof (prstat.pr_reg);
4966 sect->filepos = note->descpos + offsetof (prstatus_t, pr_reg);
4967 sect->flags = SEC_HAS_CONTENTS;
4968 sect->alignment_power = 2;
4970 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
4975 #endif /* defined (HAVE_PRSTATUS_T) */
4978 /* There isn't a consistent prfpregset_t across platforms,
4979 but it doesn't matter, because we don't have to pick this
4980 data structure apart. */
4983 elfcore_grok_prfpreg (abfd, note)
4985 Elf_Internal_Note* note;
4991 /* Make a ".reg2/999" section. */
4993 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
4994 name = bfd_alloc (abfd, strlen (buf) + 1);
4999 sect = bfd_make_section (abfd, name);
5002 sect->_raw_size = note->descsz;
5003 sect->filepos = note->descpos;
5004 sect->flags = SEC_HAS_CONTENTS;
5005 sect->alignment_power = 2;
5007 if (! elfcore_maybe_make_sect (abfd, ".reg2", sect))
5013 #if defined (HAVE_PRPSINFO_T)
5014 # define elfcore_psinfo_t prpsinfo_t
5017 #if defined (HAVE_PSINFO_T)
5018 # define elfcore_psinfo_t psinfo_t
5022 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5024 /* return a malloc'ed copy of a string at START which is at
5025 most MAX bytes long, possibly without a terminating '\0'.
5026 the copy will always have a terminating '\0'. */
5029 elfcore_strndup (abfd, start, max)
5035 char* end = memchr (start, '\0', max);
5043 dup = bfd_alloc (abfd, len + 1);
5047 memcpy (dup, start, len);
5054 elfcore_grok_psinfo (abfd, note)
5056 Elf_Internal_Note* note;
5058 elfcore_psinfo_t psinfo;
5060 if (note->descsz != sizeof (elfcore_psinfo_t))
5063 memcpy (&psinfo, note->descdata, note->descsz);
5065 elf_tdata (abfd)->core_program
5066 = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
5068 elf_tdata (abfd)->core_command
5069 = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
5071 /* Note that for some reason, a spurious space is tacked
5072 onto the end of the args in some (at least one anyway)
5073 implementations, so strip it off if it exists. */
5076 char* command = elf_tdata (abfd)->core_command;
5077 int n = strlen (command);
5079 if (0 < n && command[n - 1] == ' ')
5080 command[n - 1] = '\0';
5085 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5088 #if defined (HAVE_PSTATUS_T)
5090 elfcore_grok_pstatus (abfd, note)
5092 Elf_Internal_Note* note;
5096 if (note->descsz != sizeof (pstat))
5099 memcpy (&pstat, note->descdata, sizeof (pstat));
5101 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5103 /* Could grab some more details from the "representative"
5104 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5105 NT_LWPSTATUS note, presumably. */
5109 #endif /* defined (HAVE_PSTATUS_T) */
5112 #if defined (HAVE_LWPSTATUS_T)
5114 elfcore_grok_lwpstatus (abfd, note)
5116 Elf_Internal_Note* note;
5118 lwpstatus_t lwpstat;
5123 if (note->descsz != sizeof (lwpstat))
5126 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
5128 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
5129 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
5131 /* Make a ".reg/999" section. */
5133 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5134 name = bfd_alloc (abfd, strlen (buf) + 1);
5139 sect = bfd_make_section (abfd, name);
5143 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5144 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
5145 sect->filepos = note->descpos
5146 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
5149 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5150 sect->_raw_size = sizeof (lwpstat.pr_reg);
5151 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
5154 sect->flags = SEC_HAS_CONTENTS;
5155 sect->alignment_power = 2;
5157 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
5160 /* Make a ".reg2/999" section */
5162 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
5163 name = bfd_alloc (abfd, strlen (buf) + 1);
5168 sect = bfd_make_section (abfd, name);
5172 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5173 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
5174 sect->filepos = note->descpos
5175 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
5178 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5179 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
5180 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
5183 sect->flags = SEC_HAS_CONTENTS;
5184 sect->alignment_power = 2;
5186 if (!elfcore_maybe_make_sect (abfd, ".reg2", sect))
5191 #endif /* defined (HAVE_LWPSTATUS_T) */
5196 elfcore_grok_note (abfd, note)
5198 Elf_Internal_Note* note;
5205 #if defined (HAVE_PRSTATUS_T)
5207 return elfcore_grok_prstatus (abfd, note);
5210 #if defined (HAVE_PSTATUS_T)
5212 return elfcore_grok_pstatus (abfd, note);
5215 #if defined (HAVE_LWPSTATUS_T)
5217 return elfcore_grok_lwpstatus (abfd, note);
5220 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
5221 return elfcore_grok_prfpreg (abfd, note);
5223 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5226 return elfcore_grok_psinfo (abfd, note);
5233 elfcore_read_notes (abfd, offset, size)
5244 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5247 buf = bfd_malloc ((size_t) size);
5251 if (bfd_read (buf, size, 1, abfd) != size)
5259 while (p < buf + size)
5261 /* FIXME: bad alignment assumption. */
5262 Elf_External_Note* xnp = (Elf_External_Note*) p;
5263 Elf_Internal_Note in;
5265 in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
5267 in.namesz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->namesz);
5268 in.namedata = xnp->name;
5270 in.descsz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->descsz);
5271 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
5272 in.descpos = offset + (in.descdata - buf);
5274 if (! elfcore_grok_note (abfd, &in))
5277 p = in.descdata + BFD_ALIGN (in.descsz, 4);
5287 _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
5289 Elf_Internal_Phdr* phdr;
5292 if (! bfd_section_from_phdr (abfd, phdr, sec_num))
5295 if (phdr->p_type == PT_NOTE
5296 && ! elfcore_read_notes (abfd, phdr->p_offset, phdr->p_filesz))