void
md_begin (void)
{
/* Initialize the `cgen' interface. */
/* Set the machine number and endian. */
gas_cgen_cpu_desc = frv_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
CGEN_CPU_OPEN_ENDIAN,
CGEN_ENDIAN_BIG,
CGEN_CPU_OPEN_END);
frv_cgen_init_asm (gas_cgen_cpu_desc);
/* This is a callback from cgen to gas to parse operands. */
cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
/* Set the ELF flags if desired. */
if (frv_flags)
bfd_set_private_flags (stdoutput, frv_flags);
/* Set the machine type */
bfd_default_set_arch_mach (stdoutput, bfd_arch_frv, frv_mach);
/* Set up gp size so we can put local common items in .sbss */
bfd_set_gp_size (stdoutput, g_switch_value);
frv_vliw_reset (& vliw, frv_mach, frv_flags);
}
bfd_boolean
nlm_set_arch_mach (bfd * abfd,
enum bfd_architecture arch,
unsigned long machine)
{
bfd_default_set_arch_mach (abfd, arch, machine);
return arch == nlm_architecture (abfd);
}
/* Set parameters about this a.out file that are machine-dependent.
This routine is called from some_aout_object_p just before it returns. */
static const bfd_target *
MY (callback) (bfd *abfd)
{
struct internal_exec *execp = exec_hdr (abfd);
/* Calculate the file positions of the parts of a newly read aout header */
obj_textsec (abfd)->size = N_TXTSIZE (*execp);
/* The virtual memory addresses of the sections */
obj_textsec (abfd)->vma = N_TXTADDR (*execp);
obj_datasec (abfd)->vma = N_DATADDR (*execp);
obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
obj_textsec (abfd)->lma = obj_textsec (abfd)->vma;
obj_datasec (abfd)->lma = obj_datasec (abfd)->vma;
obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
/* The file offsets of the sections */
obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
obj_datasec (abfd)->filepos = N_DATOFF (*execp);
/* The file offsets of the relocation info */
obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
/* The file offsets of the string table and symbol table. */
obj_sym_filepos (abfd) = N_SYMOFF (*execp);
obj_str_filepos (abfd) = N_STROFF (*execp);
/* Determine the architecture and machine type of the object file. */
#ifdef SET_ARCH_MACH
SET_ARCH_MACH (abfd, *execp);
#else
bfd_default_set_arch_mach (abfd, DEFAULT_ARCH, 0);
#endif
if (obj_aout_subformat (abfd) == gnu_encap_format)
{
/* The file offsets of the relocation info */
obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF (*execp);
obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF (*execp);
/* The file offsets of the string table and symbol table. */
obj_sym_filepos (abfd) = N_GNU_SYMOFF (*execp);
obj_str_filepos (abfd) = (obj_sym_filepos (abfd) + execp->a_syms);
abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
bfd_get_symcount (abfd) = execp->a_syms / 12;
obj_symbol_entry_size (abfd) = 12;
obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
}
return abfd->xvec;
}
void
rs6000_nat_target::create_inferior (const char *exec_file,
const std::string &allargs,
char **env, int from_tty)
{
enum bfd_architecture arch;
unsigned long mach;
bfd abfd;
struct gdbarch_info info;
inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty);
if (__power_rs ())
{
arch = bfd_arch_rs6000;
mach = bfd_mach_rs6k;
}
else
{
arch = bfd_arch_powerpc;
mach = bfd_mach_ppc;
}
/* FIXME: schauer/2002-02-25:
We don't know if we are executing a 32 or 64 bit executable,
and have no way to pass the proper word size to rs6000_gdbarch_init.
So we have to avoid switching to a new architecture, if the architecture
matches already.
Blindly calling rs6000_gdbarch_init used to work in older versions of
GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
determine the wordsize. */
if (exec_bfd)
{
const struct bfd_arch_info *exec_bfd_arch_info;
exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
if (arch == exec_bfd_arch_info->arch)
return;
}
bfd_default_set_arch_mach (&abfd, arch, mach);
gdbarch_info_init (&info);
info.bfd_arch_info = bfd_get_arch_info (&abfd);
info.abfd = exec_bfd;
if (!gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
_("rs6000_create_inferior: failed "
"to select architecture"));
}
static bfd_boolean
aout_adobe_set_arch_mach (bfd *abfd,
enum bfd_architecture arch,
unsigned long machine)
{
if (! bfd_default_set_arch_mach (abfd, arch, machine))
return FALSE;
if (arch == bfd_arch_unknown
|| arch == bfd_arch_m68k)
return TRUE;
return FALSE;
}
bfd_boolean
nlm_mkobject (bfd * abfd)
{
bfd_size_type amt = sizeof (struct nlm_obj_tdata);
nlm_tdata (abfd) = bfd_zalloc (abfd, amt);
if (nlm_tdata (abfd) == NULL)
return FALSE;
if (nlm_architecture (abfd) != bfd_arch_unknown)
bfd_default_set_arch_mach (abfd, nlm_architecture (abfd),
nlm_machine (abfd));
/* Since everything is done at close time, do we need any initialization ? */
return TRUE;
}
static bfd_boolean
versados_mkobject (bfd *abfd)
{
if (abfd->tdata.versados_data == NULL)
{
bfd_size_type amt = sizeof (tdata_type);
tdata_type *tdata = bfd_alloc (abfd, amt);
if (tdata == NULL)
return FALSE;
abfd->tdata.versados_data = tdata;
tdata->symbols = NULL;
VDATA (abfd)->alert = 0x12345678;
}
bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0);
return TRUE;
}
void
md_begin (void)
{
/* Initialize the `cgen' interface. */
/* Set the machine number and endian. */
gas_cgen_cpu_desc = mt_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, mt_mach_bitmask,
CGEN_CPU_OPEN_ENDIAN,
CGEN_ENDIAN_BIG,
CGEN_CPU_OPEN_END);
mt_cgen_init_asm (gas_cgen_cpu_desc);
/* This is a callback from cgen to gas to parse operands. */
cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
/* Set the ELF flags if desired. */
if (mt_flags)
bfd_set_private_flags (stdoutput, mt_flags);
/* Set the machine type. */
bfd_default_set_arch_mach (stdoutput, bfd_arch_mt, mt_mach);
}
static const bfd_target *
irix_core_core_file_p (bfd *abfd)
{
int val;
struct coreout coreout;
struct idesc *idg, *idf, *ids;
bfd_size_type amt;
val = bfd_bread ((PTR) &coreout, (bfd_size_type) sizeof coreout, abfd);
if (val != sizeof coreout)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return 0;
}
if (coreout.c_version != CORE_VERSION1)
return 0;
/* Have we got a corefile? */
switch (coreout.c_magic)
{
case CORE_MAGIC: break;
#ifdef CORE_MAGIC64
case CORE_MAGIC64: break;
#endif
#ifdef CORE_MAGICN32
case CORE_MAGICN32: break;
#endif
default: return 0; /* Un-identifiable or not corefile. */
}
amt = sizeof (struct sgi_core_struct);
core_hdr (abfd) = (struct sgi_core_struct *) bfd_zalloc (abfd, amt);
if (!core_hdr (abfd))
return NULL;
strncpy (core_command (abfd), coreout.c_name, CORE_NAMESIZE);
core_signal (abfd) = coreout.c_sigcause;
if (bfd_seek (abfd, coreout.c_vmapoffset, SEEK_SET) != 0)
goto fail;
/* Process corefile sections. */
#ifdef CORE_MAGIC64
if (coreout.c_magic == (int) CORE_MAGIC64)
{
if (! do_sections64 (abfd, & coreout))
goto fail;
}
else
#endif
if (! do_sections (abfd, & coreout))
goto fail;
/* Make sure that the regs are contiguous within the core file. */
idg = &coreout.c_idesc[I_GPREGS];
idf = &coreout.c_idesc[I_FPREGS];
ids = &coreout.c_idesc[I_SPECREGS];
if (idg->i_offset + idg->i_len != idf->i_offset
|| idf->i_offset + idf->i_len != ids->i_offset)
goto fail; /* Can't deal with non-contig regs */
if (bfd_seek (abfd, idg->i_offset, SEEK_SET) != 0)
goto fail;
if (!make_bfd_asection (abfd, ".reg",
SEC_HAS_CONTENTS,
idg->i_len + idf->i_len + ids->i_len,
0,
idg->i_offset))
goto fail;
/* OK, we believe you. You're a core file (sure, sure). */
bfd_default_set_arch_mach (abfd, bfd_arch_mips, 0);
return abfd->xvec;
fail:
bfd_release (abfd, core_hdr (abfd));
core_hdr (abfd) = NULL;
bfd_section_list_clear (abfd);
return NULL;
}
static const bfd_target *
netbsd_core_file_p (bfd *abfd)
{
int val;
unsigned i;
file_ptr offset;
asection *asect;
struct core core;
struct coreseg coreseg;
bfd_size_type amt = sizeof core;
val = bfd_bread (&core, amt, abfd);
if (val != sizeof core)
{
/* Too small to be a core file. */
bfd_set_error (bfd_error_wrong_format);
return 0;
}
if (CORE_GETMAGIC (core) != COREMAGIC)
{
bfd_set_error (bfd_error_wrong_format);
return 0;
}
amt = sizeof (struct netbsd_core_struct);
rawptr = (struct netbsd_core_struct *) bfd_zalloc (abfd, amt);
if (rawptr == NULL)
return 0;
rawptr->core = core;
abfd->tdata.netbsd_core_data = rawptr;
offset = core.c_hdrsize;
for (i = 0; i < core.c_nseg; i++)
{
const char *sname;
flagword flags;
if (bfd_seek (abfd, offset, SEEK_SET) != 0)
goto punt;
val = bfd_bread (&coreseg, sizeof coreseg, abfd);
if (val != sizeof coreseg)
{
bfd_set_error (bfd_error_file_truncated);
goto punt;
}
if (CORE_GETMAGIC (coreseg) != CORESEGMAGIC)
{
bfd_set_error (bfd_error_wrong_format);
goto punt;
}
offset += core.c_seghdrsize;
switch (CORE_GETFLAG (coreseg))
{
case CORE_CPU:
sname = ".reg";
flags = SEC_ALLOC + SEC_HAS_CONTENTS;
break;
case CORE_DATA:
sname = ".data";
flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
break;
case CORE_STACK:
sname = ".stack";
flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
break;
default:
sname = ".unknown";
flags = SEC_ALLOC + SEC_HAS_CONTENTS;
break;
}
asect = bfd_make_section_anyway_with_flags (abfd, sname, flags);
if (asect == NULL)
goto punt;
asect->size = coreseg.c_size;
asect->vma = coreseg.c_addr;
asect->filepos = offset;
asect->alignment_power = 2;
if (CORE_GETFLAG (coreseg) == CORE_CPU)
{
bfd_size_type wcookie_offset;
switch (CORE_GETMID (core))
{
case M_SPARC_NETBSD:
wcookie_offset = SPARC_WCOOKIE_OFFSET;
break;
case M_SPARC64_OPENBSD:
wcookie_offset = SPARC64_WCOOKIE_OFFSET;
break;
default:
wcookie_offset = 0;
break;
}
if (wcookie_offset > 0 && coreseg.c_size > wcookie_offset)
{
/* Truncate the .reg section. */
asect->size = wcookie_offset;
/* And create the .wcookie section. */
flags = SEC_ALLOC + SEC_HAS_CONTENTS;
asect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
flags);
if (asect == NULL)
goto punt;
asect->size = coreseg.c_size - wcookie_offset;
asect->vma = 0;
asect->filepos = offset + wcookie_offset;
asect->alignment_power = 2;
}
}
offset += coreseg.c_size;
}
/* Set architecture from machine ID. */
switch (CORE_GETMID (core))
{
case M_ALPHA_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
break;
case M_ARM6_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_3);
break;
case M_X86_64_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
break;
case M_386_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386);
break;
case M_68K_NETBSD:
case M_68K4K_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0);
break;
case M_88K_OPENBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_m88k, 0);
break;
case M_HPPA_OPENBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_hppa, bfd_mach_hppa11);
break;
case M_POWERPC_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_powerpc, bfd_mach_ppc);
break;
case M_SPARC_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
break;
case M_SPARC64_NETBSD:
case M_SPARC64_OPENBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc_v9);
break;
case M_VAX_NETBSD:
case M_VAX4K_NETBSD:
bfd_default_set_arch_mach (abfd, bfd_arch_vax, 0);
break;
}
/* OK, we believe you. You're a core file (sure, sure). */
return abfd->xvec;
punt:
bfd_release (abfd, abfd->tdata.any);
abfd->tdata.any = NULL;
bfd_section_list_clear (abfd);
return 0;
}
const bfd_target *
xcoff64_core_p (bfd *abfd)
{
enum bfd_architecture arch;
unsigned long mach;
struct core_dumpxx core, *new_core_hdr;
struct stat statbuf;
asection *sec;
struct __ld_info64 ldinfo;
bfd_vma ld_offset;
bfd_size_type i;
struct vm_infox vminfo;
const bfd_target *return_value = NULL;
flagword flags;
/* Get the header. */
if (bfd_seek (abfd, 0, SEEK_SET) != 0)
goto xcoff64_core_p_error;
if (sizeof (struct core_dumpxx)
!= bfd_bread (&core, sizeof (struct core_dumpxx), abfd))
goto xcoff64_core_p_error;
if (bfd_stat (abfd, &statbuf) < 0)
goto xcoff64_core_p_error;
/* Sanity checks
c_flag has CORE_VERSION_1, Aix 4+
c_entries = 0 for Aix 4.3+
IS_PROC64 is a macro defined in procinfo.h, test for 64 bit process.
We will still be confused if a Aix 4.3 64 bit core file is
copied over to a Aix 5 machine.
Check file header offsets
See rs6000-core.c for comment on size of core
If there isn't enough of a real core file, bail. */
if ((CORE_VERSION_1 != (core.c_flag & CORE_VERSION_1))
|| (0 != core.c_entries)
|| (! (IS_PROC64 (&core.c_u.U_proc)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_fdsinfox)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_loader)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_loader + core.c_lsize)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_thr)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_segregion)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_stack)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_stack + core.c_size)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_data)))
|| ((CHECK_FILE_OFFSET (statbuf, core.c_data + core.c_datasize)))
|| (! (core.c_flag & UBLOCK_VALID))
|| (! (core.c_flag & LE_VALID)))
goto xcoff64_core_p_error;
/* Check for truncated stack or general truncating. */
if ((! (core.c_flag & USTACK_VALID))
|| (core.c_flag & CORE_TRUNC))
{
bfd_set_error (bfd_error_file_truncated);
return return_value;
}
new_core_hdr = bfd_zalloc (abfd, sizeof (struct core_dumpxx));
if (NULL == new_core_hdr)
return return_value;
memcpy (new_core_hdr, &core, sizeof (struct core_dumpxx));
/* The core_hdr() macro is no longer used here because it would
expand to code relying on gcc's cast-as-lvalue extension,
which was removed in gcc 4.0. */
abfd->tdata.any = new_core_hdr;
/* .stack section. */
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
sec = bfd_make_section_anyway_with_flags (abfd, ".stack", flags);
if (NULL == sec)
return return_value;
sec->size = core.c_size;
sec->vma = core.c_stackorg;
sec->filepos = core.c_stack;
/* .reg section for all registers. */
flags = SEC_HAS_CONTENTS | SEC_IN_MEMORY;
sec = bfd_make_section_anyway_with_flags (abfd, ".reg", flags);
if (NULL == sec)
return return_value;
sec->size = sizeof (struct __context64);
sec->vma = 0;
sec->filepos = 0;
sec->contents = (bfd_byte *)&new_core_hdr->c_flt.r64;
/* .ldinfo section.
To actually find out how long this section is in this particular
core dump would require going down the whole list of struct
ld_info's. See if we can just fake it. */
flags = SEC_HAS_CONTENTS;
sec = bfd_make_section_anyway_with_flags (abfd, ".ldinfo", flags);
if (NULL == sec)
return return_value;
sec->size = core.c_lsize;
sec->vma = 0;
sec->filepos = core.c_loader;
/* AIX 4 adds data sections from loaded objects to the core file,
which can be found by examining ldinfo, and anonymously mmapped
regions. */
/* .data section from executable. */
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
sec = bfd_make_section_anyway_with_flags (abfd, ".data", flags);
if (NULL == sec)
return return_value;
sec->size = core.c_datasize;
sec->vma = core.c_dataorg;
sec->filepos = core.c_data;
/* .data sections from loaded objects. */
ld_offset = core.c_loader;
while (1)
{
if (bfd_seek (abfd, ld_offset, SEEK_SET) != 0)
return return_value;
if (sizeof (struct __ld_info64) !=
bfd_bread (&ldinfo, sizeof (struct __ld_info64), abfd))
return return_value;
if (ldinfo.ldinfo_core)
{
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
sec = bfd_make_section_anyway_with_flags (abfd, ".data", flags);
if (NULL == sec)
return return_value;
sec->size = ldinfo.ldinfo_datasize;
sec->vma = ldinfo.ldinfo_dataorg;
sec->filepos = ldinfo.ldinfo_core;
}
if (0 == ldinfo.ldinfo_next)
break;
ld_offset += ldinfo.ldinfo_next;
}
/* .vmdata sections from anonymously mmapped regions. */
if (core.c_vmregions)
{
if (bfd_seek (abfd, core.c_vmm, SEEK_SET) != 0)
return return_value;
for (i = 0; i < core.c_vmregions; i++)
if (sizeof (struct vm_infox) !=
bfd_bread (&vminfo, sizeof (struct vm_infox), abfd))
return return_value;
if (vminfo.vminfo_offset)
{
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
sec = bfd_make_section_anyway_with_flags (abfd, ".vmdata", flags);
if (NULL == sec)
return return_value;
sec->size = vminfo.vminfo_size;
sec->vma = vminfo.vminfo_addr;
sec->filepos = vminfo.vminfo_offset;
}
}
/* Set the architecture and machine. */
arch = DEFAULT_ARCHITECTURE;
mach = DEFAULT_MACHINE;
bfd_default_set_arch_mach (abfd, arch, mach);
return_value = (bfd_target *) abfd->xvec; /* This is garbage for now. */
xcoff64_core_p_error:
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return return_value;
}
const bfd_target *
rs6000coff_core_p (bfd *abfd)
{
CoreHdr core;
struct stat statbuf;
bfd_size_type size;
char *tmpptr;
/* Values from new and old core structures. */
int c_flag;
file_ptr c_stack, c_regoff, c_loader;
bfd_size_type c_size, c_regsize, c_lsize;
bfd_vma c_stackend;
void *c_regptr;
int proc64;
if (!read_hdr (abfd, &core))
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
/* This isn't the right handler for 64-bit core files on AIX 5.x. */
if (CORE_NEW (core) && CNEW_IS_CORE_DUMPXX (core))
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
/* Copy fields from new or old core structure. */
if (CORE_NEW (core))
{
c_flag = core.new_dump.c_flag;
c_stack = (file_ptr) core.new_dump.c_stack;
c_size = core.new_dump.c_size;
c_stackend = CNEW_STACKORG (core.new_dump) + c_size;
c_lsize = CNEW_LSIZE (core.new_dump);
c_loader = CNEW_LOADER (core.new_dump);
#ifndef BFD64
proc64 = CNEW_PROC64 (core.new_dump);
}
else
{
c_flag = core.old.c_flag;
c_stack = (file_ptr) (ptr_to_uint) core.old.c_stack;
c_size = core.old.c_size;
c_stackend = COLD_STACKEND;
c_lsize = 0x7ffffff;
c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
#endif
proc64 = 0;
}
if (proc64)
{
c_regsize = sizeof (CNEW_CONTEXT64 (core.new_dump));
c_regptr = &CNEW_CONTEXT64 (core.new_dump);
}
else if (CORE_NEW (core))
{
c_regsize = sizeof (CNEW_MSTSAVE (core.new_dump));
c_regptr = &CNEW_MSTSAVE (core.new_dump);
}
#ifndef BFD64
else
{
c_regsize = sizeof (COLD_MSTSAVE (core.old));
c_regptr = &COLD_MSTSAVE (core.old);
}
#endif
c_regoff = (char *) c_regptr - (char *) &core;
if (bfd_stat (abfd, &statbuf) < 0)
{
bfd_set_error (bfd_error_system_call);
return NULL;
}
/* If the core file ulimit is too small, the system will first
omit the data segment, then omit the stack, then decline to
dump core altogether (as far as I know UBLOCK_VALID and LE_VALID
are always set) (this is based on experimentation on AIX 3.2).
Now, the thing is that GDB users will be surprised
if segments just silently don't appear (well, maybe they would
think to check "info files", I don't know).
For the data segment, we have no choice but to keep going if it's
not there, since the default behavior is not to dump it (regardless
of the ulimit, it's based on SA_FULLDUMP). But for the stack segment,
if it's not there, we refuse to have anything to do with this core
file. The usefulness of a core dump without a stack segment is pretty
limited anyway. */
if (!(c_flag & UBLOCK_VALID)
|| !(c_flag & LE_VALID))
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
if (!(c_flag & USTACK_VALID))
{
bfd_set_error (bfd_error_file_truncated);
return NULL;
}
/* Don't check the core file size for a full core, AIX 4.1 includes
additional shared library sections in a full core. */
if (!(c_flag & (FULL_CORE | CORE_TRUNC)))
{
/* If the size is wrong, it means we're misinterpreting something. */
if (c_stack + (file_ptr) c_size != statbuf.st_size)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
}
/* Sanity check on the c_tab field. */
if (!CORE_NEW (core)
&& (
#ifndef BFD64
c_loader < (file_ptr) sizeof core.old
#else
c_loader < (file_ptr) sizeof core.new_dump
#endif
|| c_loader >= statbuf.st_size
|| c_loader >= c_stack))
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
/* Issue warning if the core file was truncated during writing. */
if (c_flag & CORE_TRUNC)
_bfd_error_handler (_("%s: warning core file truncated"),
bfd_get_filename (abfd));
/* Allocate core file header. */
#ifndef BFD64
size = CORE_NEW (core) ? sizeof (core.new_dump) : sizeof (core.old);
#else
size = sizeof (core.new_dump);
#endif
tmpptr = (char *) bfd_zalloc (abfd, (bfd_size_type) size);
if (!tmpptr)
return NULL;
/* Copy core file header. */
memcpy (tmpptr, &core, size);
set_tdata (abfd, tmpptr);
/* Set architecture. */
if (CORE_NEW (core))
{
enum bfd_architecture arch;
unsigned long mach;
switch (CNEW_IMPL (core.new_dump))
{
case POWER_RS1:
case POWER_RSC:
case POWER_RS2:
arch = bfd_arch_rs6000;
mach = bfd_mach_rs6k;
break;
default:
arch = bfd_arch_powerpc;
mach = bfd_mach_ppc;
break;
}
bfd_default_set_arch_mach (abfd, arch, mach);
}
/* .stack section. */
if (!make_bfd_asection (abfd, ".stack",
SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
c_size, c_stackend - c_size, c_stack))
goto fail;
/* .reg section for all registers. */
if (!make_bfd_asection (abfd, ".reg",
SEC_HAS_CONTENTS,
c_regsize, (bfd_vma) 0, c_regoff))
goto fail;
/* .ldinfo section.
To actually find out how long this section is in this particular
core dump would require going down the whole list of struct ld_info's.
See if we can just fake it. */
if (!make_bfd_asection (abfd, ".ldinfo",
SEC_HAS_CONTENTS,
c_lsize, (bfd_vma) 0, c_loader))
goto fail;
#ifndef CORE_VERSION_1
/* .data section if present.
AIX 3 dumps the complete data section and sets FULL_CORE if the
ulimit is large enough, otherwise the data section is omitted.
AIX 4 sets FULL_CORE even if the core file is truncated, we have
to examine core.c_datasize below to find out the actual size of
the .data section. */
if (c_flag & FULL_CORE)
{
if (!make_bfd_asection (abfd, ".data",
SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
(bfd_size_type) core.old.c_u.u_dsize,
(bfd_vma)
CDATA_ADDR (core.old.c_u.u_dsize),
c_stack + c_size))
goto fail;
}
#endif
#ifdef CORE_VERSION_1
/* AIX 4 adds data sections from loaded objects to the core file,
which can be found by examining ldinfo, and anonymously mmapped
regions. */
{
LdInfo ldinfo;
bfd_size_type ldi_datasize;
file_ptr ldi_core;
uint ldi_next;
bfd_vma ldi_dataorg;
bfd_vma core_dataorg;
/* Fields from new and old core structures. */
bfd_size_type c_datasize, c_vmregions;
file_ptr c_data, c_vmm;
if (CORE_NEW (core))
{
c_datasize = CNEW_DATASIZE (core.new_dump);
c_data = (file_ptr) core.new_dump.c_data;
c_vmregions = core.new_dump.c_vmregions;
c_vmm = (file_ptr) core.new_dump.c_vmm;
}
#ifndef BFD64
else
{
c_datasize = core.old.c_datasize;
c_data = (file_ptr) (ptr_to_uint) core.old.c_data;
c_vmregions = core.old.c_vmregions;
c_vmm = (file_ptr) (ptr_to_uint) core.old.c_vmm;
}
#endif
/* .data section from executable. */
if (c_datasize)
{
/* If Large Memory Model is used, then the .data segment should start from
BDATAORG which has been defined in the system header files. */
if (c_flag & CORE_BIGDATA)
core_dataorg = BDATAORG;
else
core_dataorg = CDATA_ADDR (c_datasize);
if (!make_bfd_asection (abfd, ".data",
SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
c_datasize,
(bfd_vma) core_dataorg,
c_data))
goto fail;
}
/* .data sections from loaded objects. */
if (proc64)
size = (unsigned long) ((LdInfo *) 0)->l64.ldinfo_filename;
else
size = (unsigned long) ((LdInfo *) 0)->l32.ldinfo_filename;
while (1)
{
if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
goto fail;
if (bfd_bread (&ldinfo, size, abfd) != size)
goto fail;
if (proc64)
{
ldi_core = ldinfo.l64.ldinfo_core;
ldi_datasize = ldinfo.l64.ldinfo_datasize;
ldi_dataorg = (bfd_vma) ldinfo.l64.ldinfo_dataorg;
ldi_next = ldinfo.l64.ldinfo_next;
}
else
{
ldi_core = ldinfo.l32.ldinfo_core;
ldi_datasize = ldinfo.l32.ldinfo_datasize;
ldi_dataorg = (bfd_vma) (ptr_to_uint) ldinfo.l32.ldinfo_dataorg;
ldi_next = ldinfo.l32.ldinfo_next;
}
if (ldi_core)
if (!make_bfd_asection (abfd, ".data",
SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
ldi_datasize, ldi_dataorg, ldi_core))
goto fail;
if (ldi_next == 0)
break;
c_loader += ldi_next;
}
/* .vmdata sections from anonymously mmapped regions. */
if (c_vmregions)
{
bfd_size_type i;
if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
goto fail;
for (i = 0; i < c_vmregions; i++)
{
VmInfo vminfo;
bfd_size_type vminfo_size;
file_ptr vminfo_offset;
bfd_vma vminfo_addr;
#ifndef BFD64
size = CORE_NEW (core) ? sizeof (vminfo.new_dump) : sizeof (vminfo.old);
#else
size = sizeof (vminfo.new_dump);
#endif
if (bfd_bread (&vminfo, size, abfd) != size)
goto fail;
if (CORE_NEW (core))
{
vminfo_addr = (bfd_vma) vminfo.new_dump.vminfo_addr;
vminfo_size = vminfo.new_dump.vminfo_size;
vminfo_offset = vminfo.new_dump.vminfo_offset;
}
#ifndef BFD64
else
{
vminfo_addr = (bfd_vma) (ptr_to_uint) vminfo.old.vminfo_addr;
vminfo_size = vminfo.old.vminfo_size;
vminfo_offset = vminfo.old.vminfo_offset;
}
#endif
if (vminfo_offset)
if (!make_bfd_asection (abfd, ".vmdata",
SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
vminfo_size, vminfo_addr,
vminfo_offset))
goto fail;
}
}
}
#endif
return abfd->xvec; /* This is garbage for now. */
fail:
bfd_release (abfd, abfd->tdata.any);
abfd->tdata.any = NULL;
bfd_section_list_clear (abfd);
return NULL;
}
