X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fcore-sol2.c;h=456eebc8f621c72f6c638a70c92d8183e2afef90;hb=2789202a9c2e05785ac16b579a1cb2cbf2006a76;hp=46b5eb6086c172506a3ce6e0012947b82095d9d2;hpb=27e232885db363fb545fd2f450e72d929e59b8f6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/core-sol2.c b/gdb/core-sol2.c index 46b5eb6086..456eebc8f6 100644 --- a/gdb/core-sol2.c +++ b/gdb/core-sol2.c @@ -1,5 +1,6 @@ /* Machine independent support for Solaris 2 core files for GDB. - Copyright 1994 Free Software Foundation, Inc. + Copyright 1994, 1995, 1996, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. This file is part of GDB. @@ -27,6 +28,12 @@ and sparc-nat.c to be able to read both flavours. */ #include "defs.h" + +#if defined (__sparcv9) +/* Fails to get included by the Solaris system header files. */ +# include +#endif + #include #include #include @@ -34,6 +41,7 @@ #include #include #include "gdb_string.h" +#include "regcache.h" #include "inferior.h" #include "target.h" @@ -45,36 +53,60 @@ static void fetch_core_registers (char *, unsigned, int, CORE_ADDR); +/* Fetch registers from core file data pointed to by CORE_REG_SECT. When + WHICH is 0, the the general register set is fetched; when WHICH is + 2, the floating point registers are fetched. CORE_REG_SIZE is used + to validate the size of the data pointed to by CORE_REG_SECT. REG_ADDR + is unused. */ + static void -fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) - char *core_reg_sect; - unsigned core_reg_size; - int which; - CORE_ADDR reg_addr; /* Unused in this version */ +fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, + CORE_ADDR reg_addr) { - prgregset_t prgregset; - prfpregset_t prfpregset; + int i; if (which == 0) { - if (core_reg_size == sizeof (prgregset)) + prgregset_t prgregset; + + if (core_reg_size == sizeof (prgregset_t)) { memcpy ((char *) &prgregset, core_reg_sect, sizeof (prgregset)); supply_gregset (&prgregset); } +#if defined (HAVE_PRGREGSET32_T) + /* 32-bit corefile, 64-bit debugger. */ + else if (core_reg_size == sizeof (prgregset32_t)) + { + prgreg32_t *core_gregs; + + /* Can't use memcpy here, because the core file contains + 32-bit regs; supply_register expects 64-bit regs. */ + core_gregs = (prgreg32_t *) core_reg_sect; + for (i = 0; i < NPRGREG; i++) + prgregset[i] = core_gregs[i]; + + supply_gregset (&prgregset); + } +#endif /* HAVE_PRGREGSET32_T */ else if (core_reg_size == sizeof (struct regs)) { -#define gregs ((struct regs *)core_reg_sect) + struct regs *gregs = (struct regs *) core_reg_sect; + /* G0 *always* holds 0. */ - *(int *) ®isters[REGISTER_BYTE (0)] = 0; + *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0; /* The globals and output registers. */ - memcpy (®isters[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1, - 15 * REGISTER_RAW_SIZE (G1_REGNUM)); - *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps; - *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc; - *(int *) ®isters[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc; - *(int *) ®isters[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y; + memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], + &gregs->r_g1, 15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM)); + *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)] + = gregs->r_ps; + *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] + = gregs->r_pc; + *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (DEPRECATED_NPC_REGNUM)] + = gregs->r_npc; + *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (Y_REGNUM)] + = gregs->r_y; /* My best guess at where to get the locals and input registers is exactly where they usually are, right above @@ -84,10 +116,10 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) { int sp; - sp = *(int *) ®isters[REGISTER_BYTE (SP_REGNUM)]; + sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)]; if (0 != target_read_memory (sp, - ®isters[REGISTER_BYTE (L0_REGNUM)], - 16 * REGISTER_RAW_SIZE (L0_REGNUM))) + &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], + 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM))) { warning ("couldn't read input and local registers from core file\n"); } @@ -100,18 +132,45 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) } else if (which == 2) { - if (core_reg_size == sizeof (prfpregset)) + prfpregset_t prfpregset; + + if (core_reg_size == sizeof (prfpregset_t)) { memcpy ((char *) &prfpregset, core_reg_sect, sizeof (prfpregset)); supply_fpregset (&prfpregset); } +#if defined (HAVE_PRFPREGSET32_T) + /* 32-bit corefile, 64-bit debugger. */ + else if (core_reg_size == sizeof (prfpregset32_t)) + { + prfpregset32_t *core_fpregset; + + /* Can't use memcpy here, because the core file contains + 32-bit regs; supply_fpregset expects 64-bit regs. */ + + core_fpregset = (prfpregset32_t *) core_reg_sect; + for (i = 0; i < 16; i++) + prfpregset.pr_fr.pr_dregs[i] = core_fpregset->pr_fr.pr_dregs[i]; + while (i < 32) + prfpregset.pr_fr.pr_dregs[i++] = 0; + + prfpregset.pr_fsr = core_fpregset->pr_fsr; + prfpregset.pr_qcnt = core_fpregset->pr_qcnt; + prfpregset.pr_q_entrysize = core_fpregset->pr_q_entrysize; + prfpregset.pr_en = core_fpregset->pr_en; + /* We will not use the pr_q array. */ + + supply_fpregset (&prfpregset); + } +#endif /* HAVE_PRFPREGSET32_T */ else if (core_reg_size >= sizeof (struct fpu)) { -#define fpuregs ((struct fpu *) core_reg_sect) - memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &fpuregs->fpu_fr, - sizeof (fpuregs->fpu_fr)); - memcpy (®isters[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr, - sizeof (FPU_FSR_TYPE)); + struct fpu *fpuregs = (struct fpu *) core_reg_sect; + + memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], + &fpuregs->fpu_fr, sizeof (fpuregs->fpu_fr)); + memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)], + &fpuregs->fpu_fsr, sizeof (FPU_FSR_TYPE)); } else { @@ -133,7 +192,7 @@ static struct core_fns solaris_core_fns = }; void -_initialize_core_solaris () +_initialize_core_solaris (void) { add_core_fns (&solaris_core_fns); }