2004-01-07 Michael Chastain <mec.gnu@mindspring.com>
[deliverable/binutils-gdb.git] / gdb / core-sol2.c
index 46b5eb6086c172506a3ce6e0012947b82095d9d2..456eebc8f621c72f6c638a70c92d8183e2afef90 100644 (file)
@@ -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.
 
    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 <v9/sys/privregs.h>
+#endif
+
 #include <time.h>
 #include <sys/types.h>
 #include <sys/regset.h>
@@ -34,6 +41,7 @@
 #include <fcntl.h>
 #include <errno.h>
 #include "gdb_string.h"
+#include "regcache.h"
 
 #include "inferior.h"
 #include "target.h"
 
 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 *) &registers[REGISTER_BYTE (0)] = 0;
+         *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0;
 
          /* The globals and output registers.  */
-         memcpy (&registers[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
-                 15 * REGISTER_RAW_SIZE (G1_REGNUM));
-         *(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
-         *(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
-         *(int *) &registers[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc;
-         *(int *) &registers[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 *) &registers[REGISTER_BYTE (SP_REGNUM)];
+           sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
            if (0 != target_read_memory (sp,
-                                     &registers[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 (&registers[REGISTER_BYTE (FP0_REGNUM)], &fpuregs->fpu_fr,
-                 sizeof (fpuregs->fpu_fr));
-         memcpy (&registers[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);
 }
This page took 0.025702 seconds and 4 git commands to generate.