1 /* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000 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
35 #define _SYSCALL32 /* For Sparc64-cross-32 */
45 static INLINE struct elf_segment_map *make_mapping
46 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
47 static boolean map_sections_to_segments PARAMS ((bfd *));
48 static int elf_sort_sections PARAMS ((const PTR, const PTR));
49 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
50 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
51 static boolean prep_headers PARAMS ((bfd *));
52 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
53 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
54 static char *elf_read PARAMS ((bfd *, long, unsigned int));
55 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
56 static boolean assign_section_numbers PARAMS ((bfd *));
57 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
58 static boolean elf_map_symbols PARAMS ((bfd *));
59 static bfd_size_type get_program_header_size PARAMS ((bfd *));
60 static boolean elfcore_read_notes PARAMS ((bfd *, bfd_vma, bfd_vma));
62 /* Swap version information in and out. The version information is
63 currently size independent. If that ever changes, this code will
64 need to move into elfcode.h. */
66 /* Swap in a Verdef structure. */
69 _bfd_elf_swap_verdef_in (abfd, src, dst)
71 const Elf_External_Verdef *src;
72 Elf_Internal_Verdef *dst;
74 dst->vd_version = bfd_h_get_16 (abfd, src->vd_version);
75 dst->vd_flags = bfd_h_get_16 (abfd, src->vd_flags);
76 dst->vd_ndx = bfd_h_get_16 (abfd, src->vd_ndx);
77 dst->vd_cnt = bfd_h_get_16 (abfd, src->vd_cnt);
78 dst->vd_hash = bfd_h_get_32 (abfd, src->vd_hash);
79 dst->vd_aux = bfd_h_get_32 (abfd, src->vd_aux);
80 dst->vd_next = bfd_h_get_32 (abfd, src->vd_next);
83 /* Swap out a Verdef structure. */
86 _bfd_elf_swap_verdef_out (abfd, src, dst)
88 const Elf_Internal_Verdef *src;
89 Elf_External_Verdef *dst;
91 bfd_h_put_16 (abfd, src->vd_version, dst->vd_version);
92 bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags);
93 bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx);
94 bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt);
95 bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash);
96 bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux);
97 bfd_h_put_32 (abfd, src->vd_next, dst->vd_next);
100 /* Swap in a Verdaux structure. */
103 _bfd_elf_swap_verdaux_in (abfd, src, dst)
105 const Elf_External_Verdaux *src;
106 Elf_Internal_Verdaux *dst;
108 dst->vda_name = bfd_h_get_32 (abfd, src->vda_name);
109 dst->vda_next = bfd_h_get_32 (abfd, src->vda_next);
112 /* Swap out a Verdaux structure. */
115 _bfd_elf_swap_verdaux_out (abfd, src, dst)
117 const Elf_Internal_Verdaux *src;
118 Elf_External_Verdaux *dst;
120 bfd_h_put_32 (abfd, src->vda_name, dst->vda_name);
121 bfd_h_put_32 (abfd, src->vda_next, dst->vda_next);
124 /* Swap in a Verneed structure. */
127 _bfd_elf_swap_verneed_in (abfd, src, dst)
129 const Elf_External_Verneed *src;
130 Elf_Internal_Verneed *dst;
132 dst->vn_version = bfd_h_get_16 (abfd, src->vn_version);
133 dst->vn_cnt = bfd_h_get_16 (abfd, src->vn_cnt);
134 dst->vn_file = bfd_h_get_32 (abfd, src->vn_file);
135 dst->vn_aux = bfd_h_get_32 (abfd, src->vn_aux);
136 dst->vn_next = bfd_h_get_32 (abfd, src->vn_next);
139 /* Swap out a Verneed structure. */
142 _bfd_elf_swap_verneed_out (abfd, src, dst)
144 const Elf_Internal_Verneed *src;
145 Elf_External_Verneed *dst;
147 bfd_h_put_16 (abfd, src->vn_version, dst->vn_version);
148 bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt);
149 bfd_h_put_32 (abfd, src->vn_file, dst->vn_file);
150 bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux);
151 bfd_h_put_32 (abfd, src->vn_next, dst->vn_next);
154 /* Swap in a Vernaux structure. */
157 _bfd_elf_swap_vernaux_in (abfd, src, dst)
159 const Elf_External_Vernaux *src;
160 Elf_Internal_Vernaux *dst;
162 dst->vna_hash = bfd_h_get_32 (abfd, src->vna_hash);
163 dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags);
164 dst->vna_other = bfd_h_get_16 (abfd, src->vna_other);
165 dst->vna_name = bfd_h_get_32 (abfd, src->vna_name);
166 dst->vna_next = bfd_h_get_32 (abfd, src->vna_next);
169 /* Swap out a Vernaux structure. */
172 _bfd_elf_swap_vernaux_out (abfd, src, dst)
174 const Elf_Internal_Vernaux *src;
175 Elf_External_Vernaux *dst;
177 bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash);
178 bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags);
179 bfd_h_put_16 (abfd, src->vna_other, dst->vna_other);
180 bfd_h_put_32 (abfd, src->vna_name, dst->vna_name);
181 bfd_h_put_32 (abfd, src->vna_next, dst->vna_next);
184 /* Swap in a Versym structure. */
187 _bfd_elf_swap_versym_in (abfd, src, dst)
189 const Elf_External_Versym *src;
190 Elf_Internal_Versym *dst;
192 dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers);
195 /* Swap out a Versym structure. */
198 _bfd_elf_swap_versym_out (abfd, src, dst)
200 const Elf_Internal_Versym *src;
201 Elf_External_Versym *dst;
203 bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers);
206 /* Standard ELF hash function. Do not change this function; you will
207 cause invalid hash tables to be generated. */
210 bfd_elf_hash (namearg)
213 const unsigned char *name = (const unsigned char *) namearg;
218 while ((ch = *name++) != '\0')
221 if ((g = (h & 0xf0000000)) != 0)
224 /* The ELF ABI says `h &= ~g', but this is equivalent in
225 this case and on some machines one insn instead of two. */
232 /* Read a specified number of bytes at a specified offset in an ELF
233 file, into a newly allocated buffer, and return a pointer to the
237 elf_read (abfd, offset, size)
244 if ((buf = bfd_alloc (abfd, size)) == NULL)
246 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
248 if (bfd_read ((PTR) buf, size, 1, abfd) != size)
250 if (bfd_get_error () != bfd_error_system_call)
251 bfd_set_error (bfd_error_file_truncated);
258 bfd_elf_mkobject (abfd)
261 /* this just does initialization */
262 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
263 elf_tdata (abfd) = (struct elf_obj_tdata *)
264 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
265 if (elf_tdata (abfd) == 0)
267 /* since everything is done at close time, do we need any
274 bfd_elf_mkcorefile (abfd)
277 /* I think this can be done just like an object file. */
278 return bfd_elf_mkobject (abfd);
282 bfd_elf_get_str_section (abfd, shindex)
284 unsigned int shindex;
286 Elf_Internal_Shdr **i_shdrp;
287 char *shstrtab = NULL;
289 unsigned int shstrtabsize;
291 i_shdrp = elf_elfsections (abfd);
292 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
295 shstrtab = (char *) i_shdrp[shindex]->contents;
296 if (shstrtab == NULL)
298 /* No cached one, attempt to read, and cache what we read. */
299 offset = i_shdrp[shindex]->sh_offset;
300 shstrtabsize = i_shdrp[shindex]->sh_size;
301 shstrtab = elf_read (abfd, offset, shstrtabsize);
302 i_shdrp[shindex]->contents = (PTR) shstrtab;
308 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
310 unsigned int shindex;
311 unsigned int strindex;
313 Elf_Internal_Shdr *hdr;
318 hdr = elf_elfsections (abfd)[shindex];
320 if (hdr->contents == NULL
321 && bfd_elf_get_str_section (abfd, shindex) == NULL)
324 if (strindex >= hdr->sh_size)
326 (*_bfd_error_handler)
327 (_("%s: invalid string offset %u >= %lu for section `%s'"),
328 bfd_get_filename (abfd), strindex, (unsigned long) hdr->sh_size,
329 ((shindex == elf_elfheader(abfd)->e_shstrndx
330 && strindex == hdr->sh_name)
332 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
336 return ((char *) hdr->contents) + strindex;
339 /* Make a BFD section from an ELF section. We store a pointer to the
340 BFD section in the bfd_section field of the header. */
343 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
345 Elf_Internal_Shdr *hdr;
351 if (hdr->bfd_section != NULL)
353 BFD_ASSERT (strcmp (name,
354 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
358 newsect = bfd_make_section_anyway (abfd, name);
362 newsect->filepos = hdr->sh_offset;
364 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
365 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
366 || ! bfd_set_section_alignment (abfd, newsect,
367 bfd_log2 (hdr->sh_addralign)))
370 flags = SEC_NO_FLAGS;
371 if (hdr->sh_type != SHT_NOBITS)
372 flags |= SEC_HAS_CONTENTS;
373 if ((hdr->sh_flags & SHF_ALLOC) != 0)
376 if (hdr->sh_type != SHT_NOBITS)
379 if ((hdr->sh_flags & SHF_WRITE) == 0)
380 flags |= SEC_READONLY;
381 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
383 else if ((flags & SEC_LOAD) != 0)
386 /* The debugging sections appear to be recognized only by name, not
388 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
389 || strncmp (name, ".line", sizeof ".line" - 1) == 0
390 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
391 flags |= SEC_DEBUGGING;
393 /* As a GNU extension, if the name begins with .gnu.linkonce, we
394 only link a single copy of the section. This is used to support
395 g++. g++ will emit each template expansion in its own section.
396 The symbols will be defined as weak, so that multiple definitions
397 are permitted. The GNU linker extension is to actually discard
398 all but one of the sections. */
399 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
400 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
402 if (! bfd_set_section_flags (abfd, newsect, flags))
405 if ((flags & SEC_ALLOC) != 0)
407 Elf_Internal_Phdr *phdr;
410 /* Look through the phdrs to see if we need to adjust the lma.
411 If all the p_paddr fields are zero, we ignore them, since
412 some ELF linkers produce such output. */
413 phdr = elf_tdata (abfd)->phdr;
414 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
416 if (phdr->p_paddr != 0)
419 if (i < elf_elfheader (abfd)->e_phnum)
421 phdr = elf_tdata (abfd)->phdr;
422 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
424 if (phdr->p_type == PT_LOAD
425 && phdr->p_vaddr != phdr->p_paddr
426 && phdr->p_vaddr <= hdr->sh_addr
427 && (phdr->p_vaddr + phdr->p_memsz
428 >= hdr->sh_addr + hdr->sh_size)
429 && ((flags & SEC_LOAD) == 0
430 || (phdr->p_offset <= (bfd_vma) hdr->sh_offset
431 && (phdr->p_offset + phdr->p_filesz
432 >= hdr->sh_offset + hdr->sh_size))))
434 newsect->lma += phdr->p_paddr - phdr->p_vaddr;
441 hdr->bfd_section = newsect;
442 elf_section_data (newsect)->this_hdr = *hdr;
452 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
455 Helper functions for GDB to locate the string tables.
456 Since BFD hides string tables from callers, GDB needs to use an
457 internal hook to find them. Sun's .stabstr, in particular,
458 isn't even pointed to by the .stab section, so ordinary
459 mechanisms wouldn't work to find it, even if we had some.
462 struct elf_internal_shdr *
463 bfd_elf_find_section (abfd, name)
467 Elf_Internal_Shdr **i_shdrp;
472 i_shdrp = elf_elfsections (abfd);
475 shstrtab = bfd_elf_get_str_section
476 (abfd, elf_elfheader (abfd)->e_shstrndx);
477 if (shstrtab != NULL)
479 max = elf_elfheader (abfd)->e_shnum;
480 for (i = 1; i < max; i++)
481 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
488 const char *const bfd_elf_section_type_names[] = {
489 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
490 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
491 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
494 /* ELF relocs are against symbols. If we are producing relocateable
495 output, and the reloc is against an external symbol, and nothing
496 has given us any additional addend, the resulting reloc will also
497 be against the same symbol. In such a case, we don't want to
498 change anything about the way the reloc is handled, since it will
499 all be done at final link time. Rather than put special case code
500 into bfd_perform_relocation, all the reloc types use this howto
501 function. It just short circuits the reloc if producing
502 relocateable output against an external symbol. */
505 bfd_reloc_status_type
506 bfd_elf_generic_reloc (abfd,
513 bfd *abfd ATTRIBUTE_UNUSED;
514 arelent *reloc_entry;
516 PTR data ATTRIBUTE_UNUSED;
517 asection *input_section;
519 char **error_message ATTRIBUTE_UNUSED;
521 if (output_bfd != (bfd *) NULL
522 && (symbol->flags & BSF_SECTION_SYM) == 0
523 && (! reloc_entry->howto->partial_inplace
524 || reloc_entry->addend == 0))
526 reloc_entry->address += input_section->output_offset;
530 return bfd_reloc_continue;
533 /* Print out the program headers. */
536 _bfd_elf_print_private_bfd_data (abfd, farg)
540 FILE *f = (FILE *) farg;
541 Elf_Internal_Phdr *p;
543 bfd_byte *dynbuf = NULL;
545 p = elf_tdata (abfd)->phdr;
550 fprintf (f, _("\nProgram Header:\n"));
551 c = elf_elfheader (abfd)->e_phnum;
552 for (i = 0; i < c; i++, p++)
559 case PT_NULL: s = "NULL"; break;
560 case PT_LOAD: s = "LOAD"; break;
561 case PT_DYNAMIC: s = "DYNAMIC"; break;
562 case PT_INTERP: s = "INTERP"; break;
563 case PT_NOTE: s = "NOTE"; break;
564 case PT_SHLIB: s = "SHLIB"; break;
565 case PT_PHDR: s = "PHDR"; break;
566 default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
568 fprintf (f, "%8s off 0x", s);
569 fprintf_vma (f, p->p_offset);
570 fprintf (f, " vaddr 0x");
571 fprintf_vma (f, p->p_vaddr);
572 fprintf (f, " paddr 0x");
573 fprintf_vma (f, p->p_paddr);
574 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
575 fprintf (f, " filesz 0x");
576 fprintf_vma (f, p->p_filesz);
577 fprintf (f, " memsz 0x");
578 fprintf_vma (f, p->p_memsz);
579 fprintf (f, " flags %c%c%c",
580 (p->p_flags & PF_R) != 0 ? 'r' : '-',
581 (p->p_flags & PF_W) != 0 ? 'w' : '-',
582 (p->p_flags & PF_X) != 0 ? 'x' : '-');
583 if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
584 fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
589 s = bfd_get_section_by_name (abfd, ".dynamic");
594 bfd_byte *extdyn, *extdynend;
596 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
598 fprintf (f, _("\nDynamic Section:\n"));
600 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
603 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
607 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
610 link = elf_elfsections (abfd)[elfsec]->sh_link;
612 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
613 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
616 extdynend = extdyn + s->_raw_size;
617 for (; extdyn < extdynend; extdyn += extdynsize)
619 Elf_Internal_Dyn dyn;
624 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
626 if (dyn.d_tag == DT_NULL)
633 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
637 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
638 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
639 case DT_PLTGOT: name = "PLTGOT"; break;
640 case DT_HASH: name = "HASH"; break;
641 case DT_STRTAB: name = "STRTAB"; break;
642 case DT_SYMTAB: name = "SYMTAB"; break;
643 case DT_RELA: name = "RELA"; break;
644 case DT_RELASZ: name = "RELASZ"; break;
645 case DT_RELAENT: name = "RELAENT"; break;
646 case DT_STRSZ: name = "STRSZ"; break;
647 case DT_SYMENT: name = "SYMENT"; break;
648 case DT_INIT: name = "INIT"; break;
649 case DT_FINI: name = "FINI"; break;
650 case DT_SONAME: name = "SONAME"; stringp = true; break;
651 case DT_RPATH: name = "RPATH"; stringp = true; break;
652 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
653 case DT_REL: name = "REL"; break;
654 case DT_RELSZ: name = "RELSZ"; break;
655 case DT_RELENT: name = "RELENT"; break;
656 case DT_PLTREL: name = "PLTREL"; break;
657 case DT_DEBUG: name = "DEBUG"; break;
658 case DT_TEXTREL: name = "TEXTREL"; break;
659 case DT_JMPREL: name = "JMPREL"; break;
660 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
661 case DT_FILTER: name = "FILTER"; stringp = true; break;
662 case DT_VERSYM: name = "VERSYM"; break;
663 case DT_VERDEF: name = "VERDEF"; break;
664 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
665 case DT_VERNEED: name = "VERNEED"; break;
666 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
669 fprintf (f, " %-11s ", name);
671 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
676 string = bfd_elf_string_from_elf_section (abfd, link,
680 fprintf (f, "%s", string);
689 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
690 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
692 if (! _bfd_elf_slurp_version_tables (abfd))
696 if (elf_dynverdef (abfd) != 0)
698 Elf_Internal_Verdef *t;
700 fprintf (f, _("\nVersion definitions:\n"));
701 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
703 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
704 t->vd_flags, t->vd_hash, t->vd_nodename);
705 if (t->vd_auxptr->vda_nextptr != NULL)
707 Elf_Internal_Verdaux *a;
710 for (a = t->vd_auxptr->vda_nextptr;
713 fprintf (f, "%s ", a->vda_nodename);
719 if (elf_dynverref (abfd) != 0)
721 Elf_Internal_Verneed *t;
723 fprintf (f, _("\nVersion References:\n"));
724 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
726 Elf_Internal_Vernaux *a;
728 fprintf (f, _(" required from %s:\n"), t->vn_filename);
729 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
730 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
731 a->vna_flags, a->vna_other, a->vna_nodename);
743 /* Display ELF-specific fields of a symbol. */
746 bfd_elf_print_symbol (abfd, filep, symbol, how)
750 bfd_print_symbol_type how;
752 FILE *file = (FILE *) filep;
755 case bfd_print_symbol_name:
756 fprintf (file, "%s", symbol->name);
758 case bfd_print_symbol_more:
759 fprintf (file, "elf ");
760 fprintf_vma (file, symbol->value);
761 fprintf (file, " %lx", (long) symbol->flags);
763 case bfd_print_symbol_all:
765 CONST char *section_name;
766 CONST char *name = NULL;
767 struct elf_backend_data *bed;
768 unsigned char st_other;
770 section_name = symbol->section ? symbol->section->name : "(*none*)";
772 bed = get_elf_backend_data (abfd);
773 if (bed->elf_backend_print_symbol_all)
774 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
779 bfd_print_symbol_vandf ((PTR) file, symbol);
782 fprintf (file, " %s\t", section_name);
783 /* Print the "other" value for a symbol. For common symbols,
784 we've already printed the size; now print the alignment.
785 For other symbols, we have no specified alignment, and
786 we've printed the address; now print the size. */
788 (bfd_is_com_section (symbol->section)
789 ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
790 : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
792 /* If we have version information, print it. */
793 if (elf_tdata (abfd)->dynversym_section != 0
794 && (elf_tdata (abfd)->dynverdef_section != 0
795 || elf_tdata (abfd)->dynverref_section != 0))
798 const char *version_string;
800 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
804 else if (vernum == 1)
805 version_string = "Base";
806 else if (vernum <= elf_tdata (abfd)->cverdefs)
808 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
811 Elf_Internal_Verneed *t;
814 for (t = elf_tdata (abfd)->verref;
818 Elf_Internal_Vernaux *a;
820 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
822 if (a->vna_other == vernum)
824 version_string = a->vna_nodename;
831 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
832 fprintf (file, " %-11s", version_string);
837 fprintf (file, " (%s)", version_string);
838 for (i = 10 - strlen (version_string); i > 0; --i)
843 /* If the st_other field is not zero, print it. */
844 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
849 case STV_INTERNAL: fprintf (file, " .internal"); break;
850 case STV_HIDDEN: fprintf (file, " .hidden"); break;
851 case STV_PROTECTED: fprintf (file, " .protected"); break;
853 /* Some other non-defined flags are also present, so print
855 fprintf (file, " 0x%02x", (unsigned int) st_other);
858 fprintf (file, " %s", name);
864 /* Create an entry in an ELF linker hash table. */
866 struct bfd_hash_entry *
867 _bfd_elf_link_hash_newfunc (entry, table, string)
868 struct bfd_hash_entry *entry;
869 struct bfd_hash_table *table;
872 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
874 /* Allocate the structure if it has not already been allocated by a
876 if (ret == (struct elf_link_hash_entry *) NULL)
877 ret = ((struct elf_link_hash_entry *)
878 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
879 if (ret == (struct elf_link_hash_entry *) NULL)
880 return (struct bfd_hash_entry *) ret;
882 /* Call the allocation method of the superclass. */
883 ret = ((struct elf_link_hash_entry *)
884 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
886 if (ret != (struct elf_link_hash_entry *) NULL)
888 /* Set local fields. */
892 ret->dynstr_index = 0;
894 ret->got.offset = (bfd_vma) -1;
895 ret->plt.offset = (bfd_vma) -1;
896 ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
897 ret->verinfo.verdef = NULL;
898 ret->vtable_entries_used = NULL;
899 ret->vtable_entries_size = 0;
900 ret->vtable_parent = NULL;
901 ret->type = STT_NOTYPE;
903 /* Assume that we have been called by a non-ELF symbol reader.
904 This flag is then reset by the code which reads an ELF input
905 file. This ensures that a symbol created by a non-ELF symbol
906 reader will have the flag set correctly. */
907 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
910 return (struct bfd_hash_entry *) ret;
913 /* Copy data from an indirect symbol to its direct symbol, hiding the
914 old indirect symbol. */
917 _bfd_elf_link_hash_copy_indirect (dir, ind)
918 struct elf_link_hash_entry *dir, *ind;
920 /* Copy down any references that we may have already seen to the
921 symbol which just became indirect. */
923 dir->elf_link_hash_flags |=
924 (ind->elf_link_hash_flags
925 & (ELF_LINK_HASH_REF_DYNAMIC
926 | ELF_LINK_HASH_REF_REGULAR
927 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
928 | ELF_LINK_NON_GOT_REF));
930 /* Copy over the global and procedure linkage table offset entries.
931 These may have been already set up by a check_relocs routine. */
932 if (dir->got.offset == (bfd_vma) -1)
934 dir->got.offset = ind->got.offset;
935 ind->got.offset = (bfd_vma) -1;
937 BFD_ASSERT (ind->got.offset == (bfd_vma) -1);
939 if (dir->plt.offset == (bfd_vma) -1)
941 dir->plt.offset = ind->plt.offset;
942 ind->plt.offset = (bfd_vma) -1;
944 BFD_ASSERT (ind->plt.offset == (bfd_vma) -1);
946 if (dir->dynindx == -1)
948 dir->dynindx = ind->dynindx;
949 dir->dynstr_index = ind->dynstr_index;
951 ind->dynstr_index = 0;
953 BFD_ASSERT (ind->dynindx == -1);
957 _bfd_elf_link_hash_hide_symbol(info, h)
958 struct bfd_link_info *info ATTRIBUTE_UNUSED;
959 struct elf_link_hash_entry *h;
961 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
963 h->plt.offset = (bfd_vma) -1;
966 /* Initialize an ELF linker hash table. */
969 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
970 struct elf_link_hash_table *table;
972 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
973 struct bfd_hash_table *,
976 table->dynamic_sections_created = false;
977 table->dynobj = NULL;
978 /* The first dynamic symbol is a dummy. */
979 table->dynsymcount = 1;
980 table->dynstr = NULL;
981 table->bucketcount = 0;
982 table->needed = NULL;
984 table->stab_info = NULL;
985 table->dynlocal = NULL;
986 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
989 /* Create an ELF linker hash table. */
991 struct bfd_link_hash_table *
992 _bfd_elf_link_hash_table_create (abfd)
995 struct elf_link_hash_table *ret;
997 ret = ((struct elf_link_hash_table *)
998 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
999 if (ret == (struct elf_link_hash_table *) NULL)
1002 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1004 bfd_release (abfd, ret);
1011 /* This is a hook for the ELF emulation code in the generic linker to
1012 tell the backend linker what file name to use for the DT_NEEDED
1013 entry for a dynamic object. The generic linker passes name as an
1014 empty string to indicate that no DT_NEEDED entry should be made. */
1017 bfd_elf_set_dt_needed_name (abfd, name)
1021 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1022 && bfd_get_format (abfd) == bfd_object)
1023 elf_dt_name (abfd) = name;
1026 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1027 the linker ELF emulation code. */
1029 struct bfd_link_needed_list *
1030 bfd_elf_get_needed_list (abfd, info)
1031 bfd *abfd ATTRIBUTE_UNUSED;
1032 struct bfd_link_info *info;
1034 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1036 return elf_hash_table (info)->needed;
1039 /* Get the name actually used for a dynamic object for a link. This
1040 is the SONAME entry if there is one. Otherwise, it is the string
1041 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1044 bfd_elf_get_dt_soname (abfd)
1047 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1048 && bfd_get_format (abfd) == bfd_object)
1049 return elf_dt_name (abfd);
1053 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1054 the ELF linker emulation code. */
1057 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1059 struct bfd_link_needed_list **pneeded;
1062 bfd_byte *dynbuf = NULL;
1065 bfd_byte *extdyn, *extdynend;
1067 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1071 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1072 || bfd_get_format (abfd) != bfd_object)
1075 s = bfd_get_section_by_name (abfd, ".dynamic");
1076 if (s == NULL || s->_raw_size == 0)
1079 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1083 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1087 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1091 link = elf_elfsections (abfd)[elfsec]->sh_link;
1093 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1094 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1097 extdynend = extdyn + s->_raw_size;
1098 for (; extdyn < extdynend; extdyn += extdynsize)
1100 Elf_Internal_Dyn dyn;
1102 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1104 if (dyn.d_tag == DT_NULL)
1107 if (dyn.d_tag == DT_NEEDED)
1110 struct bfd_link_needed_list *l;
1112 string = bfd_elf_string_from_elf_section (abfd, link,
1117 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof *l);
1138 /* Allocate an ELF string table--force the first byte to be zero. */
1140 struct bfd_strtab_hash *
1141 _bfd_elf_stringtab_init ()
1143 struct bfd_strtab_hash *ret;
1145 ret = _bfd_stringtab_init ();
1150 loc = _bfd_stringtab_add (ret, "", true, false);
1151 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1152 if (loc == (bfd_size_type) -1)
1154 _bfd_stringtab_free (ret);
1161 /* ELF .o/exec file reading */
1163 /* Create a new bfd section from an ELF section header. */
1166 bfd_section_from_shdr (abfd, shindex)
1168 unsigned int shindex;
1170 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1171 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1172 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1175 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1177 switch (hdr->sh_type)
1180 /* Inactive section. Throw it away. */
1183 case SHT_PROGBITS: /* Normal section with contents. */
1184 case SHT_DYNAMIC: /* Dynamic linking information. */
1185 case SHT_NOBITS: /* .bss section. */
1186 case SHT_HASH: /* .hash section. */
1187 case SHT_NOTE: /* .note section. */
1188 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1190 case SHT_SYMTAB: /* A symbol table */
1191 if (elf_onesymtab (abfd) == shindex)
1194 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1195 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1196 elf_onesymtab (abfd) = shindex;
1197 elf_tdata (abfd)->symtab_hdr = *hdr;
1198 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1199 abfd->flags |= HAS_SYMS;
1201 /* Sometimes a shared object will map in the symbol table. If
1202 SHF_ALLOC is set, and this is a shared object, then we also
1203 treat this section as a BFD section. We can not base the
1204 decision purely on SHF_ALLOC, because that flag is sometimes
1205 set in a relocateable object file, which would confuse the
1207 if ((hdr->sh_flags & SHF_ALLOC) != 0
1208 && (abfd->flags & DYNAMIC) != 0
1209 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1214 case SHT_DYNSYM: /* A dynamic symbol table */
1215 if (elf_dynsymtab (abfd) == shindex)
1218 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1219 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1220 elf_dynsymtab (abfd) = shindex;
1221 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1222 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1223 abfd->flags |= HAS_SYMS;
1225 /* Besides being a symbol table, we also treat this as a regular
1226 section, so that objcopy can handle it. */
1227 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1229 case SHT_STRTAB: /* A string table */
1230 if (hdr->bfd_section != NULL)
1232 if (ehdr->e_shstrndx == shindex)
1234 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1235 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1241 for (i = 1; i < ehdr->e_shnum; i++)
1243 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1244 if (hdr2->sh_link == shindex)
1246 if (! bfd_section_from_shdr (abfd, i))
1248 if (elf_onesymtab (abfd) == i)
1250 elf_tdata (abfd)->strtab_hdr = *hdr;
1251 elf_elfsections (abfd)[shindex] =
1252 &elf_tdata (abfd)->strtab_hdr;
1255 if (elf_dynsymtab (abfd) == i)
1257 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1258 elf_elfsections (abfd)[shindex] = hdr =
1259 &elf_tdata (abfd)->dynstrtab_hdr;
1260 /* We also treat this as a regular section, so
1261 that objcopy can handle it. */
1264 #if 0 /* Not handling other string tables specially right now. */
1265 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1266 /* We have a strtab for some random other section. */
1267 newsect = (asection *) hdr2->bfd_section;
1270 hdr->bfd_section = newsect;
1271 hdr2 = &elf_section_data (newsect)->str_hdr;
1273 elf_elfsections (abfd)[shindex] = hdr2;
1279 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1283 /* *These* do a lot of work -- but build no sections! */
1285 asection *target_sect;
1286 Elf_Internal_Shdr *hdr2;
1288 /* Check for a bogus link to avoid crashing. */
1289 if (hdr->sh_link >= ehdr->e_shnum)
1291 ((*_bfd_error_handler)
1292 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1293 bfd_get_filename (abfd), hdr->sh_link, name, shindex));
1294 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1297 /* For some incomprehensible reason Oracle distributes
1298 libraries for Solaris in which some of the objects have
1299 bogus sh_link fields. It would be nice if we could just
1300 reject them, but, unfortunately, some people need to use
1301 them. We scan through the section headers; if we find only
1302 one suitable symbol table, we clobber the sh_link to point
1303 to it. I hope this doesn't break anything. */
1304 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1305 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1311 for (scan = 1; scan < ehdr->e_shnum; scan++)
1313 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1314 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1325 hdr->sh_link = found;
1328 /* Get the symbol table. */
1329 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1330 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1333 /* If this reloc section does not use the main symbol table we
1334 don't treat it as a reloc section. BFD can't adequately
1335 represent such a section, so at least for now, we don't
1336 try. We just present it as a normal section. We also
1337 can't use it as a reloc section if it points to the null
1339 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1340 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1342 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1344 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1345 if (target_sect == NULL)
1348 if ((target_sect->flags & SEC_RELOC) == 0
1349 || target_sect->reloc_count == 0)
1350 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1353 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1354 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
1355 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1358 elf_elfsections (abfd)[shindex] = hdr2;
1359 target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
1360 target_sect->flags |= SEC_RELOC;
1361 target_sect->relocation = NULL;
1362 target_sect->rel_filepos = hdr->sh_offset;
1363 /* In the section to which the relocations apply, mark whether
1364 its relocations are of the REL or RELA variety. */
1365 if (hdr->sh_size != 0)
1366 elf_section_data (target_sect)->use_rela_p
1367 = (hdr->sh_type == SHT_RELA);
1368 abfd->flags |= HAS_RELOC;
1373 case SHT_GNU_verdef:
1374 elf_dynverdef (abfd) = shindex;
1375 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1376 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1379 case SHT_GNU_versym:
1380 elf_dynversym (abfd) = shindex;
1381 elf_tdata (abfd)->dynversym_hdr = *hdr;
1382 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1385 case SHT_GNU_verneed:
1386 elf_dynverref (abfd) = shindex;
1387 elf_tdata (abfd)->dynverref_hdr = *hdr;
1388 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1395 /* Check for any processor-specific section types. */
1397 if (bed->elf_backend_section_from_shdr)
1398 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1406 /* Given an ELF section number, retrieve the corresponding BFD
1410 bfd_section_from_elf_index (abfd, index)
1414 BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
1415 if (index >= elf_elfheader (abfd)->e_shnum)
1417 return elf_elfsections (abfd)[index]->bfd_section;
1421 _bfd_elf_new_section_hook (abfd, sec)
1425 struct bfd_elf_section_data *sdata;
1427 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, sizeof (*sdata));
1430 sec->used_by_bfd = (PTR) sdata;
1432 /* Indicate whether or not this section should use RELA relocations. */
1434 = get_elf_backend_data (abfd)->default_use_rela_p;
1439 /* Create a new bfd section from an ELF program header.
1441 Since program segments have no names, we generate a synthetic name
1442 of the form segment<NUM>, where NUM is generally the index in the
1443 program header table. For segments that are split (see below) we
1444 generate the names segment<NUM>a and segment<NUM>b.
1446 Note that some program segments may have a file size that is different than
1447 (less than) the memory size. All this means is that at execution the
1448 system must allocate the amount of memory specified by the memory size,
1449 but only initialize it with the first "file size" bytes read from the
1450 file. This would occur for example, with program segments consisting
1451 of combined data+bss.
1453 To handle the above situation, this routine generates TWO bfd sections
1454 for the single program segment. The first has the length specified by
1455 the file size of the segment, and the second has the length specified
1456 by the difference between the two sizes. In effect, the segment is split
1457 into it's initialized and uninitialized parts.
1462 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
1464 Elf_Internal_Phdr *hdr;
1466 const char *typename;
1473 split = ((hdr->p_memsz > 0)
1474 && (hdr->p_filesz > 0)
1475 && (hdr->p_memsz > hdr->p_filesz));
1476 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
1477 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1480 strcpy (name, namebuf);
1481 newsect = bfd_make_section (abfd, name);
1482 if (newsect == NULL)
1484 newsect->vma = hdr->p_vaddr;
1485 newsect->lma = hdr->p_paddr;
1486 newsect->_raw_size = hdr->p_filesz;
1487 newsect->filepos = hdr->p_offset;
1488 newsect->flags |= SEC_HAS_CONTENTS;
1489 if (hdr->p_type == PT_LOAD)
1491 newsect->flags |= SEC_ALLOC;
1492 newsect->flags |= SEC_LOAD;
1493 if (hdr->p_flags & PF_X)
1495 /* FIXME: all we known is that it has execute PERMISSION,
1497 newsect->flags |= SEC_CODE;
1500 if (!(hdr->p_flags & PF_W))
1502 newsect->flags |= SEC_READONLY;
1507 sprintf (namebuf, "%s%db", typename, index);
1508 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1511 strcpy (name, namebuf);
1512 newsect = bfd_make_section (abfd, name);
1513 if (newsect == NULL)
1515 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1516 newsect->lma = hdr->p_paddr + hdr->p_filesz;
1517 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1518 if (hdr->p_type == PT_LOAD)
1520 newsect->flags |= SEC_ALLOC;
1521 if (hdr->p_flags & PF_X)
1522 newsect->flags |= SEC_CODE;
1524 if (!(hdr->p_flags & PF_W))
1525 newsect->flags |= SEC_READONLY;
1532 bfd_section_from_phdr (abfd, hdr, index)
1534 Elf_Internal_Phdr *hdr;
1537 struct elf_backend_data *bed;
1539 switch (hdr->p_type)
1542 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
1545 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
1548 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
1551 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
1554 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
1556 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
1561 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
1564 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
1567 /* Check for any processor-specific program segment types.
1568 If no handler for them, default to making "segment" sections. */
1569 bed = get_elf_backend_data (abfd);
1570 if (bed->elf_backend_section_from_phdr)
1571 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
1573 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
1577 /* Initialize REL_HDR, the section-header for new section, containing
1578 relocations against ASECT. If USE_RELA_P is true, we use RELA
1579 relocations; otherwise, we use REL relocations. */
1582 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
1584 Elf_Internal_Shdr *rel_hdr;
1589 struct elf_backend_data *bed;
1591 bed = get_elf_backend_data (abfd);
1592 name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1595 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1597 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1599 if (rel_hdr->sh_name == (unsigned int) -1)
1601 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1602 rel_hdr->sh_entsize = (use_rela_p
1603 ? bed->s->sizeof_rela
1604 : bed->s->sizeof_rel);
1605 rel_hdr->sh_addralign = bed->s->file_align;
1606 rel_hdr->sh_flags = 0;
1607 rel_hdr->sh_addr = 0;
1608 rel_hdr->sh_size = 0;
1609 rel_hdr->sh_offset = 0;
1614 /* Set up an ELF internal section header for a section. */
1618 elf_fake_sections (abfd, asect, failedptrarg)
1623 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1624 boolean *failedptr = (boolean *) failedptrarg;
1625 Elf_Internal_Shdr *this_hdr;
1629 /* We already failed; just get out of the bfd_map_over_sections
1634 this_hdr = &elf_section_data (asect)->this_hdr;
1636 this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1639 if (this_hdr->sh_name == (unsigned long) -1)
1645 this_hdr->sh_flags = 0;
1647 if ((asect->flags & SEC_ALLOC) != 0
1648 || asect->user_set_vma)
1649 this_hdr->sh_addr = asect->vma;
1651 this_hdr->sh_addr = 0;
1653 this_hdr->sh_offset = 0;
1654 this_hdr->sh_size = asect->_raw_size;
1655 this_hdr->sh_link = 0;
1656 this_hdr->sh_addralign = 1 << asect->alignment_power;
1657 /* The sh_entsize and sh_info fields may have been set already by
1658 copy_private_section_data. */
1660 this_hdr->bfd_section = asect;
1661 this_hdr->contents = NULL;
1663 /* FIXME: This should not be based on section names. */
1664 if (strcmp (asect->name, ".dynstr") == 0)
1665 this_hdr->sh_type = SHT_STRTAB;
1666 else if (strcmp (asect->name, ".hash") == 0)
1668 this_hdr->sh_type = SHT_HASH;
1669 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
1671 else if (strcmp (asect->name, ".dynsym") == 0)
1673 this_hdr->sh_type = SHT_DYNSYM;
1674 this_hdr->sh_entsize = bed->s->sizeof_sym;
1676 else if (strcmp (asect->name, ".dynamic") == 0)
1678 this_hdr->sh_type = SHT_DYNAMIC;
1679 this_hdr->sh_entsize = bed->s->sizeof_dyn;
1681 else if (strncmp (asect->name, ".rela", 5) == 0
1682 && get_elf_backend_data (abfd)->may_use_rela_p)
1684 this_hdr->sh_type = SHT_RELA;
1685 this_hdr->sh_entsize = bed->s->sizeof_rela;
1687 else if (strncmp (asect->name, ".rel", 4) == 0
1688 && get_elf_backend_data (abfd)->may_use_rel_p)
1690 this_hdr->sh_type = SHT_REL;
1691 this_hdr->sh_entsize = bed->s->sizeof_rel;
1693 else if (strncmp (asect->name, ".note", 5) == 0)
1694 this_hdr->sh_type = SHT_NOTE;
1695 else if (strncmp (asect->name, ".stab", 5) == 0
1696 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1697 this_hdr->sh_type = SHT_STRTAB;
1698 else if (strcmp (asect->name, ".gnu.version") == 0)
1700 this_hdr->sh_type = SHT_GNU_versym;
1701 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
1703 else if (strcmp (asect->name, ".gnu.version_d") == 0)
1705 this_hdr->sh_type = SHT_GNU_verdef;
1706 this_hdr->sh_entsize = 0;
1707 /* objcopy or strip will copy over sh_info, but may not set
1708 cverdefs. The linker will set cverdefs, but sh_info will be
1710 if (this_hdr->sh_info == 0)
1711 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
1713 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
1714 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
1716 else if (strcmp (asect->name, ".gnu.version_r") == 0)
1718 this_hdr->sh_type = SHT_GNU_verneed;
1719 this_hdr->sh_entsize = 0;
1720 /* objcopy or strip will copy over sh_info, but may not set
1721 cverrefs. The linker will set cverrefs, but sh_info will be
1723 if (this_hdr->sh_info == 0)
1724 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
1726 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
1727 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
1729 else if ((asect->flags & SEC_ALLOC) != 0
1730 && (asect->flags & SEC_LOAD) != 0)
1731 this_hdr->sh_type = SHT_PROGBITS;
1732 else if ((asect->flags & SEC_ALLOC) != 0
1733 && ((asect->flags & SEC_LOAD) == 0))
1734 this_hdr->sh_type = SHT_NOBITS;
1738 this_hdr->sh_type = SHT_PROGBITS;
1741 if ((asect->flags & SEC_ALLOC) != 0)
1742 this_hdr->sh_flags |= SHF_ALLOC;
1743 if ((asect->flags & SEC_READONLY) == 0)
1744 this_hdr->sh_flags |= SHF_WRITE;
1745 if ((asect->flags & SEC_CODE) != 0)
1746 this_hdr->sh_flags |= SHF_EXECINSTR;
1748 /* Check for processor-specific section types. */
1749 if (bed->elf_backend_fake_sections)
1750 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1752 /* If the section has relocs, set up a section header for the
1753 SHT_REL[A] section. If two relocation sections are required for
1754 this section, it is up to the processor-specific back-end to
1755 create the other. */
1756 if ((asect->flags & SEC_RELOC) != 0
1757 && !_bfd_elf_init_reloc_shdr (abfd,
1758 &elf_section_data (asect)->rel_hdr,
1760 elf_section_data (asect)->use_rela_p))
1764 /* Get elf arch size (32 / 64).
1765 Returns -1 if not elf. */
1768 bfd_elf_get_arch_size (abfd)
1771 if (abfd->xvec->flavour != bfd_target_elf_flavour)
1773 bfd_set_error (bfd_error_wrong_format);
1777 return (get_elf_backend_data (abfd))->s->arch_size;
1780 /* True if addresses "naturally" sign extend. Return 0/1 if known.
1783 bfd_elf_get_sign_extend_vma (abfd)
1786 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1788 bfd_set_error (bfd_error_wrong_format);
1791 return (get_elf_backend_data (abfd)->sign_extend_vma);
1794 /* Assign all ELF section numbers. The dummy first section is handled here
1795 too. The link/info pointers for the standard section types are filled
1796 in here too, while we're at it. */
1799 assign_section_numbers (abfd)
1802 struct elf_obj_tdata *t = elf_tdata (abfd);
1804 unsigned int section_number;
1805 Elf_Internal_Shdr **i_shdrp;
1809 for (sec = abfd->sections; sec; sec = sec->next)
1811 struct bfd_elf_section_data *d = elf_section_data (sec);
1813 d->this_idx = section_number++;
1814 if ((sec->flags & SEC_RELOC) == 0)
1817 d->rel_idx = section_number++;
1820 d->rel_idx2 = section_number++;
1825 t->shstrtab_section = section_number++;
1826 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1827 t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1829 if (bfd_get_symcount (abfd) > 0)
1831 t->symtab_section = section_number++;
1832 t->strtab_section = section_number++;
1835 elf_elfheader (abfd)->e_shnum = section_number;
1837 /* Set up the list of section header pointers, in agreement with the
1839 i_shdrp = ((Elf_Internal_Shdr **)
1840 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1841 if (i_shdrp == NULL)
1844 i_shdrp[0] = ((Elf_Internal_Shdr *)
1845 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1846 if (i_shdrp[0] == NULL)
1848 bfd_release (abfd, i_shdrp);
1851 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1853 elf_elfsections (abfd) = i_shdrp;
1855 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1856 if (bfd_get_symcount (abfd) > 0)
1858 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1859 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1860 t->symtab_hdr.sh_link = t->strtab_section;
1862 for (sec = abfd->sections; sec; sec = sec->next)
1864 struct bfd_elf_section_data *d = elf_section_data (sec);
1868 i_shdrp[d->this_idx] = &d->this_hdr;
1869 if (d->rel_idx != 0)
1870 i_shdrp[d->rel_idx] = &d->rel_hdr;
1871 if (d->rel_idx2 != 0)
1872 i_shdrp[d->rel_idx2] = d->rel_hdr2;
1874 /* Fill in the sh_link and sh_info fields while we're at it. */
1876 /* sh_link of a reloc section is the section index of the symbol
1877 table. sh_info is the section index of the section to which
1878 the relocation entries apply. */
1879 if (d->rel_idx != 0)
1881 d->rel_hdr.sh_link = t->symtab_section;
1882 d->rel_hdr.sh_info = d->this_idx;
1884 if (d->rel_idx2 != 0)
1886 d->rel_hdr2->sh_link = t->symtab_section;
1887 d->rel_hdr2->sh_info = d->this_idx;
1890 switch (d->this_hdr.sh_type)
1894 /* A reloc section which we are treating as a normal BFD
1895 section. sh_link is the section index of the symbol
1896 table. sh_info is the section index of the section to
1897 which the relocation entries apply. We assume that an
1898 allocated reloc section uses the dynamic symbol table.
1899 FIXME: How can we be sure? */
1900 s = bfd_get_section_by_name (abfd, ".dynsym");
1902 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1904 /* We look up the section the relocs apply to by name. */
1906 if (d->this_hdr.sh_type == SHT_REL)
1910 s = bfd_get_section_by_name (abfd, name);
1912 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1916 /* We assume that a section named .stab*str is a stabs
1917 string section. We look for a section with the same name
1918 but without the trailing ``str'', and set its sh_link
1919 field to point to this section. */
1920 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1921 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1926 len = strlen (sec->name);
1927 alc = (char *) bfd_malloc (len - 2);
1930 strncpy (alc, sec->name, len - 3);
1931 alc[len - 3] = '\0';
1932 s = bfd_get_section_by_name (abfd, alc);
1936 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
1938 /* This is a .stab section. */
1939 elf_section_data (s)->this_hdr.sh_entsize =
1940 4 + 2 * bfd_elf_get_arch_size (abfd) / 8;
1947 case SHT_GNU_verneed:
1948 case SHT_GNU_verdef:
1949 /* sh_link is the section header index of the string table
1950 used for the dynamic entries, or the symbol table, or the
1952 s = bfd_get_section_by_name (abfd, ".dynstr");
1954 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1958 case SHT_GNU_versym:
1959 /* sh_link is the section header index of the symbol table
1960 this hash table or version table is for. */
1961 s = bfd_get_section_by_name (abfd, ".dynsym");
1963 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1971 /* Map symbol from it's internal number to the external number, moving
1972 all local symbols to be at the head of the list. */
1975 sym_is_global (abfd, sym)
1979 /* If the backend has a special mapping, use it. */
1980 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1981 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1984 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1985 || bfd_is_und_section (bfd_get_section (sym))
1986 || bfd_is_com_section (bfd_get_section (sym)));
1990 elf_map_symbols (abfd)
1993 int symcount = bfd_get_symcount (abfd);
1994 asymbol **syms = bfd_get_outsymbols (abfd);
1995 asymbol **sect_syms;
1997 int num_globals = 0;
1998 int num_locals2 = 0;
1999 int num_globals2 = 0;
2001 int num_sections = 0;
2008 fprintf (stderr, "elf_map_symbols\n");
2012 /* Add a section symbol for each BFD section. FIXME: Is this really
2014 for (asect = abfd->sections; asect; asect = asect->next)
2016 if (max_index < asect->index)
2017 max_index = asect->index;
2021 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
2022 if (sect_syms == NULL)
2024 elf_section_syms (abfd) = sect_syms;
2026 for (idx = 0; idx < symcount; idx++)
2030 if ((sym->flags & BSF_SECTION_SYM) != 0
2037 if (sec->owner != NULL)
2039 if (sec->owner != abfd)
2041 if (sec->output_offset != 0)
2044 sec = sec->output_section;
2046 /* Empty sections in the input files may have had a section
2047 symbol created for them. (See the comment near the end of
2048 _bfd_generic_link_output_symbols in linker.c). If the linker
2049 script discards such sections then we will reach this point.
2050 Since we know that we cannot avoid this case, we detect it
2051 and skip the abort and the assignment to the sect_syms array.
2052 To reproduce this particular case try running the linker
2053 testsuite test ld-scripts/weak.exp for an ELF port that uses
2054 the generic linker. */
2055 if (sec->owner == NULL)
2058 BFD_ASSERT (sec->owner == abfd);
2060 sect_syms[sec->index] = syms[idx];
2065 for (asect = abfd->sections; asect; asect = asect->next)
2067 if (sect_syms[asect->index] != NULL)
2070 sym = bfd_make_empty_symbol (abfd);
2073 sym->the_bfd = abfd;
2074 sym->name = asect->name;
2076 /* Set the flags to 0 to indicate that this one was newly added. */
2078 sym->section = asect;
2079 sect_syms[asect->index] = sym;
2083 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
2084 asect->name, (long) asect->vma, asect->index, (long) asect);
2088 /* Classify all of the symbols. */
2089 for (idx = 0; idx < symcount; idx++)
2091 if (!sym_is_global (abfd, syms[idx]))
2096 for (asect = abfd->sections; asect; asect = asect->next)
2098 if (sect_syms[asect->index] != NULL
2099 && sect_syms[asect->index]->flags == 0)
2101 sect_syms[asect->index]->flags = BSF_SECTION_SYM;
2102 if (!sym_is_global (abfd, sect_syms[asect->index]))
2106 sect_syms[asect->index]->flags = 0;
2110 /* Now sort the symbols so the local symbols are first. */
2111 new_syms = ((asymbol **)
2113 (num_locals + num_globals) * sizeof (asymbol *)));
2114 if (new_syms == NULL)
2117 for (idx = 0; idx < symcount; idx++)
2119 asymbol *sym = syms[idx];
2122 if (!sym_is_global (abfd, sym))
2125 i = num_locals + num_globals2++;
2127 sym->udata.i = i + 1;
2129 for (asect = abfd->sections; asect; asect = asect->next)
2131 if (sect_syms[asect->index] != NULL
2132 && sect_syms[asect->index]->flags == 0)
2134 asymbol *sym = sect_syms[asect->index];
2137 sym->flags = BSF_SECTION_SYM;
2138 if (!sym_is_global (abfd, sym))
2141 i = num_locals + num_globals2++;
2143 sym->udata.i = i + 1;
2147 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2149 elf_num_locals (abfd) = num_locals;
2150 elf_num_globals (abfd) = num_globals;
2154 /* Align to the maximum file alignment that could be required for any
2155 ELF data structure. */
2157 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2158 static INLINE file_ptr
2159 align_file_position (off, align)
2163 return (off + align - 1) & ~(align - 1);
2166 /* Assign a file position to a section, optionally aligning to the
2167 required section alignment. */
2170 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2171 Elf_Internal_Shdr *i_shdrp;
2179 al = i_shdrp->sh_addralign;
2181 offset = BFD_ALIGN (offset, al);
2183 i_shdrp->sh_offset = offset;
2184 if (i_shdrp->bfd_section != NULL)
2185 i_shdrp->bfd_section->filepos = offset;
2186 if (i_shdrp->sh_type != SHT_NOBITS)
2187 offset += i_shdrp->sh_size;
2191 /* Compute the file positions we are going to put the sections at, and
2192 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2193 is not NULL, this is being called by the ELF backend linker. */
2196 _bfd_elf_compute_section_file_positions (abfd, link_info)
2198 struct bfd_link_info *link_info;
2200 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2202 struct bfd_strtab_hash *strtab;
2203 Elf_Internal_Shdr *shstrtab_hdr;
2205 if (abfd->output_has_begun)
2208 /* Do any elf backend specific processing first. */
2209 if (bed->elf_backend_begin_write_processing)
2210 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2212 if (! prep_headers (abfd))
2215 /* Post process the headers if necessary. */
2216 if (bed->elf_backend_post_process_headers)
2217 (*bed->elf_backend_post_process_headers) (abfd, link_info);
2220 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2224 if (!assign_section_numbers (abfd))
2227 /* The backend linker builds symbol table information itself. */
2228 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2230 /* Non-zero if doing a relocatable link. */
2231 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2233 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2237 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2238 /* sh_name was set in prep_headers. */
2239 shstrtab_hdr->sh_type = SHT_STRTAB;
2240 shstrtab_hdr->sh_flags = 0;
2241 shstrtab_hdr->sh_addr = 0;
2242 shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
2243 shstrtab_hdr->sh_entsize = 0;
2244 shstrtab_hdr->sh_link = 0;
2245 shstrtab_hdr->sh_info = 0;
2246 /* sh_offset is set in assign_file_positions_except_relocs. */
2247 shstrtab_hdr->sh_addralign = 1;
2249 if (!assign_file_positions_except_relocs (abfd))
2252 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2255 Elf_Internal_Shdr *hdr;
2257 off = elf_tdata (abfd)->next_file_pos;
2259 hdr = &elf_tdata (abfd)->symtab_hdr;
2260 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2262 hdr = &elf_tdata (abfd)->strtab_hdr;
2263 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2265 elf_tdata (abfd)->next_file_pos = off;
2267 /* Now that we know where the .strtab section goes, write it
2269 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2270 || ! _bfd_stringtab_emit (abfd, strtab))
2272 _bfd_stringtab_free (strtab);
2275 abfd->output_has_begun = true;
2280 /* Create a mapping from a set of sections to a program segment. */
2282 static INLINE struct elf_segment_map *
2283 make_mapping (abfd, sections, from, to, phdr)
2285 asection **sections;
2290 struct elf_segment_map *m;
2294 m = ((struct elf_segment_map *)
2296 (sizeof (struct elf_segment_map)
2297 + (to - from - 1) * sizeof (asection *))));
2301 m->p_type = PT_LOAD;
2302 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2303 m->sections[i - from] = *hdrpp;
2304 m->count = to - from;
2306 if (from == 0 && phdr)
2308 /* Include the headers in the first PT_LOAD segment. */
2309 m->includes_filehdr = 1;
2310 m->includes_phdrs = 1;
2316 /* Set up a mapping from BFD sections to program segments. */
2319 map_sections_to_segments (abfd)
2322 asection **sections = NULL;
2326 struct elf_segment_map *mfirst;
2327 struct elf_segment_map **pm;
2328 struct elf_segment_map *m;
2330 unsigned int phdr_index;
2331 bfd_vma maxpagesize;
2333 boolean phdr_in_segment = true;
2337 if (elf_tdata (abfd)->segment_map != NULL)
2340 if (bfd_count_sections (abfd) == 0)
2343 /* Select the allocated sections, and sort them. */
2345 sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
2346 * sizeof (asection *));
2347 if (sections == NULL)
2351 for (s = abfd->sections; s != NULL; s = s->next)
2353 if ((s->flags & SEC_ALLOC) != 0)
2359 BFD_ASSERT (i <= bfd_count_sections (abfd));
2362 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2364 /* Build the mapping. */
2369 /* If we have a .interp section, then create a PT_PHDR segment for
2370 the program headers and a PT_INTERP segment for the .interp
2372 s = bfd_get_section_by_name (abfd, ".interp");
2373 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2375 m = ((struct elf_segment_map *)
2376 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2380 m->p_type = PT_PHDR;
2381 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2382 m->p_flags = PF_R | PF_X;
2383 m->p_flags_valid = 1;
2384 m->includes_phdrs = 1;
2389 m = ((struct elf_segment_map *)
2390 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2394 m->p_type = PT_INTERP;
2402 /* Look through the sections. We put sections in the same program
2403 segment when the start of the second section can be placed within
2404 a few bytes of the end of the first section. */
2407 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2409 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2411 && (dynsec->flags & SEC_LOAD) == 0)
2414 /* Deal with -Ttext or something similar such that the first section
2415 is not adjacent to the program headers. This is an
2416 approximation, since at this point we don't know exactly how many
2417 program headers we will need. */
2420 bfd_size_type phdr_size;
2422 phdr_size = elf_tdata (abfd)->program_header_size;
2424 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2425 if ((abfd->flags & D_PAGED) == 0
2426 || sections[0]->lma < phdr_size
2427 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2428 phdr_in_segment = false;
2431 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2434 boolean new_segment;
2438 /* See if this section and the last one will fit in the same
2441 if (last_hdr == NULL)
2443 /* If we don't have a segment yet, then we don't need a new
2444 one (we build the last one after this loop). */
2445 new_segment = false;
2447 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
2449 /* If this section has a different relation between the
2450 virtual address and the load address, then we need a new
2454 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2455 < BFD_ALIGN (hdr->lma, maxpagesize))
2457 /* If putting this section in this segment would force us to
2458 skip a page in the segment, then we need a new segment. */
2461 else if ((last_hdr->flags & SEC_LOAD) == 0
2462 && (hdr->flags & SEC_LOAD) != 0)
2464 /* We don't want to put a loadable section after a
2465 nonloadable section in the same segment. */
2468 else if ((abfd->flags & D_PAGED) == 0)
2470 /* If the file is not demand paged, which means that we
2471 don't require the sections to be correctly aligned in the
2472 file, then there is no other reason for a new segment. */
2473 new_segment = false;
2476 && (hdr->flags & SEC_READONLY) == 0
2477 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2480 /* We don't want to put a writable section in a read only
2481 segment, unless they are on the same page in memory
2482 anyhow. We already know that the last section does not
2483 bring us past the current section on the page, so the
2484 only case in which the new section is not on the same
2485 page as the previous section is when the previous section
2486 ends precisely on a page boundary. */
2491 /* Otherwise, we can use the same segment. */
2492 new_segment = false;
2497 if ((hdr->flags & SEC_READONLY) == 0)
2503 /* We need a new program segment. We must create a new program
2504 header holding all the sections from phdr_index until hdr. */
2506 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2513 if ((hdr->flags & SEC_READONLY) == 0)
2520 phdr_in_segment = false;
2523 /* Create a final PT_LOAD program segment. */
2524 if (last_hdr != NULL)
2526 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2534 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2537 m = ((struct elf_segment_map *)
2538 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2542 m->p_type = PT_DYNAMIC;
2544 m->sections[0] = dynsec;
2550 /* For each loadable .note section, add a PT_NOTE segment. We don't
2551 use bfd_get_section_by_name, because if we link together
2552 nonloadable .note sections and loadable .note sections, we will
2553 generate two .note sections in the output file. FIXME: Using
2554 names for section types is bogus anyhow. */
2555 for (s = abfd->sections; s != NULL; s = s->next)
2557 if ((s->flags & SEC_LOAD) != 0
2558 && strncmp (s->name, ".note", 5) == 0)
2560 m = ((struct elf_segment_map *)
2561 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2565 m->p_type = PT_NOTE;
2577 elf_tdata (abfd)->segment_map = mfirst;
2581 if (sections != NULL)
2586 /* Sort sections by address. */
2589 elf_sort_sections (arg1, arg2)
2593 const asection *sec1 = *(const asection **) arg1;
2594 const asection *sec2 = *(const asection **) arg2;
2596 /* Sort by LMA first, since this is the address used to
2597 place the section into a segment. */
2598 if (sec1->lma < sec2->lma)
2600 else if (sec1->lma > sec2->lma)
2603 /* Then sort by VMA. Normally the LMA and the VMA will be
2604 the same, and this will do nothing. */
2605 if (sec1->vma < sec2->vma)
2607 else if (sec1->vma > sec2->vma)
2610 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2612 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2617 return sec1->target_index - sec2->target_index;
2627 /* Sort by size, to put zero sized sections before others at the
2630 if (sec1->_raw_size < sec2->_raw_size)
2632 if (sec1->_raw_size > sec2->_raw_size)
2635 return sec1->target_index - sec2->target_index;
2638 /* Assign file positions to the sections based on the mapping from
2639 sections to segments. This function also sets up some fields in
2640 the file header, and writes out the program headers. */
2643 assign_file_positions_for_segments (abfd)
2646 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2648 struct elf_segment_map *m;
2650 Elf_Internal_Phdr *phdrs;
2652 bfd_vma filehdr_vaddr, filehdr_paddr;
2653 bfd_vma phdrs_vaddr, phdrs_paddr;
2654 Elf_Internal_Phdr *p;
2656 if (elf_tdata (abfd)->segment_map == NULL)
2658 if (! map_sections_to_segments (abfd))
2662 if (bed->elf_backend_modify_segment_map)
2664 if (! (*bed->elf_backend_modify_segment_map) (abfd))
2669 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2672 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
2673 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
2674 elf_elfheader (abfd)->e_phnum = count;
2679 /* If we already counted the number of program segments, make sure
2680 that we allocated enough space. This happens when SIZEOF_HEADERS
2681 is used in a linker script. */
2682 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
2683 if (alloc != 0 && count > alloc)
2685 ((*_bfd_error_handler)
2686 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2687 bfd_get_filename (abfd), alloc, count));
2688 bfd_set_error (bfd_error_bad_value);
2695 phdrs = ((Elf_Internal_Phdr *)
2696 bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
2700 off = bed->s->sizeof_ehdr;
2701 off += alloc * bed->s->sizeof_phdr;
2708 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2715 /* If elf_segment_map is not from map_sections_to_segments, the
2716 sections may not be correctly ordered. */
2718 qsort (m->sections, (size_t) m->count, sizeof (asection *),
2721 p->p_type = m->p_type;
2722 p->p_flags = m->p_flags;
2724 if (p->p_type == PT_LOAD
2726 && (m->sections[0]->flags & SEC_ALLOC) != 0)
2728 if ((abfd->flags & D_PAGED) != 0)
2729 off += (m->sections[0]->vma - off) % bed->maxpagesize;
2732 bfd_size_type align;
2735 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2737 bfd_size_type secalign;
2739 secalign = bfd_get_section_alignment (abfd, *secpp);
2740 if (secalign > align)
2744 off += (m->sections[0]->vma - off) % (1 << align);
2751 p->p_vaddr = m->sections[0]->vma;
2753 if (m->p_paddr_valid)
2754 p->p_paddr = m->p_paddr;
2755 else if (m->count == 0)
2758 p->p_paddr = m->sections[0]->lma;
2760 if (p->p_type == PT_LOAD
2761 && (abfd->flags & D_PAGED) != 0)
2762 p->p_align = bed->maxpagesize;
2763 else if (m->count == 0)
2764 p->p_align = bed->s->file_align;
2772 if (m->includes_filehdr)
2774 if (! m->p_flags_valid)
2777 p->p_filesz = bed->s->sizeof_ehdr;
2778 p->p_memsz = bed->s->sizeof_ehdr;
2781 BFD_ASSERT (p->p_type == PT_LOAD);
2783 if (p->p_vaddr < (bfd_vma) off)
2785 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2786 bfd_get_filename (abfd));
2787 bfd_set_error (bfd_error_bad_value);
2792 if (! m->p_paddr_valid)
2795 if (p->p_type == PT_LOAD)
2797 filehdr_vaddr = p->p_vaddr;
2798 filehdr_paddr = p->p_paddr;
2802 if (m->includes_phdrs)
2804 if (! m->p_flags_valid)
2807 if (m->includes_filehdr)
2809 if (p->p_type == PT_LOAD)
2811 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
2812 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
2817 p->p_offset = bed->s->sizeof_ehdr;
2821 BFD_ASSERT (p->p_type == PT_LOAD);
2822 p->p_vaddr -= off - p->p_offset;
2823 if (! m->p_paddr_valid)
2824 p->p_paddr -= off - p->p_offset;
2827 if (p->p_type == PT_LOAD)
2829 phdrs_vaddr = p->p_vaddr;
2830 phdrs_paddr = p->p_paddr;
2833 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
2836 p->p_filesz += alloc * bed->s->sizeof_phdr;
2837 p->p_memsz += alloc * bed->s->sizeof_phdr;
2840 if (p->p_type == PT_LOAD
2841 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
2843 if (! m->includes_filehdr && ! m->includes_phdrs)
2849 adjust = off - (p->p_offset + p->p_filesz);
2850 p->p_filesz += adjust;
2851 p->p_memsz += adjust;
2857 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2861 bfd_size_type align;
2865 align = 1 << bfd_get_section_alignment (abfd, sec);
2867 /* The section may have artificial alignment forced by a
2868 link script. Notice this case by the gap between the
2869 cumulative phdr vma and the section's vma. */
2870 if (p->p_vaddr + p->p_memsz < sec->vma)
2872 bfd_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
2874 p->p_memsz += adjust;
2877 if ((flags & SEC_LOAD) != 0)
2878 p->p_filesz += adjust;
2881 if (p->p_type == PT_LOAD)
2883 bfd_signed_vma adjust;
2885 if ((flags & SEC_LOAD) != 0)
2887 adjust = sec->lma - (p->p_paddr + p->p_memsz);
2891 else if ((flags & SEC_ALLOC) != 0)
2893 /* The section VMA must equal the file position
2894 modulo the page size. FIXME: I'm not sure if
2895 this adjustment is really necessary. We used to
2896 not have the SEC_LOAD case just above, and then
2897 this was necessary, but now I'm not sure. */
2898 if ((abfd->flags & D_PAGED) != 0)
2899 adjust = (sec->vma - voff) % bed->maxpagesize;
2901 adjust = (sec->vma - voff) % align;
2910 (* _bfd_error_handler)
2911 (_("Error: First section in segment (%s) starts at 0x%x"),
2912 bfd_section_name (abfd, sec), sec->lma);
2913 (* _bfd_error_handler)
2914 (_(" whereas segment starts at 0x%x"),
2919 p->p_memsz += adjust;
2922 if ((flags & SEC_LOAD) != 0)
2923 p->p_filesz += adjust;
2928 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2929 used in a linker script we may have a section with
2930 SEC_LOAD clear but which is supposed to have
2932 if ((flags & SEC_LOAD) != 0
2933 || (flags & SEC_HAS_CONTENTS) != 0)
2934 off += sec->_raw_size;
2936 if ((flags & SEC_ALLOC) != 0)
2937 voff += sec->_raw_size;
2940 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
2942 /* The actual "note" segment has i == 0.
2943 This is the one that actually contains everything. */
2947 p->p_filesz = sec->_raw_size;
2948 off += sec->_raw_size;
2953 /* Fake sections -- don't need to be written. */
2956 flags = sec->flags = 0;
2963 p->p_memsz += sec->_raw_size;
2965 if ((flags & SEC_LOAD) != 0)
2966 p->p_filesz += sec->_raw_size;
2968 if (align > p->p_align
2969 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
2973 if (! m->p_flags_valid)
2976 if ((flags & SEC_CODE) != 0)
2978 if ((flags & SEC_READONLY) == 0)
2984 /* Now that we have set the section file positions, we can set up
2985 the file positions for the non PT_LOAD segments. */
2986 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2990 if (p->p_type != PT_LOAD && m->count > 0)
2992 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
2993 p->p_offset = m->sections[0]->filepos;
2997 if (m->includes_filehdr)
2999 p->p_vaddr = filehdr_vaddr;
3000 if (! m->p_paddr_valid)
3001 p->p_paddr = filehdr_paddr;
3003 else if (m->includes_phdrs)
3005 p->p_vaddr = phdrs_vaddr;
3006 if (! m->p_paddr_valid)
3007 p->p_paddr = phdrs_paddr;
3012 /* Clear out any program headers we allocated but did not use. */
3013 for (; count < alloc; count++, p++)
3015 memset (p, 0, sizeof *p);
3016 p->p_type = PT_NULL;
3019 elf_tdata (abfd)->phdr = phdrs;
3021 elf_tdata (abfd)->next_file_pos = off;
3023 /* Write out the program headers. */
3024 if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
3025 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3031 /* Get the size of the program header.
3033 If this is called by the linker before any of the section VMA's are set, it
3034 can't calculate the correct value for a strange memory layout. This only
3035 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3036 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3037 data segment (exclusive of .interp and .dynamic).
3039 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3040 will be two segments. */
3042 static bfd_size_type
3043 get_program_header_size (abfd)
3048 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3050 /* We can't return a different result each time we're called. */
3051 if (elf_tdata (abfd)->program_header_size != 0)
3052 return elf_tdata (abfd)->program_header_size;
3054 if (elf_tdata (abfd)->segment_map != NULL)
3056 struct elf_segment_map *m;
3059 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3061 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3062 return elf_tdata (abfd)->program_header_size;
3065 /* Assume we will need exactly two PT_LOAD segments: one for text
3066 and one for data. */
3069 s = bfd_get_section_by_name (abfd, ".interp");
3070 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3072 /* If we have a loadable interpreter section, we need a
3073 PT_INTERP segment. In this case, assume we also need a
3074 PT_PHDR segment, although that may not be true for all
3079 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3081 /* We need a PT_DYNAMIC segment. */
3085 for (s = abfd->sections; s != NULL; s = s->next)
3087 if ((s->flags & SEC_LOAD) != 0
3088 && strncmp (s->name, ".note", 5) == 0)
3090 /* We need a PT_NOTE segment. */
3095 /* Let the backend count up any program headers it might need. */
3096 if (bed->elf_backend_additional_program_headers)
3100 a = (*bed->elf_backend_additional_program_headers) (abfd);
3106 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3107 return elf_tdata (abfd)->program_header_size;
3110 /* Work out the file positions of all the sections. This is called by
3111 _bfd_elf_compute_section_file_positions. All the section sizes and
3112 VMAs must be known before this is called.
3114 We do not consider reloc sections at this point, unless they form
3115 part of the loadable image. Reloc sections are assigned file
3116 positions in assign_file_positions_for_relocs, which is called by
3117 write_object_contents and final_link.
3119 We also don't set the positions of the .symtab and .strtab here. */
3122 assign_file_positions_except_relocs (abfd)
3125 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
3126 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
3127 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
3129 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3131 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3132 && bfd_get_format (abfd) != bfd_core)
3134 Elf_Internal_Shdr **hdrpp;
3137 /* Start after the ELF header. */
3138 off = i_ehdrp->e_ehsize;
3140 /* We are not creating an executable, which means that we are
3141 not creating a program header, and that the actual order of
3142 the sections in the file is unimportant. */
3143 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3145 Elf_Internal_Shdr *hdr;
3148 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
3150 hdr->sh_offset = -1;
3153 if (i == tdata->symtab_section
3154 || i == tdata->strtab_section)
3156 hdr->sh_offset = -1;
3160 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3166 Elf_Internal_Shdr **hdrpp;
3168 /* Assign file positions for the loaded sections based on the
3169 assignment of sections to segments. */
3170 if (! assign_file_positions_for_segments (abfd))
3173 /* Assign file positions for the other sections. */
3175 off = elf_tdata (abfd)->next_file_pos;
3176 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3178 Elf_Internal_Shdr *hdr;
3181 if (hdr->bfd_section != NULL
3182 && hdr->bfd_section->filepos != 0)
3183 hdr->sh_offset = hdr->bfd_section->filepos;
3184 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3186 ((*_bfd_error_handler)
3187 (_("%s: warning: allocated section `%s' not in segment"),
3188 bfd_get_filename (abfd),
3189 (hdr->bfd_section == NULL
3191 : hdr->bfd_section->name)));
3192 if ((abfd->flags & D_PAGED) != 0)
3193 off += (hdr->sh_addr - off) % bed->maxpagesize;
3195 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3196 off = _bfd_elf_assign_file_position_for_section (hdr, off,
3199 else if (hdr->sh_type == SHT_REL
3200 || hdr->sh_type == SHT_RELA
3201 || hdr == i_shdrpp[tdata->symtab_section]
3202 || hdr == i_shdrpp[tdata->strtab_section])
3203 hdr->sh_offset = -1;
3205 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3209 /* Place the section headers. */
3210 off = align_file_position (off, bed->s->file_align);
3211 i_ehdrp->e_shoff = off;
3212 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3214 elf_tdata (abfd)->next_file_pos = off;
3223 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3224 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3225 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3227 struct bfd_strtab_hash *shstrtab;
3228 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3230 i_ehdrp = elf_elfheader (abfd);
3231 i_shdrp = elf_elfsections (abfd);
3233 shstrtab = _bfd_elf_stringtab_init ();
3234 if (shstrtab == NULL)
3237 elf_shstrtab (abfd) = shstrtab;
3239 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3240 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3241 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3242 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3244 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3245 i_ehdrp->e_ident[EI_DATA] =
3246 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3247 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3249 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NONE;
3250 i_ehdrp->e_ident[EI_ABIVERSION] = 0;
3252 for (count = EI_PAD; count < EI_NIDENT; count++)
3253 i_ehdrp->e_ident[count] = 0;
3255 if ((abfd->flags & DYNAMIC) != 0)
3256 i_ehdrp->e_type = ET_DYN;
3257 else if ((abfd->flags & EXEC_P) != 0)
3258 i_ehdrp->e_type = ET_EXEC;
3259 else if (bfd_get_format (abfd) == bfd_core)
3260 i_ehdrp->e_type = ET_CORE;
3262 i_ehdrp->e_type = ET_REL;
3264 switch (bfd_get_arch (abfd))
3266 case bfd_arch_unknown:
3267 i_ehdrp->e_machine = EM_NONE;
3269 case bfd_arch_sparc:
3270 if (bfd_elf_get_arch_size (abfd) == 64)
3271 i_ehdrp->e_machine = EM_SPARCV9;
3273 i_ehdrp->e_machine = EM_SPARC;
3276 i_ehdrp->e_machine = EM_S370;
3279 i_ehdrp->e_machine = EM_386;
3282 i_ehdrp->e_machine = EM_IA_64;
3284 case bfd_arch_m68hc11:
3285 i_ehdrp->e_machine = EM_68HC11;
3287 case bfd_arch_m68hc12:
3288 i_ehdrp->e_machine = EM_68HC12;
3291 i_ehdrp->e_machine = EM_68K;
3294 i_ehdrp->e_machine = EM_88K;
3297 i_ehdrp->e_machine = EM_860;
3300 i_ehdrp->e_machine = EM_960;
3302 case bfd_arch_mips: /* MIPS Rxxxx */
3303 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
3306 i_ehdrp->e_machine = EM_PARISC;
3308 case bfd_arch_powerpc:
3309 i_ehdrp->e_machine = EM_PPC;
3311 case bfd_arch_alpha:
3312 i_ehdrp->e_machine = EM_ALPHA;
3315 i_ehdrp->e_machine = EM_SH;
3318 i_ehdrp->e_machine = EM_CYGNUS_D10V;
3321 i_ehdrp->e_machine = EM_CYGNUS_D30V;
3324 i_ehdrp->e_machine = EM_CYGNUS_FR30;
3326 case bfd_arch_mcore:
3327 i_ehdrp->e_machine = EM_MCORE;
3330 i_ehdrp->e_machine = EM_AVR;
3333 switch (bfd_get_mach (abfd))
3336 case 0: i_ehdrp->e_machine = EM_CYGNUS_V850; break;
3340 i_ehdrp->e_machine = EM_CYGNUS_ARC;
3343 i_ehdrp->e_machine = EM_ARM;
3346 i_ehdrp->e_machine = EM_CYGNUS_M32R;
3348 case bfd_arch_mn10200:
3349 i_ehdrp->e_machine = EM_CYGNUS_MN10200;
3351 case bfd_arch_mn10300:
3352 i_ehdrp->e_machine = EM_CYGNUS_MN10300;
3355 i_ehdrp->e_machine = EM_PJ;
3357 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3359 i_ehdrp->e_machine = EM_NONE;
3361 i_ehdrp->e_version = bed->s->ev_current;
3362 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3364 /* no program header, for now. */
3365 i_ehdrp->e_phoff = 0;
3366 i_ehdrp->e_phentsize = 0;
3367 i_ehdrp->e_phnum = 0;
3369 /* each bfd section is section header entry */
3370 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3371 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3373 /* if we're building an executable, we'll need a program header table */
3374 if (abfd->flags & EXEC_P)
3376 /* it all happens later */
3378 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3380 /* elf_build_phdrs() returns a (NULL-terminated) array of
3381 Elf_Internal_Phdrs */
3382 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3383 i_ehdrp->e_phoff = outbase;
3384 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3389 i_ehdrp->e_phentsize = 0;
3391 i_ehdrp->e_phoff = 0;
3394 elf_tdata (abfd)->symtab_hdr.sh_name =
3395 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
3396 elf_tdata (abfd)->strtab_hdr.sh_name =
3397 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
3398 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3399 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
3400 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3401 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3402 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3408 /* Assign file positions for all the reloc sections which are not part
3409 of the loadable file image. */
3412 _bfd_elf_assign_file_positions_for_relocs (abfd)
3417 Elf_Internal_Shdr **shdrpp;
3419 off = elf_tdata (abfd)->next_file_pos;
3421 for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
3422 i < elf_elfheader (abfd)->e_shnum;
3425 Elf_Internal_Shdr *shdrp;
3428 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3429 && shdrp->sh_offset == -1)
3430 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3433 elf_tdata (abfd)->next_file_pos = off;
3437 _bfd_elf_write_object_contents (abfd)
3440 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3441 Elf_Internal_Ehdr *i_ehdrp;
3442 Elf_Internal_Shdr **i_shdrp;
3446 if (! abfd->output_has_begun
3447 && ! _bfd_elf_compute_section_file_positions
3448 (abfd, (struct bfd_link_info *) NULL))
3451 i_shdrp = elf_elfsections (abfd);
3452 i_ehdrp = elf_elfheader (abfd);
3455 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3459 _bfd_elf_assign_file_positions_for_relocs (abfd);
3461 /* After writing the headers, we need to write the sections too... */
3462 for (count = 1; count < i_ehdrp->e_shnum; count++)
3464 if (bed->elf_backend_section_processing)
3465 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3466 if (i_shdrp[count]->contents)
3468 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3469 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
3471 != i_shdrp[count]->sh_size))
3476 /* Write out the section header names. */
3477 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
3478 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
3481 if (bed->elf_backend_final_write_processing)
3482 (*bed->elf_backend_final_write_processing) (abfd,
3483 elf_tdata (abfd)->linker);
3485 return bed->s->write_shdrs_and_ehdr (abfd);
3489 _bfd_elf_write_corefile_contents (abfd)
3492 /* Hopefully this can be done just like an object file. */
3493 return _bfd_elf_write_object_contents (abfd);
3495 /* given a section, search the header to find them... */
3497 _bfd_elf_section_from_bfd_section (abfd, asect)
3501 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3502 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
3504 Elf_Internal_Shdr *hdr;
3505 int maxindex = elf_elfheader (abfd)->e_shnum;
3507 for (index = 0; index < maxindex; index++)
3509 hdr = i_shdrp[index];
3510 if (hdr->bfd_section == asect)
3514 if (bed->elf_backend_section_from_bfd_section)
3516 for (index = 0; index < maxindex; index++)
3520 hdr = i_shdrp[index];
3522 if ((*bed->elf_backend_section_from_bfd_section)
3523 (abfd, hdr, asect, &retval))
3528 if (bfd_is_abs_section (asect))
3530 if (bfd_is_com_section (asect))
3532 if (bfd_is_und_section (asect))
3535 bfd_set_error (bfd_error_nonrepresentable_section);
3540 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3544 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
3546 asymbol **asym_ptr_ptr;
3548 asymbol *asym_ptr = *asym_ptr_ptr;
3550 flagword flags = asym_ptr->flags;
3552 /* When gas creates relocations against local labels, it creates its
3553 own symbol for the section, but does put the symbol into the
3554 symbol chain, so udata is 0. When the linker is generating
3555 relocatable output, this section symbol may be for one of the
3556 input sections rather than the output section. */
3557 if (asym_ptr->udata.i == 0
3558 && (flags & BSF_SECTION_SYM)
3559 && asym_ptr->section)
3563 if (asym_ptr->section->output_section != NULL)
3564 indx = asym_ptr->section->output_section->index;
3566 indx = asym_ptr->section->index;
3567 if (elf_section_syms (abfd)[indx])
3568 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
3571 idx = asym_ptr->udata.i;
3575 /* This case can occur when using --strip-symbol on a symbol
3576 which is used in a relocation entry. */
3577 (*_bfd_error_handler)
3578 (_("%s: symbol `%s' required but not present"),
3579 bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
3580 bfd_set_error (bfd_error_no_symbols);
3587 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3588 (long) asym_ptr, asym_ptr->name, idx, flags,
3589 elf_symbol_flags (flags));
3597 /* Copy private BFD data. This copies any program header information. */
3600 copy_private_bfd_data (ibfd, obfd)
3604 Elf_Internal_Ehdr *iehdr;
3605 struct elf_segment_map *mfirst;
3606 struct elf_segment_map **pm;
3607 struct elf_segment_map *m;
3608 Elf_Internal_Phdr *p;
3610 unsigned int num_segments;
3611 boolean phdr_included = false;
3613 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3614 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3617 if (elf_tdata (ibfd)->phdr == NULL)
3620 iehdr = elf_elfheader (ibfd);
3625 num_segments = elf_elfheader (ibfd)->e_phnum;
3627 #define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3628 ((addr) >= (bottom) \
3629 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3630 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3632 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3634 #define IS_COREFILE_NOTE(p, s) \
3635 (p->p_type == PT_NOTE \
3636 && bfd_get_format (ibfd) == bfd_core \
3637 && s->vma == 0 && s->lma == 0 \
3638 && (bfd_vma) s->filepos >= p->p_offset \
3639 && (bfd_vma) s->filepos + s->_raw_size \
3640 <= p->p_offset + p->p_filesz)
3642 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3643 linker, which generates a PT_INTERP section with p_vaddr and
3644 p_memsz set to 0. */
3646 #define IS_SOLARIS_PT_INTERP(p, s) \
3648 && p->p_filesz > 0 \
3649 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3650 && s->_raw_size > 0 \
3651 && (bfd_vma) s->filepos >= p->p_offset \
3652 && ((bfd_vma) s->filepos + s->_raw_size \
3653 <= p->p_offset + p->p_filesz))
3655 /* Scan through the segments specified in the program header
3656 of the input BFD. */
3657 for (i = 0, p = elf_tdata (ibfd)->phdr; i < num_segments; i++, p++)
3661 asection **sections;
3664 bfd_vma matching_lma;
3665 bfd_vma suggested_lma;
3668 /* For each section in the input BFD, decide if it should be
3669 included in the current segment. A section will be included
3670 if it is within the address space of the segment, and it is
3671 an allocated segment, and there is an output section
3672 associated with it. */
3674 for (s = ibfd->sections; s != NULL; s = s->next)
3675 if (s->output_section != NULL)
3677 if ((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3678 || IS_SOLARIS_PT_INTERP (p, s))
3679 && (s->flags & SEC_ALLOC) != 0)
3681 else if (IS_COREFILE_NOTE (p, s))
3685 /* Allocate a segment map big enough to contain all of the
3686 sections we have selected. */
3687 m = ((struct elf_segment_map *)
3689 (sizeof (struct elf_segment_map)
3690 + ((size_t) csecs - 1) * sizeof (asection *))));
3694 /* Initialise the fields of the segment map. Default to
3695 using the physical address of the segment in the input BFD. */
3697 m->p_type = p->p_type;
3698 m->p_flags = p->p_flags;
3699 m->p_flags_valid = 1;
3700 m->p_paddr = p->p_paddr;
3701 m->p_paddr_valid = 1;
3703 /* Determine if this segment contains the ELF file header
3704 and if it contains the program headers themselves. */
3705 m->includes_filehdr = (p->p_offset == 0
3706 && p->p_filesz >= iehdr->e_ehsize);
3708 m->includes_phdrs = 0;
3710 if (! phdr_included || p->p_type != PT_LOAD)
3713 (p->p_offset <= (bfd_vma) iehdr->e_phoff
3714 && (p->p_offset + p->p_filesz
3715 >= ((bfd_vma) iehdr->e_phoff
3716 + iehdr->e_phnum * iehdr->e_phentsize)));
3717 if (p->p_type == PT_LOAD && m->includes_phdrs)
3718 phdr_included = true;
3723 /* Special segments, such as the PT_PHDR segment, may contain
3724 no sections, but ordinary, loadable segments should contain
3727 if (p->p_type == PT_LOAD)
3729 (_("%s: warning: Empty loadable segment detected\n"),
3730 bfd_get_filename (ibfd));
3739 /* Now scan the sections in the input BFD again and attempt
3740 to add their corresponding output sections to the segment map.
3741 The problem here is how to handle an output section which has
3742 been moved (ie had its LMA changed). There are four possibilities:
3744 1. None of the sections have been moved.
3745 In this case we can continue to use the segment LMA from the
3748 2. All of the sections have been moved by the same amount.
3749 In this case we can change the segment's LMA to match the LMA
3750 of the first section.
3752 3. Some of the sections have been moved, others have not.
3753 In this case those sections which have not been moved can be
3754 placed in the current segment which will have to have its size,
3755 and possibly its LMA changed, and a new segment or segments will
3756 have to be created to contain the other sections.
3758 4. The sections have been moved, but not be the same amount.
3759 In this case we can change the segment's LMA to match the LMA
3760 of the first section and we will have to create a new segment
3761 or segments to contain the other sections.
3763 In order to save time, we allocate an array to hold the section
3764 pointers that we are interested in. As these sections get assigned
3765 to a segment, they are removed from this array. */
3767 sections = (asection **) bfd_malloc (sizeof (asection *) * csecs);
3768 if (sections == NULL)
3771 /* Step One: Scan for segment vs section LMA conflicts.
3772 Also add the sections to the section array allocated above.
3773 Also add the sections to the current segment. In the common
3774 case, where the sections have not been moved, this means that
3775 we have completely filled the segment, and there is nothing
3782 for (j = 0, s = ibfd->sections; s != NULL; s = s->next)
3784 os = s->output_section;
3786 if ((((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
3787 || IS_SOLARIS_PT_INTERP (p, s))
3788 && (s->flags & SEC_ALLOC) != 0)
3789 || IS_COREFILE_NOTE (p, s))
3794 /* The Solaris native linker always sets p_paddr to 0.
3795 We try to catch that case here, and set it to the
3801 && (os->vma == (p->p_vaddr
3802 + (m->includes_filehdr
3805 + (m->includes_phdrs
3806 ? iehdr->e_phnum * iehdr->e_phentsize
3808 m->p_paddr = p->p_vaddr;
3810 /* Match up the physical address of the segment with the
3811 LMA address of the output section. */
3812 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3813 || IS_COREFILE_NOTE (p, s))
3815 if (matching_lma == 0)
3816 matching_lma = os->lma;
3818 /* We assume that if the section fits within the segment
3819 that it does not overlap any other section within that
3821 m->sections[isec++] = os;
3823 else if (suggested_lma == 0)
3824 suggested_lma = os->lma;
3828 BFD_ASSERT (j == csecs);
3830 /* Step Two: Adjust the physical address of the current segment,
3834 /* All of the sections fitted within the segment as currently
3835 specified. This is the default case. Add the segment to
3836 the list of built segments and carry on to process the next
3837 program header in the input BFD. */
3847 if (matching_lma != 0)
3849 /* At least one section fits inside the current segment.
3850 Keep it, but modify its physical address to match the
3851 LMA of the first section that fitted. */
3853 m->p_paddr = matching_lma;
3857 /* None of the sections fitted inside the current segment.
3858 Change the current segment's physical address to match
3859 the LMA of the first section. */
3861 m->p_paddr = suggested_lma;
3864 /* Offset the segment physical address from the lma to allow
3865 for space taken up by elf headers. */
3866 if (m->includes_filehdr)
3867 m->p_paddr -= iehdr->e_ehsize;
3869 if (m->includes_phdrs)
3870 m->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
3873 /* Step Three: Loop over the sections again, this time assigning
3874 those that fit to the current segment and remvoing them from the
3875 sections array; but making sure not to leave large gaps. Once all
3876 possible sections have been assigned to the current segment it is
3877 added to the list of built segments and if sections still remain
3878 to be assigned, a new segment is constructed before repeating
3886 /* Fill the current segment with sections that fit. */
3887 for (j = 0; j < csecs; j++)
3894 os = s->output_section;
3896 if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
3897 || IS_COREFILE_NOTE (p, s))
3901 /* If the first section in a segment does not start at
3902 the beginning of the segment, then something is wrong. */
3903 if (os->lma != (m->p_paddr
3904 + (m->includes_filehdr
3905 ? iehdr->e_ehsize : 0)
3906 + (m->includes_phdrs
3907 ? iehdr->e_phnum * iehdr->e_phentsize
3913 asection * prev_sec;
3914 bfd_vma maxpagesize;
3916 prev_sec = m->sections[m->count - 1];
3917 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
3919 /* If the gap between the end of the previous section
3920 and the start of this section is more than maxpagesize
3921 then we need to start a new segment. */
3922 if (BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
3923 < BFD_ALIGN (os->lma, maxpagesize))
3925 if (suggested_lma == 0)
3926 suggested_lma = os->lma;
3932 m->sections[m->count++] = os;
3936 else if (suggested_lma == 0)
3937 suggested_lma = os->lma;
3940 BFD_ASSERT (m->count > 0);
3942 /* Add the current segment to the list of built segments. */
3948 /* We still have not allocated all of the sections to
3949 segments. Create a new segment here, initialise it
3950 and carry on looping. */
3952 m = ((struct elf_segment_map *)
3954 (sizeof (struct elf_segment_map)
3955 + ((size_t) csecs - 1) * sizeof (asection *))));
3959 /* Initialise the fields of the segment map. Set the physical
3960 physical address to the LMA of the first section that has
3961 not yet been assigned. */
3964 m->p_type = p->p_type;
3965 m->p_flags = p->p_flags;
3966 m->p_flags_valid = 1;
3967 m->p_paddr = suggested_lma;
3968 m->p_paddr_valid = 1;
3969 m->includes_filehdr = 0;
3970 m->includes_phdrs = 0;
3973 while (isec < csecs);
3978 /* The Solaris linker creates program headers in which all the
3979 p_paddr fields are zero. When we try to objcopy or strip such a
3980 file, we get confused. Check for this case, and if we find it
3981 reset the p_paddr_valid fields. */
3982 for (m = mfirst; m != NULL; m = m->next)
3983 if (m->p_paddr != 0)
3987 for (m = mfirst; m != NULL; m = m->next)
3988 m->p_paddr_valid = 0;
3991 elf_tdata (obfd)->segment_map = mfirst;
3994 /* Final Step: Sort the segments into ascending order of physical address. */
3997 struct elf_segment_map* prev;
4000 for (m = mfirst->next; m != NULL; prev = m, m = m->next)
4002 /* Yes I know - its a bubble sort....*/
4003 if (m->next != NULL && (m->next->p_paddr < m->p_paddr))
4005 /* swap m and m->next */
4006 prev->next = m->next;
4007 m->next = m->next->next;
4008 prev->next->next = m;
4017 #undef IS_CONTAINED_BY
4018 #undef IS_SOLARIS_PT_INTERP
4019 #undef IS_COREFILE_NOTE
4023 /* Copy private section information. This copies over the entsize
4024 field, and sometimes the info field. */
4027 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
4033 Elf_Internal_Shdr *ihdr, *ohdr;
4035 if (ibfd->xvec->flavour != bfd_target_elf_flavour
4036 || obfd->xvec->flavour != bfd_target_elf_flavour)
4039 /* Copy over private BFD data if it has not already been copied.
4040 This must be done here, rather than in the copy_private_bfd_data
4041 entry point, because the latter is called after the section
4042 contents have been set, which means that the program headers have
4043 already been worked out. */
4044 if (elf_tdata (obfd)->segment_map == NULL
4045 && elf_tdata (ibfd)->phdr != NULL)
4049 /* Only set up the segments if there are no more SEC_ALLOC
4050 sections. FIXME: This won't do the right thing if objcopy is
4051 used to remove the last SEC_ALLOC section, since objcopy
4052 won't call this routine in that case. */
4053 for (s = isec->next; s != NULL; s = s->next)
4054 if ((s->flags & SEC_ALLOC) != 0)
4058 if (! copy_private_bfd_data (ibfd, obfd))
4063 ihdr = &elf_section_data (isec)->this_hdr;
4064 ohdr = &elf_section_data (osec)->this_hdr;
4066 ohdr->sh_entsize = ihdr->sh_entsize;
4068 if (ihdr->sh_type == SHT_SYMTAB
4069 || ihdr->sh_type == SHT_DYNSYM
4070 || ihdr->sh_type == SHT_GNU_verneed
4071 || ihdr->sh_type == SHT_GNU_verdef)
4072 ohdr->sh_info = ihdr->sh_info;
4074 elf_section_data (osec)->use_rela_p
4075 = elf_section_data (isec)->use_rela_p;
4080 /* Copy private symbol information. If this symbol is in a section
4081 which we did not map into a BFD section, try to map the section
4082 index correctly. We use special macro definitions for the mapped
4083 section indices; these definitions are interpreted by the
4084 swap_out_syms function. */
4086 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
4087 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
4088 #define MAP_STRTAB (SHN_LORESERVE - 3)
4089 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
4092 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
4098 elf_symbol_type *isym, *osym;
4100 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4101 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4104 isym = elf_symbol_from (ibfd, isymarg);
4105 osym = elf_symbol_from (obfd, osymarg);
4109 && bfd_is_abs_section (isym->symbol.section))
4113 shndx = isym->internal_elf_sym.st_shndx;
4114 if (shndx == elf_onesymtab (ibfd))
4115 shndx = MAP_ONESYMTAB;
4116 else if (shndx == elf_dynsymtab (ibfd))
4117 shndx = MAP_DYNSYMTAB;
4118 else if (shndx == elf_tdata (ibfd)->strtab_section)
4120 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
4121 shndx = MAP_SHSTRTAB;
4122 osym->internal_elf_sym.st_shndx = shndx;
4128 /* Swap out the symbols. */
4131 swap_out_syms (abfd, sttp, relocatable_p)
4133 struct bfd_strtab_hash **sttp;
4136 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4138 if (!elf_map_symbols (abfd))
4141 /* Dump out the symtabs. */
4143 int symcount = bfd_get_symcount (abfd);
4144 asymbol **syms = bfd_get_outsymbols (abfd);
4145 struct bfd_strtab_hash *stt;
4146 Elf_Internal_Shdr *symtab_hdr;
4147 Elf_Internal_Shdr *symstrtab_hdr;
4148 char *outbound_syms;
4151 stt = _bfd_elf_stringtab_init ();
4155 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4156 symtab_hdr->sh_type = SHT_SYMTAB;
4157 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
4158 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
4159 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
4160 symtab_hdr->sh_addralign = bed->s->file_align;
4162 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4163 symstrtab_hdr->sh_type = SHT_STRTAB;
4165 outbound_syms = bfd_alloc (abfd,
4166 (1 + symcount) * bed->s->sizeof_sym);
4167 if (outbound_syms == NULL)
4169 symtab_hdr->contents = (PTR) outbound_syms;
4171 /* now generate the data (for "contents") */
4173 /* Fill in zeroth symbol and swap it out. */
4174 Elf_Internal_Sym sym;
4180 sym.st_shndx = SHN_UNDEF;
4181 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4182 outbound_syms += bed->s->sizeof_sym;
4184 for (idx = 0; idx < symcount; idx++)
4186 Elf_Internal_Sym sym;
4187 bfd_vma value = syms[idx]->value;
4188 elf_symbol_type *type_ptr;
4189 flagword flags = syms[idx]->flags;
4192 if (flags & BSF_SECTION_SYM)
4193 /* Section symbols have no names. */
4197 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4200 if (sym.st_name == (unsigned long) -1)
4204 type_ptr = elf_symbol_from (abfd, syms[idx]);
4206 if ((flags & BSF_SECTION_SYM) == 0
4207 && bfd_is_com_section (syms[idx]->section))
4209 /* ELF common symbols put the alignment into the `value' field,
4210 and the size into the `size' field. This is backwards from
4211 how BFD handles it, so reverse it here. */
4212 sym.st_size = value;
4213 if (type_ptr == NULL
4214 || type_ptr->internal_elf_sym.st_value == 0)
4215 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4217 sym.st_value = type_ptr->internal_elf_sym.st_value;
4218 sym.st_shndx = _bfd_elf_section_from_bfd_section
4219 (abfd, syms[idx]->section);
4223 asection *sec = syms[idx]->section;
4226 if (sec->output_section)
4228 value += sec->output_offset;
4229 sec = sec->output_section;
4231 /* Don't add in the section vma for relocatable output. */
4232 if (! relocatable_p)
4234 sym.st_value = value;
4235 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4237 if (bfd_is_abs_section (sec)
4239 && type_ptr->internal_elf_sym.st_shndx != 0)
4241 /* This symbol is in a real ELF section which we did
4242 not create as a BFD section. Undo the mapping done
4243 by copy_private_symbol_data. */
4244 shndx = type_ptr->internal_elf_sym.st_shndx;
4248 shndx = elf_onesymtab (abfd);
4251 shndx = elf_dynsymtab (abfd);
4254 shndx = elf_tdata (abfd)->strtab_section;
4257 shndx = elf_tdata (abfd)->shstrtab_section;
4265 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4271 /* Writing this would be a hell of a lot easier if
4272 we had some decent documentation on bfd, and
4273 knew what to expect of the library, and what to
4274 demand of applications. For example, it
4275 appears that `objcopy' might not set the
4276 section of a symbol to be a section that is
4277 actually in the output file. */
4278 sec2 = bfd_get_section_by_name (abfd, sec->name);
4279 BFD_ASSERT (sec2 != 0);
4280 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4281 BFD_ASSERT (shndx != -1);
4285 sym.st_shndx = shndx;
4288 if ((flags & BSF_FUNCTION) != 0)
4290 else if ((flags & BSF_OBJECT) != 0)
4295 /* Processor-specific types */
4296 if (type_ptr != NULL
4297 && bed->elf_backend_get_symbol_type)
4298 type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
4300 if (flags & BSF_SECTION_SYM)
4301 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4302 else if (bfd_is_com_section (syms[idx]->section))
4303 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
4304 else if (bfd_is_und_section (syms[idx]->section))
4305 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
4309 else if (flags & BSF_FILE)
4310 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4313 int bind = STB_LOCAL;
4315 if (flags & BSF_LOCAL)
4317 else if (flags & BSF_WEAK)
4319 else if (flags & BSF_GLOBAL)
4322 sym.st_info = ELF_ST_INFO (bind, type);
4325 if (type_ptr != NULL)
4326 sym.st_other = type_ptr->internal_elf_sym.st_other;
4330 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4331 outbound_syms += bed->s->sizeof_sym;
4335 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
4336 symstrtab_hdr->sh_type = SHT_STRTAB;
4338 symstrtab_hdr->sh_flags = 0;
4339 symstrtab_hdr->sh_addr = 0;
4340 symstrtab_hdr->sh_entsize = 0;
4341 symstrtab_hdr->sh_link = 0;
4342 symstrtab_hdr->sh_info = 0;
4343 symstrtab_hdr->sh_addralign = 1;
4349 /* Return the number of bytes required to hold the symtab vector.
4351 Note that we base it on the count plus 1, since we will null terminate
4352 the vector allocated based on this size. However, the ELF symbol table
4353 always has a dummy entry as symbol #0, so it ends up even. */
4356 _bfd_elf_get_symtab_upper_bound (abfd)
4361 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
4363 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4364 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4370 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
4375 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4377 if (elf_dynsymtab (abfd) == 0)
4379 bfd_set_error (bfd_error_invalid_operation);
4383 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4384 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4390 _bfd_elf_get_reloc_upper_bound (abfd, asect)
4391 bfd *abfd ATTRIBUTE_UNUSED;
4394 return (asect->reloc_count + 1) * sizeof (arelent *);
4397 /* Canonicalize the relocs. */
4400 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
4409 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd,
4415 tblptr = section->relocation;
4416 for (i = 0; i < section->reloc_count; i++)
4417 *relptr++ = tblptr++;
4421 return section->reloc_count;
4425 _bfd_elf_get_symtab (abfd, alocation)
4427 asymbol **alocation;
4429 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table
4430 (abfd, alocation, false);
4433 bfd_get_symcount (abfd) = symcount;
4438 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
4440 asymbol **alocation;
4442 return get_elf_backend_data (abfd)->s->slurp_symbol_table
4443 (abfd, alocation, true);
4446 /* Return the size required for the dynamic reloc entries. Any
4447 section that was actually installed in the BFD, and has type
4448 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4449 considered to be a dynamic reloc section. */
4452 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
4458 if (elf_dynsymtab (abfd) == 0)
4460 bfd_set_error (bfd_error_invalid_operation);
4464 ret = sizeof (arelent *);
4465 for (s = abfd->sections; s != NULL; s = s->next)
4466 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4467 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4468 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4469 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
4470 * sizeof (arelent *));
4475 /* Canonicalize the dynamic relocation entries. Note that we return
4476 the dynamic relocations as a single block, although they are
4477 actually associated with particular sections; the interface, which
4478 was designed for SunOS style shared libraries, expects that there
4479 is only one set of dynamic relocs. Any section that was actually
4480 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4481 the dynamic symbol table, is considered to be a dynamic reloc
4485 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
4490 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
4494 if (elf_dynsymtab (abfd) == 0)
4496 bfd_set_error (bfd_error_invalid_operation);
4500 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
4502 for (s = abfd->sections; s != NULL; s = s->next)
4504 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4505 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4506 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4511 if (! (*slurp_relocs) (abfd, s, syms, true))
4513 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
4515 for (i = 0; i < count; i++)
4526 /* Read in the version information. */
4529 _bfd_elf_slurp_version_tables (abfd)
4532 bfd_byte *contents = NULL;
4534 if (elf_dynverdef (abfd) != 0)
4536 Elf_Internal_Shdr *hdr;
4537 Elf_External_Verdef *everdef;
4538 Elf_Internal_Verdef *iverdef;
4539 Elf_Internal_Verdef *iverdefarr;
4540 Elf_Internal_Verdef iverdefmem;
4542 unsigned int maxidx;
4544 hdr = &elf_tdata (abfd)->dynverdef_hdr;
4546 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4547 if (contents == NULL)
4549 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4550 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4553 /* We know the number of entries in the section but not the maximum
4554 index. Therefore we have to run through all entries and find
4556 everdef = (Elf_External_Verdef *) contents;
4558 for (i = 0; i < hdr->sh_info; ++i)
4560 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
4562 if ((iverdefmem.vd_ndx & VERSYM_VERSION) > maxidx)
4563 maxidx = iverdefmem.vd_ndx & VERSYM_VERSION;
4565 everdef = ((Elf_External_Verdef *)
4566 ((bfd_byte *) everdef + iverdefmem.vd_next));
4569 elf_tdata (abfd)->verdef =
4570 ((Elf_Internal_Verdef *)
4571 bfd_zalloc (abfd, maxidx * sizeof (Elf_Internal_Verdef)));
4572 if (elf_tdata (abfd)->verdef == NULL)
4575 elf_tdata (abfd)->cverdefs = maxidx;
4577 everdef = (Elf_External_Verdef *) contents;
4578 iverdefarr = elf_tdata (abfd)->verdef;
4579 for (i = 0; i < hdr->sh_info; i++)
4581 Elf_External_Verdaux *everdaux;
4582 Elf_Internal_Verdaux *iverdaux;
4585 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
4587 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
4588 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
4590 iverdef->vd_bfd = abfd;
4592 iverdef->vd_auxptr = ((Elf_Internal_Verdaux *)
4595 * sizeof (Elf_Internal_Verdaux))));
4596 if (iverdef->vd_auxptr == NULL)
4599 everdaux = ((Elf_External_Verdaux *)
4600 ((bfd_byte *) everdef + iverdef->vd_aux));
4601 iverdaux = iverdef->vd_auxptr;
4602 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
4604 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
4606 iverdaux->vda_nodename =
4607 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4608 iverdaux->vda_name);
4609 if (iverdaux->vda_nodename == NULL)
4612 if (j + 1 < iverdef->vd_cnt)
4613 iverdaux->vda_nextptr = iverdaux + 1;
4615 iverdaux->vda_nextptr = NULL;
4617 everdaux = ((Elf_External_Verdaux *)
4618 ((bfd_byte *) everdaux + iverdaux->vda_next));
4621 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
4623 if (i + 1 < hdr->sh_info)
4624 iverdef->vd_nextdef = iverdef + 1;
4626 iverdef->vd_nextdef = NULL;
4628 everdef = ((Elf_External_Verdef *)
4629 ((bfd_byte *) everdef + iverdef->vd_next));
4636 if (elf_dynverref (abfd) != 0)
4638 Elf_Internal_Shdr *hdr;
4639 Elf_External_Verneed *everneed;
4640 Elf_Internal_Verneed *iverneed;
4643 hdr = &elf_tdata (abfd)->dynverref_hdr;
4645 elf_tdata (abfd)->verref =
4646 ((Elf_Internal_Verneed *)
4647 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed)));
4648 if (elf_tdata (abfd)->verref == NULL)
4651 elf_tdata (abfd)->cverrefs = hdr->sh_info;
4653 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4654 if (contents == NULL)
4656 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4657 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4660 everneed = (Elf_External_Verneed *) contents;
4661 iverneed = elf_tdata (abfd)->verref;
4662 for (i = 0; i < hdr->sh_info; i++, iverneed++)
4664 Elf_External_Vernaux *evernaux;
4665 Elf_Internal_Vernaux *ivernaux;
4668 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
4670 iverneed->vn_bfd = abfd;
4672 iverneed->vn_filename =
4673 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4675 if (iverneed->vn_filename == NULL)
4678 iverneed->vn_auxptr =
4679 ((Elf_Internal_Vernaux *)
4681 iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux)));
4683 evernaux = ((Elf_External_Vernaux *)
4684 ((bfd_byte *) everneed + iverneed->vn_aux));
4685 ivernaux = iverneed->vn_auxptr;
4686 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
4688 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
4690 ivernaux->vna_nodename =
4691 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4692 ivernaux->vna_name);
4693 if (ivernaux->vna_nodename == NULL)
4696 if (j + 1 < iverneed->vn_cnt)
4697 ivernaux->vna_nextptr = ivernaux + 1;
4699 ivernaux->vna_nextptr = NULL;
4701 evernaux = ((Elf_External_Vernaux *)
4702 ((bfd_byte *) evernaux + ivernaux->vna_next));
4705 if (i + 1 < hdr->sh_info)
4706 iverneed->vn_nextref = iverneed + 1;
4708 iverneed->vn_nextref = NULL;
4710 everneed = ((Elf_External_Verneed *)
4711 ((bfd_byte *) everneed + iverneed->vn_next));
4721 if (contents == NULL)
4727 _bfd_elf_make_empty_symbol (abfd)
4730 elf_symbol_type *newsym;
4732 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
4737 newsym->symbol.the_bfd = abfd;
4738 return &newsym->symbol;
4743 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
4744 bfd *ignore_abfd ATTRIBUTE_UNUSED;
4748 bfd_symbol_info (symbol, ret);
4751 /* Return whether a symbol name implies a local symbol. Most targets
4752 use this function for the is_local_label_name entry point, but some
4756 _bfd_elf_is_local_label_name (abfd, name)
4757 bfd *abfd ATTRIBUTE_UNUSED;
4760 /* Normal local symbols start with ``.L''. */
4761 if (name[0] == '.' && name[1] == 'L')
4764 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4765 DWARF debugging symbols starting with ``..''. */
4766 if (name[0] == '.' && name[1] == '.')
4769 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4770 emitting DWARF debugging output. I suspect this is actually a
4771 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4772 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4773 underscore to be emitted on some ELF targets). For ease of use,
4774 we treat such symbols as local. */
4775 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
4782 _bfd_elf_get_lineno (ignore_abfd, symbol)
4783 bfd *ignore_abfd ATTRIBUTE_UNUSED;
4784 asymbol *symbol ATTRIBUTE_UNUSED;
4791 _bfd_elf_set_arch_mach (abfd, arch, machine)
4793 enum bfd_architecture arch;
4794 unsigned long machine;
4796 /* If this isn't the right architecture for this backend, and this
4797 isn't the generic backend, fail. */
4798 if (arch != get_elf_backend_data (abfd)->arch
4799 && arch != bfd_arch_unknown
4800 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
4803 return bfd_default_set_arch_mach (abfd, arch, machine);
4806 /* Find the nearest line to a particular section and offset, for error
4810 _bfd_elf_find_nearest_line (abfd,
4821 CONST char **filename_ptr;
4822 CONST char **functionname_ptr;
4823 unsigned int *line_ptr;
4826 const char *filename;
4831 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4832 filename_ptr, functionname_ptr,
4836 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4837 filename_ptr, functionname_ptr,
4841 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4842 &found, filename_ptr,
4843 functionname_ptr, line_ptr,
4844 &elf_tdata (abfd)->line_info))
4849 if (symbols == NULL)
4856 for (p = symbols; *p != NULL; p++)
4860 q = (elf_symbol_type *) *p;
4862 if (bfd_get_section (&q->symbol) != section)
4865 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4870 filename = bfd_asymbol_name (&q->symbol);
4874 if (q->symbol.section == section
4875 && q->symbol.value >= low_func
4876 && q->symbol.value <= offset)
4878 func = (asymbol *) q;
4879 low_func = q->symbol.value;
4888 *filename_ptr = filename;
4889 *functionname_ptr = bfd_asymbol_name (func);
4895 _bfd_elf_sizeof_headers (abfd, reloc)
4901 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
4903 ret += get_program_header_size (abfd);
4908 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
4913 bfd_size_type count;
4915 Elf_Internal_Shdr *hdr;
4917 if (! abfd->output_has_begun
4918 && ! _bfd_elf_compute_section_file_positions
4919 (abfd, (struct bfd_link_info *) NULL))
4922 hdr = &elf_section_data (section)->this_hdr;
4924 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
4926 if (bfd_write (location, 1, count, abfd) != count)
4933 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
4934 bfd *abfd ATTRIBUTE_UNUSED;
4935 arelent *cache_ptr ATTRIBUTE_UNUSED;
4936 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
4943 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
4946 Elf_Internal_Rel *dst;
4952 /* Try to convert a non-ELF reloc into an ELF one. */
4955 _bfd_elf_validate_reloc (abfd, areloc)
4959 /* Check whether we really have an ELF howto. */
4961 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
4963 bfd_reloc_code_real_type code;
4964 reloc_howto_type *howto;
4966 /* Alien reloc: Try to determine its type to replace it with an
4967 equivalent ELF reloc. */
4969 if (areloc->howto->pc_relative)
4971 switch (areloc->howto->bitsize)
4974 code = BFD_RELOC_8_PCREL;
4977 code = BFD_RELOC_12_PCREL;
4980 code = BFD_RELOC_16_PCREL;
4983 code = BFD_RELOC_24_PCREL;
4986 code = BFD_RELOC_32_PCREL;
4989 code = BFD_RELOC_64_PCREL;
4995 howto = bfd_reloc_type_lookup (abfd, code);
4997 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
4999 if (howto->pcrel_offset)
5000 areloc->addend += areloc->address;
5002 areloc->addend -= areloc->address; /* addend is unsigned!! */
5007 switch (areloc->howto->bitsize)
5013 code = BFD_RELOC_14;
5016 code = BFD_RELOC_16;
5019 code = BFD_RELOC_26;
5022 code = BFD_RELOC_32;
5025 code = BFD_RELOC_64;
5031 howto = bfd_reloc_type_lookup (abfd, code);
5035 areloc->howto = howto;
5043 (*_bfd_error_handler)
5044 (_("%s: unsupported relocation type %s"),
5045 bfd_get_filename (abfd), areloc->howto->name);
5046 bfd_set_error (bfd_error_bad_value);
5051 _bfd_elf_close_and_cleanup (abfd)
5054 if (bfd_get_format (abfd) == bfd_object)
5056 if (elf_shstrtab (abfd) != NULL)
5057 _bfd_stringtab_free (elf_shstrtab (abfd));
5060 return _bfd_generic_close_and_cleanup (abfd);
5063 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5064 in the relocation's offset. Thus we cannot allow any sort of sanity
5065 range-checking to interfere. There is nothing else to do in processing
5068 bfd_reloc_status_type
5069 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
5070 bfd *abfd ATTRIBUTE_UNUSED;
5071 arelent *re ATTRIBUTE_UNUSED;
5072 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
5073 PTR data ATTRIBUTE_UNUSED;
5074 asection *is ATTRIBUTE_UNUSED;
5075 bfd *obfd ATTRIBUTE_UNUSED;
5076 char **errmsg ATTRIBUTE_UNUSED;
5078 return bfd_reloc_ok;
5082 /* Elf core file support. Much of this only works on native
5083 toolchains, since we rely on knowing the
5084 machine-dependent procfs structure in order to pick
5085 out details about the corefile. */
5087 #ifdef HAVE_SYS_PROCFS_H
5088 # include <sys/procfs.h>
5092 /* Define offsetof for those systems which lack it. */
5095 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
5099 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5102 elfcore_make_pid (abfd)
5105 return ((elf_tdata (abfd)->core_lwpid << 16)
5106 + (elf_tdata (abfd)->core_pid));
5110 /* If there isn't a section called NAME, make one, using
5111 data from SECT. Note, this function will generate a
5112 reference to NAME, so you shouldn't deallocate or
5116 elfcore_maybe_make_sect (abfd, name, sect)
5123 if (bfd_get_section_by_name (abfd, name) != NULL)
5126 sect2 = bfd_make_section (abfd, name);
5130 sect2->_raw_size = sect->_raw_size;
5131 sect2->filepos = sect->filepos;
5132 sect2->flags = sect->flags;
5133 sect2->alignment_power = sect->alignment_power;
5138 /* prstatus_t exists on:
5140 linux 2.[01] + glibc
5144 #if defined (HAVE_PRSTATUS_T)
5146 elfcore_grok_prstatus (abfd, note)
5148 Elf_Internal_Note* note;
5155 if (note->descsz == sizeof (prstatus_t))
5159 raw_size = sizeof (prstat.pr_reg);
5160 memcpy (&prstat, note->descdata, sizeof (prstat));
5162 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5163 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5165 /* pr_who exists on:
5168 pr_who doesn't exist on:
5171 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5172 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5175 #if defined (__sparcv9)
5176 else if (note->descsz == sizeof (prstatus32_t))
5178 /* 64-bit host, 32-bit corefile */
5179 prstatus32_t prstat;
5181 raw_size = sizeof (prstat.pr_reg);
5182 memcpy (&prstat, note->descdata, sizeof (prstat));
5184 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5185 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5187 /* pr_who exists on:
5190 pr_who doesn't exist on:
5193 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5194 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5197 #endif /* __sparcv9 */
5200 /* Fail - we don't know how to handle any other
5201 note size (ie. data object type). */
5205 /* Make a ".reg/999" section. */
5207 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5208 name = bfd_alloc (abfd, strlen (buf) + 1);
5213 sect = bfd_make_section (abfd, name);
5217 if (note->descsz == sizeof (prstatus_t))
5219 sect->_raw_size = raw_size;
5220 sect->filepos = note->descpos + offsetof (prstatus_t, pr_reg);
5222 #if defined (__sparcv9)
5223 else if (note->descsz == sizeof (prstatus32_t))
5225 sect->_raw_size = raw_size;
5226 sect->filepos = note->descpos + offsetof (prstatus32_t, pr_reg);
5230 sect->flags = SEC_HAS_CONTENTS;
5231 sect->alignment_power = 2;
5233 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
5238 #endif /* defined (HAVE_PRSTATUS_T) */
5241 /* Create a pseudosection containing the exact contents of NOTE. This
5242 actually creates up to two pseudosections:
5243 - For the single-threaded case, a section named NAME, unless
5244 such a section already exists.
5245 - For the multi-threaded case, a section named "NAME/PID", where
5246 PID is elfcore_make_pid (abfd).
5247 Both pseudosections have identical contents: the contents of NOTE. */
5250 elfcore_make_note_pseudosection (abfd, name, note)
5253 Elf_Internal_Note* note;
5256 char *threaded_name;
5259 /* Build the section name. */
5261 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
5262 threaded_name = bfd_alloc (abfd, strlen (buf) + 1);
5263 if (threaded_name == NULL)
5265 strcpy (threaded_name, buf);
5267 sect = bfd_make_section (abfd, threaded_name);
5270 sect->_raw_size = note->descsz;
5271 sect->filepos = note->descpos;
5272 sect->flags = SEC_HAS_CONTENTS;
5273 sect->alignment_power = 2;
5275 if (! elfcore_maybe_make_sect (abfd, name, sect))
5282 /* There isn't a consistent prfpregset_t across platforms,
5283 but it doesn't matter, because we don't have to pick this
5284 data structure apart. */
5286 elfcore_grok_prfpreg (abfd, note)
5288 Elf_Internal_Note* note;
5290 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
5294 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
5295 type of 5 (NT_PRXFPREG). Just include the whole note's contents
5298 elfcore_grok_prxfpreg (abfd, note)
5300 Elf_Internal_Note* note;
5302 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
5306 #if defined (HAVE_PRPSINFO_T)
5307 typedef prpsinfo_t elfcore_psinfo_t;
5308 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5309 typedef prpsinfo32_t elfcore_psinfo32_t;
5313 #if defined (HAVE_PSINFO_T)
5314 typedef psinfo_t elfcore_psinfo_t;
5315 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5316 typedef psinfo32_t elfcore_psinfo32_t;
5321 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5323 /* return a malloc'ed copy of a string at START which is at
5324 most MAX bytes long, possibly without a terminating '\0'.
5325 the copy will always have a terminating '\0'. */
5328 elfcore_strndup (abfd, start, max)
5334 char* end = memchr (start, '\0', max);
5342 dup = bfd_alloc (abfd, len + 1);
5346 memcpy (dup, start, len);
5353 elfcore_grok_psinfo (abfd, note)
5355 Elf_Internal_Note* note;
5357 if (note->descsz == sizeof (elfcore_psinfo_t))
5359 elfcore_psinfo_t psinfo;
5361 memcpy (&psinfo, note->descdata, note->descsz);
5363 elf_tdata (abfd)->core_program
5364 = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
5366 elf_tdata (abfd)->core_command
5367 = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
5369 #if defined (__sparcv9)
5370 else if (note->descsz == sizeof (elfcore_psinfo32_t))
5372 /* 64-bit host, 32-bit corefile */
5373 elfcore_psinfo32_t psinfo;
5375 memcpy (&psinfo, note->descdata, note->descsz);
5377 elf_tdata (abfd)->core_program
5378 = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
5380 elf_tdata (abfd)->core_command
5381 = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
5387 /* Fail - we don't know how to handle any other
5388 note size (ie. data object type). */
5392 /* Note that for some reason, a spurious space is tacked
5393 onto the end of the args in some (at least one anyway)
5394 implementations, so strip it off if it exists. */
5397 char* command = elf_tdata (abfd)->core_command;
5398 int n = strlen (command);
5400 if (0 < n && command[n - 1] == ' ')
5401 command[n - 1] = '\0';
5406 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5409 #if defined (HAVE_PSTATUS_T)
5411 elfcore_grok_pstatus (abfd, note)
5413 Elf_Internal_Note* note;
5415 if (note->descsz == sizeof (pstatus_t))
5419 memcpy (&pstat, note->descdata, sizeof (pstat));
5421 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5423 #if defined (__sparcv9)
5424 else if (note->descsz == sizeof (pstatus32_t))
5426 /* 64-bit host, 32-bit corefile */
5429 memcpy (&pstat, note->descdata, sizeof (pstat));
5431 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5434 /* Could grab some more details from the "representative"
5435 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5436 NT_LWPSTATUS note, presumably. */
5440 #endif /* defined (HAVE_PSTATUS_T) */
5443 #if defined (HAVE_LWPSTATUS_T)
5445 elfcore_grok_lwpstatus (abfd, note)
5447 Elf_Internal_Note* note;
5449 lwpstatus_t lwpstat;
5454 if (note->descsz != sizeof (lwpstat))
5457 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
5459 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
5460 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
5462 /* Make a ".reg/999" section. */
5464 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5465 name = bfd_alloc (abfd, strlen (buf) + 1);
5470 sect = bfd_make_section (abfd, name);
5474 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5475 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
5476 sect->filepos = note->descpos
5477 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
5480 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5481 sect->_raw_size = sizeof (lwpstat.pr_reg);
5482 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
5485 sect->flags = SEC_HAS_CONTENTS;
5486 sect->alignment_power = 2;
5488 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
5491 /* Make a ".reg2/999" section */
5493 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
5494 name = bfd_alloc (abfd, strlen (buf) + 1);
5499 sect = bfd_make_section (abfd, name);
5503 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5504 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
5505 sect->filepos = note->descpos
5506 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
5509 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5510 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
5511 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
5514 sect->flags = SEC_HAS_CONTENTS;
5515 sect->alignment_power = 2;
5517 if (!elfcore_maybe_make_sect (abfd, ".reg2", sect))
5522 #endif /* defined (HAVE_LWPSTATUS_T) */
5524 #if defined (HAVE_WIN32_PSTATUS_T)
5526 elfcore_grok_win32pstatus (abfd, note)
5528 Elf_Internal_Note * note;
5533 win32_pstatus_t pstatus;
5535 if (note->descsz < sizeof (pstatus))
5538 memcpy (& pstatus, note->descdata, note->descsz);
5540 switch (pstatus.data_type)
5542 case NOTE_INFO_PROCESS:
5543 /* FIXME: need to add ->core_command. */
5544 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
5545 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
5548 case NOTE_INFO_THREAD:
5549 /* Make a ".reg/999" section. */
5550 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
5552 name = bfd_alloc (abfd, strlen (buf) + 1);
5558 sect = bfd_make_section (abfd, name);
5562 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
5563 sect->filepos = note->descpos + offsetof (struct win32_pstatus,
5564 data.thread_info.thread_context);
5565 sect->flags = SEC_HAS_CONTENTS;
5566 sect->alignment_power = 2;
5568 if (pstatus.data.thread_info.is_active_thread)
5569 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
5573 case NOTE_INFO_MODULE:
5574 /* Make a ".module/xxxxxxxx" section. */
5575 sprintf (buf, ".module/%08x" , pstatus.data.module_info.base_address);
5577 name = bfd_alloc (abfd, strlen (buf) + 1);
5583 sect = bfd_make_section (abfd, name);
5588 sect->_raw_size = note->descsz;
5589 sect->filepos = note->descpos;
5590 sect->flags = SEC_HAS_CONTENTS;
5591 sect->alignment_power = 2;
5600 #endif /* HAVE_WIN32_PSTATUS_T */
5603 elfcore_grok_note (abfd, note)
5605 Elf_Internal_Note* note;
5612 #if defined (HAVE_PRSTATUS_T)
5614 return elfcore_grok_prstatus (abfd, note);
5617 #if defined (HAVE_PSTATUS_T)
5619 return elfcore_grok_pstatus (abfd, note);
5622 #if defined (HAVE_LWPSTATUS_T)
5624 return elfcore_grok_lwpstatus (abfd, note);
5627 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
5628 return elfcore_grok_prfpreg (abfd, note);
5630 #if defined (HAVE_WIN32_PSTATUS_T)
5631 case NT_WIN32PSTATUS:
5632 return elfcore_grok_win32pstatus (abfd, note);
5635 case NT_PRXFPREG: /* Linux SSE extension */
5636 if (note->namesz == 5
5637 && ! strcmp (note->namedata, "LINUX"))
5638 return elfcore_grok_prxfpreg (abfd, note);
5642 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5645 return elfcore_grok_psinfo (abfd, note);
5652 elfcore_read_notes (abfd, offset, size)
5663 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5666 buf = bfd_malloc ((size_t) size);
5670 if (bfd_read (buf, size, 1, abfd) != size)
5678 while (p < buf + size)
5680 /* FIXME: bad alignment assumption. */
5681 Elf_External_Note* xnp = (Elf_External_Note*) p;
5682 Elf_Internal_Note in;
5684 in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
5686 in.namesz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->namesz);
5687 in.namedata = xnp->name;
5689 in.descsz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->descsz);
5690 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
5691 in.descpos = offset + (in.descdata - buf);
5693 if (! elfcore_grok_note (abfd, &in))
5696 p = in.descdata + BFD_ALIGN (in.descsz, 4);
5704 /* FIXME: This function is now unnecessary. Callers can just call
5705 bfd_section_from_phdr directly. */
5708 _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
5710 Elf_Internal_Phdr* phdr;
5713 if (! bfd_section_from_phdr (abfd, phdr, sec_num))
5721 /* Providing external access to the ELF program header table. */
5723 /* Return an upper bound on the number of bytes required to store a
5724 copy of ABFD's program header table entries. Return -1 if an error
5725 occurs; bfd_get_error will return an appropriate code. */
5727 bfd_get_elf_phdr_upper_bound (abfd)
5730 if (abfd->xvec->flavour != bfd_target_elf_flavour)
5732 bfd_set_error (bfd_error_wrong_format);
5736 return (elf_elfheader (abfd)->e_phnum
5737 * sizeof (Elf_Internal_Phdr));
5741 /* Copy ABFD's program header table entries to *PHDRS. The entries
5742 will be stored as an array of Elf_Internal_Phdr structures, as
5743 defined in include/elf/internal.h. To find out how large the
5744 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
5746 Return the number of program header table entries read, or -1 if an
5747 error occurs; bfd_get_error will return an appropriate code. */
5749 bfd_get_elf_phdrs (abfd, phdrs)
5755 if (abfd->xvec->flavour != bfd_target_elf_flavour)
5757 bfd_set_error (bfd_error_wrong_format);
5761 num_phdrs = elf_elfheader (abfd)->e_phnum;
5762 memcpy (phdrs, elf_tdata (abfd)->phdr,
5763 num_phdrs * sizeof (Elf_Internal_Phdr));