projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
2002-09-18 Andrew Cagney <ac131313@redhat.com>
[deliverable/binutils-gdb.git] / gdb / rs6000-nat.c
diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index 95833c684c214f733160cf40bd11e30de01d8e35..65256f447118ee3485077059fd4d01a79d2b917e 100644 (file)
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c
@@ -32,6 +32,7 @@
 #include "gdb-stabs.h"
 #include "regcache.h"
 #include "arch-utils.h"
+#include "language.h"          /* for local_hex_string().  */
 #include "ppc-tdep.h"
 
 #include <sys/ptrace.h>
@@ -145,18 +146,43 @@ static void exec_one_dummy_insn (void);
 extern void
 fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
 
-/* Conversion from gdb-to-system special purpose register numbers. */
+/* Given REGNO, a gdb register number, return the corresponding
+   number suitable for use as a ptrace() parameter.  Return -1 if
+   there's no suitable mapping.  Also, set the int pointed to by
+   ISFLOAT to indicate whether REGNO is a floating point register.  */
 
-static int special_regs[] =
+static int
+regmap (int regno, int *isfloat)
 {
-  IAR,                         /* PC_REGNUM    */
-  MSR,                         /* PS_REGNUM    */
-  CR,                          /* CR_REGNUM    */
-  LR,                          /* LR_REGNUM    */
-  CTR,                         /* CTR_REGNUM   */
-  XER,                         /* XER_REGNUM   */
-  MQ                           /* MQ_REGNUM    */
-};
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+  *isfloat = 0;
+  if (tdep->ppc_gp0_regnum <= regno && regno <= tdep->ppc_gplast_regnum)
+    return regno;
+  else if (FP0_REGNUM <= regno && regno <= FPLAST_REGNUM)
+    {
+      *isfloat = 1;
+      return regno - FP0_REGNUM + FPR0;
+    }
+  else if (regno == PC_REGNUM)
+    return IAR;
+  else if (regno == tdep->ppc_ps_regnum)
+    return MSR;
+  else if (regno == tdep->ppc_cr_regnum)
+    return CR;
+  else if (regno == tdep->ppc_lr_regnum)
+    return LR;
+  else if (regno == tdep->ppc_ctr_regnum)
+    return CTR;
+  else if (regno == tdep->ppc_xer_regnum)
+    return XER;
+  else if (regno == tdep->ppc_fpscr_regnum)
+    return FPSCR;
+  else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
+    return MQ;
+  else
+    return -1;
+}
 
 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
 
@@ -194,35 +220,30 @@ static void
 fetch_register (int regno)
 {
   int *addr = alloca (MAX_REGISTER_RAW_SIZE);
-  int nr;
+  int nr, isfloat;
 
   /* Retrieved values may be -1, so infer errors from errno. */
   errno = 0;
 
+  nr = regmap (regno, &isfloat);
+
   /* Floating-point registers. */
-  if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
-    {
-      nr = regno - FP0_REGNUM + FPR0;
-      rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
-    }
+  if (isfloat)
+    rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 
   /* Bogus register number. */
-  else if (regno > LAST_UISA_SP_REGNUM)
+  else if (nr < 0)
     {
       if (regno >= NUM_REGS)
        fprintf_unfiltered (gdb_stderr,
                            "gdb error: register no %d not implemented.\n",
                            regno);
+      return;
     }
 
   /* Fixed-point registers. */
   else
     {
-      if (regno >= FIRST_UISA_SP_REGNUM)
-       nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
-      else
-       nr = regno;
-
       if (!ARCH64 ())
        *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
       else
@@ -256,7 +277,7 @@ static void
 store_register (int regno)
 {
   int *addr = alloca (MAX_REGISTER_RAW_SIZE);
-  int nr;
+  int nr, isfloat;
 
   /* Fetch the register's value from the register cache.  */
   regcache_collect (regno, addr);
@@ -264,15 +285,14 @@ store_register (int regno)
   /* -1 can be a successful return value, so infer errors from errno. */
   errno = 0;
 
+  nr = regmap (regno, &isfloat);
+
   /* Floating-point registers. */
-  if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
-    {
-      nr = regno - FP0_REGNUM + FPR0;
-      rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
-    }
+  if (isfloat)
+    rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 
   /* Bogus register number. */
-  else if (regno > LAST_UISA_SP_REGNUM)
+  else if (nr < 0)
     {
       if (regno >= NUM_REGS)
        fprintf_unfiltered (gdb_stderr,
@@ -291,11 +311,6 @@ store_register (int regno)
           (%sp). */
        exec_one_dummy_insn ();
 
-      if (regno >= FIRST_UISA_SP_REGNUM)
-       nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
-      else
-       nr = regno;
-
       /* The PT_WRITE_GPR operation is rather odd.  For 32-bit inferiors,
          the register's value is passed by value, but for 64-bit inferiors,
         the address of a buffer containing the value is passed.  */
@@ -332,17 +347,30 @@ fetch_inferior_registers (int regno)
 
   else
     {
-      /* read 32 general purpose registers. */
-      for (regno = 0; regno < 32; regno++)
-       fetch_register (regno);
+      struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+      /* Read 32 general purpose registers.  */
+      for (regno = tdep->ppc_gp0_regnum;
+           regno <= tdep->ppc_gplast_regnum;
+          regno++)
+       {
+         fetch_register (regno);
+       }
 
-      /* read general purpose floating point registers. */
+      /* Read general purpose floating point registers.  */
       for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
        fetch_register (regno);
 
-      /* read special registers. */
-      for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
-       fetch_register (regno);
+      /* Read special registers.  */
+      fetch_register (PC_REGNUM);
+      fetch_register (tdep->ppc_ps_regnum);
+      fetch_register (tdep->ppc_cr_regnum);
+      fetch_register (tdep->ppc_lr_regnum);
+      fetch_register (tdep->ppc_ctr_regnum);
+      fetch_register (tdep->ppc_xer_regnum);
+      fetch_register (tdep->ppc_fpscr_regnum);
+      if (tdep->ppc_mq_regnum >= 0)
+       fetch_register (tdep->ppc_mq_regnum);
     }
 }
 
@@ -358,18 +386,30 @@ store_inferior_registers (int regno)
 
   else
     {
-      /* write general purpose registers first! */
-      for (regno = GPR0; regno <= GPR31; regno++)
-       store_register (regno);
+      struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+      /* Write general purpose registers first.  */
+      for (regno = tdep->ppc_gp0_regnum;
+           regno <= tdep->ppc_gplast_regnum;
+          regno++)
+       {
+         store_register (regno);
+       }
 
-      /* write floating point registers now. */
+      /* Write floating point registers.  */
       for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
        store_register (regno);
 
-      /* write special registers. */
-
-      for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
-       store_register (regno);
+      /* Write special registers.  */
+      store_register (PC_REGNUM);
+      store_register (tdep->ppc_ps_regnum);
+      store_register (tdep->ppc_cr_regnum);
+      store_register (tdep->ppc_lr_regnum);
+      store_register (tdep->ppc_ctr_regnum);
+      store_register (tdep->ppc_xer_regnum);
+      store_register (tdep->ppc_fpscr_regnum);
+      if (tdep->ppc_mq_regnum >= 0)
+       store_register (tdep->ppc_mq_regnum);
     }
 }
 
@@ -550,6 +590,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
       supply_register (tdep->ppc_lr_regnum, (char *) &regs->r64.lr);
       supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r64.ctr);
       supply_register (tdep->ppc_xer_regnum, (char *) &regs->r64.xer);
+      supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r64.fpscr);
     }
   else
     {
@@ -565,6 +606,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
       supply_register (tdep->ppc_lr_regnum, (char *) &regs->r32.lr);
       supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r32.ctr);
       supply_register (tdep->ppc_xer_regnum, (char *) &regs->r32.xer);
+      supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r32.fpscr);
       if (tdep->ppc_mq_regnum >= 0)
        supply_register (tdep->ppc_mq_regnum, (char *) &regs->r32.mq);
     }
GDB Binutils - Deliverables
This page took 0.030909 seconds and 4 git commands to generate.