/* ELF executable support for BFD.
- Copyright 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
+ Copyright 1993, 94, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
haven't bothered yet.
*/
+/* For sparc64-cross-sparc32. */
+#define _SYSCALL32
#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
static boolean elf_map_symbols PARAMS ((bfd *));
static bfd_size_type get_program_header_size PARAMS ((bfd *));
+static boolean elfcore_read_notes PARAMS ((bfd *, bfd_vma, bfd_vma));
/* Swap version information in and out. The version information is
currently size independent. If that ever changes, this code will
/* Standard ELF hash function. Do not change this function; you will
cause invalid hash tables to be generated. */
+
unsigned long
-bfd_elf_hash (name)
- CONST unsigned char *name;
+bfd_elf_hash (namearg)
+ const char *namearg;
{
+ const unsigned char *name = (const unsigned char *) namearg;
unsigned long h = 0;
unsigned long g;
int ch;
input_section,
output_bfd,
error_message)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
arelent *reloc_entry;
asymbol *symbol;
- PTR data;
+ PTR data ATTRIBUTE_UNUSED;
asection *input_section;
bfd *output_bfd;
- char **error_message;
+ char **error_message ATTRIBUTE_UNUSED;
{
if (output_bfd != (bfd *) NULL
&& (symbol->flags & BSF_SECTION_SYM) == 0
case DT_DEBUG: name = "DEBUG"; break;
case DT_TEXTREL: name = "TEXTREL"; break;
case DT_JMPREL: name = "JMPREL"; break;
- case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
- case DT_FILTER: name = "FILTER"; stringp = true; break;
+ case DT_BIND_NOW: name = "BIND_NOW"; break;
+ case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
+ case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
+ case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
+ case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
+ case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
+ case DT_FLAGS: name = "FLAGS"; break;
+ case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
+ case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
+ case DT_CHECKSUM: name = "CHECKSUM"; break;
+ case DT_PLTPADSZ: name = "PLTPADSZ"; break;
+ case DT_MOVEENT: name = "MOVEENT"; break;
+ case DT_MOVESZ: name = "MOVESZ"; break;
+ case DT_FEATURE: name = "FEATURE"; break;
+ case DT_POSFLAG_1: name = "POSFLAG_1"; break;
+ case DT_SYMINSZ: name = "SYMINSZ"; break;
+ case DT_SYMINENT: name = "SYMINENT"; break;
+ case DT_CONFIG: name = "CONFIG"; stringp = true; break;
+ case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
+ case DT_AUDIT: name = "AUDIT"; stringp = true; break;
+ case DT_PLTPAD: name = "PLTPAD"; break;
+ case DT_MOVETAB: name = "MOVETAB"; break;
+ case DT_SYMINFO: name = "SYMINFO"; break;
+ case DT_RELACOUNT: name = "RELACOUNT"; break;
+ case DT_RELCOUNT: name = "RELCOUNT"; break;
+ case DT_FLAGS_1: name = "FLAGS_1"; break;
case DT_VERSYM: name = "VERSYM"; break;
case DT_VERDEF: name = "VERDEF"; break;
case DT_VERDEFNUM: name = "VERDEFNUM"; break;
case DT_VERNEED: name = "VERNEED"; break;
case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
+ case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
+ case DT_USED: name = "USED"; break;
+ case DT_FILTER: name = "FILTER"; stringp = true; break;
}
fprintf (f, " %-11s ", name);
case bfd_print_symbol_all:
{
CONST char *section_name;
+ CONST char *name = NULL;
+ struct elf_backend_data *bed;
+ unsigned char st_other;
+
section_name = symbol->section ? symbol->section->name : "(*none*)";
- bfd_print_symbol_vandf ((PTR) file, symbol);
+
+ bed = get_elf_backend_data (abfd);
+ if (bed->elf_backend_print_symbol_all)
+ name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
+
+ if (name == NULL)
+ {
+ name = symbol->name;
+ bfd_print_symbol_vandf ((PTR) file, symbol);
+ }
+
fprintf (file, " %s\t", section_name);
/* Print the "other" value for a symbol. For common symbols,
we've already printed the size; now print the alignment.
}
/* If the st_other field is not zero, print it. */
- if (((elf_symbol_type *) symbol)->internal_elf_sym.st_other != 0)
- fprintf (file, " 0x%02x",
- ((unsigned int)
- ((elf_symbol_type *) symbol)->internal_elf_sym.st_other));
+ st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
+
+ switch (st_other)
+ {
+ case 0: break;
+ case STV_INTERNAL: fprintf (file, " .internal"); break;
+ case STV_HIDDEN: fprintf (file, " .hidden"); break;
+ case STV_PROTECTED: fprintf (file, " .protected"); break;
+ default:
+ /* Some other non-defined flags are also present, so print
+ everything hex. */
+ fprintf (file, " 0x%02x", (unsigned int) st_other);
+ }
- fprintf (file, " %s", symbol->name);
+ fprintf (file, " %s", name);
}
break;
}
return (struct bfd_hash_entry *) ret;
}
+/* Copy data from an indirect symbol to its direct symbol, hiding the
+ old indirect symbol. */
+
+void
+_bfd_elf_link_hash_copy_indirect (dir, ind)
+ struct elf_link_hash_entry *dir, *ind;
+{
+ /* Copy down any references that we may have already seen to the
+ symbol which just became indirect. */
+
+ dir->elf_link_hash_flags |=
+ (ind->elf_link_hash_flags
+ & (ELF_LINK_HASH_REF_DYNAMIC
+ | ELF_LINK_HASH_REF_REGULAR
+ | ELF_LINK_HASH_REF_REGULAR_NONWEAK
+ | ELF_LINK_NON_GOT_REF));
+
+ /* Copy over the global and procedure linkage table offset entries.
+ These may have been already set up by a check_relocs routine. */
+ if (dir->got.offset == (bfd_vma) -1)
+ {
+ dir->got.offset = ind->got.offset;
+ ind->got.offset = (bfd_vma) -1;
+ }
+ BFD_ASSERT (ind->got.offset == (bfd_vma) -1);
+
+ if (dir->plt.offset == (bfd_vma) -1)
+ {
+ dir->plt.offset = ind->plt.offset;
+ ind->plt.offset = (bfd_vma) -1;
+ }
+ BFD_ASSERT (ind->plt.offset == (bfd_vma) -1);
+
+ if (dir->dynindx == -1)
+ {
+ dir->dynindx = ind->dynindx;
+ dir->dynstr_index = ind->dynstr_index;
+ ind->dynindx = -1;
+ ind->dynstr_index = 0;
+ }
+ BFD_ASSERT (ind->dynindx == -1);
+}
+
+void
+_bfd_elf_link_hash_hide_symbol (info, h)
+ struct bfd_link_info *info ATTRIBUTE_UNUSED;
+ struct elf_link_hash_entry *h;
+{
+ h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+ h->dynindx = -1;
+ h->plt.offset = (bfd_vma) -1;
+}
+
/* Initialize an ELF linker hash table. */
boolean
table->dynstr = NULL;
table->bucketcount = 0;
table->needed = NULL;
+ table->runpath = NULL;
table->hgot = NULL;
table->stab_info = NULL;
+ table->dynlocal = NULL;
return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
}
elf_dt_name (abfd) = name;
}
+void
+bfd_elf_set_dt_needed_soname (abfd, name)
+ bfd *abfd;
+ const char *name;
+{
+ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
+ && bfd_get_format (abfd) == bfd_object)
+ elf_dt_soname (abfd) = name;
+}
+
/* Get the list of DT_NEEDED entries for a link. This is a hook for
the linker ELF emulation code. */
struct bfd_link_needed_list *
bfd_elf_get_needed_list (abfd, info)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info;
{
if (info->hash->creator->flavour != bfd_target_elf_flavour)
return elf_hash_table (info)->needed;
}
+/* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
+ hook for the linker ELF emulation code. */
+
+struct bfd_link_needed_list *
+bfd_elf_get_runpath_list (abfd, info)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ struct bfd_link_info *info;
+{
+ if (info->hash->creator->flavour != bfd_target_elf_flavour)
+ return NULL;
+ return elf_hash_table (info)->runpath;
+}
+
/* Get the name actually used for a dynamic object for a link. This
is the SONAME entry if there is one. Otherwise, it is the string
passed to bfd_elf_set_dt_needed_name, or it is the filename. */
/* If this reloc section does not use the main symbol table we
don't treat it as a reloc section. BFD can't adequately
represent such a section, so at least for now, we don't
- try. We just present it as a normal section. */
- if (hdr->sh_link != elf_onesymtab (abfd))
+ try. We just present it as a normal section. We also
+ can't use it as a reloc section if it points to the null
+ section. */
+ if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
if (! bfd_section_from_shdr (abfd, hdr->sh_info))
target_sect->rel_filepos = hdr->sh_offset;
/* In the section to which the relocations apply, mark whether
its relocations are of the REL or RELA variety. */
- elf_section_data (target_sect)->use_rela_p
- = (hdr->sh_type == SHT_RELA);
+ if (hdr->sh_size != 0)
+ elf_section_data (target_sect)->use_rela_p
+ = (hdr->sh_type == SHT_RELA);
abfd->flags |= HAS_RELOC;
return true;
}
*/
boolean
-bfd_section_from_phdr (abfd, hdr, index)
+_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
bfd *abfd;
Elf_Internal_Phdr *hdr;
int index;
+ const char *typename;
{
asection *newsect;
char *name;
split = ((hdr->p_memsz > 0)
&& (hdr->p_filesz > 0)
&& (hdr->p_memsz > hdr->p_filesz));
- sprintf (namebuf, split ? "segment%da" : "segment%d", index);
+ sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
name = bfd_alloc (abfd, strlen (namebuf) + 1);
if (!name)
return false;
if (split)
{
- sprintf (namebuf, "segment%db", index);
+ sprintf (namebuf, "%s%db", typename, index);
name = bfd_alloc (abfd, strlen (namebuf) + 1);
if (!name)
return false;
return true;
}
+boolean
+bfd_section_from_phdr (abfd, hdr, index)
+ bfd *abfd;
+ Elf_Internal_Phdr *hdr;
+ int index;
+{
+ struct elf_backend_data *bed;
+
+ switch (hdr->p_type)
+ {
+ case PT_NULL:
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
+
+ case PT_LOAD:
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
+
+ case PT_DYNAMIC:
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
+
+ case PT_INTERP:
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
+
+ case PT_NOTE:
+ if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
+ return false;
+ if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
+ return false;
+ return true;
+
+ case PT_SHLIB:
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
+
+ case PT_PHDR:
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
+
+ default:
+ /* Check for any processor-specific program segment types.
+ If no handler for them, default to making "segment" sections. */
+ bed = get_elf_backend_data (abfd);
+ if (bed->elf_backend_section_from_phdr)
+ return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
+ else
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
+ }
+}
+
/* Initialize REL_HDR, the section-header for new section, containing
relocations against ASECT. If USE_RELA_P is true, we use RELA
relocations; otherwise, we use REL relocations. */
else if (strcmp (asect->name, ".hash") == 0)
{
this_hdr->sh_type = SHT_HASH;
- this_hdr->sh_entsize = bed->s->arch_size / 8;
+ this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
}
else if (strcmp (asect->name, ".dynsym") == 0)
{
asection *sec;
unsigned int section_number;
Elf_Internal_Shdr **i_shdrp;
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
section_number = 1;
/* This is a .stab section. */
elf_section_data (s)->this_hdr.sh_entsize =
- 4 + 2 * (bed->s->arch_size / 8);
+ 4 + 2 * bfd_get_arch_size (abfd) / 8;
}
}
break;
elf_sort_sections);
p->p_type = m->p_type;
-
- if (m->p_flags_valid)
- p->p_flags = m->p_flags;
- else
- p->p_flags = 0;
+ p->p_flags = m->p_flags;
if (p->p_type == PT_LOAD
&& m->count > 0
if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
{
- if (i == 0) /* the actual "note" segment */
- { /* this one actually contains everything. */
+ /* The actual "note" segment has i == 0.
+ This is the one that actually contains everything. */
+ if (i == 0)
+ {
sec->filepos = off;
p->p_filesz = sec->_raw_size;
off += sec->_raw_size;
voff = off;
}
- else /* fake sections -- don't need to be written */
+ else
{
+ /* Fake sections -- don't need to be written. */
sec->filepos = 0;
sec->_raw_size = 0;
- flags = sec->flags = 0; /* no contents */
+ flags = sec->flags = 0;
}
p->p_memsz = 0;
p->p_align = 1;
bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
- i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_SYSV;
+ i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NONE;
i_ehdrp->e_ident[EI_ABIVERSION] = 0;
for (count = EI_PAD; count < EI_NIDENT; count++)
i_ehdrp->e_machine = EM_NONE;
break;
case bfd_arch_sparc:
- if (bed->s->arch_size == 64)
+ if (bfd_get_arch_size (abfd) == 64)
i_ehdrp->e_machine = EM_SPARCV9;
else
i_ehdrp->e_machine = EM_SPARC;
break;
+ case bfd_arch_i370:
+ i_ehdrp->e_machine = EM_S370;
+ break;
case bfd_arch_i386:
i_ehdrp->e_machine = EM_386;
break;
+ case bfd_arch_ia64:
+ i_ehdrp->e_machine = EM_IA_64;
+ break;
+ case bfd_arch_m68hc11:
+ i_ehdrp->e_machine = EM_68HC11;
+ break;
+ case bfd_arch_m68hc12:
+ i_ehdrp->e_machine = EM_68HC12;
+ break;
case bfd_arch_m68k:
i_ehdrp->e_machine = EM_68K;
break;
case bfd_arch_mcore:
i_ehdrp->e_machine = EM_MCORE;
break;
+ case bfd_arch_avr:
+ i_ehdrp->e_machine = EM_AVR;
+ break;
case bfd_arch_v850:
switch (bfd_get_mach (abfd))
{
case bfd_arch_mn10300:
i_ehdrp->e_machine = EM_CYGNUS_MN10300;
break;
+ case bfd_arch_pj:
+ i_ehdrp->e_machine = EM_PJ;
+ break;
+ case bfd_arch_cris:
+ i_ehdrp->e_machine = EM_CRIS;
+ break;
/* also note that EM_M32, AT&T WE32100 is unknown to bfd */
default:
i_ehdrp->e_machine = EM_NONE;
bfd *ibfd;
bfd *obfd;
{
- Elf_Internal_Ehdr *iehdr;
- struct elf_segment_map *mfirst;
- struct elf_segment_map **pm;
- struct elf_segment_map *m;
- Elf_Internal_Phdr *p;
- unsigned int i;
- unsigned int num_segments;
- boolean phdr_included = false;
-
- if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+ Elf_Internal_Ehdr * iehdr;
+ struct elf_segment_map * map;
+ struct elf_segment_map * map_first;
+ struct elf_segment_map ** pointer_to_map;
+ Elf_Internal_Phdr * segment;
+ asection * section;
+ unsigned int i;
+ unsigned int num_segments;
+ boolean phdr_included = false;
+ bfd_vma maxpagesize;
+ struct elf_segment_map * phdr_adjust_seg = NULL;
+ unsigned int phdr_adjust_num = 0;
+
+ if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
return true;
iehdr = elf_elfheader (ibfd);
- mfirst = NULL;
- pm = &mfirst;
+ map_first = NULL;
+ pointer_to_map = & map_first;
num_segments = elf_elfheader (ibfd)->e_phnum;
-
-#define IS_CONTAINED_BY(addr, len, bottom, phdr) \
- ((addr) >= (bottom) \
- && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
- || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
+ maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
+
+ /* Returns the end address of the segment + 1. */
+#define SEGMENT_END(segment, start) \
+ (start + (segment->p_memsz > segment->p_filesz \
+ ? segment->p_memsz : segment->p_filesz))
+
+ /* Returns true if the given section is contained within
+ the given segment. VMA addresses are compared. */
+#define IS_CONTAINED_BY_VMA(section, segment) \
+ (section->vma >= segment->p_vaddr \
+ && (section->vma + section->_raw_size) \
+ <= (SEGMENT_END (segment, segment->p_vaddr)))
+
+ /* Returns true if the given section is contained within
+ the given segment. LMA addresses are compared. */
+#define IS_CONTAINED_BY_LMA(section, segment, base) \
+ (section->lma >= base \
+ && (section->lma + section->_raw_size) \
+ <= SEGMENT_END (segment, base))
/* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
-
-#define IS_COREFILE_NOTE(p, s) \
- (p->p_type == PT_NOTE \
- && bfd_get_format (ibfd) == bfd_core \
- && s->vma == 0 && s->lma == 0 \
- && (bfd_vma) s->filepos >= p->p_offset \
- && (bfd_vma) s->filepos + s->_raw_size \
+#define IS_COREFILE_NOTE(p, s) \
+ (p->p_type == PT_NOTE \
+ && bfd_get_format (ibfd) == bfd_core \
+ && s->vma == 0 && s->lma == 0 \
+ && (bfd_vma) s->filepos >= p->p_offset \
+ && (bfd_vma) s->filepos + s->_raw_size \
<= p->p_offset + p->p_filesz)
/* The complicated case when p_vaddr is 0 is to handle the Solaris
linker, which generates a PT_INTERP section with p_vaddr and
p_memsz set to 0. */
-
-#define IS_SOLARIS_PT_INTERP(p, s) \
- (p->p_vaddr == 0 \
- && p->p_filesz > 0 \
- && (s->flags & SEC_HAS_CONTENTS) != 0 \
- && s->_raw_size > 0 \
- && (bfd_vma) s->filepos >= p->p_offset \
- && ((bfd_vma) s->filepos + s->_raw_size \
+#define IS_SOLARIS_PT_INTERP(p, s) \
+ ( p->p_vaddr == 0 \
+ && p->p_filesz > 0 \
+ && (s->flags & SEC_HAS_CONTENTS) != 0 \
+ && s->_raw_size > 0 \
+ && (bfd_vma) s->filepos >= p->p_offset \
+ && ((bfd_vma) s->filepos + s->_raw_size \
<= p->p_offset + p->p_filesz))
+ /* Decide if the given section should be included in the given segment.
+ A section will be included if:
+ 1. It is within the address space of the segment,
+ 2. It is an allocated segment,
+ 3. There is an output section associated with it,
+ 4. The section has not already been allocated to a previous segment. */
+#define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
+ ((((IS_CONTAINED_BY_VMA (section, segment) \
+ || IS_SOLARIS_PT_INTERP (segment, section)) \
+ && (section->flags & SEC_ALLOC) != 0) \
+ || IS_COREFILE_NOTE (segment, section)) \
+ && section->output_section != NULL \
+ && section->segment_mark == false)
+
+ /* Returns true iff seg1 starts after the end of seg2. */
+#define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
+ (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
+
+ /* Returns true iff seg1 and seg2 overlap. */
+#define SEGMENT_OVERLAPS(seg1, seg2) \
+ (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
+
+ /* Initialise the segment mark field. */
+ for (section = ibfd->sections; section != NULL; section = section->next)
+ section->segment_mark = false;
+
/* Scan through the segments specified in the program header
- of the input BFD. */
- for (i = 0, p = elf_tdata (ibfd)->phdr; i < num_segments; i++, p++)
+ of the input BFD. For this first scan we look for overlaps
+ in the loadable segments. These can be created by wierd
+ parameters to objcopy. */
+ for (i = 0, segment = elf_tdata (ibfd)->phdr;
+ i < num_segments;
+ i ++, segment ++)
{
- unsigned int csecs;
- asection *s;
- asection **sections;
- asection *os;
- unsigned int isec;
- bfd_vma matching_lma;
- bfd_vma suggested_lma;
unsigned int j;
+ Elf_Internal_Phdr * segment2;
- /* For each section in the input BFD, decide if it should be
- included in the current segment. A section will be included
- if it is within the address space of the segment, and it is
- an allocated segment, and there is an output section
- associated with it. */
- csecs = 0;
- for (s = ibfd->sections; s != NULL; s = s->next)
- if (s->output_section != NULL)
- {
- if ((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
- || IS_SOLARIS_PT_INTERP (p, s))
- && (s->flags & SEC_ALLOC) != 0)
- ++csecs;
- else if (IS_COREFILE_NOTE (p, s))
- ++csecs;
- }
+ if (segment->p_type != PT_LOAD)
+ continue;
+
+ /* Determine if this segment overlaps any previous segments. */
+ for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j ++, segment2 ++)
+ {
+ bfd_signed_vma extra_length;
+
+ if (segment2->p_type != PT_LOAD
+ || ! SEGMENT_OVERLAPS (segment, segment2))
+ continue;
+
+ /* Merge the two segments together. */
+ if (segment2->p_vaddr < segment->p_vaddr)
+ {
+ /* Extend SEGMENT2 to include SEGMENT and then delete SEGMENT. */
+ extra_length =
+ SEGMENT_END (segment, segment->p_vaddr)
+ - SEGMENT_END (segment2, segment2->p_vaddr);
+
+ if (extra_length > 0)
+ {
+ segment2->p_memsz += extra_length;
+ segment2->p_filesz += extra_length;
+ }
+
+ segment->p_type = PT_NULL;
+
+ /* Since we have deleted P we must restart the outer loop. */
+ i = 0;
+ segment = elf_tdata (ibfd)->phdr;
+ break;
+ }
+ else
+ {
+ /* Extend SEGMENT to include SEGMENT2 and then delete SEGMENT2. */
+ extra_length =
+ SEGMENT_END (segment2, segment2->p_vaddr)
+ - SEGMENT_END (segment, segment->p_vaddr);
+
+ if (extra_length > 0)
+ {
+ segment->p_memsz += extra_length;
+ segment->p_filesz += extra_length;
+ }
+
+ segment2->p_type = PT_NULL;
+ }
+ }
+ }
+
+ /* The second scan attempts to assign sections to segments. */
+ for (i = 0, segment = elf_tdata (ibfd)->phdr;
+ i < num_segments;
+ i ++, segment ++)
+ {
+ unsigned int section_count;
+ asection ** sections;
+ asection * output_section;
+ unsigned int isec;
+ bfd_vma matching_lma;
+ bfd_vma suggested_lma;
+ unsigned int j;
+
+ if (segment->p_type == PT_NULL)
+ continue;
+
+ /* Compute how many sections might be placed into this segment. */
+ section_count = 0;
+ for (section = ibfd->sections; section != NULL; section = section->next)
+ if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
+ ++ section_count;
/* Allocate a segment map big enough to contain all of the
sections we have selected. */
- m = ((struct elf_segment_map *)
+ map = ((struct elf_segment_map *)
bfd_alloc (obfd,
(sizeof (struct elf_segment_map)
- + ((size_t) csecs - 1) * sizeof (asection *))));
- if (m == NULL)
+ + ((size_t) section_count - 1) * sizeof (asection *))));
+ if (map == NULL)
return false;
/* Initialise the fields of the segment map. Default to
using the physical address of the segment in the input BFD. */
- m->next = NULL;
- m->p_type = p->p_type;
- m->p_flags = p->p_flags;
- m->p_flags_valid = 1;
- m->p_paddr = p->p_paddr;
- m->p_paddr_valid = 1;
+ map->next = NULL;
+ map->p_type = segment->p_type;
+ map->p_flags = segment->p_flags;
+ map->p_flags_valid = 1;
+ map->p_paddr = segment->p_paddr;
+ map->p_paddr_valid = 1;
/* Determine if this segment contains the ELF file header
and if it contains the program headers themselves. */
- m->includes_filehdr = (p->p_offset == 0
- && p->p_filesz >= iehdr->e_ehsize);
+ map->includes_filehdr = (segment->p_offset == 0
+ && segment->p_filesz >= iehdr->e_ehsize);
- m->includes_phdrs = 0;
+ map->includes_phdrs = 0;
- if (! phdr_included || p->p_type != PT_LOAD)
+ if (! phdr_included || segment->p_type != PT_LOAD)
{
- m->includes_phdrs =
- (p->p_offset <= (bfd_vma) iehdr->e_phoff
- && (p->p_offset + p->p_filesz
+ map->includes_phdrs =
+ (segment->p_offset <= (bfd_vma) iehdr->e_phoff
+ && (segment->p_offset + segment->p_filesz
>= ((bfd_vma) iehdr->e_phoff
+ iehdr->e_phnum * iehdr->e_phentsize)));
- if (p->p_type == PT_LOAD && m->includes_phdrs)
+
+ if (segment->p_type == PT_LOAD && map->includes_phdrs)
phdr_included = true;
}
- if (csecs == 0)
+ if (section_count == 0)
{
/* Special segments, such as the PT_PHDR segment, may contain
no sections, but ordinary, loadable segments should contain
something. */
-
- if (p->p_type == PT_LOAD)
+ if (segment->p_type == PT_LOAD)
_bfd_error_handler
(_("%s: warning: Empty loadable segment detected\n"),
bfd_get_filename (ibfd));
- m->count = 0;
- *pm = m;
- pm = &m->next;
+ map->count = 0;
+ * pointer_to_map = map;
+ pointer_to_map = & map->next;
continue;
}
pointers that we are interested in. As these sections get assigned
to a segment, they are removed from this array. */
- sections = (asection **) bfd_malloc (sizeof (asection *) * csecs);
+ sections = (asection **) bfd_malloc
+ (sizeof (asection *) * section_count);
if (sections == NULL)
return false;
case, where the sections have not been moved, this means that
we have completely filled the segment, and there is nothing
more to do. */
-
isec = 0;
- matching_lma = false;
+ matching_lma = 0;
suggested_lma = 0;
- for (j = 0, s = ibfd->sections; s != NULL; s = s->next)
+ for (j = 0, section = ibfd->sections;
+ section != NULL;
+ section = section->next)
{
- os = s->output_section;
-
- if ((((IS_CONTAINED_BY (s->vma, s->_raw_size, p->p_vaddr, p)
- || IS_SOLARIS_PT_INTERP (p, s))
- && (s->flags & SEC_ALLOC) != 0)
- || IS_COREFILE_NOTE (p, s))
- && os != NULL)
+ if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
{
- sections[j++] = s;
+ output_section = section->output_section;
+
+ sections[j ++] = section;
/* The Solaris native linker always sets p_paddr to 0.
We try to catch that case here, and set it to the
correct value. */
- if (p->p_paddr == 0
- && p->p_vaddr != 0
+ if (segment->p_paddr == 0
+ && segment->p_vaddr != 0
&& isec == 0
- && os->lma != 0
- && (os->vma == (p->p_vaddr
- + (m->includes_filehdr
- ? iehdr->e_ehsize
- : 0)
- + (m->includes_phdrs
- ? iehdr->e_phnum * iehdr->e_phentsize
- : 0))))
- m->p_paddr = p->p_vaddr;
+ && output_section->lma != 0
+ && (output_section->vma == (segment->p_vaddr
+ + (map->includes_filehdr
+ ? iehdr->e_ehsize
+ : 0)
+ + (map->includes_phdrs
+ ? iehdr->e_phnum * iehdr->e_phentsize
+ : 0))))
+ map->p_paddr = segment->p_vaddr;
/* Match up the physical address of the segment with the
LMA address of the output section. */
- if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
- || IS_COREFILE_NOTE (p, s))
+ if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
+ || IS_COREFILE_NOTE (segment, section))
{
if (matching_lma == 0)
- matching_lma = os->lma;
+ matching_lma = output_section->lma;
/* We assume that if the section fits within the segment
- that it does not overlap any other section within that
+ then it does not overlap any other section within that
segment. */
- m->sections[isec++] = os;
+ map->sections[isec ++] = output_section;
}
else if (suggested_lma == 0)
- suggested_lma = os->lma;
+ suggested_lma = output_section->lma;
}
}
- BFD_ASSERT (j == csecs);
+ BFD_ASSERT (j == section_count);
/* Step Two: Adjust the physical address of the current segment,
if necessary. */
- if (isec == csecs)
+ if (isec == section_count)
{
/* All of the sections fitted within the segment as currently
specified. This is the default case. Add the segment to
the list of built segments and carry on to process the next
program header in the input BFD. */
- m->count = csecs;
- *pm = m;
- pm = &m->next;
+ map->count = section_count;
+ * pointer_to_map = map;
+ pointer_to_map = & map->next;
free (sections);
continue;
}
- else if (matching_lma != 0)
- {
- /* At least one section fits inside the current segment.
- Keep it, but modify its physical address to match the
- LMA of the first section that fitted. */
-
- m->p_paddr = matching_lma;
- }
else
{
- /* None of the sections fitted inside the current segment.
- Change the current segment's physical address to match
- the LMA of the first section. */
+ if (matching_lma != 0)
+ {
+ /* At least one section fits inside the current segment.
+ Keep it, but modify its physical address to match the
+ LMA of the first section that fitted. */
+ map->p_paddr = matching_lma;
+ }
+ else
+ {
+ /* None of the sections fitted inside the current segment.
+ Change the current segment's physical address to match
+ the LMA of the first section. */
+ map->p_paddr = suggested_lma;
+ }
- m->p_paddr = suggested_lma;
+ /* Offset the segment physical address from the lma
+ to allow for space taken up by elf headers. */
+ if (map->includes_filehdr)
+ map->p_paddr -= iehdr->e_ehsize;
+
+ if (map->includes_phdrs)
+ {
+ map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
+
+ /* iehdr->e_phnum is just an estimate of the number
+ of program headers that we will need. Make a note
+ here of the number we used and the segment we chose
+ to hold these headers, so that we can adjust the
+ offset when we know the correct value. */
+ phdr_adjust_num = iehdr->e_phnum;
+ phdr_adjust_seg = map;
+ }
}
/* Step Three: Loop over the sections again, this time assigning
isec = 0;
do
{
- m->count = 0;
+ map->count = 0;
suggested_lma = 0;
/* Fill the current segment with sections that fit. */
- for (j = 0; j < csecs; j++)
+ for (j = 0; j < section_count; j++)
{
- s = sections[j];
+ section = sections[j];
- if (s == NULL)
+ if (section == NULL)
continue;
- os = s->output_section;
+ output_section = section->output_section;
- if (IS_CONTAINED_BY (os->lma, os->_raw_size, m->p_paddr, p)
- || IS_COREFILE_NOTE (p, s))
+ BFD_ASSERT (output_section != NULL);
+
+ if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
+ || IS_COREFILE_NOTE (segment, section))
{
- if (m->count == 0)
+ if (map->count == 0)
{
/* If the first section in a segment does not start at
- the beginning of the segment, then something is wrong. */
- if (os->lma != m->p_paddr)
+ the beginning of the segment, then something is
+ wrong. */
+ if (output_section->lma !=
+ (map->p_paddr
+ + (map->includes_filehdr ? iehdr->e_ehsize : 0)
+ + (map->includes_phdrs
+ ? iehdr->e_phnum * iehdr->e_phentsize
+ : 0)))
abort ();
}
else
{
asection * prev_sec;
- bfd_vma maxpagesize;
- prev_sec = m->sections[m->count - 1];
- maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
+ prev_sec = map->sections[map->count - 1];
/* If the gap between the end of the previous section
- and the start of this section is more than maxpagesize
- then we need to start a new segment. */
- if (BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
- < BFD_ALIGN (os->lma, maxpagesize))
+ and the start of this section is more than
+ maxpagesize then we need to start a new segment. */
+ if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
+ < BFD_ALIGN (output_section->lma, maxpagesize))
+ || ((prev_sec->lma + prev_sec->_raw_size) > output_section->lma))
{
if (suggested_lma == 0)
- suggested_lma = os->lma;
+ suggested_lma = output_section->lma;
continue;
}
}
- m->sections[m->count++] = os;
+ map->sections[map->count++] = output_section;
++isec;
sections[j] = NULL;
+ section->segment_mark = true;
}
else if (suggested_lma == 0)
- suggested_lma = os->lma;
+ suggested_lma = output_section->lma;
}
- BFD_ASSERT (m->count > 0);
+ BFD_ASSERT (map->count > 0);
/* Add the current segment to the list of built segments. */
- *pm = m;
- pm = &m->next;
+ * pointer_to_map = map;
+ pointer_to_map = & map->next;
- if (isec < csecs)
+ if (isec < section_count)
{
/* We still have not allocated all of the sections to
segments. Create a new segment here, initialise it
and carry on looping. */
-
- m = ((struct elf_segment_map *)
- bfd_alloc (obfd,
- (sizeof (struct elf_segment_map)
- + ((size_t) csecs - 1) * sizeof (asection *))));
- if (m == NULL)
+ map = ((struct elf_segment_map *)
+ bfd_alloc (obfd,
+ (sizeof (struct elf_segment_map)
+ + ((size_t) section_count - 1)
+ * sizeof (asection *))));
+ if (map == NULL)
return false;
/* Initialise the fields of the segment map. Set the physical
physical address to the LMA of the first section that has
not yet been assigned. */
-
- m->next = NULL;
- m->p_type = p->p_type;
- m->p_flags = p->p_flags;
- m->p_flags_valid = 1;
- m->p_paddr = suggested_lma;
- m->p_paddr_valid = 1;
- m->includes_filehdr = 0;
- m->includes_phdrs = 0;
+ map->next = NULL;
+ map->p_type = segment->p_type;
+ map->p_flags = segment->p_flags;
+ map->p_flags_valid = 1;
+ map->p_paddr = suggested_lma;
+ map->p_paddr_valid = 1;
+ map->includes_filehdr = 0;
+ map->includes_phdrs = 0;
}
}
- while (isec < csecs);
+ while (isec < section_count);
free (sections);
}
p_paddr fields are zero. When we try to objcopy or strip such a
file, we get confused. Check for this case, and if we find it
reset the p_paddr_valid fields. */
- for (m = mfirst; m != NULL; m = m->next)
- if (m->p_paddr != 0)
+ for (map = map_first; map != NULL; map = map->next)
+ if (map->p_paddr != 0)
break;
- if (m == NULL)
+ if (map == NULL)
{
- for (m = mfirst; m != NULL; m = m->next)
- m->p_paddr_valid = 0;
+ for (map = map_first; map != NULL; map = map->next)
+ map->p_paddr_valid = 0;
}
- elf_tdata (obfd)->segment_map = mfirst;
+ elf_tdata (obfd)->segment_map = map_first;
+ /* If we had to estimate the number of program headers that were
+ going to be needed, then check our estimate know and adjust
+ the offset if necessary. */
+ if (phdr_adjust_seg != NULL)
+ {
+ unsigned int count;
+
+ for (count = 0, map = map_first; map != NULL; map = map->next)
+ count ++;
+
+ if (count > phdr_adjust_num)
+ phdr_adjust_seg->p_paddr
+ -= (count - phdr_adjust_num) * iehdr->e_phentsize;
+ }
+
#if 0
- /* Final Step: Sort the segments into ascending order of physical address. */
- if (mfirst != NULL)
+ /* Final Step: Sort the segments into ascending order of physical address. */
+ if (map_first != NULL)
{
- struct elf_segment_map* prev;
+ struct elf_segment_map * prev;
- prev = mfirst;
- for (m = mfirst->next; m != NULL; prev = m, m = m->next)
+ prev = map_first;
+ for (map = map_first->next; map != NULL; prev = map, map = map->next)
{
- /* Yes I know - its a bubble sort....*/
- if (m->next != NULL && (m->next->p_paddr < m->p_paddr))
+ /* Yes I know - its a bubble sort.... */
+ if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
{
- /* swap m and m->next */
- prev->next = m->next;
- m->next = m->next->next;
- prev->next->next = m;
+ /* Swap map and map->next. */
+ prev->next = map->next;
+ map->next = map->next->next;
+ prev->next->next = map;
- /* restart loop. */
- m = mfirst;
+ /* Restart loop. */
+ map = map_first;
}
}
}
#endif
-#undef IS_CONTAINED_BY
-#undef IS_SOLARIS_PT_INTERP
+#undef SEGMENT_END
+#undef IS_CONTAINED_BY_VMA
+#undef IS_CONTAINED_BY_LMA
#undef IS_COREFILE_NOTE
+#undef IS_SOLARIS_PT_INTERP
+#undef INCLUDE_SECTION_IN_SEGMENT
+#undef SEGMENT_AFTER_SEGMENT
+#undef SEGMENT_OVERLAPS
return true;
}
type = STT_NOTYPE;
/* Processor-specific types */
- if (bed->elf_backend_get_symbol_type)
+ if (type_ptr != NULL
+ && bed->elf_backend_get_symbol_type)
type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
if (flags & BSF_SECTION_SYM)
long
_bfd_elf_get_reloc_upper_bound (abfd, asect)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
sec_ptr asect;
{
return (asect->reloc_count + 1) * sizeof (arelent *);
Elf_Internal_Shdr *hdr;
Elf_External_Verdef *everdef;
Elf_Internal_Verdef *iverdef;
+ Elf_Internal_Verdef *iverdefarr;
+ Elf_Internal_Verdef iverdefmem;
unsigned int i;
+ unsigned int maxidx;
hdr = &elf_tdata (abfd)->dynverdef_hdr;
- elf_tdata (abfd)->verdef =
- ((Elf_Internal_Verdef *)
- bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verdef)));
- if (elf_tdata (abfd)->verdef == NULL)
- goto error_return;
-
- elf_tdata (abfd)->cverdefs = hdr->sh_info;
-
contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
if (contents == NULL)
goto error_return;
|| bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
goto error_return;
+ /* We know the number of entries in the section but not the maximum
+ index. Therefore we have to run through all entries and find
+ the maximum. */
+ everdef = (Elf_External_Verdef *) contents;
+ maxidx = 0;
+ for (i = 0; i < hdr->sh_info; ++i)
+ {
+ _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
+
+ if ((iverdefmem.vd_ndx & VERSYM_VERSION) > maxidx)
+ maxidx = iverdefmem.vd_ndx & VERSYM_VERSION;
+
+ everdef = ((Elf_External_Verdef *)
+ ((bfd_byte *) everdef + iverdefmem.vd_next));
+ }
+
+ elf_tdata (abfd)->verdef =
+ ((Elf_Internal_Verdef *)
+ bfd_zalloc (abfd, maxidx * sizeof (Elf_Internal_Verdef)));
+ if (elf_tdata (abfd)->verdef == NULL)
+ goto error_return;
+
+ elf_tdata (abfd)->cverdefs = maxidx;
+
everdef = (Elf_External_Verdef *) contents;
- iverdef = elf_tdata (abfd)->verdef;
- for (i = 0; i < hdr->sh_info; i++, iverdef++)
+ iverdefarr = elf_tdata (abfd)->verdef;
+ for (i = 0; i < hdr->sh_info; i++)
{
Elf_External_Verdaux *everdaux;
Elf_Internal_Verdaux *iverdaux;
unsigned int j;
- _bfd_elf_swap_verdef_in (abfd, everdef, iverdef);
+ _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
+
+ iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
+ memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
iverdef->vd_bfd = abfd;
void
_bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
- bfd *ignore_abfd;
+ bfd *ignore_abfd ATTRIBUTE_UNUSED;
asymbol *symbol;
symbol_info *ret;
{
boolean
_bfd_elf_is_local_label_name (abfd, name)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
const char *name;
{
/* Normal local symbols start with ``.L''. */
alent *
_bfd_elf_get_lineno (ignore_abfd, symbol)
- bfd *ignore_abfd;
- asymbol *symbol;
+ bfd *ignore_abfd ATTRIBUTE_UNUSED;
+ asymbol *symbol ATTRIBUTE_UNUSED;
{
abort ();
return NULL;
if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
filename_ptr, functionname_ptr,
- line_ptr))
+ line_ptr, 0))
return true;
if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
void
_bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
- bfd *abfd;
- arelent *cache_ptr;
- Elf_Internal_Rela *dst;
+ bfd *abfd ATTRIBUTE_UNUSED;
+ arelent *cache_ptr ATTRIBUTE_UNUSED;
+ Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
{
abort ();
}
bfd_reloc_status_type
_bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
- bfd *abfd;
- arelent *re;
- struct symbol_cache_entry *symbol;
- PTR data;
- asection *is;
- bfd *obfd;
- char **errmsg;
+ bfd *abfd ATTRIBUTE_UNUSED;
+ arelent *re ATTRIBUTE_UNUSED;
+ struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
+ PTR data ATTRIBUTE_UNUSED;
+ asection *is ATTRIBUTE_UNUSED;
+ bfd *obfd ATTRIBUTE_UNUSED;
+ char **errmsg ATTRIBUTE_UNUSED;
{
return bfd_reloc_ok;
}
/* prstatus_t exists on:
- solaris 2.[567]
+ solaris 2.5+
linux 2.[01] + glibc
unixware 4.2
*/
bfd* abfd;
Elf_Internal_Note* note;
{
- prstatus_t prstat;
char buf[100];
char* name;
asection* sect;
+ int raw_size;
+ int offset;
- if (note->descsz != sizeof (prstat))
- return true;
+ if (note->descsz == sizeof (prstatus_t))
+ {
+ prstatus_t prstat;
- memcpy (&prstat, note->descdata, sizeof (prstat));
+ raw_size = sizeof (prstat.pr_reg);
+ offset = offsetof (prstatus_t, pr_reg);
+ memcpy (&prstat, note->descdata, sizeof (prstat));
- elf_tdata (abfd)->core_signal = prstat.pr_cursig;
- elf_tdata (abfd)->core_pid = prstat.pr_pid;
+ elf_tdata (abfd)->core_signal = prstat.pr_cursig;
+ elf_tdata (abfd)->core_pid = prstat.pr_pid;
- /* pr_who exists on:
- solaris 2.[567]
- unixware 4.2
- pr_who doesn't exist on:
- linux 2.[01]
- */
+ /* pr_who exists on:
+ solaris 2.5+
+ unixware 4.2
+ pr_who doesn't exist on:
+ linux 2.[01]
+ */
#if defined (HAVE_PRSTATUS_T_PR_WHO)
- elf_tdata (abfd)->core_lwpid = prstat.pr_who;
+ elf_tdata (abfd)->core_lwpid = prstat.pr_who;
+#endif
+ }
+#if defined (HAVE_PRSTATUS32_T)
+ else if (note->descsz == sizeof (prstatus32_t))
+ {
+ /* 64-bit host, 32-bit corefile */
+ prstatus32_t prstat;
+
+ raw_size = sizeof (prstat.pr_reg);
+ offset = offsetof (prstatus32_t, pr_reg);
+ memcpy (&prstat, note->descdata, sizeof (prstat));
+
+ elf_tdata (abfd)->core_signal = prstat.pr_cursig;
+ elf_tdata (abfd)->core_pid = prstat.pr_pid;
+
+ /* pr_who exists on:
+ solaris 2.5+
+ unixware 4.2
+ pr_who doesn't exist on:
+ linux 2.[01]
+ */
+#if defined (HAVE_PRSTATUS32_T_PR_WHO)
+ elf_tdata (abfd)->core_lwpid = prstat.pr_who;
#endif
+ }
+#endif /* HAVE_PRSTATUS32_T */
+ else
+ {
+ /* Fail - we don't know how to handle any other
+ note size (ie. data object type). */
+ return true;
+ }
/* Make a ".reg/999" section. */
sect = bfd_make_section (abfd, name);
if (sect == NULL)
return false;
- sect->_raw_size = sizeof (prstat.pr_reg);
- sect->filepos = note->descpos + offsetof (prstatus_t, pr_reg);
+
+ sect->_raw_size = raw_size;
+ sect->filepos = note->descpos + offset;
+
sect->flags = SEC_HAS_CONTENTS;
sect->alignment_power = 2;
#endif /* defined (HAVE_PRSTATUS_T) */
-/* There isn't a consistent prfpregset_t across platforms,
- but it doesn't matter, because we don't have to pick this
- data structure apart. */
+/* Create a pseudosection containing the exact contents of NOTE. This
+ actually creates up to two pseudosections:
+ - For the single-threaded case, a section named NAME, unless
+ such a section already exists.
+ - For the multi-threaded case, a section named "NAME/PID", where
+ PID is elfcore_make_pid (abfd).
+ Both pseudosections have identical contents: the contents of NOTE. */
static boolean
-elfcore_grok_prfpreg (abfd, note)
+elfcore_make_note_pseudosection (abfd, name, note)
bfd* abfd;
+ char *name;
Elf_Internal_Note* note;
{
char buf[100];
- char* name;
+ char *threaded_name;
asection* sect;
- /* Make a ".reg2/999" section. */
+ /* Build the section name. */
- sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
- name = bfd_alloc (abfd, strlen (buf) + 1);
- if (name == NULL)
+ sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
+ threaded_name = bfd_alloc (abfd, strlen (buf) + 1);
+ if (threaded_name == NULL)
return false;
- strcpy (name, buf);
+ strcpy (threaded_name, buf);
- sect = bfd_make_section (abfd, name);
+ sect = bfd_make_section (abfd, threaded_name);
if (sect == NULL)
return false;
sect->_raw_size = note->descsz;
sect->flags = SEC_HAS_CONTENTS;
sect->alignment_power = 2;
- if (! elfcore_maybe_make_sect (abfd, ".reg2", sect))
+ if (! elfcore_maybe_make_sect (abfd, name, sect))
return false;
return true;
}
+
+/* There isn't a consistent prfpregset_t across platforms,
+ but it doesn't matter, because we don't have to pick this
+ data structure apart. */
+static boolean
+elfcore_grok_prfpreg (abfd, note)
+ bfd* abfd;
+ Elf_Internal_Note* note;
+{
+ return elfcore_make_note_pseudosection (abfd, ".reg2", note);
+}
+
+
+/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
+ type of 5 (NT_PRXFPREG). Just include the whole note's contents
+ literally. */
+static boolean
+elfcore_grok_prxfpreg (abfd, note)
+ bfd* abfd;
+ Elf_Internal_Note* note;
+{
+ return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
+}
+
+
#if defined (HAVE_PRPSINFO_T)
-# define elfcore_psinfo_t prpsinfo_t
+typedef prpsinfo_t elfcore_psinfo_t;
+#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
+typedef prpsinfo32_t elfcore_psinfo32_t;
+#endif
#endif
#if defined (HAVE_PSINFO_T)
-# define elfcore_psinfo_t psinfo_t
+typedef psinfo_t elfcore_psinfo_t;
+#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
+typedef psinfo32_t elfcore_psinfo32_t;
+#endif
#endif
bfd* abfd;
Elf_Internal_Note* note;
{
- elfcore_psinfo_t psinfo;
+ if (note->descsz == sizeof (elfcore_psinfo_t))
+ {
+ elfcore_psinfo_t psinfo;
- if (note->descsz != sizeof (elfcore_psinfo_t))
- return true;
+ memcpy (&psinfo, note->descdata, sizeof (psinfo));
- memcpy (&psinfo, note->descdata, note->descsz);
+ elf_tdata (abfd)->core_program
+ = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
- elf_tdata (abfd)->core_program
- = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
+ elf_tdata (abfd)->core_command
+ = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
+ }
+#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
+ else if (note->descsz == sizeof (elfcore_psinfo32_t))
+ {
+ /* 64-bit host, 32-bit corefile */
+ elfcore_psinfo32_t psinfo;
+
+ memcpy (&psinfo, note->descdata, sizeof (psinfo));
+
+ elf_tdata (abfd)->core_program
+ = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
+
+ elf_tdata (abfd)->core_command
+ = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
+ }
+#endif
- elf_tdata (abfd)->core_command
- = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
+ else
+ {
+ /* Fail - we don't know how to handle any other
+ note size (ie. data object type). */
+ return true;
+ }
/* Note that for some reason, a spurious space is tacked
onto the end of the args in some (at least one anyway)
bfd* abfd;
Elf_Internal_Note* note;
{
- pstatus_t pstat;
+ if (note->descsz == sizeof (pstatus_t))
+ {
+ pstatus_t pstat;
- if (note->descsz != sizeof (pstat))
- return true;
+ memcpy (&pstat, note->descdata, sizeof (pstat));
- memcpy (&pstat, note->descdata, sizeof (pstat));
+ elf_tdata (abfd)->core_pid = pstat.pr_pid;
+ }
+#if defined (HAVE_PSTATUS32_T)
+ else if (note->descsz == sizeof (pstatus32_t))
+ {
+ /* 64-bit host, 32-bit corefile */
+ pstatus32_t pstat;
- elf_tdata (abfd)->core_pid = pstat.pr_pid;
+ memcpy (&pstat, note->descdata, sizeof (pstat));
+ elf_tdata (abfd)->core_pid = pstat.pr_pid;
+ }
+#endif
/* Could grab some more details from the "representative"
lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
NT_LWPSTATUS note, presumably. */
}
#endif /* defined (HAVE_LWPSTATUS_T) */
+#if defined (HAVE_WIN32_PSTATUS_T)
+static boolean
+elfcore_grok_win32pstatus (abfd, note)
+ bfd * abfd;
+ Elf_Internal_Note * note;
+{
+ char buf[30];
+ char * name;
+ asection * sect;
+ win32_pstatus_t pstatus;
+
+ if (note->descsz < sizeof (pstatus))
+ return true;
+
+ memcpy (& pstatus, note->descdata, note->descsz);
+
+ switch (pstatus.data_type)
+ {
+ case NOTE_INFO_PROCESS:
+ /* FIXME: need to add ->core_command. */
+ elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
+ elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
+ break ;
+
+ case NOTE_INFO_THREAD:
+ /* Make a ".reg/999" section. */
+ sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
+
+ name = bfd_alloc (abfd, strlen (buf) + 1);
+ if (name == NULL)
+ return false;
+
+ strcpy (name, buf);
+ sect = bfd_make_section (abfd, name);
+ if (sect == NULL)
+ return false;
+
+ sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
+ sect->filepos = note->descpos + offsetof (struct win32_pstatus,
+ data.thread_info.thread_context);
+ sect->flags = SEC_HAS_CONTENTS;
+ sect->alignment_power = 2;
+
+ if (pstatus.data.thread_info.is_active_thread)
+ if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
+ return false;
+ break;
+
+ case NOTE_INFO_MODULE:
+ /* Make a ".module/xxxxxxxx" section. */
+ sprintf (buf, ".module/%08x" , pstatus.data.module_info.base_address);
+
+ name = bfd_alloc (abfd, strlen (buf) + 1);
+ if (name == NULL)
+ return false;
+
+ strcpy (name, buf);
+
+ sect = bfd_make_section (abfd, name);
+
+ if (sect == NULL)
+ return false;
+
+ sect->_raw_size = note->descsz;
+ sect->filepos = note->descpos;
+ sect->flags = SEC_HAS_CONTENTS;
+ sect->alignment_power = 2;
+ break;
+
+ default:
+ return true;
+ }
+
+ return true;
+}
+#endif /* HAVE_WIN32_PSTATUS_T */
static boolean
elfcore_grok_note (abfd, note)
case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
return elfcore_grok_prfpreg (abfd, note);
+#if defined (HAVE_WIN32_PSTATUS_T)
+ case NT_WIN32PSTATUS:
+ return elfcore_grok_win32pstatus (abfd, note);
+#endif
+
+ case NT_PRXFPREG: /* Linux SSE extension */
+ if (note->namesz == 5
+ && ! strcmp (note->namedata, "LINUX"))
+ return elfcore_grok_prxfpreg (abfd, note);
+ else
+ return true;
+
#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
case NT_PRPSINFO:
case NT_PSINFO:
}
+/* FIXME: This function is now unnecessary. Callers can just call
+ bfd_section_from_phdr directly. */
boolean
_bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
if (! bfd_section_from_phdr (abfd, phdr, sec_num))
return false;
- if (phdr->p_type == PT_NOTE
- && ! elfcore_read_notes (abfd, phdr->p_offset, phdr->p_filesz))
- return false;
-
return true;
}
+
+\f
+/* Providing external access to the ELF program header table. */
+
+/* Return an upper bound on the number of bytes required to store a
+ copy of ABFD's program header table entries. Return -1 if an error
+ occurs; bfd_get_error will return an appropriate code. */
+long
+bfd_get_elf_phdr_upper_bound (abfd)
+ bfd *abfd;
+{
+ if (abfd->xvec->flavour != bfd_target_elf_flavour)
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return -1;
+ }
+
+ return (elf_elfheader (abfd)->e_phnum
+ * sizeof (Elf_Internal_Phdr));
+}
+
+
+/* Copy ABFD's program header table entries to *PHDRS. The entries
+ will be stored as an array of Elf_Internal_Phdr structures, as
+ defined in include/elf/internal.h. To find out how large the
+ buffer needs to be, call bfd_get_elf_phdr_upper_bound.
+
+ Return the number of program header table entries read, or -1 if an
+ error occurs; bfd_get_error will return an appropriate code. */
+int
+bfd_get_elf_phdrs (abfd, phdrs)
+ bfd *abfd;
+ void *phdrs;
+{
+ int num_phdrs;
+
+ if (abfd->xvec->flavour != bfd_target_elf_flavour)
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return -1;
+ }
+
+ num_phdrs = elf_elfheader (abfd)->e_phnum;
+ memcpy (phdrs, elf_tdata (abfd)->phdr,
+ num_phdrs * sizeof (Elf_Internal_Phdr));
+
+ return num_phdrs;
+}
projects / deliverable / binutils-gdb.git / blobdiff